fs/sysv/ialloc.c

/* */
This source file includes following definitions.
sv_sb_fic_inode
sysv_free_inode
sysv_new_inode
sysv_count_free_inodes
   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 #ifdef MODULE
  23 #include <linux/module.h>
  24 #endif
  25 
  26 #include <linux/sched.h>
  27 #include <linux/kernel.h>
  28 #include <linux/fs.h>
  29 #include <linux/sysv_fs.h>
  30 #include <linux/stddef.h>
  31 #include <linux/stat.h>
  32 #include <linux/string.h>
  33 #include <linux/locks.h>
  34 
  35 /* We don't trust the value of
  36    sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
  37    but we nevertheless keep it up to date. */
  38 
  39 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
  40 
  41 /* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
  42 static inline sysv_ino_t * sv_sb_fic_inode (struct super_block * sb, unsigned int i)
     /*  */
  43 {
  44         if (sb->sv_bh1 == sb->sv_bh2)
  45                 return &sb->sv_sb_fic_inodes[i];
  46         else {
  47                 /* 512 byte Xenix FS */
  48                 unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
  49                 if (offset < 512)
  50                         return (sysv_ino_t*)(sb->sv_sbd1 + offset);
  51                 else
  52                         return (sysv_ino_t*)(sb->sv_sbd2 + offset);
  53         }
  54 }
  55 
  56 void sysv_free_inode(struct inode * inode)
     /*  */
  57 {
  58         struct super_block * sb;
  59         unsigned int ino;
  60         struct buffer_head * bh;
  61         struct sysv_inode * raw_inode;
  62 
  63         if (!inode)
  64                 return;
  65         if (!inode->i_dev) {
  66                 printk("sysv_free_inode: inode has no device\n");
  67                 return;
  68         }
  69         if (inode->i_count != 1) {
  70                 printk("sysv_free_inode: inode has count=%d\n", inode->i_count);
  71                 return;
  72         }
  73         if (inode->i_nlink) {
  74                 printk("sysv_free_inode: inode has nlink=%d\n", inode->i_nlink);
  75                 return;
  76         }
  77         if (!(sb = inode->i_sb)) {
  78                 printk("sysv_free_inode: inode on nonexistent device\n");
  79                 return;
  80         }
  81         ino = inode->i_ino;
  82         if (ino <= SYSV_ROOT_INO || ino > sb->sv_ninodes) {
  83                 printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
  84                 return;
  85         }
  86         if (!(bh = sv_bread(sb, inode->i_dev, sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits)))) {
  87                 printk("sysv_free_inode: unable to read inode block on device %d/%d\n",MAJOR(inode->i_dev),MINOR(inode->i_dev));
  88                 clear_inode(inode);
  89                 return;
  90         }
  91         raw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
  92         lock_super(sb);
  93         if (*sb->sv_sb_fic_count < sb->sv_fic_size)
  94                 *sv_sb_fic_inode(sb,(*sb->sv_sb_fic_count)++) = ino;
  95         (*sb->sv_sb_total_free_inodes)++;
  96         mark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
  97         if (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
  98         sb->s_dirt = 1; /* and needs time stamp */
  99         memset(raw_inode, 0, sizeof(struct sysv_inode));
 100         mark_buffer_dirty(bh, 1);
 101         unlock_super(sb);
 102         brelse(bh);
 103         clear_inode(inode);
 104 }
 105 
 106 struct inode * sysv_new_inode(const struct inode * dir)
     /*  */
 107 {
 108         struct inode * inode;
 109         struct super_block * sb;
 110         struct buffer_head * bh;
 111         struct sysv_inode * raw_inode;
 112         int i,j,ino,block;
 113 
 114         if (!dir || !(inode = get_empty_inode()))
 115                 return NULL;
 116         sb = dir->i_sb;
 117         inode->i_sb = sb;
 118         inode->i_flags = inode->i_sb->s_flags;
 119         lock_super(sb);         /* protect against task switches */
 120         if ((*sb->sv_sb_fic_count == 0)
 121             || (*sv_sb_fic_inode(sb,(*sb->sv_sb_fic_count)-1) == 0) /* Applies only to SystemV2 FS */
 122            ) {
 123                 /* Rebuild cache of free inodes: */
 124                 /* i : index into cache slot being filled            */
 125                 /* ino : inode we are trying                         */
 126                 /* block : firstinodezone + (ino-1)/inodes_per_block */
 127                 /* j : (ino-1)%inodes_per_block                      */
 128                 /* bh : buffer for block                             */
 129                 /* raw_inode : pointer to inode ino in the block     */
 130                 for (i = 0, ino = SYSV_ROOT_INO+1, block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; i < sb->sv_fic_size && block < sb->sv_firstdatazone ; block++, j = 0) {
 131                         if (!(bh = sv_bread(sb, sb->s_dev, block))) {
 132                                 printk("sysv_new_inode: unable to read inode table\n");
 133                                 break;  /* go with what we've got */
 134                                 /* FIXME: Perhaps try the next block? */
 135                         }
 136                         raw_inode = (struct sysv_inode *) bh->b_data + j;
 137                         for (; j < sb->sv_inodes_per_block && i < sb->sv_fic_size; ino++, j++, raw_inode++) {
 138                                 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
 139                                         *sv_sb_fic_inode(sb,i++) = ino;
 140                         }
 141                         brelse(bh);
 142                 }
 143                 if (i == 0) {
 144                         iput(inode);
 145                         unlock_super(sb);
 146                         return NULL;    /* no inodes available */
 147                 }
 148                 *sb->sv_sb_fic_count = i;
 149         }
 150         /* Now *sb->sv_sb_fic_count > 0. */
 151         ino = *sv_sb_fic_inode(sb,--(*sb->sv_sb_fic_count));
 152         mark_buffer_dirty(sb->sv_bh1, 1); /* super-block has been modified */
 153         if (sb->sv_bh1 != sb->sv_bh2) mark_buffer_dirty(sb->sv_bh2, 1);
 154         sb->s_dirt = 1; /* and needs time stamp */
 155         inode->i_count = 1;
 156         inode->i_nlink = 1;
 157         inode->i_dev = sb->s_dev;
 158         inode->i_uid = current->fsuid;
 159         inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
 160         inode->i_dirt = 1;
 161         inode->i_ino = ino;
 162         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 163         inode->i_op = NULL;
 164         inode->i_blocks = inode->i_blksize = 0;
 165         insert_inode_hash(inode);
 166         /* Change directory entry: */
 167         inode->i_mode = 0;              /* for sysv_write_inode() */
 168         inode->i_size = 0;              /* ditto */
 169         sysv_write_inode(inode);        /* ensure inode not allocated again */
 170                                         /* FIXME: caller may call this too. */
 171         inode->i_dirt = 1;              /* cleared by sysv_write_inode() */
 172         /* That's it. */
 173         (*sb->sv_sb_total_free_inodes)--;
 174         mark_buffer_dirty(sb->sv_bh2, 1); /* super-block has been modified again */
 175         sb->s_dirt = 1; /* and needs time stamp again */
 176         unlock_super(sb);
 177         return inode;
 178 }
 179 
 180 unsigned long sysv_count_free_inodes(struct super_block * sb)
     /*  */
 181 {
 182 #if 1 /* test */
 183         struct buffer_head * bh;
 184         struct sysv_inode * raw_inode;
 185         int j,block,count;
 186 
 187         /* this causes a lot of disk traffic ... */
 188         count = 0;
 189         lock_super(sb);
 190         /* i : index into cache slot being filled            */
 191         /* ino : inode we are trying                         */
 192         /* block : firstinodezone + (ino-1)/inodes_per_block */
 193         /* j : (ino-1)%inodes_per_block                      */
 194         /* bh : buffer for block                             */
 195         /* raw_inode : pointer to inode ino in the block     */
 196         for (block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; block < sb->sv_firstdatazone ; block++, j = 0) {
 197                 if (!(bh = sv_bread(sb, sb->s_dev, block))) {
 198                         printk("sysv_count_free_inodes: unable to read inode table\n");
 199                         break;  /* go with what we've got */
 200                         /* FIXME: Perhaps try the next block? */
 201                 }
 202                 raw_inode = (struct sysv_inode *) bh->b_data + j;
 203                 for (; j < sb->sv_inodes_per_block ; j++, raw_inode++)
 204                         if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
 205                                 count++;
 206                 brelse(bh);
 207         }
 208         if (count != *sb->sv_sb_total_free_inodes) {
 209                 printk("sysv_count_free_inodes: free inode count was %d, correcting to %d\n",(short)(*sb->sv_sb_total_free_inodes),count);
 210                 if (!(sb->s_flags & MS_RDONLY)) {
 211                         *sb->sv_sb_total_free_inodes = count;
 212                         mark_buffer_dirty(sb->sv_bh2, 1); /* super-block has been modified */
 213                         sb->s_dirt = 1; /* and needs time stamp */
 214                 }
 215         }
 216         unlock_super(sb);
 217         return count;
 218 #else
 219         return *sb->sv_sb_total_free_inodes;
 220 #endif
 221 }
 222
/* */
root/fs/sysv/ialloc.c

DEFINITIONS
