fs/logfs/inode.c

   1 /*
   2  * fs/logfs/inode.c     - inode handling code
   3  *
   4  * As should be obvious for Linux kernel code, license is GPLv2
   5  *
   6  * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
   7  */
   8 #include "logfs.h"
   9 #include <linux/slab.h>
  10 #include <linux/writeback.h>
  11 #include <linux/backing-dev.h>
  12
  13 /*
  14  * How soon to reuse old inode numbers?  LogFS doesn't store deleted inodes
  15  * on the medium.  It therefore also lacks a method to store the previous
  16  * generation number for deleted inodes.  Instead a single generation number
  17  * is stored which will be used for new inodes.  Being just a 32bit counter,
  18  * this can obvious wrap relatively quickly.  So we only reuse inodes if we
  19  * know that a fair number of inodes can be created before we have to increment
  20  * the generation again - effectively adding some bits to the counter.
  21  * But being too aggressive here means we keep a very large and very sparse
  22  * inode file, wasting space on indirect blocks.
  23  * So what is a good value?  Beats me.  64k seems moderately bad on both
  24  * fronts, so let's use that for now...
  25  *
  26  * NFS sucks, as everyone already knows.
  27  */
  28 #define INOS_PER_WRAP (0x10000)
  29
  30 /*
  31  * Logfs' requirement to read inodes for garbage collection makes life a bit
  32  * harder.  GC may have to read inodes that are in I_FREEING state, when they
  33  * are being written out - and waiting for GC to make progress, naturally.
  34  *
  35  * So we cannot just call iget() or some variant of it, but first have to check
  36  * wether the inode in question might be in I_FREEING state.  Therefore we
  37  * maintain our own per-sb list of "almost deleted" inodes and check against
  38  * that list first.  Normally this should be at most 1-2 entries long.
  39  *
  40  * Also, inodes have logfs-specific reference counting on top of what the vfs
  41  * does.  When .destroy_inode is called, normally the reference count will drop
  42  * to zero and the inode gets deleted.  But if GC accessed the inode, its
  43  * refcount will remain nonzero and final deletion will have to wait.
  44  *
  45  * As a result we have two sets of functions to get/put inodes:
  46  * logfs_safe_iget/logfs_safe_iput      - safe to call from GC context
  47  * logfs_iget/iput                      - normal version
  48  */
  49 static struct kmem_cache *logfs_inode_cache;
  50
  51 static DEFINE_SPINLOCK(logfs_inode_lock);
  52
  53 static void logfs_inode_setops(struct inode *inode)
  54 {
  55         switch (inode->i_mode & S_IFMT) {
  56         case S_IFDIR:
  57                 inode->i_op = &logfs_dir_iops;
  58                 inode->i_fop = &logfs_dir_fops;
  59                 inode->i_mapping->a_ops = &logfs_reg_aops;
  60                 break;
  61         case S_IFREG:
  62                 inode->i_op = &logfs_reg_iops;
  63                 inode->i_fop = &logfs_reg_fops;
  64                 inode->i_mapping->a_ops = &logfs_reg_aops;
  65                 break;
  66         case S_IFLNK:
  67                 inode->i_op = &logfs_symlink_iops;
  68                 inode->i_mapping->a_ops = &logfs_reg_aops;
  69                 break;
  70         case S_IFSOCK:  /* fall through */
  71         case S_IFBLK:   /* fall through */
  72         case S_IFCHR:   /* fall through */
  73         case S_IFIFO:
  74                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  75                 break;
  76         default:
  77                 BUG();
  78         }
  79 }
  80
  81 static struct inode *__logfs_iget(struct super_block *sb, ino_t ino)
  82 {
  83         struct inode *inode = iget_locked(sb, ino);
  84         int err;
  85
  86         if (!inode)
  87                 return ERR_PTR(-ENOMEM);
  88         if (!(inode->i_state & I_NEW))
  89                 return inode;
  90
  91         err = logfs_read_inode(inode);
  92         if (err || inode->i_nlink == 0) {
  93                 /* inode->i_nlink == 0 can be true when called from
  94                  * block validator */
  95                 /* set i_nlink to 0 to prevent caching */
  96                 inode->i_nlink = 0;
  97                 logfs_inode(inode)->li_flags |= LOGFS_IF_ZOMBIE;
  98                 iget_failed(inode);
  99                 if (!err)
 100                         err = -ENOENT;
 101                 return ERR_PTR(err);
 102         }
 103
 104         logfs_inode_setops(inode);
 105         unlock_new_inode(inode);
 106         return inode;
 107 }
 108
 109 struct inode *logfs_iget(struct super_block *sb, ino_t ino)
 110 {
 111         BUG_ON(ino == LOGFS_INO_MASTER);
 112         BUG_ON(ino == LOGFS_INO_SEGFILE);
 113         return __logfs_iget(sb, ino);
 114 }
 115
 116 /*
 117  * is_cached is set to 1 if we hand out a cached inode, 0 otherwise.
 118  * this allows logfs_iput to do the right thing later
 119  */
 120 struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *is_cached)
 121 {
 122         struct logfs_super *super = logfs_super(sb);
 123         struct logfs_inode *li;
 124
 125         if (ino == LOGFS_INO_MASTER)
 126                 return super->s_master_inode;
 127         if (ino == LOGFS_INO_SEGFILE)
 128                 return super->s_segfile_inode;
 129
 130         spin_lock(&logfs_inode_lock);
 131         list_for_each_entry(li, &super->s_freeing_list, li_freeing_list)
 132                 if (li->vfs_inode.i_ino == ino) {
 133                         li->li_refcount++;
 134                         spin_unlock(&logfs_inode_lock);
 135                         *is_cached = 1;
 136                         return &li->vfs_inode;
 137                 }
 138         spin_unlock(&logfs_inode_lock);
 139
 140         *is_cached = 0;
 141         return __logfs_iget(sb, ino);
 142 }
 143
 144 static void __logfs_destroy_inode(struct inode *inode)
 145 {
 146         struct logfs_inode *li = logfs_inode(inode);
 147
 148         BUG_ON(li->li_block);
 149         list_del(&li->li_freeing_list);
 150         kmem_cache_free(logfs_inode_cache, li);
 151 }
 152
 153 static void logfs_destroy_inode(struct inode *inode)
 154 {
 155         struct logfs_inode *li = logfs_inode(inode);
 156
 157         BUG_ON(list_empty(&li->li_freeing_list));
 158         spin_lock(&logfs_inode_lock);
 159         li->li_refcount--;
 160         if (li->li_refcount == 0)
 161                 __logfs_destroy_inode(inode);
 162         spin_unlock(&logfs_inode_lock);
 163 }
 164
 165 void logfs_safe_iput(struct inode *inode, int is_cached)
 166 {
 167         if (inode->i_ino == LOGFS_INO_MASTER)
 168                 return;
 169         if (inode->i_ino == LOGFS_INO_SEGFILE)
 170                 return;
 171
 172         if (is_cached) {
 173                 logfs_destroy_inode(inode);
 174                 return;
 175         }
 176
 177         iput(inode);
 178 }
 179
 180 static void logfs_init_inode(struct super_block *sb, struct inode *inode)
 181 {
 182         struct logfs_inode *li = logfs_inode(inode);
 183         int i;
 184
 185         li->li_flags    = 0;
 186         li->li_height   = 0;
 187         li->li_used_bytes = 0;
 188         li->li_block    = NULL;
 189         inode->i_uid    = 0;
 190         inode->i_gid    = 0;
 191         inode->i_size   = 0;
 192         inode->i_blocks = 0;
 193         inode->i_ctime  = CURRENT_TIME;
 194         inode->i_mtime  = CURRENT_TIME;
 195         inode->i_nlink  = 1;
 196         INIT_LIST_HEAD(&li->li_freeing_list);
 197
 198         for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
 199                 li->li_data[i] = 0;
 200
 201         return;
 202 }
 203
 204 static struct inode *logfs_alloc_inode(struct super_block *sb)
 205 {
 206         struct logfs_inode *li;
 207
 208         li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS);
 209         if (!li)
 210                 return NULL;
 211         logfs_init_inode(sb, &li->vfs_inode);
 212         return &li->vfs_inode;
 213 }
 214
 215 /*
 216  * In logfs inodes are written to an inode file.  The inode file, like any
 217  * other file, is managed with a inode.  The inode file's inode, aka master
 218  * inode, requires special handling in several respects.  First, it cannot be
 219  * written to the inode file, so it is stored in the journal instead.
 220  *
 221  * Secondly, this inode cannot be written back and destroyed before all other
 222  * inodes have been written.  The ordering is important.  Linux' VFS is happily
 223  * unaware of the ordering constraint and would ordinarily destroy the master
 224  * inode at umount time while other inodes are still in use and dirty.  Not
 225  * good.
 226  *
 227  * So logfs makes sure the master inode is not written until all other inodes
 228  * have been destroyed.  Sadly, this method has another side-effect.  The VFS
 229  * will notice one remaining inode and print a frightening warning message.
 230  * Worse, it is impossible to judge whether such a warning was caused by the
 231  * master inode or any other inodes have leaked as well.
 232  *
 233  * Our attempt of solving this is with logfs_new_meta_inode() below.  Its
 234  * purpose is to create a new inode that will not trigger the warning if such
 235  * an inode is still in use.  An ugly hack, no doubt.  Suggections for
 236  * improvement are welcome.
 237  */
 238 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino)
 239 {
 240         struct inode *inode;
 241
 242         inode = logfs_alloc_inode(sb);
 243         if (!inode)
 244                 return ERR_PTR(-ENOMEM);
 245
 246         inode->i_mode = S_IFREG;
 247         inode->i_ino = ino;
 248         inode->i_sb = sb;
 249
 250         /* This is a blatant copy of alloc_inode code.  We'd need alloc_inode
 251          * to be nonstatic, alas. */
 252         {
 253                 struct address_space * const mapping = &inode->i_data;
 254
 255                 mapping->a_ops = &logfs_reg_aops;
 256                 mapping->host = inode;
 257                 mapping->flags = 0;
 258                 mapping_set_gfp_mask(mapping, GFP_NOFS);
 259                 mapping->assoc_mapping = NULL;
 260                 mapping->backing_dev_info = &default_backing_dev_info;
 261                 inode->i_mapping = mapping;
 262                 inode->i_nlink = 1;
 263         }
 264
 265         return inode;
 266 }
 267
 268 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino)
 269 {
 270         struct inode *inode;
 271         int err;
 272
 273         inode = logfs_new_meta_inode(sb, ino);
 274         if (IS_ERR(inode))
 275                 return inode;
 276
 277         err = logfs_read_inode(inode);
 278         if (err) {
 279                 destroy_meta_inode(inode);
 280                 return ERR_PTR(err);
 281         }
 282         logfs_inode_setops(inode);
 283         return inode;
 284 }
 285
 286 static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
 287 {
 288         int ret;
 289         long flags = WF_LOCK;
 290
 291         /* Can only happen if creat() failed.  Safe to skip. */
 292         if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN)
 293                 return 0;
 294
 295         ret = __logfs_write_inode(inode, flags);
 296         LOGFS_BUG_ON(ret, inode->i_sb);
 297         return ret;
 298 }
 299
 300 void destroy_meta_inode(struct inode *inode)
 301 {
 302         if (inode) {
 303                 if (inode->i_data.nrpages)
 304                         truncate_inode_pages(&inode->i_data, 0);
 305                 logfs_clear_inode(inode);
 306                 kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
 307         }
 308 }
 309
 310 /* called with inode_lock held */
 311 static void logfs_drop_inode(struct inode *inode)
 312 {
 313         struct logfs_super *super = logfs_super(inode->i_sb);
 314         struct logfs_inode *li = logfs_inode(inode);
 315
 316         spin_lock(&logfs_inode_lock);
 317         list_move(&li->li_freeing_list, &super->s_freeing_list);
 318         spin_unlock(&logfs_inode_lock);
 319         generic_drop_inode(inode);
 320 }
 321
 322 static void logfs_set_ino_generation(struct super_block *sb,
 323                 struct inode *inode)
 324 {
 325         struct logfs_super *super = logfs_super(sb);
 326         u64 ino;
 327
 328         mutex_lock(&super->s_journal_mutex);
 329         ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1);
 330         super->s_last_ino = ino;
 331         super->s_inos_till_wrap--;
 332         if (super->s_inos_till_wrap < 0) {
 333                 super->s_last_ino = LOGFS_RESERVED_INOS;
 334                 super->s_generation++;
 335                 super->s_inos_till_wrap = INOS_PER_WRAP;
 336         }
 337         inode->i_ino = ino;
 338         inode->i_generation = super->s_generation;
 339         mutex_unlock(&super->s_journal_mutex);
 340 }
 341
 342 struct inode *logfs_new_inode(struct inode *dir, int mode)
 343 {
 344         struct super_block *sb = dir->i_sb;
 345         struct inode *inode;
 346
 347         inode = new_inode(sb);
 348         if (!inode)
 349                 return ERR_PTR(-ENOMEM);
 350
 351         logfs_init_inode(sb, inode);
 352
 353         /* inherit parent flags */
 354         logfs_inode(inode)->li_flags |=
 355                 logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED;
 356
 357         inode->i_mode = mode;
 358         logfs_set_ino_generation(sb, inode);
 359
 360         inode->i_uid = current_fsuid();
 361         inode->i_gid = current_fsgid();
 362         if (dir->i_mode & S_ISGID) {
 363                 inode->i_gid = dir->i_gid;
 364                 if (S_ISDIR(mode))
 365                         inode->i_mode |= S_ISGID;
 366         }
 367
 368         logfs_inode_setops(inode);
 369         insert_inode_hash(inode);
 370
 371         return inode;
 372 }
 373
 374 static void logfs_init_once(void *_li)
 375 {
 376         struct logfs_inode *li = _li;
 377         int i;
 378
 379         li->li_flags = 0;
 380         li->li_used_bytes = 0;
 381         li->li_refcount = 1;
 382         for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
 383                 li->li_data[i] = 0;
 384         inode_init_once(&li->vfs_inode);
 385 }
 386
 387 static int logfs_sync_fs(struct super_block *sb, int wait)
 388 {
 389         /* FIXME: write anchor */
 390         logfs_super(sb)->s_devops->sync(sb);
 391         return 0;
 392 }
 393
 394 const struct super_operations logfs_super_operations = {
 395         .alloc_inode    = logfs_alloc_inode,
 396         .clear_inode    = logfs_clear_inode,
 397         .delete_inode   = logfs_delete_inode,
 398         .destroy_inode  = logfs_destroy_inode,
 399         .drop_inode     = logfs_drop_inode,
 400         .write_inode    = logfs_write_inode,
 401         .statfs         = logfs_statfs,
 402         .sync_fs        = logfs_sync_fs,
 403 };
 404
 405 int logfs_init_inode_cache(void)
 406 {
 407         logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
 408                         sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT,
 409                         logfs_init_once);
 410         if (!logfs_inode_cache)
 411                 return -ENOMEM;
 412         return 0;
 413 }
 414
 415 void logfs_destroy_inode_cache(void)
 416 {
 417         kmem_cache_destroy(logfs_inode_cache);
 418 }