linux/fs/logfs/inode.c
<<
>>
Prefs
   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 */
  49static struct kmem_cache *logfs_inode_cache;
  50
  51static DEFINE_SPINLOCK(logfs_inode_lock);
  52
  53static 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
  81static 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                clear_nlink(inode);
  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
 109struct 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 */
 120struct 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
 144static void logfs_i_callback(struct rcu_head *head)
 145{
 146        struct inode *inode = container_of(head, struct inode, i_rcu);
 147        kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
 148}
 149
 150static void __logfs_destroy_inode(struct inode *inode)
 151{
 152        struct logfs_inode *li = logfs_inode(inode);
 153
 154        BUG_ON(li->li_block);
 155        list_del(&li->li_freeing_list);
 156        call_rcu(&inode->i_rcu, logfs_i_callback);
 157}
 158
 159static void __logfs_destroy_meta_inode(struct inode *inode)
 160{
 161        struct logfs_inode *li = logfs_inode(inode);
 162        BUG_ON(li->li_block);
 163        call_rcu(&inode->i_rcu, logfs_i_callback);
 164}
 165
 166static void logfs_destroy_inode(struct inode *inode)
 167{
 168        struct logfs_inode *li = logfs_inode(inode);
 169
 170        if (inode->i_ino < LOGFS_RESERVED_INOS) {
 171                /*
 172                 * The reserved inodes are never destroyed unless we are in
 173                 * unmont path.
 174                 */
 175                __logfs_destroy_meta_inode(inode);
 176                return;
 177        }
 178
 179        BUG_ON(list_empty(&li->li_freeing_list));
 180        spin_lock(&logfs_inode_lock);
 181        li->li_refcount--;
 182        if (li->li_refcount == 0)
 183                __logfs_destroy_inode(inode);
 184        spin_unlock(&logfs_inode_lock);
 185}
 186
 187void logfs_safe_iput(struct inode *inode, int is_cached)
 188{
 189        if (inode->i_ino == LOGFS_INO_MASTER)
 190                return;
 191        if (inode->i_ino == LOGFS_INO_SEGFILE)
 192                return;
 193
 194        if (is_cached) {
 195                logfs_destroy_inode(inode);
 196                return;
 197        }
 198
 199        iput(inode);
 200}
 201
 202static void logfs_init_inode(struct super_block *sb, struct inode *inode)
 203{
 204        struct logfs_inode *li = logfs_inode(inode);
 205        int i;
 206
 207        li->li_flags    = 0;
 208        li->li_height   = 0;
 209        li->li_used_bytes = 0;
 210        li->li_block    = NULL;
 211        i_uid_write(inode, 0);
 212        i_gid_write(inode, 0);
 213        inode->i_size   = 0;
 214        inode->i_blocks = 0;
 215        inode->i_ctime  = CURRENT_TIME;
 216        inode->i_mtime  = CURRENT_TIME;
 217        li->li_refcount = 1;
 218        INIT_LIST_HEAD(&li->li_freeing_list);
 219
 220        for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
 221                li->li_data[i] = 0;
 222
 223        return;
 224}
 225
 226static struct inode *logfs_alloc_inode(struct super_block *sb)
 227{
 228        struct logfs_inode *li;
 229
 230        li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS);
 231        if (!li)
 232                return NULL;
 233        logfs_init_inode(sb, &li->vfs_inode);
 234        return &li->vfs_inode;
 235}
 236
 237/*
 238 * In logfs inodes are written to an inode file.  The inode file, like any
 239 * other file, is managed with a inode.  The inode file's inode, aka master
 240 * inode, requires special handling in several respects.  First, it cannot be
 241 * written to the inode file, so it is stored in the journal instead.
 242 *
 243 * Secondly, this inode cannot be written back and destroyed before all other
 244 * inodes have been written.  The ordering is important.  Linux' VFS is happily
 245 * unaware of the ordering constraint and would ordinarily destroy the master
 246 * inode at umount time while other inodes are still in use and dirty.  Not
 247 * good.
 248 *
 249 * So logfs makes sure the master inode is not written until all other inodes
 250 * have been destroyed.  Sadly, this method has another side-effect.  The VFS
 251 * will notice one remaining inode and print a frightening warning message.
 252 * Worse, it is impossible to judge whether such a warning was caused by the
 253 * master inode or any other inodes have leaked as well.
 254 *
 255 * Our attempt of solving this is with logfs_new_meta_inode() below.  Its
 256 * purpose is to create a new inode that will not trigger the warning if such
 257 * an inode is still in use.  An ugly hack, no doubt.  Suggections for
 258 * improvement are welcome.
 259 *
 260 * AV: that's what ->put_super() is for...
 261 */
 262struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino)
 263{
 264        struct inode *inode;
 265
 266        inode = new_inode(sb);
 267        if (!inode)
 268                return ERR_PTR(-ENOMEM);
 269
 270        inode->i_mode = S_IFREG;
 271        inode->i_ino = ino;
 272        inode->i_data.a_ops = &logfs_reg_aops;
 273        mapping_set_gfp_mask(&inode->i_data, GFP_NOFS);
 274
 275        return inode;
 276}
 277
 278struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino)
 279{
 280        struct inode *inode;
 281        int err;
 282
 283        inode = logfs_new_meta_inode(sb, ino);
 284        if (IS_ERR(inode))
 285                return inode;
 286
 287        err = logfs_read_inode(inode);
 288        if (err) {
 289                iput(inode);
 290                return ERR_PTR(err);
 291        }
 292        logfs_inode_setops(inode);
 293        return inode;
 294}
 295
 296static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
 297{
 298        int ret;
 299        long flags = WF_LOCK;
 300
 301        /* Can only happen if creat() failed.  Safe to skip. */
 302        if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN)
 303                return 0;
 304
 305        ret = __logfs_write_inode(inode, NULL, flags);
 306        LOGFS_BUG_ON(ret, inode->i_sb);
 307        return ret;
 308}
 309
 310/* called with inode->i_lock held */
 311static int 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        return generic_drop_inode(inode);
 320}
 321
 322static 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
 342struct inode *logfs_new_inode(struct inode *dir, umode_t 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_init_owner(inode, dir, mode);
 361        logfs_inode_setops(inode);
 362        insert_inode_hash(inode);
 363
 364        return inode;
 365}
 366
 367static void logfs_init_once(void *_li)
 368{
 369        struct logfs_inode *li = _li;
 370        int i;
 371
 372        li->li_flags = 0;
 373        li->li_used_bytes = 0;
 374        li->li_refcount = 1;
 375        for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
 376                li->li_data[i] = 0;
 377        inode_init_once(&li->vfs_inode);
 378}
 379
 380static int logfs_sync_fs(struct super_block *sb, int wait)
 381{
 382        logfs_get_wblocks(sb, NULL, WF_LOCK);
 383        logfs_write_anchor(sb);
 384        logfs_put_wblocks(sb, NULL, WF_LOCK);
 385        return 0;
 386}
 387
 388static void logfs_put_super(struct super_block *sb)
 389{
 390        struct logfs_super *super = logfs_super(sb);
 391        /* kill the meta-inodes */
 392        iput(super->s_segfile_inode);
 393        iput(super->s_master_inode);
 394        iput(super->s_mapping_inode);
 395}
 396
 397const struct super_operations logfs_super_operations = {
 398        .alloc_inode    = logfs_alloc_inode,
 399        .destroy_inode  = logfs_destroy_inode,
 400        .evict_inode    = logfs_evict_inode,
 401        .drop_inode     = logfs_drop_inode,
 402        .put_super      = logfs_put_super,
 403        .write_inode    = logfs_write_inode,
 404        .statfs         = logfs_statfs,
 405        .sync_fs        = logfs_sync_fs,
 406};
 407
 408int logfs_init_inode_cache(void)
 409{
 410        logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
 411                        sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT,
 412                        logfs_init_once);
 413        if (!logfs_inode_cache)
 414                return -ENOMEM;
 415        return 0;
 416}
 417
 418void logfs_destroy_inode_cache(void)
 419{
 420        /*
 421         * Make sure all delayed rcu free inodes are flushed before we
 422         * destroy cache.
 423         */
 424        rcu_barrier();
 425        kmem_cache_destroy(logfs_inode_cache);
 426}
 427
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.