This source file includes following definitions.
- minix_put_inode
- minix_put_super
- minix_read_super
- minix_statfs
- block_bmap
- minix_bmap
- inode_getblk
- block_getblk
- minix_getblk
- minix_bread
- minix_read_inode
- minix_write_inode
1
2
3
4
5
6
7 #include <linux/sched.h>
8 #include <linux/minix_fs.h>
9 #include <linux/kernel.h>
10 #include <linux/mm.h>
11 #include <linux/string.h>
12 #include <linux/stat.h>
13 #include <linux/locks.h>
14
15 #include <asm/system.h>
16 #include <asm/segment.h>
17
18 void minix_put_inode(struct inode *inode)
19 {
20 if (inode->i_nlink)
21 return;
22 inode->i_size = 0;
23 minix_truncate(inode);
24 minix_free_inode(inode);
25 }
26
27 void minix_put_super(struct super_block *sb)
28 {
29 int i;
30
31 lock_super(sb);
32 sb->s_dev = 0;
33 for(i = 0 ; i < MINIX_I_MAP_SLOTS ; i++)
34 brelse(sb->u.minix_sb.s_imap[i]);
35 for(i = 0 ; i < MINIX_Z_MAP_SLOTS ; i++)
36 brelse(sb->u.minix_sb.s_zmap[i]);
37 unlock_super(sb);
38 return;
39 }
40
41 static struct super_operations minix_sops = {
42 minix_read_inode,
43 NULL,
44 minix_write_inode,
45 minix_put_inode,
46 minix_put_super,
47 NULL,
48 minix_statfs
49 };
50
51 struct super_block *minix_read_super(struct super_block *s,void *data,
52 int silent)
53 {
54 struct buffer_head *bh;
55 struct minix_super_block *ms;
56 int i,dev=s->s_dev,block;
57
58 if (32 != sizeof (struct minix_inode))
59 panic("bad i-node size");
60 lock_super(s);
61 if (!(bh = bread(dev,1,BLOCK_SIZE))) {
62 s->s_dev=0;
63 unlock_super(s);
64 printk("MINIX-fs: unable to read superblock\n");
65 return NULL;
66 }
67 ms = (struct minix_super_block *) bh->b_data;
68 s->s_blocksize = 1024;
69 s->u.minix_sb.s_ninodes = ms->s_ninodes;
70 s->u.minix_sb.s_nzones = ms->s_nzones;
71 s->u.minix_sb.s_imap_blocks = ms->s_imap_blocks;
72 s->u.minix_sb.s_zmap_blocks = ms->s_zmap_blocks;
73 s->u.minix_sb.s_firstdatazone = ms->s_firstdatazone;
74 s->u.minix_sb.s_log_zone_size = ms->s_log_zone_size;
75 s->u.minix_sb.s_max_size = ms->s_max_size;
76 s->s_magic = ms->s_magic;
77 brelse(bh);
78 if (s->s_magic == MINIX_SUPER_MAGIC) {
79 s->u.minix_sb.s_dirsize = 16;
80 s->u.minix_sb.s_namelen = 14;
81 } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
82 s->u.minix_sb.s_dirsize = 32;
83 s->u.minix_sb.s_namelen = 30;
84 } else {
85 s->s_dev = 0;
86 unlock_super(s);
87 if (!silent)
88 printk("VFS: Can't find a minix filesystem on dev 0x%04x.\n",
89 dev);
90 return NULL;
91 }
92 for (i=0;i < MINIX_I_MAP_SLOTS;i++)
93 s->u.minix_sb.s_imap[i] = NULL;
94 for (i=0;i < MINIX_Z_MAP_SLOTS;i++)
95 s->u.minix_sb.s_zmap[i] = NULL;
96 block=2;
97 for (i=0 ; i < s->u.minix_sb.s_imap_blocks ; i++)
98 if ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
99 block++;
100 else
101 break;
102 for (i=0 ; i < s->u.minix_sb.s_zmap_blocks ; i++)
103 if ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
104 block++;
105 else
106 break;
107 if (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
108 for(i=0;i<MINIX_I_MAP_SLOTS;i++)
109 brelse(s->u.minix_sb.s_imap[i]);
110 for(i=0;i<MINIX_Z_MAP_SLOTS;i++)
111 brelse(s->u.minix_sb.s_zmap[i]);
112 s->s_dev=0;
113 unlock_super(s);
114 printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
115 return NULL;
116 }
117 s->u.minix_sb.s_imap[0]->b_data[0] |= 1;
118 s->u.minix_sb.s_zmap[0]->b_data[0] |= 1;
119
120 s->s_dev = dev;
121 s->s_op = &minix_sops;
122 s->s_mounted = iget(s,MINIX_ROOT_INO);
123 unlock_super(s);
124 if (!s->s_mounted) {
125 s->s_dev = 0;
126 printk("MINIX-fs: get root inode failed\n");
127 return NULL;
128 }
129 return s;
130 }
131
132 void minix_statfs(struct super_block *sb, struct statfs *buf)
133 {
134 long tmp;
135
136 put_fs_long(MINIX_SUPER_MAGIC, &buf->f_type);
137 put_fs_long(1024, &buf->f_bsize);
138 put_fs_long(sb->u.minix_sb.s_nzones << sb->u.minix_sb.s_log_zone_size, &buf->f_blocks);
139 tmp = minix_count_free_blocks(sb);
140 put_fs_long(tmp, &buf->f_bfree);
141 put_fs_long(tmp, &buf->f_bavail);
142 put_fs_long(sb->u.minix_sb.s_ninodes, &buf->f_files);
143 put_fs_long(minix_count_free_inodes(sb), &buf->f_ffree);
144 put_fs_long(sb->u.minix_sb.s_namelen, &buf->f_namelen);
145
146 }
147
148 #define inode_bmap(inode,nr) ((inode)->u.minix_i.i_data[(nr)])
149
150 static int block_bmap(struct buffer_head * bh, int nr)
151 {
152 int tmp;
153
154 if (!bh)
155 return 0;
156 tmp = ((unsigned short *) bh->b_data)[nr];
157 brelse(bh);
158 return tmp;
159 }
160
161 int minix_bmap(struct inode * inode,int block)
162 {
163 int i;
164
165 if (block<0) {
166 printk("minix_bmap: block<0");
167 return 0;
168 }
169 if (block >= 7+512+512*512) {
170 printk("minix_bmap: block>big");
171 return 0;
172 }
173 if (block < 7)
174 return inode_bmap(inode,block);
175 block -= 7;
176 if (block < 512) {
177 i = inode_bmap(inode,7);
178 if (!i)
179 return 0;
180 return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
181 }
182 block -= 512;
183 i = inode_bmap(inode,8);
184 if (!i)
185 return 0;
186 i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
187 if (!i)
188 return 0;
189 return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
190 }
191
192 static struct buffer_head * inode_getblk(struct inode * inode, int nr, int create)
193 {
194 int tmp;
195 unsigned short *p;
196 struct buffer_head * result;
197
198 p = inode->u.minix_i.i_data + nr;
199 repeat:
200 tmp = *p;
201 if (tmp) {
202 result = getblk(inode->i_dev, tmp, BLOCK_SIZE);
203 if (tmp == *p)
204 return result;
205 brelse(result);
206 goto repeat;
207 }
208 if (!create)
209 return NULL;
210 tmp = minix_new_block(inode->i_sb);
211 if (!tmp)
212 return NULL;
213 result = getblk(inode->i_dev, tmp, BLOCK_SIZE);
214 if (*p) {
215 minix_free_block(inode->i_sb,tmp);
216 brelse(result);
217 goto repeat;
218 }
219 *p = tmp;
220 inode->i_ctime = CURRENT_TIME;
221 inode->i_dirt = 1;
222 return result;
223 }
224
225 static struct buffer_head * block_getblk(struct inode * inode,
226 struct buffer_head * bh, int nr, int create)
227 {
228 int tmp;
229 unsigned short *p;
230 struct buffer_head * result;
231
232 if (!bh)
233 return NULL;
234 if (!bh->b_uptodate) {
235 ll_rw_block(READ, 1, &bh);
236 wait_on_buffer(bh);
237 if (!bh->b_uptodate) {
238 brelse(bh);
239 return NULL;
240 }
241 }
242 p = nr + (unsigned short *) bh->b_data;
243 repeat:
244 tmp = *p;
245 if (tmp) {
246 result = getblk(bh->b_dev, tmp, BLOCK_SIZE);
247 if (tmp == *p) {
248 brelse(bh);
249 return result;
250 }
251 brelse(result);
252 goto repeat;
253 }
254 if (!create) {
255 brelse(bh);
256 return NULL;
257 }
258 tmp = minix_new_block(inode->i_sb);
259 if (!tmp) {
260 brelse(bh);
261 return NULL;
262 }
263 result = getblk(bh->b_dev, tmp, BLOCK_SIZE);
264 if (*p) {
265 minix_free_block(inode->i_sb,tmp);
266 brelse(result);
267 goto repeat;
268 }
269 *p = tmp;
270 bh->b_dirt = 1;
271 brelse(bh);
272 return result;
273 }
274
275 struct buffer_head * minix_getblk(struct inode * inode, int block, int create)
276 {
277 struct buffer_head * bh;
278
279 if (block<0) {
280 printk("minix_getblk: block<0");
281 return NULL;
282 }
283 if (block >= 7+512+512*512) {
284 printk("minix_getblk: block>big");
285 return NULL;
286 }
287 if (block < 7)
288 return inode_getblk(inode,block,create);
289 block -= 7;
290 if (block < 512) {
291 bh = inode_getblk(inode,7,create);
292 return block_getblk(inode, bh, block, create);
293 }
294 block -= 512;
295 bh = inode_getblk(inode,8,create);
296 bh = block_getblk(inode, bh, block>>9, create);
297 return block_getblk(inode, bh, block & 511, create);
298 }
299
300 struct buffer_head * minix_bread(struct inode * inode, int block, int create)
301 {
302 struct buffer_head * bh;
303
304 bh = minix_getblk(inode,block,create);
305 if (!bh || bh->b_uptodate)
306 return bh;
307 ll_rw_block(READ, 1, &bh);
308 wait_on_buffer(bh);
309 if (bh->b_uptodate)
310 return bh;
311 brelse(bh);
312 return NULL;
313 }
314
315 void minix_read_inode(struct inode * inode)
316 {
317 struct buffer_head * bh;
318 struct minix_inode * raw_inode;
319 int block, ino;
320
321 ino = inode->i_ino;
322 inode->i_op = NULL;
323 inode->i_mode = 0;
324 if (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
325 printk("Bad inode number on dev 0x%04x: %d is out of range\n",
326 inode->i_dev, ino);
327 return;
328 }
329 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
330 inode->i_sb->u.minix_sb.s_zmap_blocks +
331 (ino-1)/MINIX_INODES_PER_BLOCK;
332 if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
333 printk("Major problem: unable to read inode from dev 0x%04x\n",
334 inode->i_dev);
335 return;
336 }
337 raw_inode = ((struct minix_inode *) bh->b_data) +
338 (ino-1)%MINIX_INODES_PER_BLOCK;
339 inode->i_mode = raw_inode->i_mode;
340 inode->i_uid = raw_inode->i_uid;
341 inode->i_gid = raw_inode->i_gid;
342 inode->i_nlink = raw_inode->i_nlinks;
343 inode->i_size = raw_inode->i_size;
344 inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
345 inode->i_blocks = inode->i_blksize = 0;
346 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
347 inode->i_rdev = raw_inode->i_zone[0];
348 else for (block = 0; block < 9; block++)
349 inode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
350 brelse(bh);
351 if (S_ISREG(inode->i_mode))
352 inode->i_op = &minix_file_inode_operations;
353 else if (S_ISDIR(inode->i_mode))
354 inode->i_op = &minix_dir_inode_operations;
355 else if (S_ISLNK(inode->i_mode))
356 inode->i_op = &minix_symlink_inode_operations;
357 else if (S_ISCHR(inode->i_mode))
358 inode->i_op = &chrdev_inode_operations;
359 else if (S_ISBLK(inode->i_mode))
360 inode->i_op = &blkdev_inode_operations;
361 else if (S_ISFIFO(inode->i_mode))
362 init_fifo(inode);
363 }
364
365 void minix_write_inode(struct inode * inode)
366 {
367 struct buffer_head * bh;
368 struct minix_inode * raw_inode;
369 int ino, block;
370
371 ino = inode->i_ino;
372 if (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
373 printk("Bad inode number on dev 0x%04x: %d is out of range\n",
374 inode->i_dev, ino);
375 inode->i_dirt = 0;
376 return;
377 }
378 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
379 (ino-1)/MINIX_INODES_PER_BLOCK;
380 if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
381 printk("unable to read i-node block\n");
382 inode->i_dirt = 0;
383 return;
384 }
385 raw_inode = ((struct minix_inode *)bh->b_data) +
386 (ino-1)%MINIX_INODES_PER_BLOCK;
387 raw_inode->i_mode = inode->i_mode;
388 raw_inode->i_uid = inode->i_uid;
389 raw_inode->i_gid = inode->i_gid;
390 raw_inode->i_nlinks = inode->i_nlink;
391 raw_inode->i_size = inode->i_size;
392 raw_inode->i_time = inode->i_mtime;
393 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
394 raw_inode->i_zone[0] = inode->i_rdev;
395 else for (block = 0; block < 9; block++)
396 raw_inode->i_zone[block] = inode->u.minix_i.i_data[block];
397 inode->i_dirt=0;
398 bh->b_dirt=1;
399 brelse(bh);
400 }
![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
![[previous]](../icons/left.png)
![[last]](../icons/n_last.png)
![[bottom]](../icons/n_bottom.png){kind=icon}