cregit-Linux how code gets into the kernel

Release 4.7 fs/logfs/inode.c

Directory: fs/logfs
/*
 * fs/logfs/inode.c     - inode handling code
 *
 * As should be obvious for Linux kernel code, license is GPLv2
 *
 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
 */
#include "logfs.h"
#include <linux/slab.h>
#include <linux/writeback.h>
#include <linux/backing-dev.h>

/*
 * How soon to reuse old inode numbers?  LogFS doesn't store deleted inodes
 * on the medium.  It therefore also lacks a method to store the previous
 * generation number for deleted inodes.  Instead a single generation number
 * is stored which will be used for new inodes.  Being just a 32bit counter,
 * this can obvious wrap relatively quickly.  So we only reuse inodes if we
 * know that a fair number of inodes can be created before we have to increment
 * the generation again - effectively adding some bits to the counter.
 * But being too aggressive here means we keep a very large and very sparse
 * inode file, wasting space on indirect blocks.
 * So what is a good value?  Beats me.  64k seems moderately bad on both
 * fronts, so let's use that for now...
 *
 * NFS sucks, as everyone already knows.
 */

#define INOS_PER_WRAP (0x10000)

/*
 * Logfs' requirement to read inodes for garbage collection makes life a bit
 * harder.  GC may have to read inodes that are in I_FREEING state, when they
 * are being written out - and waiting for GC to make progress, naturally.
 *
 * So we cannot just call iget() or some variant of it, but first have to check
 * whether the inode in question might be in I_FREEING state.  Therefore we
 * maintain our own per-sb list of "almost deleted" inodes and check against
 * that list first.  Normally this should be at most 1-2 entries long.
 *
 * Also, inodes have logfs-specific reference counting on top of what the vfs
 * does.  When .destroy_inode is called, normally the reference count will drop
 * to zero and the inode gets deleted.  But if GC accessed the inode, its
 * refcount will remain nonzero and final deletion will have to wait.
 *
 * As a result we have two sets of functions to get/put inodes:
 * logfs_safe_iget/logfs_safe_iput      - safe to call from GC context
 * logfs_iget/iput                      - normal version
 */

static struct kmem_cache *logfs_inode_cache;

static DEFINE_SPINLOCK(logfs_inode_lock);


static void logfs_inode_setops(struct inode *inode) { switch (inode->i_mode & S_IFMT) { case S_IFDIR: inode->i_op = &logfs_dir_iops; inode->i_fop = &logfs_dir_fops; inode->i_mapping->a_ops = &logfs_reg_aops; break; case S_IFREG: inode->i_op = &logfs_reg_iops; inode->i_fop = &logfs_reg_fops; inode->i_mapping->a_ops = &logfs_reg_aops; break; case S_IFLNK: inode->i_op = &page_symlink_inode_operations; inode_nohighmem(inode); inode->i_mapping->a_ops = &logfs_reg_aops; break; case S_IFSOCK: /* fall through */ case S_IFBLK: /* fall through */ case S_IFCHR: /* fall through */ case S_IFIFO: init_special_inode(inode, inode->i_mode, inode->i_rdev); break; default: BUG(); } }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel12795.49%133.33%
al viroal viro64.51%266.67%
Total133100.00%3100.00%


