blob: 790cc0d0e970a643b7387ea964eb1e8d7fde0fcc [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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#include "minix.h"
14#include <linux/buffer_head.h>
15#include <linux/slab.h>
16#include <linux/init.h>
17#include <linux/highuid.h>
18#include <linux/vfs.h>
19
20static void minix_read_inode(struct inode * inode);
21static int minix_write_inode(struct inode * inode, int wait);
22static int minix_statfs(struct super_block *sb, struct kstatfs *buf);
23static int minix_remount (struct super_block * sb, int * flags, char * data);
24
25static void minix_delete_inode(struct inode *inode)
26{
Mark Fashehfef26652005-09-09 13:01:31 -070027 truncate_inode_pages(&inode->i_data, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 inode->i_size = 0;
29 minix_truncate(inode);
30 minix_free_inode(inode);
31}
32
33static void minix_put_super(struct super_block *sb)
34{
35 int i;
36 struct minix_sb_info *sbi = minix_sb(sb);
37
38 if (!(sb->s_flags & MS_RDONLY)) {
39 sbi->s_ms->s_state = sbi->s_mount_state;
40 mark_buffer_dirty(sbi->s_sbh);
41 }
42 for (i = 0; i < sbi->s_imap_blocks; i++)
43 brelse(sbi->s_imap[i]);
44 for (i = 0; i < sbi->s_zmap_blocks; i++)
45 brelse(sbi->s_zmap[i]);
46 brelse (sbi->s_sbh);
47 kfree(sbi->s_imap);
48 sb->s_fs_info = NULL;
49 kfree(sbi);
50
51 return;
52}
53
54static kmem_cache_t * minix_inode_cachep;
55
56static struct inode *minix_alloc_inode(struct super_block *sb)
57{
58 struct minix_inode_info *ei;
59 ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, SLAB_KERNEL);
60 if (!ei)
61 return NULL;
62 return &ei->vfs_inode;
63}
64
65static void minix_destroy_inode(struct inode *inode)
66{
67 kmem_cache_free(minix_inode_cachep, minix_i(inode));
68}
69
70static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
71{
72 struct minix_inode_info *ei = (struct minix_inode_info *) foo;
73
74 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
75 SLAB_CTOR_CONSTRUCTOR)
76 inode_init_once(&ei->vfs_inode);
77}
78
79static int init_inodecache(void)
80{
81 minix_inode_cachep = kmem_cache_create("minix_inode_cache",
82 sizeof(struct minix_inode_info),
83 0, SLAB_RECLAIM_ACCOUNT,
84 init_once, NULL);
85 if (minix_inode_cachep == NULL)
86 return -ENOMEM;
87 return 0;
88}
89
90static void destroy_inodecache(void)
91{
92 if (kmem_cache_destroy(minix_inode_cachep))
93 printk(KERN_INFO "minix_inode_cache: not all structures were freed\n");
94}
95
96static struct super_operations minix_sops = {
97 .alloc_inode = minix_alloc_inode,
98 .destroy_inode = minix_destroy_inode,
99 .read_inode = minix_read_inode,
100 .write_inode = minix_write_inode,
101 .delete_inode = minix_delete_inode,
102 .put_super = minix_put_super,
103 .statfs = minix_statfs,
104 .remount_fs = minix_remount,
105};
106
107static int minix_remount (struct super_block * sb, int * flags, char * data)
108{
109 struct minix_sb_info * sbi = minix_sb(sb);
110 struct minix_super_block * ms;
111
112 ms = sbi->s_ms;
113 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
114 return 0;
115 if (*flags & MS_RDONLY) {
116 if (ms->s_state & MINIX_VALID_FS ||
117 !(sbi->s_mount_state & MINIX_VALID_FS))
118 return 0;
119 /* Mounting a rw partition read-only. */
120 ms->s_state = sbi->s_mount_state;
121 mark_buffer_dirty(sbi->s_sbh);
122 } else {
123 /* Mount a partition which is read-only, read-write. */
124 sbi->s_mount_state = ms->s_state;
125 ms->s_state &= ~MINIX_VALID_FS;
126 mark_buffer_dirty(sbi->s_sbh);
127
128 if (!(sbi->s_mount_state & MINIX_VALID_FS))
129 printk ("MINIX-fs warning: remounting unchecked fs, "
130 "running fsck is recommended.\n");
131 else if ((sbi->s_mount_state & MINIX_ERROR_FS))
132 printk ("MINIX-fs warning: remounting fs with errors, "
133 "running fsck is recommended.\n");
134 }
135 return 0;
136}
137
138static int minix_fill_super(struct super_block *s, void *data, int silent)
139{
140 struct buffer_head *bh;
141 struct buffer_head **map;
142 struct minix_super_block *ms;
143 int i, block;
144 struct inode *root_inode;
145 struct minix_sb_info *sbi;
146
147 sbi = kmalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
148 if (!sbi)
149 return -ENOMEM;
150 s->s_fs_info = sbi;
151 memset(sbi, 0, sizeof(struct minix_sb_info));
152
153 /* N.B. These should be compile-time tests.
154 Unfortunately that is impossible. */
155 if (32 != sizeof (struct minix_inode))
156 panic("bad V1 i-node size");
157 if (64 != sizeof(struct minix2_inode))
158 panic("bad V2 i-node size");
159
160 if (!sb_set_blocksize(s, BLOCK_SIZE))
161 goto out_bad_hblock;
162
163 if (!(bh = sb_bread(s, 1)))
164 goto out_bad_sb;
165
166 ms = (struct minix_super_block *) bh->b_data;
167 sbi->s_ms = ms;
168 sbi->s_sbh = bh;
169 sbi->s_mount_state = ms->s_state;
170 sbi->s_ninodes = ms->s_ninodes;
171 sbi->s_nzones = ms->s_nzones;
172 sbi->s_imap_blocks = ms->s_imap_blocks;
173 sbi->s_zmap_blocks = ms->s_zmap_blocks;
174 sbi->s_firstdatazone = ms->s_firstdatazone;
175 sbi->s_log_zone_size = ms->s_log_zone_size;
176 sbi->s_max_size = ms->s_max_size;
177 s->s_magic = ms->s_magic;
178 if (s->s_magic == MINIX_SUPER_MAGIC) {
179 sbi->s_version = MINIX_V1;
180 sbi->s_dirsize = 16;
181 sbi->s_namelen = 14;
182 sbi->s_link_max = MINIX_LINK_MAX;
183 } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
184 sbi->s_version = MINIX_V1;
185 sbi->s_dirsize = 32;
186 sbi->s_namelen = 30;
187 sbi->s_link_max = MINIX_LINK_MAX;
188 } else if (s->s_magic == MINIX2_SUPER_MAGIC) {
189 sbi->s_version = MINIX_V2;
190 sbi->s_nzones = ms->s_zones;
191 sbi->s_dirsize = 16;
192 sbi->s_namelen = 14;
193 sbi->s_link_max = MINIX2_LINK_MAX;
194 } else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
195 sbi->s_version = MINIX_V2;
196 sbi->s_nzones = ms->s_zones;
197 sbi->s_dirsize = 32;
198 sbi->s_namelen = 30;
199 sbi->s_link_max = MINIX2_LINK_MAX;
200 } else
201 goto out_no_fs;
202
203 /*
204 * Allocate the buffer map to keep the superblock small.
205 */
206 i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
207 map = kmalloc(i, GFP_KERNEL);
208 if (!map)
209 goto out_no_map;
210 memset(map, 0, i);
211 sbi->s_imap = &map[0];
212 sbi->s_zmap = &map[sbi->s_imap_blocks];
213
214 block=2;
215 for (i=0 ; i < sbi->s_imap_blocks ; i++) {
216 if (!(sbi->s_imap[i]=sb_bread(s, block)))
217 goto out_no_bitmap;
218 block++;
219 }
220 for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
221 if (!(sbi->s_zmap[i]=sb_bread(s, block)))
222 goto out_no_bitmap;
223 block++;
224 }
225
226 minix_set_bit(0,sbi->s_imap[0]->b_data);
227 minix_set_bit(0,sbi->s_zmap[0]->b_data);
228
229 /* set up enough so that it can read an inode */
230 s->s_op = &minix_sops;
231 root_inode = iget(s, MINIX_ROOT_INO);
232 if (!root_inode || is_bad_inode(root_inode))
233 goto out_no_root;
234
235 s->s_root = d_alloc_root(root_inode);
236 if (!s->s_root)
237 goto out_iput;
238
239 if (!NO_TRUNCATE)
240 s->s_root->d_op = &minix_dentry_operations;
241
242 if (!(s->s_flags & MS_RDONLY)) {
243 ms->s_state &= ~MINIX_VALID_FS;
244 mark_buffer_dirty(bh);
245 }
246 if (!(sbi->s_mount_state & MINIX_VALID_FS))
247 printk ("MINIX-fs: mounting unchecked file system, "
248 "running fsck is recommended.\n");
249 else if (sbi->s_mount_state & MINIX_ERROR_FS)
250 printk ("MINIX-fs: mounting file system with errors, "
251 "running fsck is recommended.\n");
252 return 0;
253
254out_iput:
255 iput(root_inode);
256 goto out_freemap;
257
258out_no_root:
259 if (!silent)
260 printk("MINIX-fs: get root inode failed\n");
261 goto out_freemap;
262
263out_no_bitmap:
264 printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
265 out_freemap:
266 for (i = 0; i < sbi->s_imap_blocks; i++)
267 brelse(sbi->s_imap[i]);
268 for (i = 0; i < sbi->s_zmap_blocks; i++)
269 brelse(sbi->s_zmap[i]);
270 kfree(sbi->s_imap);
271 goto out_release;
272
273out_no_map:
274 if (!silent)
275 printk ("MINIX-fs: can't allocate map\n");
276 goto out_release;
277
278out_no_fs:
279 if (!silent)
280 printk("VFS: Can't find a Minix or Minix V2 filesystem on device "
281 "%s.\n", s->s_id);
282 out_release:
283 brelse(bh);
284 goto out;
285
286out_bad_hblock:
287 printk("MINIX-fs: blocksize too small for device.\n");
288 goto out;
289
290out_bad_sb:
291 printk("MINIX-fs: unable to read superblock\n");
292 out:
293 s->s_fs_info = NULL;
294 kfree(sbi);
295 return -EINVAL;
296}
297
298static int minix_statfs(struct super_block *sb, struct kstatfs *buf)
299{
300 struct minix_sb_info *sbi = minix_sb(sb);
301 buf->f_type = sb->s_magic;
302 buf->f_bsize = sb->s_blocksize;
303 buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
304 buf->f_bfree = minix_count_free_blocks(sbi);
305 buf->f_bavail = buf->f_bfree;
306 buf->f_files = sbi->s_ninodes;
307 buf->f_ffree = minix_count_free_inodes(sbi);
308 buf->f_namelen = sbi->s_namelen;
309 return 0;
310}
311
312static int minix_get_block(struct inode *inode, sector_t block,
313 struct buffer_head *bh_result, int create)
314{
315 if (INODE_VERSION(inode) == MINIX_V1)
316 return V1_minix_get_block(inode, block, bh_result, create);
317 else
318 return V2_minix_get_block(inode, block, bh_result, create);
319}
320
321static int minix_writepage(struct page *page, struct writeback_control *wbc)
322{
323 return block_write_full_page(page, minix_get_block, wbc);
324}
325static int minix_readpage(struct file *file, struct page *page)
326{
327 return block_read_full_page(page,minix_get_block);
328}
329static int minix_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
330{
331 return block_prepare_write(page,from,to,minix_get_block);
332}
333static sector_t minix_bmap(struct address_space *mapping, sector_t block)
334{
335 return generic_block_bmap(mapping,block,minix_get_block);
336}
337static struct address_space_operations minix_aops = {
338 .readpage = minix_readpage,
339 .writepage = minix_writepage,
340 .sync_page = block_sync_page,
341 .prepare_write = minix_prepare_write,
342 .commit_write = generic_commit_write,
343 .bmap = minix_bmap
344};
345
346static struct inode_operations minix_symlink_inode_operations = {
347 .readlink = generic_readlink,
348 .follow_link = page_follow_link_light,
349 .put_link = page_put_link,
350 .getattr = minix_getattr,
351};
352
353void minix_set_inode(struct inode *inode, dev_t rdev)
354{
355 if (S_ISREG(inode->i_mode)) {
356 inode->i_op = &minix_file_inode_operations;
357 inode->i_fop = &minix_file_operations;
358 inode->i_mapping->a_ops = &minix_aops;
359 } else if (S_ISDIR(inode->i_mode)) {
360 inode->i_op = &minix_dir_inode_operations;
361 inode->i_fop = &minix_dir_operations;
362 inode->i_mapping->a_ops = &minix_aops;
363 } else if (S_ISLNK(inode->i_mode)) {
364 inode->i_op = &minix_symlink_inode_operations;
365 inode->i_mapping->a_ops = &minix_aops;
366 } else
367 init_special_inode(inode, inode->i_mode, rdev);
368}
369
370/*
371 * The minix V1 function to read an inode.
372 */
373static void V1_minix_read_inode(struct inode * inode)
374{
375 struct buffer_head * bh;
376 struct minix_inode * raw_inode;
377 struct minix_inode_info *minix_inode = minix_i(inode);
378 int i;
379
380 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
381 if (!raw_inode) {
382 make_bad_inode(inode);
383 return;
384 }
385 inode->i_mode = raw_inode->i_mode;
386 inode->i_uid = (uid_t)raw_inode->i_uid;
387 inode->i_gid = (gid_t)raw_inode->i_gid;
388 inode->i_nlink = raw_inode->i_nlinks;
389 inode->i_size = raw_inode->i_size;
390 inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
391 inode->i_mtime.tv_nsec = 0;
392 inode->i_atime.tv_nsec = 0;
393 inode->i_ctime.tv_nsec = 0;
394 inode->i_blocks = inode->i_blksize = 0;
395 for (i = 0; i < 9; i++)
396 minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
397 minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
398 brelse(bh);
399}
400
401/*
402 * The minix V2 function to read an inode.
403 */
404static void V2_minix_read_inode(struct inode * inode)
405{
406 struct buffer_head * bh;
407 struct minix2_inode * raw_inode;
408 struct minix_inode_info *minix_inode = minix_i(inode);
409 int i;
410
411 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
412 if (!raw_inode) {
413 make_bad_inode(inode);
414 return;
415 }
416 inode->i_mode = raw_inode->i_mode;
417 inode->i_uid = (uid_t)raw_inode->i_uid;
418 inode->i_gid = (gid_t)raw_inode->i_gid;
419 inode->i_nlink = raw_inode->i_nlinks;
420 inode->i_size = raw_inode->i_size;
421 inode->i_mtime.tv_sec = raw_inode->i_mtime;
422 inode->i_atime.tv_sec = raw_inode->i_atime;
423 inode->i_ctime.tv_sec = raw_inode->i_ctime;
424 inode->i_mtime.tv_nsec = 0;
425 inode->i_atime.tv_nsec = 0;
426 inode->i_ctime.tv_nsec = 0;
427 inode->i_blocks = inode->i_blksize = 0;
428 for (i = 0; i < 10; i++)
429 minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
430 minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
431 brelse(bh);
432}
433
434/*
435 * The global function to read an inode.
436 */
437static void minix_read_inode(struct inode * inode)
438{
439 if (INODE_VERSION(inode) == MINIX_V1)
440 V1_minix_read_inode(inode);
441 else
442 V2_minix_read_inode(inode);
443}
444
445/*
446 * The minix V1 function to synchronize an inode.
447 */
448static struct buffer_head * V1_minix_update_inode(struct inode * inode)
449{
450 struct buffer_head * bh;
451 struct minix_inode * raw_inode;
452 struct minix_inode_info *minix_inode = minix_i(inode);
453 int i;
454
455 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
456 if (!raw_inode)
457 return NULL;
458 raw_inode->i_mode = inode->i_mode;
459 raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
460 raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
461 raw_inode->i_nlinks = inode->i_nlink;
462 raw_inode->i_size = inode->i_size;
463 raw_inode->i_time = inode->i_mtime.tv_sec;
464 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
465 raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
466 else for (i = 0; i < 9; i++)
467 raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
468 mark_buffer_dirty(bh);
469 return bh;
470}
471
472/*
473 * The minix V2 function to synchronize an inode.
474 */
475static struct buffer_head * V2_minix_update_inode(struct inode * inode)
476{
477 struct buffer_head * bh;
478 struct minix2_inode * raw_inode;
479 struct minix_inode_info *minix_inode = minix_i(inode);
480 int i;
481
482 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
483 if (!raw_inode)
484 return NULL;
485 raw_inode->i_mode = inode->i_mode;
486 raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
487 raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
488 raw_inode->i_nlinks = inode->i_nlink;
489 raw_inode->i_size = inode->i_size;
490 raw_inode->i_mtime = inode->i_mtime.tv_sec;
491 raw_inode->i_atime = inode->i_atime.tv_sec;
492 raw_inode->i_ctime = inode->i_ctime.tv_sec;
493 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
494 raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
495 else for (i = 0; i < 10; i++)
496 raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
497 mark_buffer_dirty(bh);
498 return bh;
499}
500
501static struct buffer_head *minix_update_inode(struct inode *inode)
502{
503 if (INODE_VERSION(inode) == MINIX_V1)
504 return V1_minix_update_inode(inode);
505 else
506 return V2_minix_update_inode(inode);
507}
508
509static int minix_write_inode(struct inode * inode, int wait)
510{
511 brelse(minix_update_inode(inode));
512 return 0;
513}
514
515int minix_sync_inode(struct inode * inode)
516{
517 int err = 0;
518 struct buffer_head *bh;
519
520 bh = minix_update_inode(inode);
521 if (bh && buffer_dirty(bh))
522 {
523 sync_dirty_buffer(bh);
524 if (buffer_req(bh) && !buffer_uptodate(bh))
525 {
526 printk ("IO error syncing minix inode [%s:%08lx]\n",
527 inode->i_sb->s_id, inode->i_ino);
528 err = -1;
529 }
530 }
531 else if (!bh)
532 err = -1;
533 brelse (bh);
534 return err;
535}
536
537int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
538{
539 generic_fillattr(dentry->d_inode, stat);
540 if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
541 stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size);
542 else
543 stat->blocks = (BLOCK_SIZE / 512) * V2_minix_blocks(stat->size);
544 stat->blksize = BLOCK_SIZE;
545 return 0;
546}
547
548/*
549 * The function that is called for file truncation.
550 */
551void minix_truncate(struct inode * inode)
552{
553 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
554 return;
555 if (INODE_VERSION(inode) == MINIX_V1)
556 V1_minix_truncate(inode);
557 else
558 V2_minix_truncate(inode);
559}
560
561static struct super_block *minix_get_sb(struct file_system_type *fs_type,
562 int flags, const char *dev_name, void *data)
563{
564 return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super);
565}
566
567static struct file_system_type minix_fs_type = {
568 .owner = THIS_MODULE,
569 .name = "minix",
570 .get_sb = minix_get_sb,
571 .kill_sb = kill_block_super,
572 .fs_flags = FS_REQUIRES_DEV,
573};
574
575static int __init init_minix_fs(void)
576{
577 int err = init_inodecache();
578 if (err)
579 goto out1;
580 err = register_filesystem(&minix_fs_type);
581 if (err)
582 goto out;
583 return 0;
584out:
585 destroy_inodecache();
586out1:
587 return err;
588}
589
590static void __exit exit_minix_fs(void)
591{
592 unregister_filesystem(&minix_fs_type);
593 destroy_inodecache();
594}
595
596module_init(init_minix_fs)
597module_exit(exit_minix_fs)
598MODULE_LICENSE("GPL");
599