fs/sysv/ialloc.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  linux/fs/sysv/ialloc.c
0004  *
0005  *  minix/bitmap.c
0006  *  Copyright (C) 1991, 1992  Linus Torvalds
0007  *
0008  *  ext/freelists.c
0009  *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
0010  *
0011  *  xenix/alloc.c
0012  *  Copyright (C) 1992  Doug Evans
0013  *
0014  *  coh/alloc.c
0015  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
0016  *
0017  *  sysv/ialloc.c
0018  *  Copyright (C) 1993  Bruno Haible
0019  *
0020  *  This file contains code for allocating/freeing inodes.
0021  */
0022
0023 #include <linux/kernel.h>
0024 #include <linux/stddef.h>
0025 #include <linux/sched.h>
0026 #include <linux/stat.h>
0027 #include <linux/string.h>
0028 #include <linux/buffer_head.h>
0029 #include <linux/writeback.h>
0030 #include "sysv.h"
0031
0032 /* We don't trust the value of
0033    sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
0034    but we nevertheless keep it up to date. */
0035
0036 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
0037
0038 /* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
0039 static inline sysv_ino_t *
0040 sv_sb_fic_inode(struct super_block * sb, unsigned int i)
0041 {
0042     struct sysv_sb_info *sbi = SYSV_SB(sb);
0043
0044     if (sbi->s_bh1 == sbi->s_bh2)
0045         return &sbi->s_sb_fic_inodes[i];
0046     else {
0047         /* 512 byte Xenix FS */
0048         unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
0049         if (offset < 512)
0050             return (sysv_ino_t*)(sbi->s_sbd1 + offset);
0051         else
0052             return (sysv_ino_t*)(sbi->s_sbd2 + offset);
0053     }
0054 }
0055
0056 struct sysv_inode *
0057 sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
0058 {
0059     struct sysv_sb_info *sbi = SYSV_SB(sb);
0060     struct sysv_inode *res;
0061     int block = sbi->s_firstinodezone + sbi->s_block_base;
0062
0063     block += (ino-1) >> sbi->s_inodes_per_block_bits;
0064     *bh = sb_bread(sb, block);
0065     if (!*bh)
0066         return NULL;
0067     res = (struct sysv_inode *)(*bh)->b_data;
0068     return res + ((ino-1) & sbi->s_inodes_per_block_1);
0069 }
0070
0071 static int refill_free_cache(struct super_block *sb)
0072 {
0073     struct sysv_sb_info *sbi = SYSV_SB(sb);
0074     struct buffer_head * bh;
0075     struct sysv_inode * raw_inode;
0076     int i = 0, ino;
0077
0078     ino = SYSV_ROOT_INO+1;
0079     raw_inode = sysv_raw_inode(sb, ino, &bh);
0080     if (!raw_inode)
0081         goto out;
0082     while (ino <= sbi->s_ninodes) {
0083         if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
0084             *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
0085             if (i == sbi->s_fic_size)
0086                 break;
0087         }
0088         if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
0089             brelse(bh);
0090             raw_inode = sysv_raw_inode(sb, ino, &bh);
0091             if (!raw_inode)
0092                 goto out;
0093         } else
0094             raw_inode++;
0095     }
0096     brelse(bh);
0097 out:
0098     return i;
0099 }
0100
0101 void sysv_free_inode(struct inode * inode)
0102 {
0103     struct super_block *sb = inode->i_sb;
0104     struct sysv_sb_info *sbi = SYSV_SB(sb);
0105     unsigned int ino;
0106     struct buffer_head * bh;
0107     struct sysv_inode * raw_inode;
0108     unsigned count;
0109
0110     sb = inode->i_sb;
0111     ino = inode->i_ino;
0112     if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
0113         printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
0114         return;
0115     }
0116     raw_inode = sysv_raw_inode(sb, ino, &bh);
0117     if (!raw_inode) {
0118         printk("sysv_free_inode: unable to read inode block on device "
0119                "%s\n", inode->i_sb->s_id);
0120         return;
0121     }
0122     mutex_lock(&sbi->s_lock);
0123     count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
0124     if (count < sbi->s_fic_size) {
0125         *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
0126         *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
0127     }
0128     fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
0129     dirty_sb(sb);
0130     memset(raw_inode, 0, sizeof(struct sysv_inode));
0131     mark_buffer_dirty(bh);
0132     mutex_unlock(&sbi->s_lock);
0133     brelse(bh);
0134 }
0135
0136 struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
0137 {
0138     struct super_block *sb = dir->i_sb;
0139     struct sysv_sb_info *sbi = SYSV_SB(sb);
0140     struct inode *inode;
0141     sysv_ino_t ino;
0142     unsigned count;
0143     struct writeback_control wbc = {
0144         .sync_mode = WB_SYNC_NONE
0145     };
0146
0147     inode = new_inode(sb);
0148     if (!inode)
0149         return ERR_PTR(-ENOMEM);
0150
0151     mutex_lock(&sbi->s_lock);
0152     count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
0153     if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
0154         count = refill_free_cache(sb);
0155         if (count == 0) {
0156             iput(inode);
0157             mutex_unlock(&sbi->s_lock);
0158             return ERR_PTR(-ENOSPC);
0159         }
0160     }
0161     /* Now count > 0. */
0162     ino = *sv_sb_fic_inode(sb,--count);
0163     *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
0164     fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
0165     dirty_sb(sb);
0166     inode_init_owner(&init_user_ns, inode, dir, mode);
0167     inode->i_ino = fs16_to_cpu(sbi, ino);
0168     inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
0169     inode->i_blocks = 0;
0170     memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
0171     SYSV_I(inode)->i_dir_start_lookup = 0;
0172     insert_inode_hash(inode);
0173     mark_inode_dirty(inode);
0174
0175     sysv_write_inode(inode, &wbc);  /* ensure inode not allocated again */
0176     mark_inode_dirty(inode);    /* cleared by sysv_write_inode() */
0177     /* That's it. */
0178     mutex_unlock(&sbi->s_lock);
0179     return inode;
0180 }
0181
0182 unsigned long sysv_count_free_inodes(struct super_block * sb)
0183 {
0184     struct sysv_sb_info *sbi = SYSV_SB(sb);
0185     struct buffer_head * bh;
0186     struct sysv_inode * raw_inode;
0187     int ino, count, sb_count;
0188
0189     mutex_lock(&sbi->s_lock);
0190
0191     sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);
0192
0193     if (0)
0194         goto trust_sb;
0195
0196     /* this causes a lot of disk traffic ... */
0197     count = 0;
0198     ino = SYSV_ROOT_INO+1;
0199     raw_inode = sysv_raw_inode(sb, ino, &bh);
0200     if (!raw_inode)
0201         goto Eio;
0202     while (ino <= sbi->s_ninodes) {
0203         if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
0204             count++;
0205         if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
0206             brelse(bh);
0207             raw_inode = sysv_raw_inode(sb, ino, &bh);
0208             if (!raw_inode)
0209                 goto Eio;
0210         } else
0211             raw_inode++;
0212     }
0213     brelse(bh);
0214     if (count != sb_count)
0215         goto Einval;
0216 out:
0217     mutex_unlock(&sbi->s_lock);
0218     return count;
0219
0220 Einval:
0221     printk("sysv_count_free_inodes: "
0222         "free inode count was %d, correcting to %d\n",
0223         sb_count, count);
0224     if (!sb_rdonly(sb)) {
0225         *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
0226         dirty_sb(sb);
0227     }
0228     goto out;
0229
0230 Eio:
0231     printk("sysv_count_free_inodes: unable to read inode table\n");
0232 trust_sb:
0233     count = sb_count;
0234     goto out;
0235 }