linux/fs/sysv/ialloc.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/sysv/ialloc.c
   3 *
   4 *  minix/bitmap.c
   5 *  Copyright (C) 1991, 1992  Linus Torvalds
   6 *
   7 *  ext/freelists.c
   8 *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
   9 *
  10 *  xenix/alloc.c
  11 *  Copyright (C) 1992  Doug Evans
  12 *
  13 *  coh/alloc.c
  14 *  Copyright (C) 1993  Pascal Haible, Bruno Haible
  15 *
  16 *  sysv/ialloc.c
  17 *  Copyright (C) 1993  Bruno Haible
  18 *
  19 *  This file contains code for allocating/freeing inodes.
  20 */
  21
  22#include <linux/kernel.h>
  23#include <linux/stddef.h>
  24#include <linux/sched.h>
  25#include <linux/stat.h>
  26#include <linux/string.h>
  27#include <linux/buffer_head.h>
  28#include <linux/writeback.h>
  29#include "sysv.h"
  30
  31/* We don't trust the value of
  32   sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
  33   but we nevertheless keep it up to date. */
  34
  35/* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
  36
  37/* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
  38static inline sysv_ino_t *
  39sv_sb_fic_inode(struct super_block * sb, unsigned int i)
  40{
  41        struct sysv_sb_info *sbi = SYSV_SB(sb);
  42
  43        if (sbi->s_bh1 == sbi->s_bh2)
  44                return &sbi->s_sb_fic_inodes[i];
  45        else {
  46                /* 512 byte Xenix FS */
  47                unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
  48                if (offset < 512)
  49                        return (sysv_ino_t*)(sbi->s_sbd1 + offset);
  50                else
  51                        return (sysv_ino_t*)(sbi->s_sbd2 + offset);
  52        }
  53}
  54
  55struct sysv_inode *
  56sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
  57{
  58        struct sysv_sb_info *sbi = SYSV_SB(sb);
  59        struct sysv_inode *res;
  60        int block = sbi->s_firstinodezone + sbi->s_block_base;
  61
  62        block += (ino-1) >> sbi->s_inodes_per_block_bits;
  63        *bh = sb_bread(sb, block);
  64        if (!*bh)
  65                return NULL;
  66        res = (struct sysv_inode *)(*bh)->b_data;
  67        return res + ((ino-1) & sbi->s_inodes_per_block_1);
  68}
  69
  70static int refill_free_cache(struct super_block *sb)
  71{
  72        struct sysv_sb_info *sbi = SYSV_SB(sb);
  73        struct buffer_head * bh;
  74        struct sysv_inode * raw_inode;
  75        int i = 0, ino;
  76
  77        ino = SYSV_ROOT_INO+1;
  78        raw_inode = sysv_raw_inode(sb, ino, &bh);
  79        if (!raw_inode)
  80                goto out;
  81        while (ino <= sbi->s_ninodes) {
  82                if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
  83                        *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
  84                        if (i == sbi->s_fic_size)
  85                                break;
  86                }
  87                if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
  88                        brelse(bh);
  89                        raw_inode = sysv_raw_inode(sb, ino, &bh);
  90                        if (!raw_inode)
  91                                goto out;
  92                } else
  93                        raw_inode++;
  94        }
  95        brelse(bh);
  96out:
  97        return i;
  98}
  99
 100void sysv_free_inode(struct inode * inode)
 101{
 102        struct super_block *sb = inode->i_sb;
 103        struct sysv_sb_info *sbi = SYSV_SB(sb);
 104        unsigned int ino;
 105        struct buffer_head * bh;
 106        struct sysv_inode * raw_inode;
 107        unsigned count;
 108
 109        sb = inode->i_sb;
 110        ino = inode->i_ino;
 111        if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
 112                printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
 113                return;
 114        }
 115        raw_inode = sysv_raw_inode(sb, ino, &bh);
 116        if (!raw_inode) {
 117                printk("sysv_free_inode: unable to read inode block on device "
 118                       "%s\n", inode->i_sb->s_id);
 119                return;
 120        }
 121        lock_super(sb);
 122        count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
 123        if (count < sbi->s_fic_size) {
 124                *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
 125                *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
 126        }
 127        fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
 128        dirty_sb(sb);
 129        memset(raw_inode, 0, sizeof(struct sysv_inode));
 130        mark_buffer_dirty(bh);
 131        unlock_super(sb);
 132        brelse(bh);
 133}
 134
 135struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
 136{
 137        struct super_block *sb = dir->i_sb;
 138        struct sysv_sb_info *sbi = SYSV_SB(sb);
 139        struct inode *inode;
 140        sysv_ino_t ino;
 141        unsigned count;
 142        struct writeback_control wbc = {
 143                .sync_mode = WB_SYNC_NONE
 144        };
 145
 146        inode = new_inode(sb);
 147        if (!inode)
 148                return ERR_PTR(-ENOMEM);
 149
 150        lock_super(sb);
 151        count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
 152        if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
 153                count = refill_free_cache(sb);
 154                if (count == 0) {
 155                        iput(inode);
 156                        unlock_super(sb);
 157                        return ERR_PTR(-ENOSPC);
 158                }
 159        }
 160        /* Now count > 0. */
 161        ino = *sv_sb_fic_inode(sb,--count);
 162        *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
 163        fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
 164        dirty_sb(sb);
 165        inode_init_owner(inode, dir, mode);
 166        inode->i_ino = fs16_to_cpu(sbi, ino);
 167        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
 168        inode->i_blocks = 0;
 169        memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
 170        SYSV_I(inode)->i_dir_start_lookup = 0;
 171        insert_inode_hash(inode);
 172        mark_inode_dirty(inode);
 173
 174        sysv_write_inode(inode, &wbc);  /* ensure inode not allocated again */
 175        mark_inode_dirty(inode);        /* cleared by sysv_write_inode() */
 176        /* That's it. */
 177        unlock_super(sb);
 178        return inode;
 179}
 180
 181unsigned long sysv_count_free_inodes(struct super_block * sb)
 182{
 183        struct sysv_sb_info *sbi = SYSV_SB(sb);
 184        struct buffer_head * bh;
 185        struct sysv_inode * raw_inode;
 186        int ino, count, sb_count;
 187
 188        lock_super(sb);
 189
 190        sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);
 191
 192        if (0)
 193                goto trust_sb;
 194
 195        /* this causes a lot of disk traffic ... */
 196        count = 0;
 197        ino = SYSV_ROOT_INO+1;
 198        raw_inode = sysv_raw_inode(sb, ino, &bh);
 199        if (!raw_inode)
 200                goto Eio;
 201        while (ino <= sbi->s_ninodes) {
 202                if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
 203                        count++;
 204                if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
 205                        brelse(bh);
 206                        raw_inode = sysv_raw_inode(sb, ino, &bh);
 207                        if (!raw_inode)
 208                                goto Eio;
 209                } else
 210                        raw_inode++;
 211        }
 212        brelse(bh);
 213        if (count != sb_count)
 214                goto Einval;
 215out:
 216        unlock_super(sb);
 217        return count;
 218
 219Einval:
 220        printk("sysv_count_free_inodes: "
 221                "free inode count was %d, correcting to %d\n",
 222                sb_count, count);
 223        if (!(sb->s_flags & MS_RDONLY)) {
 224                *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
 225                dirty_sb(sb);
 226        }
 227        goto out;
 228
 229Eio:
 230        printk("sysv_count_free_inodes: unable to read inode table\n");
 231trust_sb:
 232        count = sb_count;
 233        goto out;
 234}
 235
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.