Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  fs/bfs/inode.c
0004  *  BFS superblock and inode operations.
0005  *  Copyright (C) 1999-2018 Tigran Aivazian <aivazian.tigran@gmail.com>
0006  *  From fs/minix, Copyright (C) 1991, 1992 Linus Torvalds.
0007  *  Made endianness-clean by Andrew Stribblehill <ads@wompom.org>, 2005.
0008  */
0009 
0010 #include <linux/module.h>
0011 #include <linux/mm.h>
0012 #include <linux/slab.h>
0013 #include <linux/init.h>
0014 #include <linux/fs.h>
0015 #include <linux/buffer_head.h>
0016 #include <linux/vfs.h>
0017 #include <linux/writeback.h>
0018 #include <linux/uio.h>
0019 #include <linux/uaccess.h>
0020 #include "bfs.h"
0021 
0022 MODULE_AUTHOR("Tigran Aivazian <aivazian.tigran@gmail.com>");
0023 MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
0024 MODULE_LICENSE("GPL");
0025 
0026 #undef DEBUG
0027 
0028 #ifdef DEBUG
0029 #define dprintf(x...)   printf(x)
0030 #else
0031 #define dprintf(x...)
0032 #endif
0033 
0034 struct inode *bfs_iget(struct super_block *sb, unsigned long ino)
0035 {
0036     struct bfs_inode *di;
0037     struct inode *inode;
0038     struct buffer_head *bh;
0039     int block, off;
0040 
0041     inode = iget_locked(sb, ino);
0042     if (!inode)
0043         return ERR_PTR(-ENOMEM);
0044     if (!(inode->i_state & I_NEW))
0045         return inode;
0046 
0047     if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) {
0048         printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino);
0049         goto error;
0050     }
0051 
0052     block = (ino - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
0053     bh = sb_bread(inode->i_sb, block);
0054     if (!bh) {
0055         printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id,
0056                                     ino);
0057         goto error;
0058     }
0059 
0060     off = (ino - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
0061     di = (struct bfs_inode *)bh->b_data + off;
0062 
0063     inode->i_mode = 0x0000FFFF & le32_to_cpu(di->i_mode);
0064     if (le32_to_cpu(di->i_vtype) == BFS_VDIR) {
0065         inode->i_mode |= S_IFDIR;
0066         inode->i_op = &bfs_dir_inops;
0067         inode->i_fop = &bfs_dir_operations;
0068     } else if (le32_to_cpu(di->i_vtype) == BFS_VREG) {
0069         inode->i_mode |= S_IFREG;
0070         inode->i_op = &bfs_file_inops;
0071         inode->i_fop = &bfs_file_operations;
0072         inode->i_mapping->a_ops = &bfs_aops;
0073     }
0074 
0075     BFS_I(inode)->i_sblock =  le32_to_cpu(di->i_sblock);
0076     BFS_I(inode)->i_eblock =  le32_to_cpu(di->i_eblock);
0077     BFS_I(inode)->i_dsk_ino = le16_to_cpu(di->i_ino);
0078     i_uid_write(inode, le32_to_cpu(di->i_uid));
0079     i_gid_write(inode,  le32_to_cpu(di->i_gid));
0080     set_nlink(inode, le32_to_cpu(di->i_nlink));
0081     inode->i_size = BFS_FILESIZE(di);
0082     inode->i_blocks = BFS_FILEBLOCKS(di);
0083     inode->i_atime.tv_sec =  le32_to_cpu(di->i_atime);
0084     inode->i_mtime.tv_sec =  le32_to_cpu(di->i_mtime);
0085     inode->i_ctime.tv_sec =  le32_to_cpu(di->i_ctime);
0086     inode->i_atime.tv_nsec = 0;
0087     inode->i_mtime.tv_nsec = 0;
0088     inode->i_ctime.tv_nsec = 0;
0089 
0090     brelse(bh);
0091     unlock_new_inode(inode);
0092     return inode;
0093 
0094 error:
0095     iget_failed(inode);
0096     return ERR_PTR(-EIO);
0097 }
0098 
0099 static struct bfs_inode *find_inode(struct super_block *sb, u16 ino, struct buffer_head **p)
0100 {
0101     if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(sb)->si_lasti)) {
0102         printf("Bad inode number %s:%08x\n", sb->s_id, ino);
0103         return ERR_PTR(-EIO);
0104     }
0105 
0106     ino -= BFS_ROOT_INO;
0107 
0108     *p = sb_bread(sb, 1 + ino / BFS_INODES_PER_BLOCK);
0109     if (!*p) {
0110         printf("Unable to read inode %s:%08x\n", sb->s_id, ino);
0111         return ERR_PTR(-EIO);
0112     }
0113 
0114     return (struct bfs_inode *)(*p)->b_data +  ino % BFS_INODES_PER_BLOCK;
0115 }
0116 
0117 static int bfs_write_inode(struct inode *inode, struct writeback_control *wbc)
0118 {
0119     struct bfs_sb_info *info = BFS_SB(inode->i_sb);
0120     unsigned int ino = (u16)inode->i_ino;
0121     unsigned long i_sblock;
0122     struct bfs_inode *di;
0123     struct buffer_head *bh;
0124     int err = 0;
0125 
0126     dprintf("ino=%08x\n", ino);
0127 
0128     di = find_inode(inode->i_sb, ino, &bh);
0129     if (IS_ERR(di))
0130         return PTR_ERR(di);
0131 
0132     mutex_lock(&info->bfs_lock);
0133 
0134     if (ino == BFS_ROOT_INO)
0135         di->i_vtype = cpu_to_le32(BFS_VDIR);
0136     else
0137         di->i_vtype = cpu_to_le32(BFS_VREG);
0138 
0139     di->i_ino = cpu_to_le16(ino);
0140     di->i_mode = cpu_to_le32(inode->i_mode);
0141     di->i_uid = cpu_to_le32(i_uid_read(inode));
0142     di->i_gid = cpu_to_le32(i_gid_read(inode));
0143     di->i_nlink = cpu_to_le32(inode->i_nlink);
0144     di->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
0145     di->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
0146     di->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
0147     i_sblock = BFS_I(inode)->i_sblock;
0148     di->i_sblock = cpu_to_le32(i_sblock);
0149     di->i_eblock = cpu_to_le32(BFS_I(inode)->i_eblock);
0150     di->i_eoffset = cpu_to_le32(i_sblock * BFS_BSIZE + inode->i_size - 1);
0151 
0152     mark_buffer_dirty(bh);
0153     if (wbc->sync_mode == WB_SYNC_ALL) {
0154         sync_dirty_buffer(bh);
0155         if (buffer_req(bh) && !buffer_uptodate(bh))
0156             err = -EIO;
0157     }
0158     brelse(bh);
0159     mutex_unlock(&info->bfs_lock);
0160     return err;
0161 }
0162 
0163 static void bfs_evict_inode(struct inode *inode)
0164 {
0165     unsigned long ino = inode->i_ino;
0166     struct bfs_inode *di;
0167     struct buffer_head *bh;
0168     struct super_block *s = inode->i_sb;
0169     struct bfs_sb_info *info = BFS_SB(s);
0170     struct bfs_inode_info *bi = BFS_I(inode);
0171 
0172     dprintf("ino=%08lx\n", ino);
0173 
0174     truncate_inode_pages_final(&inode->i_data);
0175     invalidate_inode_buffers(inode);
0176     clear_inode(inode);
0177 
0178     if (inode->i_nlink)
0179         return;
0180 
0181     di = find_inode(s, inode->i_ino, &bh);
0182     if (IS_ERR(di))
0183         return;
0184 
0185     mutex_lock(&info->bfs_lock);
0186     /* clear on-disk inode */
0187     memset(di, 0, sizeof(struct bfs_inode));
0188     mark_buffer_dirty(bh);
0189     brelse(bh);
0190 
0191     if (bi->i_dsk_ino) {
0192         if (bi->i_sblock)
0193             info->si_freeb += bi->i_eblock + 1 - bi->i_sblock;
0194         info->si_freei++;
0195         clear_bit(ino, info->si_imap);
0196         bfs_dump_imap("evict_inode", s);
0197     }
0198 
0199     /*
0200      * If this was the last file, make the previous block
0201      * "last block of the last file" even if there is no
0202      * real file there, saves us 1 gap.
0203      */
0204     if (info->si_lf_eblk == bi->i_eblock)
0205         info->si_lf_eblk = bi->i_sblock - 1;
0206     mutex_unlock(&info->bfs_lock);
0207 }
0208 
0209 static void bfs_put_super(struct super_block *s)
0210 {
0211     struct bfs_sb_info *info = BFS_SB(s);
0212 
0213     if (!info)
0214         return;
0215 
0216     mutex_destroy(&info->bfs_lock);
0217     kfree(info);
0218     s->s_fs_info = NULL;
0219 }
0220 
0221 static int bfs_statfs(struct dentry *dentry, struct kstatfs *buf)
0222 {
0223     struct super_block *s = dentry->d_sb;
0224     struct bfs_sb_info *info = BFS_SB(s);
0225     u64 id = huge_encode_dev(s->s_bdev->bd_dev);
0226     buf->f_type = BFS_MAGIC;
0227     buf->f_bsize = s->s_blocksize;
0228     buf->f_blocks = info->si_blocks;
0229     buf->f_bfree = buf->f_bavail = info->si_freeb;
0230     buf->f_files = info->si_lasti + 1 - BFS_ROOT_INO;
0231     buf->f_ffree = info->si_freei;
0232     buf->f_fsid = u64_to_fsid(id);
0233     buf->f_namelen = BFS_NAMELEN;
0234     return 0;
0235 }
0236 
0237 static struct kmem_cache *bfs_inode_cachep;
0238 
0239 static struct inode *bfs_alloc_inode(struct super_block *sb)
0240 {
0241     struct bfs_inode_info *bi;
0242     bi = alloc_inode_sb(sb, bfs_inode_cachep, GFP_KERNEL);
0243     if (!bi)
0244         return NULL;
0245     return &bi->vfs_inode;
0246 }
0247 
0248 static void bfs_free_inode(struct inode *inode)
0249 {
0250     kmem_cache_free(bfs_inode_cachep, BFS_I(inode));
0251 }
0252 
0253 static void init_once(void *foo)
0254 {
0255     struct bfs_inode_info *bi = foo;
0256 
0257     inode_init_once(&bi->vfs_inode);
0258 }
0259 
0260 static int __init init_inodecache(void)
0261 {
0262     bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
0263                          sizeof(struct bfs_inode_info),
0264                          0, (SLAB_RECLAIM_ACCOUNT|
0265                         SLAB_MEM_SPREAD|SLAB_ACCOUNT),
0266                          init_once);
0267     if (bfs_inode_cachep == NULL)
0268         return -ENOMEM;
0269     return 0;
0270 }
0271 
0272 static void destroy_inodecache(void)
0273 {
0274     /*
0275      * Make sure all delayed rcu free inodes are flushed before we
0276      * destroy cache.
0277      */
0278     rcu_barrier();
0279     kmem_cache_destroy(bfs_inode_cachep);
0280 }
0281 
0282 static const struct super_operations bfs_sops = {
0283     .alloc_inode    = bfs_alloc_inode,
0284     .free_inode = bfs_free_inode,
0285     .write_inode    = bfs_write_inode,
0286     .evict_inode    = bfs_evict_inode,
0287     .put_super  = bfs_put_super,
0288     .statfs     = bfs_statfs,
0289 };
0290 
0291 void bfs_dump_imap(const char *prefix, struct super_block *s)
0292 {
0293 #ifdef DEBUG
0294     int i;
0295     char *tmpbuf = (char *)get_zeroed_page(GFP_KERNEL);
0296 
0297     if (!tmpbuf)
0298         return;
0299     for (i = BFS_SB(s)->si_lasti; i >= 0; i--) {
0300         if (i > PAGE_SIZE - 100) break;
0301         if (test_bit(i, BFS_SB(s)->si_imap))
0302             strcat(tmpbuf, "1");
0303         else
0304             strcat(tmpbuf, "0");
0305     }
0306     printf("%s: lasti=%08lx <%s>\n", prefix, BFS_SB(s)->si_lasti, tmpbuf);
0307     free_page((unsigned long)tmpbuf);
0308 #endif
0309 }
0310 
0311 static int bfs_fill_super(struct super_block *s, void *data, int silent)
0312 {
0313     struct buffer_head *bh, *sbh;
0314     struct bfs_super_block *bfs_sb;
0315     struct inode *inode;
0316     unsigned i;
0317     struct bfs_sb_info *info;
0318     int ret = -EINVAL;
0319     unsigned long i_sblock, i_eblock, i_eoff, s_size;
0320 
0321     info = kzalloc(sizeof(*info), GFP_KERNEL);
0322     if (!info)
0323         return -ENOMEM;
0324     mutex_init(&info->bfs_lock);
0325     s->s_fs_info = info;
0326     s->s_time_min = 0;
0327     s->s_time_max = U32_MAX;
0328 
0329     sb_set_blocksize(s, BFS_BSIZE);
0330 
0331     sbh = sb_bread(s, 0);
0332     if (!sbh)
0333         goto out;
0334     bfs_sb = (struct bfs_super_block *)sbh->b_data;
0335     if (le32_to_cpu(bfs_sb->s_magic) != BFS_MAGIC) {
0336         if (!silent)
0337             printf("No BFS filesystem on %s (magic=%08x)\n", s->s_id,  le32_to_cpu(bfs_sb->s_magic));
0338         goto out1;
0339     }
0340     if (BFS_UNCLEAN(bfs_sb, s) && !silent)
0341         printf("%s is unclean, continuing\n", s->s_id);
0342 
0343     s->s_magic = BFS_MAGIC;
0344 
0345     if (le32_to_cpu(bfs_sb->s_start) > le32_to_cpu(bfs_sb->s_end) ||
0346         le32_to_cpu(bfs_sb->s_start) < sizeof(struct bfs_super_block) + sizeof(struct bfs_dirent)) {
0347         printf("Superblock is corrupted on %s\n", s->s_id);
0348         goto out1;
0349     }
0350 
0351     info->si_lasti = (le32_to_cpu(bfs_sb->s_start) - BFS_BSIZE) / sizeof(struct bfs_inode) + BFS_ROOT_INO - 1;
0352     if (info->si_lasti == BFS_MAX_LASTI)
0353         printf("NOTE: filesystem %s was created with 512 inodes, the real maximum is 511, mounting anyway\n", s->s_id);
0354     else if (info->si_lasti > BFS_MAX_LASTI) {
0355         printf("Impossible last inode number %lu > %d on %s\n", info->si_lasti, BFS_MAX_LASTI, s->s_id);
0356         goto out1;
0357     }
0358     for (i = 0; i < BFS_ROOT_INO; i++)
0359         set_bit(i, info->si_imap);
0360 
0361     s->s_op = &bfs_sops;
0362     inode = bfs_iget(s, BFS_ROOT_INO);
0363     if (IS_ERR(inode)) {
0364         ret = PTR_ERR(inode);
0365         goto out1;
0366     }
0367     s->s_root = d_make_root(inode);
0368     if (!s->s_root) {
0369         ret = -ENOMEM;
0370         goto out1;
0371     }
0372 
0373     info->si_blocks = (le32_to_cpu(bfs_sb->s_end) + 1) >> BFS_BSIZE_BITS;
0374     info->si_freeb = (le32_to_cpu(bfs_sb->s_end) + 1 - le32_to_cpu(bfs_sb->s_start)) >> BFS_BSIZE_BITS;
0375     info->si_freei = 0;
0376     info->si_lf_eblk = 0;
0377 
0378     /* can we read the last block? */
0379     bh = sb_bread(s, info->si_blocks - 1);
0380     if (!bh) {
0381         printf("Last block not available on %s: %lu\n", s->s_id, info->si_blocks - 1);
0382         ret = -EIO;
0383         goto out2;
0384     }
0385     brelse(bh);
0386 
0387     bh = NULL;
0388     for (i = BFS_ROOT_INO; i <= info->si_lasti; i++) {
0389         struct bfs_inode *di;
0390         int block = (i - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
0391         int off = (i - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
0392         unsigned long eblock;
0393 
0394         if (!off) {
0395             brelse(bh);
0396             bh = sb_bread(s, block);
0397         }
0398 
0399         if (!bh)
0400             continue;
0401 
0402         di = (struct bfs_inode *)bh->b_data + off;
0403 
0404         /* test if filesystem is not corrupted */
0405 
0406         i_eoff = le32_to_cpu(di->i_eoffset);
0407         i_sblock = le32_to_cpu(di->i_sblock);
0408         i_eblock = le32_to_cpu(di->i_eblock);
0409         s_size = le32_to_cpu(bfs_sb->s_end);
0410 
0411         if (i_sblock > info->si_blocks ||
0412             i_eblock > info->si_blocks ||
0413             i_sblock > i_eblock ||
0414             (i_eoff != le32_to_cpu(-1) && i_eoff > s_size) ||
0415             i_sblock * BFS_BSIZE > i_eoff) {
0416 
0417             printf("Inode 0x%08x corrupted on %s\n", i, s->s_id);
0418 
0419             brelse(bh);
0420             ret = -EIO;
0421             goto out2;
0422         }
0423 
0424         if (!di->i_ino) {
0425             info->si_freei++;
0426             continue;
0427         }
0428         set_bit(i, info->si_imap);
0429         info->si_freeb -= BFS_FILEBLOCKS(di);
0430 
0431         eblock =  le32_to_cpu(di->i_eblock);
0432         if (eblock > info->si_lf_eblk)
0433             info->si_lf_eblk = eblock;
0434     }
0435     brelse(bh);
0436     brelse(sbh);
0437     bfs_dump_imap("fill_super", s);
0438     return 0;
0439 
0440 out2:
0441     dput(s->s_root);
0442     s->s_root = NULL;
0443 out1:
0444     brelse(sbh);
0445 out:
0446     mutex_destroy(&info->bfs_lock);
0447     kfree(info);
0448     s->s_fs_info = NULL;
0449     return ret;
0450 }
0451 
0452 static struct dentry *bfs_mount(struct file_system_type *fs_type,
0453     int flags, const char *dev_name, void *data)
0454 {
0455     return mount_bdev(fs_type, flags, dev_name, data, bfs_fill_super);
0456 }
0457 
0458 static struct file_system_type bfs_fs_type = {
0459     .owner      = THIS_MODULE,
0460     .name       = "bfs",
0461     .mount      = bfs_mount,
0462     .kill_sb    = kill_block_super,
0463     .fs_flags   = FS_REQUIRES_DEV,
0464 };
0465 MODULE_ALIAS_FS("bfs");
0466 
0467 static int __init init_bfs_fs(void)
0468 {
0469     int err = init_inodecache();
0470     if (err)
0471         goto out1;
0472     err = register_filesystem(&bfs_fs_type);
0473     if (err)
0474         goto out;
0475     return 0;
0476 out:
0477     destroy_inodecache();
0478 out1:
0479     return err;
0480 }
0481 
0482 static void __exit exit_bfs_fs(void)
0483 {
0484     unregister_filesystem(&bfs_fs_type);
0485     destroy_inodecache();
0486 }
0487 
0488 module_init(init_bfs_fs)
0489 module_exit(exit_bfs_fs)
[ 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!