static struct inode *__logfs_iget(struct super_block *sb, ino_t ino) { struct inode *inode = iget_locked(sb, ino); int err; if (!inode) return ERR_PTR(-ENOMEM); if (!(inode->i_state & I_NEW)) return inode; err = logfs_read_inode(inode); if (err || inode->i_nlink == 0) { /* inode->i_nlink == 0 can be true when called from * block validator */ /* set i_nlink to 0 to prevent caching */ clear_nlink(inode); logfs_inode(inode)->li_flags |= LOGFS_IF_ZOMBIE; iget_failed(inode); if (!err) err = -ENOENT; return ERR_PTR(err); } logfs_inode_setops(inode); unlock_new_inode(inode); return inode; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel12397.62%150.00%
miklos szeredimiklos szeredi32.38%150.00%
Total126100.00%2100.00%


struct inode *logfs_iget(struct super_block *sb, ino_t ino) { BUG_ON(ino == LOGFS_INO_MASTER); BUG_ON(ino == LOGFS_INO_SEGFILE); return __logfs_iget(sb, ino); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel37100.00%1100.00%
Total37100.00%1100.00%

/* * is_cached is set to 1 if we hand out a cached inode, 0 otherwise. * this allows logfs_iput to do the right thing later */
struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *is_cached) { struct logfs_super *super = logfs_super(sb); struct logfs_inode *li; if (ino == LOGFS_INO_MASTER) return super->s_master_inode; if (ino == LOGFS_INO_SEGFILE) return super->s_segfile_inode; spin_lock(&logfs_inode_lock); list_for_each_entry(li, &super->s_freeing_list, li_freeing_list) if (li->vfs_inode.i_ino == ino) { li->li_refcount++; spin_unlock(&logfs_inode_lock); *is_cached = 1; return &li->vfs_inode; } spin_unlock(&logfs_inode_lock); *is_cached = 0; return __logfs_iget(sb, ino); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel123100.00%1100.00%
Total123100.00%1100.00%


static void logfs_i_callback(struct rcu_head *head) { struct inode *inode = container_of(head, struct inode, i_rcu); kmem_cache_free(logfs_inode_cache, logfs_inode(inode)); }

Contributors

PersonTokensPropCommitsCommitProp
nick pigginnick piggin36100.00%1100.00%
Total36100.00%1100.00%


static void __logfs_destroy_inode(struct inode *inode) { struct logfs_inode *li = logfs_inode(inode); BUG_ON(li->li_block); list_del(&li->li_freeing_list); call_rcu(&inode->i_rcu, logfs_i_callback); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel4086.96%150.00%
nick pigginnick piggin613.04%150.00%
Total46100.00%2100.00%


static void __logfs_destroy_meta_inode(struct inode *inode) { struct logfs_inode *li = logfs_inode(inode); BUG_ON(li->li_block); call_rcu(&inode->i_rcu, logfs_i_callback); }

Contributors

PersonTokensPropCommitsCommitProp
prasad joshiprasad joshi38100.00%1100.00%
Total38100.00%1100.00%


static void logfs_destroy_inode(struct inode *inode) { struct logfs_inode *li = logfs_inode(inode); if (inode->i_ino < LOGFS_RESERVED_INOS) { /* * The reserved inodes are never destroyed unless we are in * unmont path. */ __logfs_destroy_meta_inode(inode); return; } BUG_ON(list_empty(&li->li_freeing_list)); spin_lock(&logfs_inode_lock); li->li_refcount--; if (li->li_refcount == 0) __logfs_destroy_inode(inode); spin_unlock(&logfs_inode_lock); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel6278.48%150.00%
prasad joshiprasad joshi1721.52%150.00%
Total79100.00%2100.00%


void logfs_safe_iput(struct inode *inode, int is_cached) { if (inode->i_ino == LOGFS_INO_MASTER) return; if (inode->i_ino == LOGFS_INO_SEGFILE) return; if (is_cached) { logfs_destroy_inode(inode); return; } iput(inode); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel48100.00%1100.00%
Total48100.00%1100.00%


static void logfs_init_inode(struct super_block *sb, struct inode *inode) { struct logfs_inode *li = logfs_inode(inode); int i; li->li_flags = 0; li->li_height = 0; li->li_used_bytes = 0; li->li_block = NULL; i_uid_write(inode, 0); i_gid_write(inode, 0); inode->i_size = 0; inode->i_blocks = 0; inode->i_ctime = CURRENT_TIME; inode->i_mtime = CURRENT_TIME; li->li_refcount = 1; INIT_LIST_HEAD(&li->li_freeing_list); for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) li->li_data[i] = 0; return; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel11489.06%133.33%
eric w. biedermaneric w. biederman86.25%133.33%
prasad joshiprasad joshi64.69%133.33%
Total128100.00%3100.00%


static struct inode *logfs_alloc_inode(struct super_block *sb) { struct logfs_inode *li; li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS); if (!li) return NULL; logfs_init_inode(sb, &li->vfs_inode); return &li->vfs_inode; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel51100.00%1100.00%
Total51100.00%1100.00%

/* * In logfs inodes are written to an inode file. The inode file, like any * other file, is managed with a inode. The inode file's inode, aka master * inode, requires special handling in several respects. First, it cannot be * written to the inode file, so it is stored in the journal instead. * * Secondly, this inode cannot be written back and destroyed before all other * inodes have been written. The ordering is important. Linux' VFS is happily * unaware of the ordering constraint and would ordinarily destroy the master * inode at umount time while other inodes are still in use and dirty. Not * good. * * So logfs makes sure the master inode is not written until all other inodes * have been destroyed. Sadly, this method has another side-effect. The VFS * will notice one remaining inode and print a frightening warning message. * Worse, it is impossible to judge whether such a warning was caused by the * master inode or any other inodes have leaked as well. * * Our attempt of solving this is with logfs_new_meta_inode() below. Its * purpose is to create a new inode that will not trigger the warning if such * an inode is still in use. An ugly hack, no doubt. Suggections for * improvement are welcome. * * AV: that's what ->put_super() is for... */
struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino) { struct inode *inode; inode = new_inode(sb); if (!inode) return ERR_PTR(-ENOMEM); inode->i_mode = S_IFREG; inode->i_ino = ino; inode->i_data.a_ops = &logfs_reg_aops; mapping_set_gfp_mask(&inode->i_data, GFP_NOFS); return inode; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel6791.78%150.00%
al viroal viro68.22%150.00%
Total73100.00%2100.00%


struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino) { struct inode *inode; int err; inode = logfs_new_meta_inode(sb, ino); if (IS_ERR(inode)) return inode; err = logfs_read_inode(inode); if (err) { iput(inode); return ERR_PTR(err); } logfs_inode_setops(inode); return inode; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel7398.65%150.00%
al viroal viro11.35%150.00%
Total74100.00%2100.00%


static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc) { int ret; long flags = WF_LOCK; /* Can only happen if creat() failed. Safe to skip. */ if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN) return 0; ret = __logfs_write_inode(inode, NULL, flags); LOGFS_BUG_ON(ret, inode->i_sb); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel5690.32%133.33%
linus torvaldslinus torvalds46.45%133.33%
prasad joshiprasad joshi23.23%133.33%
Total62100.00%3100.00%

/* called with inode->i_lock held */
static int logfs_drop_inode(struct inode *inode) { struct logfs_super *super = logfs_super(inode->i_sb); struct logfs_inode *li = logfs_inode(inode); spin_lock(&logfs_inode_lock); list_move(&li->li_freeing_list, &super->s_freeing_list); spin_unlock(&logfs_inode_lock); return generic_drop_inode(inode); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel6195.31%150.00%
al viroal viro34.69%150.00%
Total64100.00%2100.00%


static void logfs_set_ino_generation(struct super_block *sb, struct inode *inode) { struct logfs_super *super = logfs_super(sb); u64 ino; mutex_lock(&super->s_journal_mutex); ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1); super->s_last_ino = ino; super->s_inos_till_wrap--; if (super->s_inos_till_wrap < 0) { super->s_last_ino = LOGFS_RESERVED_INOS; super->s_generation++; super->s_inos_till_wrap = INOS_PER_WRAP; } inode->i_ino = ino; inode->i_generation = super->s_generation; mutex_unlock(&super->s_journal_mutex); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel112100.00%2100.00%
Total112100.00%2100.00%


struct inode *logfs_new_inode(struct inode *dir, umode_t mode) { struct super_block *sb = dir->i_sb; struct inode *inode; inode = new_inode(sb); if (!inode) return ERR_PTR(-ENOMEM); logfs_init_inode(sb, inode); /* inherit parent flags */ logfs_inode(inode)->li_flags |= logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED; inode->i_mode = mode; logfs_set_ino_generation(sb, inode); inode_init_owner(inode, dir, mode); logfs_inode_setops(inode); insert_inode_hash(inode); return inode; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel10295.33%133.33%
al viroal viro54.67%266.67%
Total107100.00%3100.00%


static void logfs_init_once(void *_li) { struct logfs_inode *li = _li; int i; li->li_flags = 0; li->li_used_bytes = 0; li->li_refcount = 1; for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) li->li_data[i] = 0; inode_init_once(&li->vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel68100.00%1100.00%
Total68100.00%1100.00%


static int logfs_sync_fs(struct super_block *sb, int wait) { logfs_get_wblocks(sb, NULL, WF_LOCK); logfs_write_anchor(sb); logfs_put_wblocks(sb, NULL, WF_LOCK); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel2255.00%266.67%
prasad joshiprasad joshi1845.00%133.33%
Total40100.00%3100.00%


static void logfs_put_super(struct super_block *sb) { struct logfs_super *super = logfs_super(sb); /* kill the meta-inodes */ iput(super->s_segfile_inode); iput(super->s_master_inode); iput(super->s_mapping_inode); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro4195.35%150.00%
prasad joshiprasad joshi24.65%150.00%
Total43100.00%2100.00%

const struct super_operations logfs_super_operations = { .alloc_inode = logfs_alloc_inode, .destroy_inode = logfs_destroy_inode, .evict_inode = logfs_evict_inode, .drop_inode = logfs_drop_inode, .put_super = logfs_put_super, .write_inode = logfs_write_inode, .statfs = logfs_statfs, .sync_fs = logfs_sync_fs, };
int logfs_init_inode_cache(void) { logfs_inode_cache = kmem_cache_create("logfs_inode_cache", sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, logfs_init_once); if (!logfs_inode_cache) return -ENOMEM; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel3895.00%150.00%
vladimir davydovvladimir davydov25.00%150.00%
Total40100.00%2100.00%


void logfs_destroy_inode_cache(void) { /* * Make sure all delayed rcu free inodes are flushed before we * destroy cache. */ rcu_barrier(); kmem_cache_destroy(logfs_inode_cache); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel1275.00%150.00%
kirill a. shutemovkirill a. shutemov425.00%150.00%
Total16100.00%2100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel140286.28%312.50%
prasad joshiprasad joshi835.11%520.83%
al viroal viro724.43%729.17%
nick pigginnick piggin422.58%14.17%
eric w. biedermaneric w. biederman80.49%14.17%
kirill a. shutemovkirill a. shutemov40.25%14.17%
linus torvaldslinus torvalds40.25%14.17%
tejun heotejun heo30.18%14.17%
miklos szeredimiklos szeredi30.18%14.17%
vladimir davydovvladimir davydov20.12%14.17%
dave chinnerdave chinner10.06%14.17%
adam buchbinderadam buchbinder10.06%14.17%
Total1625100.00%24100.00%
Directory: fs/logfs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}