Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  linux/fs/minix/inode.c
0004  *
0005  *  Copyright (C) 1991, 1992  Linus Torvalds
0006  *
0007  *  Copyright (C) 1996  Gertjan van Wingerde
0008  *  Minix V2 fs support.
0009  *
0010  *  Modified for 680x0 by Andreas Schwab
0011  *  Updated to filesystem version 3 by Daniel Aragones
0012  */
0013 
0014 #include <linux/module.h>
0015 #include "minix.h"
0016 #include <linux/buffer_head.h>
0017 #include <linux/slab.h>
0018 #include <linux/init.h>
0019 #include <linux/highuid.h>
0020 #include <linux/vfs.h>
0021 #include <linux/writeback.h>
0022 
0023 static int minix_write_inode(struct inode *inode,
0024         struct writeback_control *wbc);
0025 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
0026 static int minix_remount (struct super_block * sb, int * flags, char * data);
0027 
0028 static void minix_evict_inode(struct inode *inode)
0029 {
0030     truncate_inode_pages_final(&inode->i_data);
0031     if (!inode->i_nlink) {
0032         inode->i_size = 0;
0033         minix_truncate(inode);
0034     }
0035     invalidate_inode_buffers(inode);
0036     clear_inode(inode);
0037     if (!inode->i_nlink)
0038         minix_free_inode(inode);
0039 }
0040 
0041 static void minix_put_super(struct super_block *sb)
0042 {
0043     int i;
0044     struct minix_sb_info *sbi = minix_sb(sb);
0045 
0046     if (!sb_rdonly(sb)) {
0047         if (sbi->s_version != MINIX_V3)  /* s_state is now out from V3 sb */
0048             sbi->s_ms->s_state = sbi->s_mount_state;
0049         mark_buffer_dirty(sbi->s_sbh);
0050     }
0051     for (i = 0; i < sbi->s_imap_blocks; i++)
0052         brelse(sbi->s_imap[i]);
0053     for (i = 0; i < sbi->s_zmap_blocks; i++)
0054         brelse(sbi->s_zmap[i]);
0055     brelse (sbi->s_sbh);
0056     kfree(sbi->s_imap);
0057     sb->s_fs_info = NULL;
0058     kfree(sbi);
0059 }
0060 
0061 static struct kmem_cache * minix_inode_cachep;
0062 
0063 static struct inode *minix_alloc_inode(struct super_block *sb)
0064 {
0065     struct minix_inode_info *ei;
0066     ei = alloc_inode_sb(sb, minix_inode_cachep, GFP_KERNEL);
0067     if (!ei)
0068         return NULL;
0069     return &ei->vfs_inode;
0070 }
0071 
0072 static void minix_free_in_core_inode(struct inode *inode)
0073 {
0074     kmem_cache_free(minix_inode_cachep, minix_i(inode));
0075 }
0076 
0077 static void init_once(void *foo)
0078 {
0079     struct minix_inode_info *ei = (struct minix_inode_info *) foo;
0080 
0081     inode_init_once(&ei->vfs_inode);
0082 }
0083 
0084 static int __init init_inodecache(void)
0085 {
0086     minix_inode_cachep = kmem_cache_create("minix_inode_cache",
0087                          sizeof(struct minix_inode_info),
0088                          0, (SLAB_RECLAIM_ACCOUNT|
0089                         SLAB_MEM_SPREAD|SLAB_ACCOUNT),
0090                          init_once);
0091     if (minix_inode_cachep == NULL)
0092         return -ENOMEM;
0093     return 0;
0094 }
0095 
0096 static void destroy_inodecache(void)
0097 {
0098     /*
0099      * Make sure all delayed rcu free inodes are flushed before we
0100      * destroy cache.
0101      */
0102     rcu_barrier();
0103     kmem_cache_destroy(minix_inode_cachep);
0104 }
0105 
0106 static const struct super_operations minix_sops = {
0107     .alloc_inode    = minix_alloc_inode,
0108     .free_inode = minix_free_in_core_inode,
0109     .write_inode    = minix_write_inode,
0110     .evict_inode    = minix_evict_inode,
0111     .put_super  = minix_put_super,
0112     .statfs     = minix_statfs,
0113     .remount_fs = minix_remount,
0114 };
0115 
0116 static int minix_remount (struct super_block * sb, int * flags, char * data)
0117 {
0118     struct minix_sb_info * sbi = minix_sb(sb);
0119     struct minix_super_block * ms;
0120 
0121     sync_filesystem(sb);
0122     ms = sbi->s_ms;
0123     if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
0124         return 0;
0125     if (*flags & SB_RDONLY) {
0126         if (ms->s_state & MINIX_VALID_FS ||
0127             !(sbi->s_mount_state & MINIX_VALID_FS))
0128             return 0;
0129         /* Mounting a rw partition read-only. */
0130         if (sbi->s_version != MINIX_V3)
0131             ms->s_state = sbi->s_mount_state;
0132         mark_buffer_dirty(sbi->s_sbh);
0133     } else {
0134         /* Mount a partition which is read-only, read-write. */
0135         if (sbi->s_version != MINIX_V3) {
0136             sbi->s_mount_state = ms->s_state;
0137             ms->s_state &= ~MINIX_VALID_FS;
0138         } else {
0139             sbi->s_mount_state = MINIX_VALID_FS;
0140         }
0141         mark_buffer_dirty(sbi->s_sbh);
0142 
0143         if (!(sbi->s_mount_state & MINIX_VALID_FS))
0144             printk("MINIX-fs warning: remounting unchecked fs, "
0145                 "running fsck is recommended\n");
0146         else if ((sbi->s_mount_state & MINIX_ERROR_FS))
0147             printk("MINIX-fs warning: remounting fs with errors, "
0148                 "running fsck is recommended\n");
0149     }
0150     return 0;
0151 }
0152 
0153 static bool minix_check_superblock(struct super_block *sb)
0154 {
0155     struct minix_sb_info *sbi = minix_sb(sb);
0156 
0157     if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
0158         return false;
0159 
0160     /*
0161      * s_max_size must not exceed the block mapping limitation.  This check
0162      * is only needed for V1 filesystems, since V2/V3 support an extra level
0163      * of indirect blocks which places the limit well above U32_MAX.
0164      */
0165     if (sbi->s_version == MINIX_V1 &&
0166         sb->s_maxbytes > (7 + 512 + 512*512) * BLOCK_SIZE)
0167         return false;
0168 
0169     return true;
0170 }
0171 
0172 static int minix_fill_super(struct super_block *s, void *data, int silent)
0173 {
0174     struct buffer_head *bh;
0175     struct buffer_head **map;
0176     struct minix_super_block *ms;
0177     struct minix3_super_block *m3s = NULL;
0178     unsigned long i, block;
0179     struct inode *root_inode;
0180     struct minix_sb_info *sbi;
0181     int ret = -EINVAL;
0182 
0183     sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
0184     if (!sbi)
0185         return -ENOMEM;
0186     s->s_fs_info = sbi;
0187 
0188     BUILD_BUG_ON(32 != sizeof (struct minix_inode));
0189     BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
0190 
0191     if (!sb_set_blocksize(s, BLOCK_SIZE))
0192         goto out_bad_hblock;
0193 
0194     if (!(bh = sb_bread(s, 1)))
0195         goto out_bad_sb;
0196 
0197     ms = (struct minix_super_block *) bh->b_data;
0198     sbi->s_ms = ms;
0199     sbi->s_sbh = bh;
0200     sbi->s_mount_state = ms->s_state;
0201     sbi->s_ninodes = ms->s_ninodes;
0202     sbi->s_nzones = ms->s_nzones;
0203     sbi->s_imap_blocks = ms->s_imap_blocks;
0204     sbi->s_zmap_blocks = ms->s_zmap_blocks;
0205     sbi->s_firstdatazone = ms->s_firstdatazone;
0206     sbi->s_log_zone_size = ms->s_log_zone_size;
0207     s->s_maxbytes = ms->s_max_size;
0208     s->s_magic = ms->s_magic;
0209     if (s->s_magic == MINIX_SUPER_MAGIC) {
0210         sbi->s_version = MINIX_V1;
0211         sbi->s_dirsize = 16;
0212         sbi->s_namelen = 14;
0213         s->s_max_links = MINIX_LINK_MAX;
0214     } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
0215         sbi->s_version = MINIX_V1;
0216         sbi->s_dirsize = 32;
0217         sbi->s_namelen = 30;
0218         s->s_max_links = MINIX_LINK_MAX;
0219     } else if (s->s_magic == MINIX2_SUPER_MAGIC) {
0220         sbi->s_version = MINIX_V2;
0221         sbi->s_nzones = ms->s_zones;
0222         sbi->s_dirsize = 16;
0223         sbi->s_namelen = 14;
0224         s->s_max_links = MINIX2_LINK_MAX;
0225     } else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
0226         sbi->s_version = MINIX_V2;
0227         sbi->s_nzones = ms->s_zones;
0228         sbi->s_dirsize = 32;
0229         sbi->s_namelen = 30;
0230         s->s_max_links = MINIX2_LINK_MAX;
0231     } else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
0232         m3s = (struct minix3_super_block *) bh->b_data;
0233         s->s_magic = m3s->s_magic;
0234         sbi->s_imap_blocks = m3s->s_imap_blocks;
0235         sbi->s_zmap_blocks = m3s->s_zmap_blocks;
0236         sbi->s_firstdatazone = m3s->s_firstdatazone;
0237         sbi->s_log_zone_size = m3s->s_log_zone_size;
0238         s->s_maxbytes = m3s->s_max_size;
0239         sbi->s_ninodes = m3s->s_ninodes;
0240         sbi->s_nzones = m3s->s_zones;
0241         sbi->s_dirsize = 64;
0242         sbi->s_namelen = 60;
0243         sbi->s_version = MINIX_V3;
0244         sbi->s_mount_state = MINIX_VALID_FS;
0245         sb_set_blocksize(s, m3s->s_blocksize);
0246         s->s_max_links = MINIX2_LINK_MAX;
0247     } else
0248         goto out_no_fs;
0249 
0250     if (!minix_check_superblock(s))
0251         goto out_illegal_sb;
0252 
0253     /*
0254      * Allocate the buffer map to keep the superblock small.
0255      */
0256     i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
0257     map = kzalloc(i, GFP_KERNEL);
0258     if (!map)
0259         goto out_no_map;
0260     sbi->s_imap = &map[0];
0261     sbi->s_zmap = &map[sbi->s_imap_blocks];
0262 
0263     block=2;
0264     for (i=0 ; i < sbi->s_imap_blocks ; i++) {
0265         if (!(sbi->s_imap[i]=sb_bread(s, block)))
0266             goto out_no_bitmap;
0267         block++;
0268     }
0269     for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
0270         if (!(sbi->s_zmap[i]=sb_bread(s, block)))
0271             goto out_no_bitmap;
0272         block++;
0273     }
0274 
0275     minix_set_bit(0,sbi->s_imap[0]->b_data);
0276     minix_set_bit(0,sbi->s_zmap[0]->b_data);
0277 
0278     /* Apparently minix can create filesystems that allocate more blocks for
0279      * the bitmaps than needed.  We simply ignore that, but verify it didn't
0280      * create one with not enough blocks and bail out if so.
0281      */
0282     block = minix_blocks_needed(sbi->s_ninodes, s->s_blocksize);
0283     if (sbi->s_imap_blocks < block) {
0284         printk("MINIX-fs: file system does not have enough "
0285                 "imap blocks allocated.  Refusing to mount.\n");
0286         goto out_no_bitmap;
0287     }
0288 
0289     block = minix_blocks_needed(
0290             (sbi->s_nzones - sbi->s_firstdatazone + 1),
0291             s->s_blocksize);
0292     if (sbi->s_zmap_blocks < block) {
0293         printk("MINIX-fs: file system does not have enough "
0294                 "zmap blocks allocated.  Refusing to mount.\n");
0295         goto out_no_bitmap;
0296     }
0297 
0298     /* set up enough so that it can read an inode */
0299     s->s_op = &minix_sops;
0300     s->s_time_min = 0;
0301     s->s_time_max = U32_MAX;
0302     root_inode = minix_iget(s, MINIX_ROOT_INO);
0303     if (IS_ERR(root_inode)) {
0304         ret = PTR_ERR(root_inode);
0305         goto out_no_root;
0306     }
0307 
0308     ret = -ENOMEM;
0309     s->s_root = d_make_root(root_inode);
0310     if (!s->s_root)
0311         goto out_no_root;
0312 
0313     if (!sb_rdonly(s)) {
0314         if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
0315             ms->s_state &= ~MINIX_VALID_FS;
0316         mark_buffer_dirty(bh);
0317     }
0318     if (!(sbi->s_mount_state & MINIX_VALID_FS))
0319         printk("MINIX-fs: mounting unchecked file system, "
0320             "running fsck is recommended\n");
0321     else if (sbi->s_mount_state & MINIX_ERROR_FS)
0322         printk("MINIX-fs: mounting file system with errors, "
0323             "running fsck is recommended\n");
0324 
0325     return 0;
0326 
0327 out_no_root:
0328     if (!silent)
0329         printk("MINIX-fs: get root inode failed\n");
0330     goto out_freemap;
0331 
0332 out_no_bitmap:
0333     printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
0334 out_freemap:
0335     for (i = 0; i < sbi->s_imap_blocks; i++)
0336         brelse(sbi->s_imap[i]);
0337     for (i = 0; i < sbi->s_zmap_blocks; i++)
0338         brelse(sbi->s_zmap[i]);
0339     kfree(sbi->s_imap);
0340     goto out_release;
0341 
0342 out_no_map:
0343     ret = -ENOMEM;
0344     if (!silent)
0345         printk("MINIX-fs: can't allocate map\n");
0346     goto out_release;
0347 
0348 out_illegal_sb:
0349     if (!silent)
0350         printk("MINIX-fs: bad superblock\n");
0351     goto out_release;
0352 
0353 out_no_fs:
0354     if (!silent)
0355         printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
0356                "on device %s.\n", s->s_id);
0357 out_release:
0358     brelse(bh);
0359     goto out;
0360 
0361 out_bad_hblock:
0362     printk("MINIX-fs: blocksize too small for device\n");
0363     goto out;
0364 
0365 out_bad_sb:
0366     printk("MINIX-fs: unable to read superblock\n");
0367 out:
0368     s->s_fs_info = NULL;
0369     kfree(sbi);
0370     return ret;
0371 }
0372 
0373 static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
0374 {
0375     struct super_block *sb = dentry->d_sb;
0376     struct minix_sb_info *sbi = minix_sb(sb);
0377     u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
0378     buf->f_type = sb->s_magic;
0379     buf->f_bsize = sb->s_blocksize;
0380     buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
0381     buf->f_bfree = minix_count_free_blocks(sb);
0382     buf->f_bavail = buf->f_bfree;
0383     buf->f_files = sbi->s_ninodes;
0384     buf->f_ffree = minix_count_free_inodes(sb);
0385     buf->f_namelen = sbi->s_namelen;
0386     buf->f_fsid = u64_to_fsid(id);
0387 
0388     return 0;
0389 }
0390 
0391 static int minix_get_block(struct inode *inode, sector_t block,
0392             struct buffer_head *bh_result, int create)
0393 {
0394     if (INODE_VERSION(inode) == MINIX_V1)
0395         return V1_minix_get_block(inode, block, bh_result, create);
0396     else
0397         return V2_minix_get_block(inode, block, bh_result, create);
0398 }
0399 
0400 static int minix_writepage(struct page *page, struct writeback_control *wbc)
0401 {
0402     return block_write_full_page(page, minix_get_block, wbc);
0403 }
0404 
0405 static int minix_read_folio(struct file *file, struct folio *folio)
0406 {
0407     return block_read_full_folio(folio, minix_get_block);
0408 }
0409 
0410 int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
0411 {
0412     return __block_write_begin(page, pos, len, minix_get_block);
0413 }
0414 
0415 static void minix_write_failed(struct address_space *mapping, loff_t to)
0416 {
0417     struct inode *inode = mapping->host;
0418 
0419     if (to > inode->i_size) {
0420         truncate_pagecache(inode, inode->i_size);
0421         minix_truncate(inode);
0422     }
0423 }
0424 
0425 static int minix_write_begin(struct file *file, struct address_space *mapping,
0426             loff_t pos, unsigned len,
0427             struct page **pagep, void **fsdata)
0428 {
0429     int ret;
0430 
0431     ret = block_write_begin(mapping, pos, len, pagep, minix_get_block);
0432     if (unlikely(ret))
0433         minix_write_failed(mapping, pos + len);
0434 
0435     return ret;
0436 }
0437 
0438 static sector_t minix_bmap(struct address_space *mapping, sector_t block)
0439 {
0440     return generic_block_bmap(mapping,block,minix_get_block);
0441 }
0442 
0443 static const struct address_space_operations minix_aops = {
0444     .dirty_folio    = block_dirty_folio,
0445     .invalidate_folio = block_invalidate_folio,
0446     .read_folio = minix_read_folio,
0447     .writepage = minix_writepage,
0448     .write_begin = minix_write_begin,
0449     .write_end = generic_write_end,
0450     .bmap = minix_bmap,
0451     .direct_IO = noop_direct_IO
0452 };
0453 
0454 static const struct inode_operations minix_symlink_inode_operations = {
0455     .get_link   = page_get_link,
0456     .getattr    = minix_getattr,
0457 };
0458 
0459 void minix_set_inode(struct inode *inode, dev_t rdev)
0460 {
0461     if (S_ISREG(inode->i_mode)) {
0462         inode->i_op = &minix_file_inode_operations;
0463         inode->i_fop = &minix_file_operations;
0464         inode->i_mapping->a_ops = &minix_aops;
0465     } else if (S_ISDIR(inode->i_mode)) {
0466         inode->i_op = &minix_dir_inode_operations;
0467         inode->i_fop = &minix_dir_operations;
0468         inode->i_mapping->a_ops = &minix_aops;
0469     } else if (S_ISLNK(inode->i_mode)) {
0470         inode->i_op = &minix_symlink_inode_operations;
0471         inode_nohighmem(inode);
0472         inode->i_mapping->a_ops = &minix_aops;
0473     } else
0474         init_special_inode(inode, inode->i_mode, rdev);
0475 }
0476 
0477 /*
0478  * The minix V1 function to read an inode.
0479  */
0480 static struct inode *V1_minix_iget(struct inode *inode)
0481 {
0482     struct buffer_head * bh;
0483     struct minix_inode * raw_inode;
0484     struct minix_inode_info *minix_inode = minix_i(inode);
0485     int i;
0486 
0487     raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
0488     if (!raw_inode) {
0489         iget_failed(inode);
0490         return ERR_PTR(-EIO);
0491     }
0492     if (raw_inode->i_nlinks == 0) {
0493         printk("MINIX-fs: deleted inode referenced: %lu\n",
0494                inode->i_ino);
0495         brelse(bh);
0496         iget_failed(inode);
0497         return ERR_PTR(-ESTALE);
0498     }
0499     inode->i_mode = raw_inode->i_mode;
0500     i_uid_write(inode, raw_inode->i_uid);
0501     i_gid_write(inode, raw_inode->i_gid);
0502     set_nlink(inode, raw_inode->i_nlinks);
0503     inode->i_size = raw_inode->i_size;
0504     inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
0505     inode->i_mtime.tv_nsec = 0;
0506     inode->i_atime.tv_nsec = 0;
0507     inode->i_ctime.tv_nsec = 0;
0508     inode->i_blocks = 0;
0509     for (i = 0; i < 9; i++)
0510         minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
0511     minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
0512     brelse(bh);
0513     unlock_new_inode(inode);
0514     return inode;
0515 }
0516 
0517 /*
0518  * The minix V2 function to read an inode.
0519  */
0520 static struct inode *V2_minix_iget(struct inode *inode)
0521 {
0522     struct buffer_head * bh;
0523     struct minix2_inode * raw_inode;
0524     struct minix_inode_info *minix_inode = minix_i(inode);
0525     int i;
0526 
0527     raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
0528     if (!raw_inode) {
0529         iget_failed(inode);
0530         return ERR_PTR(-EIO);
0531     }
0532     if (raw_inode->i_nlinks == 0) {
0533         printk("MINIX-fs: deleted inode referenced: %lu\n",
0534                inode->i_ino);
0535         brelse(bh);
0536         iget_failed(inode);
0537         return ERR_PTR(-ESTALE);
0538     }
0539     inode->i_mode = raw_inode->i_mode;
0540     i_uid_write(inode, raw_inode->i_uid);
0541     i_gid_write(inode, raw_inode->i_gid);
0542     set_nlink(inode, raw_inode->i_nlinks);
0543     inode->i_size = raw_inode->i_size;
0544     inode->i_mtime.tv_sec = raw_inode->i_mtime;
0545     inode->i_atime.tv_sec = raw_inode->i_atime;
0546     inode->i_ctime.tv_sec = raw_inode->i_ctime;
0547     inode->i_mtime.tv_nsec = 0;
0548     inode->i_atime.tv_nsec = 0;
0549     inode->i_ctime.tv_nsec = 0;
0550     inode->i_blocks = 0;
0551     for (i = 0; i < 10; i++)
0552         minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
0553     minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
0554     brelse(bh);
0555     unlock_new_inode(inode);
0556     return inode;
0557 }
0558 
0559 /*
0560  * The global function to read an inode.
0561  */
0562 struct inode *minix_iget(struct super_block *sb, unsigned long ino)
0563 {
0564     struct inode *inode;
0565 
0566     inode = iget_locked(sb, ino);
0567     if (!inode)
0568         return ERR_PTR(-ENOMEM);
0569     if (!(inode->i_state & I_NEW))
0570         return inode;
0571 
0572     if (INODE_VERSION(inode) == MINIX_V1)
0573         return V1_minix_iget(inode);
0574     else
0575         return V2_minix_iget(inode);
0576 }
0577 
0578 /*
0579  * The minix V1 function to synchronize an inode.
0580  */
0581 static struct buffer_head * V1_minix_update_inode(struct inode * inode)
0582 {
0583     struct buffer_head * bh;
0584     struct minix_inode * raw_inode;
0585     struct minix_inode_info *minix_inode = minix_i(inode);
0586     int i;
0587 
0588     raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
0589     if (!raw_inode)
0590         return NULL;
0591     raw_inode->i_mode = inode->i_mode;
0592     raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
0593     raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
0594     raw_inode->i_nlinks = inode->i_nlink;
0595     raw_inode->i_size = inode->i_size;
0596     raw_inode->i_time = inode->i_mtime.tv_sec;
0597     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
0598         raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
0599     else for (i = 0; i < 9; i++)
0600         raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
0601     mark_buffer_dirty(bh);
0602     return bh;
0603 }
0604 
0605 /*
0606  * The minix V2 function to synchronize an inode.
0607  */
0608 static struct buffer_head * V2_minix_update_inode(struct inode * inode)
0609 {
0610     struct buffer_head * bh;
0611     struct minix2_inode * raw_inode;
0612     struct minix_inode_info *minix_inode = minix_i(inode);
0613     int i;
0614 
0615     raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
0616     if (!raw_inode)
0617         return NULL;
0618     raw_inode->i_mode = inode->i_mode;
0619     raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
0620     raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
0621     raw_inode->i_nlinks = inode->i_nlink;
0622     raw_inode->i_size = inode->i_size;
0623     raw_inode->i_mtime = inode->i_mtime.tv_sec;
0624     raw_inode->i_atime = inode->i_atime.tv_sec;
0625     raw_inode->i_ctime = inode->i_ctime.tv_sec;
0626     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
0627         raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
0628     else for (i = 0; i < 10; i++)
0629         raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
0630     mark_buffer_dirty(bh);
0631     return bh;
0632 }
0633 
0634 static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
0635 {
0636     int err = 0;
0637     struct buffer_head *bh;
0638 
0639     if (INODE_VERSION(inode) == MINIX_V1)
0640         bh = V1_minix_update_inode(inode);
0641     else
0642         bh = V2_minix_update_inode(inode);
0643     if (!bh)
0644         return -EIO;
0645     if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
0646         sync_dirty_buffer(bh);
0647         if (buffer_req(bh) && !buffer_uptodate(bh)) {
0648             printk("IO error syncing minix inode [%s:%08lx]\n",
0649                 inode->i_sb->s_id, inode->i_ino);
0650             err = -EIO;
0651         }
0652     }
0653     brelse (bh);
0654     return err;
0655 }
0656 
0657 int minix_getattr(struct user_namespace *mnt_userns, const struct path *path,
0658           struct kstat *stat, u32 request_mask, unsigned int flags)
0659 {
0660     struct super_block *sb = path->dentry->d_sb;
0661     struct inode *inode = d_inode(path->dentry);
0662 
0663     generic_fillattr(&init_user_ns, inode, stat);
0664     if (INODE_VERSION(inode) == MINIX_V1)
0665         stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
0666     else
0667         stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
0668     stat->blksize = sb->s_blocksize;
0669     return 0;
0670 }
0671 
0672 /*
0673  * The function that is called for file truncation.
0674  */
0675 void minix_truncate(struct inode * inode)
0676 {
0677     if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
0678         return;
0679     if (INODE_VERSION(inode) == MINIX_V1)
0680         V1_minix_truncate(inode);
0681     else
0682         V2_minix_truncate(inode);
0683 }
0684 
0685 static struct dentry *minix_mount(struct file_system_type *fs_type,
0686     int flags, const char *dev_name, void *data)
0687 {
0688     return mount_bdev(fs_type, flags, dev_name, data, minix_fill_super);
0689 }
0690 
0691 static struct file_system_type minix_fs_type = {
0692     .owner      = THIS_MODULE,
0693     .name       = "minix",
0694     .mount      = minix_mount,
0695     .kill_sb    = kill_block_super,
0696     .fs_flags   = FS_REQUIRES_DEV,
0697 };
0698 MODULE_ALIAS_FS("minix");
0699 
0700 static int __init init_minix_fs(void)
0701 {
0702     int err = init_inodecache();
0703     if (err)
0704         goto out1;
0705     err = register_filesystem(&minix_fs_type);
0706     if (err)
0707         goto out;
0708     return 0;
0709 out:
0710     destroy_inodecache();
0711 out1:
0712     return err;
0713 }
0714 
0715 static void __exit exit_minix_fs(void)
0716 {
0717         unregister_filesystem(&minix_fs_type);
0718     destroy_inodecache();
0719 }
0720 
0721 module_init(init_minix_fs)
0722 module_exit(exit_minix_fs)
0723 MODULE_LICENSE("GPL");
0724
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!