andrey/rCore-Tutorial-v3
1
0
Fork 0
mirror of https://github.com/rcore-os/rCore-Tutorial-v3.git synced 2024-11-22 09:26:26 +04:00
Code Issues Projects Releases Wiki Activity

Fixed a bug that the efs lock was not be held correctly

Browse Source
This commit is contained in:
Yifan Wu 2021-04-15 12:10:06 +08:00
parent bfa6a80732
commit 0a8bd2c3fd
2 changed files with 19 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
easy-fs/src/efs.rs
View File

@ -112,8 +112,12 @@ impl EasyFileSystem {
pub fn root_inode(efs: &Arc<Mutex<Self>>) -> Inode {
let block_device = Arc::clone(&efs.lock().block_device);
// acquire efs lock temporarily
let (block_id, block_offset) = efs.lock().get_disk_inode_pos(0);
// release efs lock
Inode::new(
0,
block_id,
block_offset,
Arc::clone(efs),
block_device,
)

23
easy-fs/src/vfs.rs
View File

@ -20,12 +20,13 @@ pub struct Inode {
}
impl Inode {
/// We should not acquire efs lock here.
pub fn new(
inode_id: u32,
block_id: u32,
block_offset: usize,
fs: Arc<Mutex<EasyFileSystem>>,
block_device: Arc<dyn BlockDevice>,
) -> Self {
let (block_id, block_offset) = fs.lock().get_disk_inode_pos(inode_id);
Self {
block_id: block_id as usize,
block_offset,
@ -74,12 +75,14 @@ impl Inode {
}
pub fn find(&self, name: &str) -> Option<Arc<Inode>> {
let _ = self.fs.lock();
let fs = self.fs.lock();
self.read_disk_inode(|disk_inode| {
self.find_inode_id(name, disk_inode)
.map(|inode_id| {
let (block_id, block_offset) = fs.get_disk_inode_pos(inode_id);
Arc::new(Self::new(
inode_id,
block_id,
block_offset,
self.fs.clone(),
self.block_device.clone(),
))
@ -140,18 +143,20 @@ impl Inode {
&self.block_device,
);
});
// release efs lock manually because we will acquire it again in Inode::new
drop(fs);
let (block_id, block_offset) = fs.get_disk_inode_pos(new_inode_id);
// return inode
Some(Arc::new(Self::new(
new_inode_id,
block_id,
block_offset,
self.fs.clone(),
self.block_device.clone(),
)))
// release efs lock automatically by compiler
}
pub fn ls(&self) -> Vec<String> {
let _ = self.fs.lock();
let _fs = self.fs.lock();
self.read_disk_inode(|disk_inode| {
let file_count = (disk_inode.size as usize) / DIRENT_SZ;
let mut v: Vec<String> = Vec::new();
@ -172,7 +177,7 @@ impl Inode {
}
pub fn read_at(&self, offset: usize, buf: &mut [u8]) -> usize {
let _ = self.fs.lock();
let _fs = self.fs.lock();
self.read_disk_inode(|disk_inode| {
disk_inode.read_at(offset, buf, &self.block_device)
})