1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
use crate::disk::block::{DirectoryBlock, DirectoryEntry, InodeBlock};
use crate::disk::inode::{Inode, InodeMode, INODE_SIZE};
use crate::utils::from_filetype;
use crate::{utils, AyaFS};
use and_then_some::BoolExt;
use fuser::FileType;
use log::debug;
impl AyaFS {
pub(crate) fn create_file(
&mut self,
permissions: u16,
uid: u32,
gid: u32,
flags: u32,
) -> Option<(usize, &Inode)> {
self.inode_bitmap.allocate().map(|inode_index| {
self.get_inode_mut(inode_index).map(|inode| {
*inode = Inode::file(permissions, uid, gid, utils::time_now(), flags, 0, 0, 0);
});
(inode_index, self.get_inode(inode_index).unwrap())
})
}
pub(crate) fn create_directory(
&mut self,
permissions: u16,
uid: u32,
gid: u32,
flags: u32,
) -> Option<(usize, &Inode)> {
self.inode_bitmap.allocate().map(|inode_index| {
// 创建 Inode
let mut new_inode =
Inode::directory(permissions, uid, gid, utils::time_now(), flags, 0, 0, 0);
// 分配第一个 direct block
new_inode.direct[0] = self.allocate_block_for(&mut new_inode).unwrap();
new_inode.size = 2;
// 在 direct block 里分配 . 和 ..
if let Some(directory_block) =
self.get_block_mut::<DirectoryBlock>(new_inode.direct[0] as usize)
{
let dot = '.'.to_ascii_lowercase() as u8;
// add dot entry
directory_block.block.entries[0] = DirectoryEntry {
inode: inode_index as u32,
record_len: 264,
name_len: 1,
file_type: 0x2,
name: [0; 256],
};
directory_block.block.entries[0].name[0] = dot;
// add dot dot entry
directory_block.block.entries[1] = DirectoryEntry {
inode: 0, // TODO set this as parent inode number
record_len: 264,
name_len: 2,
file_type: 0x2,
name: [0; 256],
};
directory_block.block.entries[1].name[0] = dot;
directory_block.block.entries[1].name[1] = dot;
}
// 把 inode 放到指定位置
self.get_inode_mut(inode_index).map(|inode| {
*inode = new_inode;
});
(inode_index, self.get_inode(inode_index).unwrap())
})
}
pub(crate) fn create_inode(
&mut self,
permissions: u16,
mode: InodeMode,
uid: u32,
gid: u32,
flags: u32,
) -> Option<usize> {
self.inode_bitmap.allocate().map(|inode_index| {
self.get_inode_mut(inode_index).map(|inode| {
*inode = Inode::make_inode(
permissions,
mode,
uid,
gid,
utils::time_now(),
flags,
0,
0,
0,
);
});
inode_index
})
}
pub(crate) fn update_inode(&mut self, inode_index: usize, inode: Inode) -> bool {
if self.inode_bitmap.query(inode_index) {
let (block_index, offset) = self.locate_inode(inode_index);
if let Some(cached_block) = self.cached_inodes.get_block_mut::<InodeBlock>(block_index)
{
cached_block.block.inodes[offset / INODE_SIZE] = inode;
}
true
} else {
false
}
}
pub(crate) fn get_inode(&mut self, inode_index: usize) -> Option<&Inode> {
self.inode_bitmap.query(inode_index).and_then(|| {
let (block_index, offset) = self.locate_inode(inode_index);
self.cached_inodes
.get_block::<InodeBlock>(block_index)
.map(|cached_block| &cached_block.block.inodes[offset / INODE_SIZE])
})
}
pub(crate) fn get_inode_mut(&mut self, inode_index: usize) -> Option<&mut Inode> {
self.inode_bitmap.query(inode_index).and_then(|| {
let (block_index, offset) = self.locate_inode(inode_index);
self.cached_inodes
.get_block_mut::<InodeBlock>(block_index)
.map(|cached_block| {
cached_block.dirty = true; // 保守一些, 只要返回了 &mut Inode 这个页一定标记为脏
&mut cached_block.block.inodes[offset / INODE_SIZE]
})
})
}
pub(crate) fn peek_inode(&self, inode_index: usize) -> Option<&Inode> {
self.inode_bitmap.query(inode_index).and_then(|| {
let (block_index, offset) = self.locate_inode(inode_index);
self.cached_inodes
.peek_block::<InodeBlock>(block_index)
.map(|cached_block| &cached_block.block.inodes[offset / INODE_SIZE])
})
}
pub(crate) fn peek_inode_mut(&mut self, inode_index: usize) -> Option<&mut Inode> {
self.inode_bitmap.query(inode_index).and_then(|| {
let (block_index, offset) = self.locate_inode(inode_index);
self.cached_inodes
.peek_block_mut::<InodeBlock>(block_index)
.map(|cached_block| {
cached_block.dirty = true; // 保守一些, 只要返回了 &mut Inode 这个页一定标记为脏
&mut cached_block.block.inodes[offset / INODE_SIZE]
})
})
}
}
|
