fs/sysv/inode.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  linux/fs/sysv/inode.c
0004  *
0005  *  minix/inode.c
0006  *  Copyright (C) 1991, 1992  Linus Torvalds
0007  *
0008  *  xenix/inode.c
0009  *  Copyright (C) 1992  Doug Evans
0010  *
0011  *  coh/inode.c
0012  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
0013  *
0014  *  sysv/inode.c
0015  *  Copyright (C) 1993  Paul B. Monday
0016  *
0017  *  sysv/inode.c
0018  *  Copyright (C) 1993  Bruno Haible
0019  *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski
0020  *
0021  *  This file contains code for allocating/freeing inodes and for read/writing
0022  *  the superblock.
0023  */
0024
0025 #include <linux/highuid.h>
0026 #include <linux/slab.h>
0027 #include <linux/init.h>
0028 #include <linux/buffer_head.h>
0029 #include <linux/vfs.h>
0030 #include <linux/writeback.h>
0031 #include <linux/namei.h>
0032 #include <asm/byteorder.h>
0033 #include "sysv.h"
0034
0035 static int sysv_sync_fs(struct super_block *sb, int wait)
0036 {
0037     struct sysv_sb_info *sbi = SYSV_SB(sb);
0038     u32 time = (u32)ktime_get_real_seconds(), old_time;
0039
0040     mutex_lock(&sbi->s_lock);
0041
0042     /*
0043      * If we are going to write out the super block,
0044      * then attach current time stamp.
0045      * But if the filesystem was marked clean, keep it clean.
0046      */
0047     old_time = fs32_to_cpu(sbi, *sbi->s_sb_time);
0048     if (sbi->s_type == FSTYPE_SYSV4) {
0049         if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38u - old_time))
0050             *sbi->s_sb_state = cpu_to_fs32(sbi, 0x7c269d38u - time);
0051         *sbi->s_sb_time = cpu_to_fs32(sbi, time);
0052         mark_buffer_dirty(sbi->s_bh2);
0053     }
0054
0055     mutex_unlock(&sbi->s_lock);
0056
0057     return 0;
0058 }
0059
0060 static int sysv_remount(struct super_block *sb, int *flags, char *data)
0061 {
0062     struct sysv_sb_info *sbi = SYSV_SB(sb);
0063
0064     sync_filesystem(sb);
0065     if (sbi->s_forced_ro)
0066         *flags |= SB_RDONLY;
0067     return 0;
0068 }
0069
0070 static void sysv_put_super(struct super_block *sb)
0071 {
0072     struct sysv_sb_info *sbi = SYSV_SB(sb);
0073
0074     if (!sb_rdonly(sb)) {
0075         /* XXX ext2 also updates the state here */
0076         mark_buffer_dirty(sbi->s_bh1);
0077         if (sbi->s_bh1 != sbi->s_bh2)
0078             mark_buffer_dirty(sbi->s_bh2);
0079     }
0080
0081     brelse(sbi->s_bh1);
0082     if (sbi->s_bh1 != sbi->s_bh2)
0083         brelse(sbi->s_bh2);
0084
0085     kfree(sbi);
0086 }
0087
0088 static int sysv_statfs(struct dentry *dentry, struct kstatfs *buf)
0089 {
0090     struct super_block *sb = dentry->d_sb;
0091     struct sysv_sb_info *sbi = SYSV_SB(sb);
0092     u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
0093
0094     buf->f_type = sb->s_magic;
0095     buf->f_bsize = sb->s_blocksize;
0096     buf->f_blocks = sbi->s_ndatazones;
0097     buf->f_bavail = buf->f_bfree = sysv_count_free_blocks(sb);
0098     buf->f_files = sbi->s_ninodes;
0099     buf->f_ffree = sysv_count_free_inodes(sb);
0100     buf->f_namelen = SYSV_NAMELEN;
0101     buf->f_fsid = u64_to_fsid(id);
0102     return 0;
0103 }
0104
0105 /*
0106  * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
0107  */
0108 static inline void read3byte(struct sysv_sb_info *sbi,
0109     unsigned char * from, unsigned char * to)
0110 {
0111     if (sbi->s_bytesex == BYTESEX_PDP) {
0112         to[0] = from[0];
0113         to[1] = 0;
0114         to[2] = from[1];
0115         to[3] = from[2];
0116     } else if (sbi->s_bytesex == BYTESEX_LE) {
0117         to[0] = from[0];
0118         to[1] = from[1];
0119         to[2] = from[2];
0120         to[3] = 0;
0121     } else {
0122         to[0] = 0;
0123         to[1] = from[0];
0124         to[2] = from[1];
0125         to[3] = from[2];
0126     }
0127 }
0128
0129 static inline void write3byte(struct sysv_sb_info *sbi,
0130     unsigned char * from, unsigned char * to)
0131 {
0132     if (sbi->s_bytesex == BYTESEX_PDP) {
0133         to[0] = from[0];
0134         to[1] = from[2];
0135         to[2] = from[3];
0136     } else if (sbi->s_bytesex == BYTESEX_LE) {
0137         to[0] = from[0];
0138         to[1] = from[1];
0139         to[2] = from[2];
0140     } else {
0141         to[0] = from[1];
0142         to[1] = from[2];
0143         to[2] = from[3];
0144     }
0145 }
0146
0147 static const struct inode_operations sysv_symlink_inode_operations = {
0148     .get_link   = page_get_link,
0149     .getattr    = sysv_getattr,
0150 };
0151
0152 void sysv_set_inode(struct inode *inode, dev_t rdev)
0153 {
0154     if (S_ISREG(inode->i_mode)) {
0155         inode->i_op = &sysv_file_inode_operations;
0156         inode->i_fop = &sysv_file_operations;
0157         inode->i_mapping->a_ops = &sysv_aops;
0158     } else if (S_ISDIR(inode->i_mode)) {
0159         inode->i_op = &sysv_dir_inode_operations;
0160         inode->i_fop = &sysv_dir_operations;
0161         inode->i_mapping->a_ops = &sysv_aops;
0162     } else if (S_ISLNK(inode->i_mode)) {
0163         inode->i_op = &sysv_symlink_inode_operations;
0164         inode_nohighmem(inode);
0165         inode->i_mapping->a_ops = &sysv_aops;
0166     } else
0167         init_special_inode(inode, inode->i_mode, rdev);
0168 }
0169
0170 struct inode *sysv_iget(struct super_block *sb, unsigned int ino)
0171 {
0172     struct sysv_sb_info * sbi = SYSV_SB(sb);
0173     struct buffer_head * bh;
0174     struct sysv_inode * raw_inode;
0175     struct sysv_inode_info * si;
0176     struct inode *inode;
0177     unsigned int block;
0178
0179     if (!ino || ino > sbi->s_ninodes) {
0180         printk("Bad inode number on dev %s: %d is out of range\n",
0181                sb->s_id, ino);
0182         return ERR_PTR(-EIO);
0183     }
0184
0185     inode = iget_locked(sb, ino);
0186     if (!inode)
0187         return ERR_PTR(-ENOMEM);
0188     if (!(inode->i_state & I_NEW))
0189         return inode;
0190
0191     raw_inode = sysv_raw_inode(sb, ino, &bh);
0192     if (!raw_inode) {
0193         printk("Major problem: unable to read inode from dev %s\n",
0194                inode->i_sb->s_id);
0195         goto bad_inode;
0196     }
0197     /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
0198     inode->i_mode = fs16_to_cpu(sbi, raw_inode->i_mode);
0199     i_uid_write(inode, (uid_t)fs16_to_cpu(sbi, raw_inode->i_uid));
0200     i_gid_write(inode, (gid_t)fs16_to_cpu(sbi, raw_inode->i_gid));
0201     set_nlink(inode, fs16_to_cpu(sbi, raw_inode->i_nlink));
0202     inode->i_size = fs32_to_cpu(sbi, raw_inode->i_size);
0203     inode->i_atime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_atime);
0204     inode->i_mtime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_mtime);
0205     inode->i_ctime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_ctime);
0206     inode->i_ctime.tv_nsec = 0;
0207     inode->i_atime.tv_nsec = 0;
0208     inode->i_mtime.tv_nsec = 0;
0209     inode->i_blocks = 0;
0210
0211     si = SYSV_I(inode);
0212     for (block = 0; block < 10+1+1+1; block++)
0213         read3byte(sbi, &raw_inode->i_data[3*block],
0214                 (u8 *)&si->i_data[block]);
0215     brelse(bh);
0216     si->i_dir_start_lookup = 0;
0217     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
0218         sysv_set_inode(inode,
0219                    old_decode_dev(fs32_to_cpu(sbi, si->i_data[0])));
0220     else
0221         sysv_set_inode(inode, 0);
0222     unlock_new_inode(inode);
0223     return inode;
0224
0225 bad_inode:
0226     iget_failed(inode);
0227     return ERR_PTR(-EIO);
0228 }
0229
0230 static int __sysv_write_inode(struct inode *inode, int wait)
0231 {
0232     struct super_block * sb = inode->i_sb;
0233     struct sysv_sb_info * sbi = SYSV_SB(sb);
0234     struct buffer_head * bh;
0235     struct sysv_inode * raw_inode;
0236     struct sysv_inode_info * si;
0237     unsigned int ino, block;
0238     int err = 0;
0239
0240     ino = inode->i_ino;
0241     if (!ino || ino > sbi->s_ninodes) {
0242         printk("Bad inode number on dev %s: %d is out of range\n",
0243                inode->i_sb->s_id, ino);
0244         return -EIO;
0245     }
0246     raw_inode = sysv_raw_inode(sb, ino, &bh);
0247     if (!raw_inode) {
0248         printk("unable to read i-node block\n");
0249         return -EIO;
0250     }
0251
0252     raw_inode->i_mode = cpu_to_fs16(sbi, inode->i_mode);
0253     raw_inode->i_uid = cpu_to_fs16(sbi, fs_high2lowuid(i_uid_read(inode)));
0254     raw_inode->i_gid = cpu_to_fs16(sbi, fs_high2lowgid(i_gid_read(inode)));
0255     raw_inode->i_nlink = cpu_to_fs16(sbi, inode->i_nlink);
0256     raw_inode->i_size = cpu_to_fs32(sbi, inode->i_size);
0257     raw_inode->i_atime = cpu_to_fs32(sbi, inode->i_atime.tv_sec);
0258     raw_inode->i_mtime = cpu_to_fs32(sbi, inode->i_mtime.tv_sec);
0259     raw_inode->i_ctime = cpu_to_fs32(sbi, inode->i_ctime.tv_sec);
0260
0261     si = SYSV_I(inode);
0262     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
0263         si->i_data[0] = cpu_to_fs32(sbi, old_encode_dev(inode->i_rdev));
0264     for (block = 0; block < 10+1+1+1; block++)
0265         write3byte(sbi, (u8 *)&si->i_data[block],
0266             &raw_inode->i_data[3*block]);
0267     mark_buffer_dirty(bh);
0268     if (wait) {
0269                 sync_dirty_buffer(bh);
0270                 if (buffer_req(bh) && !buffer_uptodate(bh)) {
0271                         printk ("IO error syncing sysv inode [%s:%08x]\n",
0272                                 sb->s_id, ino);
0273                         err = -EIO;
0274                 }
0275         }
0276     brelse(bh);
0277     return err;
0278 }
0279
0280 int sysv_write_inode(struct inode *inode, struct writeback_control *wbc)
0281 {
0282     return __sysv_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
0283 }
0284
0285 int sysv_sync_inode(struct inode *inode)
0286 {
0287     return __sysv_write_inode(inode, 1);
0288 }
0289
0290 static void sysv_evict_inode(struct inode *inode)
0291 {
0292     truncate_inode_pages_final(&inode->i_data);
0293     if (!inode->i_nlink) {
0294         inode->i_size = 0;
0295         sysv_truncate(inode);
0296     }
0297     invalidate_inode_buffers(inode);
0298     clear_inode(inode);
0299     if (!inode->i_nlink)
0300         sysv_free_inode(inode);
0301 }
0302
0303 static struct kmem_cache *sysv_inode_cachep;
0304
0305 static struct inode *sysv_alloc_inode(struct super_block *sb)
0306 {
0307     struct sysv_inode_info *si;
0308
0309     si = alloc_inode_sb(sb, sysv_inode_cachep, GFP_KERNEL);
0310     if (!si)
0311         return NULL;
0312     return &si->vfs_inode;
0313 }
0314
0315 static void sysv_free_in_core_inode(struct inode *inode)
0316 {
0317     kmem_cache_free(sysv_inode_cachep, SYSV_I(inode));
0318 }
0319
0320 static void init_once(void *p)
0321 {
0322     struct sysv_inode_info *si = (struct sysv_inode_info *)p;
0323
0324     inode_init_once(&si->vfs_inode);
0325 }
0326
0327 const struct super_operations sysv_sops = {
0328     .alloc_inode    = sysv_alloc_inode,
0329     .free_inode = sysv_free_in_core_inode,
0330     .write_inode    = sysv_write_inode,
0331     .evict_inode    = sysv_evict_inode,
0332     .put_super  = sysv_put_super,
0333     .sync_fs    = sysv_sync_fs,
0334     .remount_fs = sysv_remount,
0335     .statfs     = sysv_statfs,
0336 };
0337
0338 int __init sysv_init_icache(void)
0339 {
0340     sysv_inode_cachep = kmem_cache_create("sysv_inode_cache",
0341             sizeof(struct sysv_inode_info), 0,
0342             SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
0343             init_once);
0344     if (!sysv_inode_cachep)
0345         return -ENOMEM;
0346     return 0;
0347 }
0348
0349 void sysv_destroy_icache(void)
0350 {
0351     /*
0352      * Make sure all delayed rcu free inodes are flushed before we
0353      * destroy cache.
0354      */
0355     rcu_barrier();
0356     kmem_cache_destroy(sysv_inode_cachep);
0357 }