1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * linux/fs/minix/inode.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * Copyright (C) 1996 Gertjan van Wingerde
8 * Minix V2 fs support.
9 *
10 * Modified for 680x0 by Andreas Schwab
11 * Updated to filesystem version 3 by Daniel Aragones
12 */
13
14 #include <linux/module.h>
15 #include "minix.h"
16 #include <linux/buffer_head.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/highuid.h>
20 #include <linux/mpage.h>
21 #include <linux/vfs.h>
22 #include <linux/writeback.h>
23 #include <linux/fs_context.h>
24
25 static int minix_write_inode(struct inode *inode,
26 struct writeback_control *wbc);
27 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
28
__minix_error_inode(struct inode * inode,const char * function,unsigned int line,const char * fmt,...)29 void __minix_error_inode(struct inode *inode, const char *function,
30 unsigned int line, const char *fmt, ...)
31 {
32 struct va_format vaf;
33 va_list args;
34
35 va_start(args, fmt);
36 vaf.fmt = fmt;
37 vaf.va = &args;
38 printk(KERN_CRIT "minix-fs error (device %s): %s:%d: "
39 "inode #%llu: comm %s: %pV\n",
40 inode->i_sb->s_id, function, line, inode->i_ino,
41 current->comm, &vaf);
42 va_end(args);
43 }
44
minix_evict_inode(struct inode * inode)45 static void minix_evict_inode(struct inode *inode)
46 {
47 truncate_inode_pages_final(&inode->i_data);
48 if (!inode->i_nlink) {
49 inode->i_size = 0;
50 minix_truncate(inode);
51 } else {
52 mmb_sync(&minix_i(inode)->i_metadata_bhs);
53 }
54 mmb_invalidate(&minix_i(inode)->i_metadata_bhs);
55 clear_inode(inode);
56 if (!inode->i_nlink)
57 minix_free_inode(inode);
58 }
59
minix_put_super(struct super_block * sb)60 static void minix_put_super(struct super_block *sb)
61 {
62 int i;
63 struct minix_sb_info *sbi = minix_sb(sb);
64
65 if (!sb_rdonly(sb)) {
66 if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
67 sbi->s_ms->s_state = sbi->s_mount_state;
68 mark_buffer_dirty(sbi->s_sbh);
69 }
70 for (i = 0; i < sbi->s_imap_blocks; i++)
71 brelse(sbi->s_imap[i]);
72 for (i = 0; i < sbi->s_zmap_blocks; i++)
73 brelse(sbi->s_zmap[i]);
74 brelse (sbi->s_sbh);
75 kfree(sbi->s_imap);
76 sb->s_fs_info = NULL;
77 kfree(sbi);
78 }
79
80 static struct kmem_cache * minix_inode_cachep;
81
minix_alloc_inode(struct super_block * sb)82 static struct inode *minix_alloc_inode(struct super_block *sb)
83 {
84 struct minix_inode_info *ei;
85 ei = alloc_inode_sb(sb, minix_inode_cachep, GFP_KERNEL);
86 if (!ei)
87 return NULL;
88 mmb_init(&ei->i_metadata_bhs, &ei->vfs_inode.i_data);
89
90 return &ei->vfs_inode;
91 }
92
minix_free_in_core_inode(struct inode * inode)93 static void minix_free_in_core_inode(struct inode *inode)
94 {
95 kmem_cache_free(minix_inode_cachep, minix_i(inode));
96 }
97
init_once(void * foo)98 static void init_once(void *foo)
99 {
100 struct minix_inode_info *ei = (struct minix_inode_info *) foo;
101
102 inode_init_once(&ei->vfs_inode);
103 }
104
init_inodecache(void)105 static int __init init_inodecache(void)
106 {
107 minix_inode_cachep = kmem_cache_create("minix_inode_cache",
108 sizeof(struct minix_inode_info),
109 0, (SLAB_RECLAIM_ACCOUNT|
110 SLAB_ACCOUNT),
111 init_once);
112 if (minix_inode_cachep == NULL)
113 return -ENOMEM;
114 return 0;
115 }
116
destroy_inodecache(void)117 static void destroy_inodecache(void)
118 {
119 /*
120 * Make sure all delayed rcu free inodes are flushed before we
121 * destroy cache.
122 */
123 rcu_barrier();
124 kmem_cache_destroy(minix_inode_cachep);
125 }
126
127 static const struct super_operations minix_sops = {
128 .alloc_inode = minix_alloc_inode,
129 .free_inode = minix_free_in_core_inode,
130 .write_inode = minix_write_inode,
131 .evict_inode = minix_evict_inode,
132 .put_super = minix_put_super,
133 .statfs = minix_statfs,
134 };
135
minix_reconfigure(struct fs_context * fc)136 static int minix_reconfigure(struct fs_context *fc)
137 {
138 struct minix_super_block * ms;
139 struct super_block *sb = fc->root->d_sb;
140 struct minix_sb_info * sbi = sb->s_fs_info;
141
142 sync_filesystem(sb);
143 ms = sbi->s_ms;
144 if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb))
145 return 0;
146 if (fc->sb_flags & SB_RDONLY) {
147 if (ms->s_state & MINIX_VALID_FS ||
148 !(sbi->s_mount_state & MINIX_VALID_FS))
149 return 0;
150 /* Mounting a rw partition read-only. */
151 if (sbi->s_version != MINIX_V3)
152 ms->s_state = sbi->s_mount_state;
153 mark_buffer_dirty(sbi->s_sbh);
154 } else {
155 /* Mount a partition which is read-only, read-write. */
156 if (sbi->s_version != MINIX_V3) {
157 sbi->s_mount_state = ms->s_state;
158 ms->s_state &= ~MINIX_VALID_FS;
159 } else {
160 sbi->s_mount_state = MINIX_VALID_FS;
161 }
162 mark_buffer_dirty(sbi->s_sbh);
163
164 if (!(sbi->s_mount_state & MINIX_VALID_FS))
165 printk("MINIX-fs warning: remounting unchecked fs, "
166 "running fsck is recommended\n");
167 else if ((sbi->s_mount_state & MINIX_ERROR_FS))
168 printk("MINIX-fs warning: remounting fs with errors, "
169 "running fsck is recommended\n");
170 }
171 return 0;
172 }
173
minix_check_superblock(struct super_block * sb)174 static bool minix_check_superblock(struct super_block *sb)
175 {
176 struct minix_sb_info *sbi = minix_sb(sb);
177 unsigned long block;
178
179 if (sbi->s_log_zone_size != 0) {
180 printk("minix-fs error: zone size must equal block size. "
181 "s_log_zone_size > 0 is not supported.\n");
182 return false;
183 }
184
185 if (sbi->s_ninodes < 1 || sbi->s_firstdatazone <= 4 ||
186 sbi->s_firstdatazone >= sbi->s_nzones)
187 return false;
188
189 /* Apparently minix can create filesystems that allocate more blocks for
190 * the bitmaps than needed. We simply ignore that, but verify it didn't
191 * create one with not enough blocks and bail out if so.
192 */
193 block = minix_blocks_needed(sbi->s_ninodes, sb->s_blocksize);
194 if (sbi->s_imap_blocks < block) {
195 printk("MINIX-fs: file system does not have enough "
196 "imap blocks allocated. Refusing to mount.\n");
197 return false;
198 }
199
200 block = minix_blocks_needed(
201 (sbi->s_nzones - sbi->s_firstdatazone + 1),
202 sb->s_blocksize);
203 if (sbi->s_zmap_blocks < block) {
204 printk("MINIX-fs: file system does not have enough "
205 "zmap blocks allocated. Refusing to mount.\n");
206 return false;
207 }
208
209 /*
210 * s_max_size must not exceed the block mapping limitation. This check
211 * is only needed for V1 filesystems, since V2/V3 support an extra level
212 * of indirect blocks which places the limit well above U32_MAX.
213 */
214 if (sbi->s_version == MINIX_V1 &&
215 sb->s_maxbytes > (7 + 512 + 512*512) * BLOCK_SIZE)
216 return false;
217
218 return true;
219 }
220
minix_fill_super(struct super_block * s,struct fs_context * fc)221 static int minix_fill_super(struct super_block *s, struct fs_context *fc)
222 {
223 struct buffer_head *bh;
224 struct buffer_head **map;
225 struct minix_super_block *ms;
226 struct minix3_super_block *m3s = NULL;
227 unsigned long i, block;
228 struct inode *root_inode;
229 struct minix_sb_info *sbi;
230 int ret = -EINVAL;
231 int silent = fc->sb_flags & SB_SILENT;
232
233 sbi = kzalloc_obj(struct minix_sb_info);
234 if (!sbi)
235 return -ENOMEM;
236 s->s_fs_info = sbi;
237
238 BUILD_BUG_ON(32 != sizeof (struct minix_inode));
239 BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
240
241 if (!sb_set_blocksize(s, BLOCK_SIZE))
242 goto out_bad_hblock;
243
244 if (!(bh = sb_bread(s, 1)))
245 goto out_bad_sb;
246
247 ms = (struct minix_super_block *) bh->b_data;
248 sbi->s_ms = ms;
249 sbi->s_sbh = bh;
250 sbi->s_mount_state = ms->s_state;
251 sbi->s_ninodes = ms->s_ninodes;
252 sbi->s_nzones = ms->s_nzones;
253 sbi->s_imap_blocks = ms->s_imap_blocks;
254 sbi->s_zmap_blocks = ms->s_zmap_blocks;
255 sbi->s_firstdatazone = ms->s_firstdatazone;
256 sbi->s_log_zone_size = ms->s_log_zone_size;
257 s->s_maxbytes = ms->s_max_size;
258 s->s_magic = ms->s_magic;
259 if (s->s_magic == MINIX_SUPER_MAGIC) {
260 sbi->s_version = MINIX_V1;
261 sbi->s_dirsize = 16;
262 sbi->s_namelen = 14;
263 s->s_max_links = MINIX_LINK_MAX;
264 } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
265 sbi->s_version = MINIX_V1;
266 sbi->s_dirsize = 32;
267 sbi->s_namelen = 30;
268 s->s_max_links = MINIX_LINK_MAX;
269 } else if (s->s_magic == MINIX2_SUPER_MAGIC) {
270 sbi->s_version = MINIX_V2;
271 sbi->s_nzones = ms->s_zones;
272 sbi->s_dirsize = 16;
273 sbi->s_namelen = 14;
274 s->s_max_links = MINIX2_LINK_MAX;
275 } else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
276 sbi->s_version = MINIX_V2;
277 sbi->s_nzones = ms->s_zones;
278 sbi->s_dirsize = 32;
279 sbi->s_namelen = 30;
280 s->s_max_links = MINIX2_LINK_MAX;
281 } else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
282 m3s = (struct minix3_super_block *) bh->b_data;
283 s->s_magic = m3s->s_magic;
284 sbi->s_imap_blocks = m3s->s_imap_blocks;
285 sbi->s_zmap_blocks = m3s->s_zmap_blocks;
286 sbi->s_firstdatazone = m3s->s_firstdatazone;
287 sbi->s_log_zone_size = m3s->s_log_zone_size;
288 s->s_maxbytes = m3s->s_max_size;
289 sbi->s_ninodes = m3s->s_ninodes;
290 sbi->s_nzones = m3s->s_zones;
291 sbi->s_dirsize = 64;
292 sbi->s_namelen = 60;
293 sbi->s_version = MINIX_V3;
294 sbi->s_mount_state = MINIX_VALID_FS;
295 sb_set_blocksize(s, m3s->s_blocksize);
296 s->s_max_links = MINIX2_LINK_MAX;
297 } else
298 goto out_no_fs;
299
300 if (!minix_check_superblock(s))
301 goto out_illegal_sb;
302
303 /*
304 * Allocate the buffer map to keep the superblock small.
305 */
306 i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
307 map = kzalloc(i, GFP_KERNEL);
308 if (!map)
309 goto out_no_map;
310 sbi->s_imap = &map[0];
311 sbi->s_zmap = &map[sbi->s_imap_blocks];
312
313 block=2;
314 for (i=0 ; i < sbi->s_imap_blocks ; i++) {
315 if (!(sbi->s_imap[i]=sb_bread(s, block)))
316 goto out_no_bitmap;
317 block++;
318 }
319 for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
320 if (!(sbi->s_zmap[i]=sb_bread(s, block)))
321 goto out_no_bitmap;
322 block++;
323 }
324
325 minix_set_bit(0,sbi->s_imap[0]->b_data);
326 minix_set_bit(0,sbi->s_zmap[0]->b_data);
327
328 /* set up enough so that it can read an inode */
329 s->s_op = &minix_sops;
330 s->s_time_min = 0;
331 s->s_time_max = U32_MAX;
332 root_inode = minix_iget(s, MINIX_ROOT_INO);
333 if (IS_ERR(root_inode)) {
334 ret = PTR_ERR(root_inode);
335 goto out_no_root;
336 }
337
338 ret = -ENOMEM;
339 s->s_root = d_make_root(root_inode);
340 if (!s->s_root)
341 goto out_no_root;
342
343 if (!sb_rdonly(s)) {
344 if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
345 ms->s_state &= ~MINIX_VALID_FS;
346 mark_buffer_dirty(bh);
347 }
348 if (!(sbi->s_mount_state & MINIX_VALID_FS))
349 printk("MINIX-fs: mounting unchecked file system, "
350 "running fsck is recommended\n");
351 else if (sbi->s_mount_state & MINIX_ERROR_FS)
352 printk("MINIX-fs: mounting file system with errors, "
353 "running fsck is recommended\n");
354
355 return 0;
356
357 out_no_root:
358 if (!silent)
359 printk("MINIX-fs: get root inode failed\n");
360 goto out_freemap;
361
362 out_no_bitmap:
363 printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
364 out_freemap:
365 for (i = 0; i < sbi->s_imap_blocks; i++)
366 brelse(sbi->s_imap[i]);
367 for (i = 0; i < sbi->s_zmap_blocks; i++)
368 brelse(sbi->s_zmap[i]);
369 kfree(sbi->s_imap);
370 goto out_release;
371
372 out_no_map:
373 ret = -ENOMEM;
374 if (!silent)
375 printk("MINIX-fs: can't allocate map\n");
376 goto out_release;
377
378 out_illegal_sb:
379 if (!silent)
380 printk("MINIX-fs: bad superblock\n");
381 goto out_release;
382
383 out_no_fs:
384 if (!silent)
385 printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
386 "on device %s.\n", s->s_id);
387 out_release:
388 brelse(bh);
389 goto out;
390
391 out_bad_hblock:
392 printk("MINIX-fs: blocksize too small for device\n");
393 goto out;
394
395 out_bad_sb:
396 printk("MINIX-fs: unable to read superblock\n");
397 out:
398 s->s_fs_info = NULL;
399 kfree(sbi);
400 return ret;
401 }
402
minix_get_tree(struct fs_context * fc)403 static int minix_get_tree(struct fs_context *fc)
404 {
405 return get_tree_bdev(fc, minix_fill_super);
406 }
407
408 static const struct fs_context_operations minix_context_ops = {
409 .get_tree = minix_get_tree,
410 .reconfigure = minix_reconfigure,
411 };
412
minix_init_fs_context(struct fs_context * fc)413 static int minix_init_fs_context(struct fs_context *fc)
414 {
415 fc->ops = &minix_context_ops;
416
417 return 0;
418 }
419
minix_statfs(struct dentry * dentry,struct kstatfs * buf)420 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
421 {
422 struct super_block *sb = dentry->d_sb;
423 struct minix_sb_info *sbi = minix_sb(sb);
424 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
425 buf->f_type = sb->s_magic;
426 buf->f_bsize = sb->s_blocksize;
427 buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
428 buf->f_bfree = minix_count_free_blocks(sb);
429 buf->f_bavail = buf->f_bfree;
430 buf->f_files = sbi->s_ninodes;
431 buf->f_ffree = minix_count_free_inodes(sb);
432 buf->f_namelen = sbi->s_namelen;
433 buf->f_fsid = u64_to_fsid(id);
434
435 return 0;
436 }
437
minix_get_block(struct inode * inode,sector_t block,struct buffer_head * bh_result,int create)438 static int minix_get_block(struct inode *inode, sector_t block,
439 struct buffer_head *bh_result, int create)
440 {
441 if (INODE_VERSION(inode) == MINIX_V1)
442 return V1_minix_get_block(inode, block, bh_result, create);
443 else
444 return V2_minix_get_block(inode, block, bh_result, create);
445 }
446
minix_writepages(struct address_space * mapping,struct writeback_control * wbc)447 static int minix_writepages(struct address_space *mapping,
448 struct writeback_control *wbc)
449 {
450 return mpage_writepages(mapping, wbc, minix_get_block);
451 }
452
minix_read_folio(struct file * file,struct folio * folio)453 static int minix_read_folio(struct file *file, struct folio *folio)
454 {
455 return block_read_full_folio(folio, minix_get_block);
456 }
457
minix_prepare_chunk(struct folio * folio,loff_t pos,unsigned len)458 int minix_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)
459 {
460 return __block_write_begin(folio, pos, len, minix_get_block);
461 }
462
minix_write_failed(struct address_space * mapping,loff_t to)463 static void minix_write_failed(struct address_space *mapping, loff_t to)
464 {
465 struct inode *inode = mapping->host;
466
467 if (to > inode->i_size) {
468 truncate_pagecache(inode, inode->i_size);
469 minix_truncate(inode);
470 }
471 }
472
minix_write_begin(const struct kiocb * iocb,struct address_space * mapping,loff_t pos,unsigned len,struct folio ** foliop,void ** fsdata)473 static int minix_write_begin(const struct kiocb *iocb,
474 struct address_space *mapping,
475 loff_t pos, unsigned len,
476 struct folio **foliop, void **fsdata)
477 {
478 int ret;
479
480 ret = block_write_begin(mapping, pos, len, foliop, minix_get_block);
481 if (unlikely(ret))
482 minix_write_failed(mapping, pos + len);
483
484 return ret;
485 }
486
minix_bmap(struct address_space * mapping,sector_t block)487 static sector_t minix_bmap(struct address_space *mapping, sector_t block)
488 {
489 return generic_block_bmap(mapping,block,minix_get_block);
490 }
491
492 static const struct address_space_operations minix_aops = {
493 .dirty_folio = block_dirty_folio,
494 .invalidate_folio = block_invalidate_folio,
495 .read_folio = minix_read_folio,
496 .writepages = minix_writepages,
497 .write_begin = minix_write_begin,
498 .write_end = generic_write_end,
499 .migrate_folio = buffer_migrate_folio,
500 .bmap = minix_bmap,
501 .direct_IO = noop_direct_IO
502 };
503
504 static const struct inode_operations minix_symlink_inode_operations = {
505 .get_link = page_get_link,
506 .getattr = minix_getattr,
507 };
508
minix_set_inode(struct inode * inode,dev_t rdev)509 void minix_set_inode(struct inode *inode, dev_t rdev)
510 {
511 if (S_ISREG(inode->i_mode)) {
512 inode->i_op = &minix_file_inode_operations;
513 inode->i_fop = &minix_file_operations;
514 inode->i_mapping->a_ops = &minix_aops;
515 } else if (S_ISDIR(inode->i_mode)) {
516 inode->i_op = &minix_dir_inode_operations;
517 inode->i_fop = &minix_dir_operations;
518 inode->i_mapping->a_ops = &minix_aops;
519 } else if (S_ISLNK(inode->i_mode)) {
520 inode->i_op = &minix_symlink_inode_operations;
521 inode_nohighmem(inode);
522 inode->i_mapping->a_ops = &minix_aops;
523 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
524 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
525 init_special_inode(inode, inode->i_mode, rdev);
526 } else {
527 printk(KERN_DEBUG "MINIX-fs: Invalid file type 0%04o for inode %llu.\n",
528 inode->i_mode, inode->i_ino);
529 make_bad_inode(inode);
530 }
531 }
532
533 /*
534 * The minix V1 function to read an inode.
535 */
V1_minix_iget(struct inode * inode)536 static struct inode *V1_minix_iget(struct inode *inode)
537 {
538 struct buffer_head * bh;
539 struct minix_inode * raw_inode;
540 struct minix_inode_info *minix_inode = minix_i(inode);
541 int i;
542
543 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
544 if (!raw_inode) {
545 iget_failed(inode);
546 return ERR_PTR(-EIO);
547 }
548 if (raw_inode->i_nlinks == 0) {
549 printk("MINIX-fs: deleted inode referenced: %llu\n",
550 inode->i_ino);
551 brelse(bh);
552 iget_failed(inode);
553 return ERR_PTR(-ESTALE);
554 }
555 inode->i_mode = raw_inode->i_mode;
556 i_uid_write(inode, raw_inode->i_uid);
557 i_gid_write(inode, raw_inode->i_gid);
558 set_nlink(inode, raw_inode->i_nlinks);
559 inode->i_size = raw_inode->i_size;
560 inode_set_mtime_to_ts(inode,
561 inode_set_atime_to_ts(inode, inode_set_ctime(inode, raw_inode->i_time, 0)));
562 inode->i_blocks = 0;
563 for (i = 0; i < 9; i++)
564 minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
565 minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
566 brelse(bh);
567 unlock_new_inode(inode);
568 return inode;
569 }
570
571 /*
572 * The minix V2 function to read an inode.
573 */
V2_minix_iget(struct inode * inode)574 static struct inode *V2_minix_iget(struct inode *inode)
575 {
576 struct buffer_head * bh;
577 struct minix2_inode * raw_inode;
578 struct minix_inode_info *minix_inode = minix_i(inode);
579 int i;
580
581 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
582 if (!raw_inode) {
583 iget_failed(inode);
584 return ERR_PTR(-EIO);
585 }
586 if (raw_inode->i_nlinks == 0) {
587 printk("MINIX-fs: deleted inode referenced: %llu\n",
588 inode->i_ino);
589 brelse(bh);
590 iget_failed(inode);
591 return ERR_PTR(-ESTALE);
592 }
593 inode->i_mode = raw_inode->i_mode;
594 i_uid_write(inode, raw_inode->i_uid);
595 i_gid_write(inode, raw_inode->i_gid);
596 set_nlink(inode, raw_inode->i_nlinks);
597 inode->i_size = raw_inode->i_size;
598 inode_set_mtime(inode, raw_inode->i_mtime, 0);
599 inode_set_atime(inode, raw_inode->i_atime, 0);
600 inode_set_ctime(inode, raw_inode->i_ctime, 0);
601 inode->i_blocks = 0;
602 for (i = 0; i < 10; i++)
603 minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
604 minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
605 brelse(bh);
606 unlock_new_inode(inode);
607 return inode;
608 }
609
610 /*
611 * The global function to read an inode.
612 */
minix_iget(struct super_block * sb,unsigned long ino)613 struct inode *minix_iget(struct super_block *sb, unsigned long ino)
614 {
615 struct inode *inode;
616
617 inode = iget_locked(sb, ino);
618 if (!inode)
619 return ERR_PTR(-ENOMEM);
620 if (!(inode_state_read_once(inode) & I_NEW))
621 return inode;
622
623 if (INODE_VERSION(inode) == MINIX_V1)
624 return V1_minix_iget(inode);
625 else
626 return V2_minix_iget(inode);
627 }
628
629 /*
630 * The minix V1 function to synchronize an inode.
631 */
V1_minix_update_inode(struct inode * inode)632 static struct buffer_head * V1_minix_update_inode(struct inode * inode)
633 {
634 struct buffer_head * bh;
635 struct minix_inode * raw_inode;
636 struct minix_inode_info *minix_inode = minix_i(inode);
637 int i;
638
639 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
640 if (!raw_inode)
641 return NULL;
642 raw_inode->i_mode = inode->i_mode;
643 raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
644 raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
645 raw_inode->i_nlinks = inode->i_nlink;
646 raw_inode->i_size = inode->i_size;
647 raw_inode->i_time = inode_get_mtime_sec(inode);
648 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
649 raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
650 else for (i = 0; i < 9; i++)
651 raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
652 mark_buffer_dirty(bh);
653 return bh;
654 }
655
656 /*
657 * The minix V2 function to synchronize an inode.
658 */
V2_minix_update_inode(struct inode * inode)659 static struct buffer_head * V2_minix_update_inode(struct inode * inode)
660 {
661 struct buffer_head * bh;
662 struct minix2_inode * raw_inode;
663 struct minix_inode_info *minix_inode = minix_i(inode);
664 int i;
665
666 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
667 if (!raw_inode)
668 return NULL;
669 raw_inode->i_mode = inode->i_mode;
670 raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
671 raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
672 raw_inode->i_nlinks = inode->i_nlink;
673 raw_inode->i_size = inode->i_size;
674 raw_inode->i_mtime = inode_get_mtime_sec(inode);
675 raw_inode->i_atime = inode_get_atime_sec(inode);
676 raw_inode->i_ctime = inode_get_ctime_sec(inode);
677 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
678 raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
679 else for (i = 0; i < 10; i++)
680 raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
681 mark_buffer_dirty(bh);
682 return bh;
683 }
684
minix_write_inode(struct inode * inode,struct writeback_control * wbc)685 static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
686 {
687 int err = 0;
688 struct buffer_head *bh;
689
690 if (INODE_VERSION(inode) == MINIX_V1)
691 bh = V1_minix_update_inode(inode);
692 else
693 bh = V2_minix_update_inode(inode);
694 if (!bh)
695 return -EIO;
696 if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
697 sync_dirty_buffer(bh);
698 if (buffer_req(bh) && !buffer_uptodate(bh)) {
699 printk("IO error syncing minix inode [%s:%08llx]\n",
700 inode->i_sb->s_id, inode->i_ino);
701 err = -EIO;
702 }
703 }
704 brelse (bh);
705 return err;
706 }
707
minix_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)708 int minix_getattr(struct mnt_idmap *idmap, const struct path *path,
709 struct kstat *stat, u32 request_mask, unsigned int flags)
710 {
711 struct super_block *sb = path->dentry->d_sb;
712 struct inode *inode = d_inode(path->dentry);
713
714 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
715 if (INODE_VERSION(inode) == MINIX_V1)
716 stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
717 else
718 stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
719 stat->blksize = sb->s_blocksize;
720 return 0;
721 }
722
723 /*
724 * The function that is called for file truncation.
725 */
minix_truncate(struct inode * inode)726 void minix_truncate(struct inode * inode)
727 {
728 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
729 return;
730 if (INODE_VERSION(inode) == MINIX_V1)
731 V1_minix_truncate(inode);
732 else
733 V2_minix_truncate(inode);
734 }
735
736 static struct file_system_type minix_fs_type = {
737 .owner = THIS_MODULE,
738 .name = "minix",
739 .kill_sb = kill_block_super,
740 .fs_flags = FS_REQUIRES_DEV,
741 .init_fs_context = minix_init_fs_context,
742 };
743 MODULE_ALIAS_FS("minix");
744
init_minix_fs(void)745 static int __init init_minix_fs(void)
746 {
747 int err = init_inodecache();
748 if (err)
749 goto out1;
750 err = register_filesystem(&minix_fs_type);
751 if (err)
752 goto out;
753 return 0;
754 out:
755 destroy_inodecache();
756 out1:
757 return err;
758 }
759
exit_minix_fs(void)760 static void __exit exit_minix_fs(void)
761 {
762 unregister_filesystem(&minix_fs_type);
763 destroy_inodecache();
764 }
765
766 module_init(init_minix_fs)
767 module_exit(exit_minix_fs)
768 MODULE_DESCRIPTION("Minix file system");
769 MODULE_LICENSE("GPL");
770
771