1 /*
2 * linux/fs/minix/inode.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * Copyright (C) 1996 Gertjan van Wingerde (gertjan@cs.vu.nl)
7 * Minix V2 fs support.
8 *
9 * Modified for 680x0 by Andreas Schwab
10 */
11
12 #include <linux/module.h>
13
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/mm.h>
17 #include <linux/malloc.h>
18 #include <linux/string.h>
19 #include <linux/stat.h>
20 #include <linux/locks.h>
21 #include <linux/init.h>
22 #include <linux/smp_lock.h>
23 #include <linux/highuid.h>
24
25 #include <asm/system.h>
26 #include <asm/bitops.h>
27
28 #include <linux/minix_fs.h>
29
30 static void minix_read_inode(struct inode * inode);
31 static void minix_write_inode(struct inode * inode, int wait);
32 static int minix_statfs(struct super_block *sb, struct statfs *buf);
33 static int minix_remount (struct super_block * sb, int * flags, char * data);
34
35 static void minix_delete_inode(struct inode *inode)
36 {
37 lock_kernel();
38
39 inode->i_size = 0;
40 minix_truncate(inode);
41 minix_free_inode(inode);
42
43 unlock_kernel();
44 }
45
46 static void minix_commit_super(struct super_block * sb)
47 {
48 mark_buffer_dirty(sb->u.minix_sb.s_sbh);
49 sb->s_dirt = 0;
50 }
51
52 static void minix_write_super(struct super_block * sb)
53 {
54 struct minix_super_block * ms;
55
56 if (!(sb->s_flags & MS_RDONLY)) {
57 ms = sb->u.minix_sb.s_ms;
58
59 if (ms->s_state & MINIX_VALID_FS)
60 ms->s_state &= ~MINIX_VALID_FS;
61 minix_commit_super(sb);
62 }
63 sb->s_dirt = 0;
64 }
65
66
67 static void minix_put_super(struct super_block *sb)
68 {
69 int i;
70
71 if (!(sb->s_flags & MS_RDONLY)) {
72 sb->u.minix_sb.s_ms->s_state = sb->u.minix_sb.s_mount_state;
73 mark_buffer_dirty(sb->u.minix_sb.s_sbh);
74 }
75 for (i = 0; i < sb->u.minix_sb.s_imap_blocks; i++)
76 brelse(sb->u.minix_sb.s_imap[i]);
77 for (i = 0; i < sb->u.minix_sb.s_zmap_blocks; i++)
78 brelse(sb->u.minix_sb.s_zmap[i]);
79 brelse (sb->u.minix_sb.s_sbh);
80 kfree(sb->u.minix_sb.s_imap);
81
82 return;
83 }
84
85 static struct super_operations minix_sops = {
86 read_inode: minix_read_inode,
87 write_inode: minix_write_inode,
88 delete_inode: minix_delete_inode,
89 put_super: minix_put_super,
90 write_super: minix_write_super,
91 statfs: minix_statfs,
92 remount_fs: minix_remount,
93 };
94
95 static int minix_remount (struct super_block * sb, int * flags, char * data)
96 {
97 struct minix_super_block * ms;
98
99 ms = sb->u.minix_sb.s_ms;
100 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
101 return 0;
102 if (*flags & MS_RDONLY) {
103 if (ms->s_state & MINIX_VALID_FS ||
104 !(sb->u.minix_sb.s_mount_state & MINIX_VALID_FS))
105 return 0;
106 /* Mounting a rw partition read-only. */
107 ms->s_state = sb->u.minix_sb.s_mount_state;
108 mark_buffer_dirty(sb->u.minix_sb.s_sbh);
109 sb->s_dirt = 1;
110 minix_commit_super(sb);
111 }
112 else {
113 /* Mount a partition which is read-only, read-write. */
114 sb->u.minix_sb.s_mount_state = ms->s_state;
115 ms->s_state &= ~MINIX_VALID_FS;
116 mark_buffer_dirty(sb->u.minix_sb.s_sbh);
117 sb->s_dirt = 1;
118
119 if (!(sb->u.minix_sb.s_mount_state & MINIX_VALID_FS))
120 printk ("MINIX-fs warning: remounting unchecked fs, "
121 "running fsck is recommended.\n");
122 else if ((sb->u.minix_sb.s_mount_state & MINIX_ERROR_FS))
123 printk ("MINIX-fs warning: remounting fs with errors, "
124 "running fsck is recommended.\n");
125 }
126 return 0;
127 }
128
129 /*
130 * Check the root directory of the filesystem to make sure
131 * it really _is_ a Minix filesystem, and to check the size
132 * of the directory entry.
133 */
134 static const char * minix_checkroot(struct super_block *s, struct inode *dir)
135 {
136 struct buffer_head *bh;
137 struct minix_dir_entry *de;
138 const char * errmsg;
139 int dirsize;
140
141 if (!S_ISDIR(dir->i_mode))
142 return "root directory is not a directory";
143
144 bh = minix_bread(dir, 0, 0);
145 if (!bh)
146 return "unable to read root directory";
147
148 de = (struct minix_dir_entry *) bh->b_data;
149 errmsg = "bad root directory '.' entry";
150 dirsize = BLOCK_SIZE;
151 if (de->inode == MINIX_ROOT_INO && strcmp(de->name, ".") == 0) {
152 errmsg = "bad root directory '..' entry";
153 dirsize = 8;
154 }
155
156 while ((dirsize <<= 1) < BLOCK_SIZE) {
157 de = (struct minix_dir_entry *) (bh->b_data + dirsize);
158 if (de->inode != MINIX_ROOT_INO)
159 continue;
160 if (strcmp(de->name, ".."))
161 continue;
162 s->u.minix_sb.s_dirsize = dirsize;
163 s->u.minix_sb.s_namelen = dirsize - 2;
164 errmsg = NULL;
165 break;
166 }
167 brelse(bh);
168 return errmsg;
169 }
170
171 static struct super_block *minix_read_super(struct super_block *s, void *data,
172 int silent)
173 {
174 struct buffer_head *bh;
175 struct buffer_head **map;
176 struct minix_super_block *ms;
177 int i, block;
178 kdev_t dev = s->s_dev;
179 const char * errmsg;
180 struct inode *root_inode;
181 unsigned int hblock;
182
183 /* N.B. These should be compile-time tests.
184 Unfortunately that is impossible. */
185 if (32 != sizeof (struct minix_inode))
186 panic("bad V1 i-node size");
187 if (64 != sizeof(struct minix2_inode))
188 panic("bad V2 i-node size");
189
190 hblock = get_hardblocksize(dev);
191 if (hblock && hblock > BLOCK_SIZE)
192 goto out_bad_hblock;
193
194 set_blocksize(dev, BLOCK_SIZE);
195 if (!(bh = bread(dev,1,BLOCK_SIZE)))
196 goto out_bad_sb;
197
198 ms = (struct minix_super_block *) bh->b_data;
199 s->u.minix_sb.s_ms = ms;
200 s->u.minix_sb.s_sbh = bh;
201 s->u.minix_sb.s_mount_state = ms->s_state;
202 s->s_blocksize = BLOCK_SIZE;
203 s->s_blocksize_bits = BLOCK_SIZE_BITS;
204 s->u.minix_sb.s_ninodes = ms->s_ninodes;
205 s->u.minix_sb.s_nzones = ms->s_nzones;
206 s->u.minix_sb.s_imap_blocks = ms->s_imap_blocks;
207 s->u.minix_sb.s_zmap_blocks = ms->s_zmap_blocks;
208 s->u.minix_sb.s_firstdatazone = ms->s_firstdatazone;
209 s->u.minix_sb.s_log_zone_size = ms->s_log_zone_size;
210 s->u.minix_sb.s_max_size = ms->s_max_size;
211 s->s_magic = ms->s_magic;
212 if (s->s_magic == MINIX_SUPER_MAGIC) {
213 s->u.minix_sb.s_version = MINIX_V1;
214 s->u.minix_sb.s_dirsize = 16;
215 s->u.minix_sb.s_namelen = 14;
216 s->u.minix_sb.s_link_max = MINIX_LINK_MAX;
217 } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
218 s->u.minix_sb.s_version = MINIX_V1;
219 s->u.minix_sb.s_dirsize = 32;
220 s->u.minix_sb.s_namelen = 30;
221 s->u.minix_sb.s_link_max = MINIX_LINK_MAX;
222 } else if (s->s_magic == MINIX2_SUPER_MAGIC) {
223 s->u.minix_sb.s_version = MINIX_V2;
224 s->u.minix_sb.s_nzones = ms->s_zones;
225 s->u.minix_sb.s_dirsize = 16;
226 s->u.minix_sb.s_namelen = 14;
227 s->u.minix_sb.s_link_max = MINIX2_LINK_MAX;
228 } else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
229 s->u.minix_sb.s_version = MINIX_V2;
230 s->u.minix_sb.s_nzones = ms->s_zones;
231 s->u.minix_sb.s_dirsize = 32;
232 s->u.minix_sb.s_namelen = 30;
233 s->u.minix_sb.s_link_max = MINIX2_LINK_MAX;
234 } else
235 goto out_no_fs;
236
237 /*
238 * Allocate the buffer map to keep the superblock small.
239 */
240 i = (s->u.minix_sb.s_imap_blocks + s->u.minix_sb.s_zmap_blocks) * sizeof(bh);
241 map = kmalloc(i, GFP_KERNEL);
242 if (!map)
243 goto out_no_map;
244 memset(map, 0, i);
245 s->u.minix_sb.s_imap = &map[0];
246 s->u.minix_sb.s_zmap = &map[s->u.minix_sb.s_imap_blocks];
247
248 block=2;
249 for (i=0 ; i < s->u.minix_sb.s_imap_blocks ; i++) {
250 if (!(s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)))
251 goto out_no_bitmap;
252 block++;
253 }
254 for (i=0 ; i < s->u.minix_sb.s_zmap_blocks ; i++) {
255 if (!(s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)))
256 goto out_no_bitmap;
257 block++;
258 }
259
260 minix_set_bit(0,s->u.minix_sb.s_imap[0]->b_data);
261 minix_set_bit(0,s->u.minix_sb.s_zmap[0]->b_data);
262 /* set up enough so that it can read an inode */
263 s->s_op = &minix_sops;
264 root_inode = iget(s, MINIX_ROOT_INO);
265 if (!root_inode)
266 goto out_no_root;
267 /*
268 * Check the fs before we get the root dentry ...
269 */
270 errmsg = minix_checkroot(s, root_inode);
271 if (errmsg)
272 goto out_bad_root;
273
274 s->s_root = d_alloc_root(root_inode);
275 if (!s->s_root)
276 goto out_iput;
277
278 s->s_root->d_op = &minix_dentry_operations;
279
280 if (!(s->s_flags & MS_RDONLY)) {
281 ms->s_state &= ~MINIX_VALID_FS;
282 mark_buffer_dirty(bh);
283 s->s_dirt = 1;
284 }
285 if (!(s->u.minix_sb.s_mount_state & MINIX_VALID_FS))
286 printk ("MINIX-fs: mounting unchecked file system, "
287 "running fsck is recommended.\n");
288 else if (s->u.minix_sb.s_mount_state & MINIX_ERROR_FS)
289 printk ("MINIX-fs: mounting file system with errors, "
290 "running fsck is recommended.\n");
291 return s;
292
293 out_bad_root:
294 if (!silent)
295 printk("MINIX-fs: %s\n", errmsg);
296 out_iput:
297 iput(root_inode);
298 goto out_freemap;
299
300 out_no_root:
301 if (!silent)
302 printk("MINIX-fs: get root inode failed\n");
303 goto out_freemap;
304
305 out_no_bitmap:
306 printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
307 out_freemap:
308 for (i = 0; i < s->u.minix_sb.s_imap_blocks; i++)
309 brelse(s->u.minix_sb.s_imap[i]);
310 for (i = 0; i < s->u.minix_sb.s_zmap_blocks; i++)
311 brelse(s->u.minix_sb.s_zmap[i]);
312 kfree(s->u.minix_sb.s_imap);
313 goto out_release;
314
315 out_no_map:
316 if (!silent)
317 printk ("MINIX-fs: can't allocate map\n");
318 goto out_release;
319
320 out_no_fs:
321 if (!silent)
322 printk("VFS: Can't find a Minix or Minix V2 filesystem on device "
323 "%s.\n", kdevname(dev));
324 out_release:
325 brelse(bh);
326 goto out;
327
328 out_bad_hblock:
329 printk("MINIX-fs: blocksize too small for device.\n");
330 goto out;
331
332 out_bad_sb:
333 printk("MINIX-fs: unable to read superblock\n");
334 out:
335 return NULL;
336 }
337
338 static int minix_statfs(struct super_block *sb, struct statfs *buf)
339 {
340 buf->f_type = sb->s_magic;
341 buf->f_bsize = sb->s_blocksize;
342 buf->f_blocks = (sb->u.minix_sb.s_nzones - sb->u.minix_sb.s_firstdatazone) << sb->u.minix_sb.s_log_zone_size;
343 buf->f_bfree = minix_count_free_blocks(sb);
344 buf->f_bavail = buf->f_bfree;
345 buf->f_files = sb->u.minix_sb.s_ninodes;
346 buf->f_ffree = minix_count_free_inodes(sb);
347 buf->f_namelen = sb->u.minix_sb.s_namelen;
348 return 0;
349 }
350
351 static int minix_get_block(struct inode *inode, long block,
352 struct buffer_head *bh_result, int create)
353 {
354 if (INODE_VERSION(inode) == MINIX_V1)
355 return V1_minix_get_block(inode, block, bh_result, create);
356 else
357 return V2_minix_get_block(inode, block, bh_result, create);
358 }
359
360 /*
361 * the global minix fs getblk function.
362 */
363 struct buffer_head *minix_getblk(struct inode *inode, int block, int create)
364 {
365 struct buffer_head dummy;
366 int error;
367
368 dummy.b_state = 0;
369 dummy.b_blocknr = -1000;
370 error = minix_get_block(inode, block, &dummy, create);
371 if (!error && buffer_mapped(&dummy)) {
372 struct buffer_head *bh;
373 bh = getblk(dummy.b_dev, dummy.b_blocknr, BLOCK_SIZE);
374 if (buffer_new(&dummy)) {
375 memset(bh->b_data, 0, BLOCK_SIZE);
376 mark_buffer_uptodate(bh, 1);
377 mark_buffer_dirty(bh);
378 }
379 return bh;
380 }
381 return NULL;
382 }
383
384 struct buffer_head * minix_bread(struct inode * inode, int block, int create)
385 {
386 struct buffer_head * bh;
387
388 bh = minix_getblk(inode, block, create);
389 if (!bh || buffer_uptodate(bh))
390 return bh;
391 ll_rw_block(READ, 1, &bh);
392 wait_on_buffer(bh);
393 if (buffer_uptodate(bh))
394 return bh;
395 brelse(bh);
396 return NULL;
397 }
398
399 static int minix_writepage(struct page *page)
400 {
401 return block_write_full_page(page,minix_get_block);
402 }
403 static int minix_readpage(struct file *file, struct page *page)
404 {
405 return block_read_full_page(page,minix_get_block);
406 }
407 static int minix_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
408 {
409 return block_prepare_write(page,from,to,minix_get_block);
410 }
411 static int minix_bmap(struct address_space *mapping, long block)
412 {
413 return generic_block_bmap(mapping,block,minix_get_block);
414 }
415 struct address_space_operations minix_aops = {
416 readpage: minix_readpage,
417 writepage: minix_writepage,
418 sync_page: block_sync_page,
419 prepare_write: minix_prepare_write,
420 commit_write: generic_commit_write,
421 bmap: minix_bmap
422 };
423
424 /*
425 * The minix V1 function to read an inode.
426 */
427 static void V1_minix_read_inode(struct inode * inode)
428 {
429 struct buffer_head * bh;
430 struct minix_inode * raw_inode;
431 int block, ino;
432
433 ino = inode->i_ino;
434 inode->i_mode = 0;
435 if (!ino || ino > inode->i_sb->u.minix_sb.s_ninodes) {
436 printk("Bad inode number on dev %s"
437 ": %d is out of range\n",
438 kdevname(inode->i_dev), ino);
439 return;
440 }
441 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
442 inode->i_sb->u.minix_sb.s_zmap_blocks +
443 (ino-1)/MINIX_INODES_PER_BLOCK;
444 if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
445 printk("Major problem: unable to read inode from dev "
446 "%s\n", kdevname(inode->i_dev));
447 return;
448 }
449 raw_inode = ((struct minix_inode *) bh->b_data) +
450 (ino-1)%MINIX_INODES_PER_BLOCK;
451 inode->i_mode = raw_inode->i_mode;
452 inode->i_uid = (uid_t)raw_inode->i_uid;
453 inode->i_gid = (gid_t)raw_inode->i_gid;
454 inode->i_nlink = raw_inode->i_nlinks;
455 inode->i_size = raw_inode->i_size;
456 inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
457 inode->i_blocks = inode->i_blksize = 0;
458 for (block = 0; block < 9; block++)
459 inode->u.minix_i.u.i1_data[block] = raw_inode->i_zone[block];
460 if (S_ISREG(inode->i_mode)) {
461 inode->i_op = &minix_file_inode_operations;
462 inode->i_fop = &minix_file_operations;
463 inode->i_mapping->a_ops = &minix_aops;
464 } else if (S_ISDIR(inode->i_mode)) {
465 inode->i_op = &minix_dir_inode_operations;
466 inode->i_fop = &minix_dir_operations;
467 } else if (S_ISLNK(inode->i_mode)) {
468 inode->i_op = &page_symlink_inode_operations;
469 inode->i_mapping->a_ops = &minix_aops;
470 } else
471 init_special_inode(inode, inode->i_mode, raw_inode->i_zone[0]);
472 brelse(bh);
473 }
474
475 /*
476 * The minix V2 function to read an inode.
477 */
478 static void V2_minix_read_inode(struct inode * inode)
479 {
480 struct buffer_head * bh;
481 struct minix2_inode * raw_inode;
482 int block, ino;
483
484 ino = inode->i_ino;
485 inode->i_mode = 0;
486 if (!ino || ino > inode->i_sb->u.minix_sb.s_ninodes) {
487 printk("Bad inode number on dev %s"
488 ": %d is out of range\n",
489 kdevname(inode->i_dev), ino);
490 return;
491 }
492 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
493 inode->i_sb->u.minix_sb.s_zmap_blocks +
494 (ino-1)/MINIX2_INODES_PER_BLOCK;
495 if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
496 printk("Major problem: unable to read inode from dev "
497 "%s\n", kdevname(inode->i_dev));
498 return;
499 }
500 raw_inode = ((struct minix2_inode *) bh->b_data) +
501 (ino-1)%MINIX2_INODES_PER_BLOCK;
502 inode->i_mode = raw_inode->i_mode;
503 inode->i_uid = (uid_t)raw_inode->i_uid;
504 inode->i_gid = (gid_t)raw_inode->i_gid;
505 inode->i_nlink = raw_inode->i_nlinks;
506 inode->i_size = raw_inode->i_size;
507 inode->i_mtime = raw_inode->i_mtime;
508 inode->i_atime = raw_inode->i_atime;
509 inode->i_ctime = raw_inode->i_ctime;
510 inode->i_blocks = inode->i_blksize = 0;
511 for (block = 0; block < 10; block++)
512 inode->u.minix_i.u.i2_data[block] = raw_inode->i_zone[block];
513 if (S_ISREG(inode->i_mode)) {
514 inode->i_op = &minix_file_inode_operations;
515 inode->i_fop = &minix_file_operations;
516 inode->i_mapping->a_ops = &minix_aops;
517 } else if (S_ISDIR(inode->i_mode)) {
518 inode->i_op = &minix_dir_inode_operations;
519 inode->i_fop = &minix_dir_operations;
520 } else if (S_ISLNK(inode->i_mode)) {
521 inode->i_op = &page_symlink_inode_operations;
522 inode->i_mapping->a_ops = &minix_aops;
523 } else
524 init_special_inode(inode, inode->i_mode, raw_inode->i_zone[0]);
525 brelse(bh);
526 }
527
528 /*
529 * The global function to read an inode.
530 */
531 static void minix_read_inode(struct inode * inode)
532 {
533 if (INODE_VERSION(inode) == MINIX_V1)
534 V1_minix_read_inode(inode);
535 else
536 V2_minix_read_inode(inode);
537 }
538
539 /*
540 * The minix V1 function to synchronize an inode.
541 */
542 static struct buffer_head * V1_minix_update_inode(struct inode * inode)
543 {
544 struct buffer_head * bh;
545 struct minix_inode * raw_inode;
546 int ino, block;
547
548 ino = inode->i_ino;
549 if (!ino || ino > inode->i_sb->u.minix_sb.s_ninodes) {
550 printk("Bad inode number on dev %s"
551 ": %d is out of range\n",
552 kdevname(inode->i_dev), ino);
553 return 0;
554 }
555 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
556 (ino-1)/MINIX_INODES_PER_BLOCK;
557 if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
558 printk("unable to read i-node block\n");
559 return 0;
560 }
561 raw_inode = ((struct minix_inode *)bh->b_data) +
562 (ino-1)%MINIX_INODES_PER_BLOCK;
563 raw_inode->i_mode = inode->i_mode;
564 raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
565 raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
566 raw_inode->i_nlinks = inode->i_nlink;
567 raw_inode->i_size = inode->i_size;
568 raw_inode->i_time = inode->i_mtime;
569 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
570 raw_inode->i_zone[0] = kdev_t_to_nr(inode->i_rdev);
571 else for (block = 0; block < 9; block++)
572 raw_inode->i_zone[block] = inode->u.minix_i.u.i1_data[block];
573 mark_buffer_dirty(bh);
574 return bh;
575 }
576
577 /*
578 * The minix V2 function to synchronize an inode.
579 */
580 static struct buffer_head * V2_minix_update_inode(struct inode * inode)
581 {
582 struct buffer_head * bh;
583 struct minix2_inode * raw_inode;
584 int ino, block;
585
586 ino = inode->i_ino;
587 if (!ino || ino > inode->i_sb->u.minix_sb.s_ninodes) {
588 printk("Bad inode number on dev %s"
589 ": %d is out of range\n",
590 kdevname(inode->i_dev), ino);
591 return 0;
592 }
593 block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
594 (ino-1)/MINIX2_INODES_PER_BLOCK;
595 if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
596 printk("unable to read i-node block\n");
597 return 0;
598 }
599 raw_inode = ((struct minix2_inode *)bh->b_data) +
600 (ino-1)%MINIX2_INODES_PER_BLOCK;
601 raw_inode->i_mode = inode->i_mode;
602 raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
603 raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
604 raw_inode->i_nlinks = inode->i_nlink;
605 raw_inode->i_size = inode->i_size;
606 raw_inode->i_mtime = inode->i_mtime;
607 raw_inode->i_atime = inode->i_atime;
608 raw_inode->i_ctime = inode->i_ctime;
609 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
610 raw_inode->i_zone[0] = kdev_t_to_nr(inode->i_rdev);
611 else for (block = 0; block < 10; block++)
612 raw_inode->i_zone[block] = inode->u.minix_i.u.i2_data[block];
613 mark_buffer_dirty(bh);
614 return bh;
615 }
616
617 static struct buffer_head *minix_update_inode(struct inode *inode)
618 {
619 if (INODE_VERSION(inode) == MINIX_V1)
620 return V1_minix_update_inode(inode);
621 else
622 return V2_minix_update_inode(inode);
623 }
624
625 static void minix_write_inode(struct inode * inode, int wait)
626 {
627 struct buffer_head *bh;
628
629 lock_kernel();
630 bh = minix_update_inode(inode);
631 unlock_kernel();
632 brelse(bh);
633 }
634
635 int minix_sync_inode(struct inode * inode)
636 {
637 int err = 0;
638 struct buffer_head *bh;
639
640 bh = minix_update_inode(inode);
641 if (bh && buffer_dirty(bh))
642 {
643 ll_rw_block(WRITE, 1, &bh);
644 wait_on_buffer(bh);
645 if (buffer_req(bh) && !buffer_uptodate(bh))
646 {
647 printk ("IO error syncing minix inode ["
648 "%s:%08lx]\n",
649 kdevname(inode->i_dev), inode->i_ino);
650 err = -1;
651 }
652 }
653 else if (!bh)
654 err = -1;
655 brelse (bh);
656 return err;
657 }
658
659 /*
660 * The function that is called for file truncation.
661 */
662 void minix_truncate(struct inode * inode)
663 {
664 if (INODE_VERSION(inode) == MINIX_V1)
665 V1_minix_truncate(inode);
666 else
667 V2_minix_truncate(inode);
668 }
669
670 static DECLARE_FSTYPE_DEV(minix_fs_type,"minix",minix_read_super);
671
672 static int __init init_minix_fs(void)
673 {
674 return register_filesystem(&minix_fs_type);
675 }
676
677 static void __exit exit_minix_fs(void)
678 {
679 unregister_filesystem(&minix_fs_type);
680 }
681
682 EXPORT_NO_SYMBOLS;
683
684 module_init(init_minix_fs)
685 module_exit(exit_minix_fs)
686
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.