[linux-2.6-block.git] / fs / logfs / inode.c

/*
 * 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();
	}
}

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;
}

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);
}

/*
 * 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);
}

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));
}

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);
}

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);
}

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);
}

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);
}

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;
}

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;
}

/*
 * 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;
}

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;
}

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;
}

/* 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);
}

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);
}

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;
}

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);
}

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;
}

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);
}

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;
}

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);
}
Commit	Line	Data
5db53f3e JE	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"
5a0e3ad6	9	#include <linux/slab.h>
5db53f3e JE	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
48fc7f7e	36	* whether the inode in question might be in I_FREEING state. Therefore we
5db53f3e JE	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:
fb417f13	67	inode->i_op = &page_symlink_inode_operations;
21fc61c7	68	inode_nohighmem(inode);
5db53f3e JE	69	inode->i_mapping->a_ops = &logfs_reg_aops;
	70	break;
	71	case S_IFSOCK: /* fall through */
	72	case S_IFBLK: /* fall through */
	73	case S_IFCHR: /* fall through */
	74	case S_IFIFO:
	75	init_special_inode(inode, inode->i_mode, inode->i_rdev);
	76	break;
	77	default:
	78	BUG();
	79	}
	80	}
	81
	82	static struct inode __logfs_iget(struct super_block sb, ino_t ino)
	83	{
	84	struct inode *inode = iget_locked(sb, ino);
	85	int err;
	86
	87	if (!inode)
	88	return ERR_PTR(-ENOMEM);
	89	if (!(inode->i_state & I_NEW))
	90	return inode;
	91
	92	err = logfs_read_inode(inode);
	93	if (err \|\| inode->i_nlink == 0) {
	94	/* inode->i_nlink == 0 can be true when called from
	95	* block validator */
	96	/* set i_nlink to 0 to prevent caching */
6d6b77f1	97	clear_nlink(inode);
5db53f3e JE	98	logfs_inode(inode)->li_flags \|= LOGFS_IF_ZOMBIE;
	99	iget_failed(inode);
	100	if (!err)
	101	err = -ENOENT;
	102	return ERR_PTR(err);
	103	}
	104
	105	logfs_inode_setops(inode);
	106	unlock_new_inode(inode);
	107	return inode;
	108	}
	109
	110	struct inode logfs_iget(struct super_block sb, ino_t ino)
	111	{
	112	BUG_ON(ino == LOGFS_INO_MASTER);
	113	BUG_ON(ino == LOGFS_INO_SEGFILE);
	114	return __logfs_iget(sb, ino);
	115	}
	116
	117	/*
	118	* is_cached is set to 1 if we hand out a cached inode, 0 otherwise.
	119	* this allows logfs_iput to do the right thing later
	120	*/
	121	struct inode logfs_safe_iget(struct super_block sb, ino_t ino, int *is_cached)
	122	{
	123	struct logfs_super *super = logfs_super(sb);
	124	struct logfs_inode *li;
	125
	126	if (ino == LOGFS_INO_MASTER)
	127	return super->s_master_inode;
	128	if (ino == LOGFS_INO_SEGFILE)
	129	return super->s_segfile_inode;
	130
	131	spin_lock(&logfs_inode_lock);
	132	list_for_each_entry(li, &super->s_freeing_list, li_freeing_list)
	133	if (li->vfs_inode.i_ino == ino) {
	134	li->li_refcount++;
	135	spin_unlock(&logfs_inode_lock);
	136	*is_cached = 1;
	137	return &li->vfs_inode;
	138	}
	139	spin_unlock(&logfs_inode_lock);
	140
	141	*is_cached = 0;
	142	return __logfs_iget(sb, ino);
	143	}
	144
fa0d7e3d NP	145	static void logfs_i_callback(struct rcu_head *head)
	146	{
	147	struct inode *inode = container_of(head, struct inode, i_rcu);
fa0d7e3d NP	148	kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
	149	}
	150
5db53f3e JE	151	static void __logfs_destroy_inode(struct inode *inode)
	152	{
	153	struct logfs_inode *li = logfs_inode(inode);
	154
	155	BUG_ON(li->li_block);
	156	list_del(&li->li_freeing_list);
fa0d7e3d	157	call_rcu(&inode->i_rcu, logfs_i_callback);
5db53f3e JE	158	}
5db53f3e JE	159
d2dcd908 PJ	160	static void __logfs_destroy_meta_inode(struct inode *inode)
	161	{
	162	struct logfs_inode *li = logfs_inode(inode);
	163	BUG_ON(li->li_block);
	164	call_rcu(&inode->i_rcu, logfs_i_callback);
	165	}
	166
5db53f3e JE	167	static void logfs_destroy_inode(struct inode *inode)
	168	{
	169	struct logfs_inode *li = logfs_inode(inode);
	170
d2dcd908 PJ	171	if (inode->i_ino < LOGFS_RESERVED_INOS) {
	172	/*
	173	* The reserved inodes are never destroyed unless we are in
	174	* unmont path.
	175	*/
	176	__logfs_destroy_meta_inode(inode);
	177	return;
	178	}
	179
5db53f3e JE	180	BUG_ON(list_empty(&li->li_freeing_list));
	181	spin_lock(&logfs_inode_lock);
	182	li->li_refcount--;
	183	if (li->li_refcount == 0)
	184	__logfs_destroy_inode(inode);
	185	spin_unlock(&logfs_inode_lock);
	186	}
	187
	188	void logfs_safe_iput(struct inode *inode, int is_cached)
	189	{
	190	if (inode->i_ino == LOGFS_INO_MASTER)
	191	return;
	192	if (inode->i_ino == LOGFS_INO_SEGFILE)
	193	return;
	194
	195	if (is_cached) {
	196	logfs_destroy_inode(inode);
	197	return;
	198	}
	199
	200	iput(inode);
	201	}
	202
	203	static void logfs_init_inode(struct super_block sb, struct inode inode)
	204	{
	205	struct logfs_inode *li = logfs_inode(inode);
	206	int i;
	207
	208	li->li_flags = 0;
	209	li->li_height = 0;
	210	li->li_used_bytes = 0;
	211	li->li_block = NULL;
1a0a994e EB	212	i_uid_write(inode, 0);
1a0a994e EB	213	i_gid_write(inode, 0);
5db53f3e JE	214	inode->i_size = 0;
	215	inode->i_blocks = 0;
	216	inode->i_ctime = CURRENT_TIME;
	217	inode->i_mtime = CURRENT_TIME;
24797535	218	li->li_refcount = 1;
5db53f3e JE	219	INIT_LIST_HEAD(&li->li_freeing_list);
	220
	221	for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
	222	li->li_data[i] = 0;
	223
	224	return;
	225	}
	226
	227	static struct inode logfs_alloc_inode(struct super_block sb)
	228	{
	229	struct logfs_inode *li;
	230
	231	li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS);
	232	if (!li)
	233	return NULL;
	234	logfs_init_inode(sb, &li->vfs_inode);
	235	return &li->vfs_inode;
	236	}
	237
	238	/*
	239	* In logfs inodes are written to an inode file. The inode file, like any
	240	* other file, is managed with a inode. The inode file's inode, aka master
	241	* inode, requires special handling in several respects. First, it cannot be
	242	* written to the inode file, so it is stored in the journal instead.
	243	*
	244	* Secondly, this inode cannot be written back and destroyed before all other
	245	* inodes have been written. The ordering is important. Linux' VFS is happily
	246	* unaware of the ordering constraint and would ordinarily destroy the master
	247	* inode at umount time while other inodes are still in use and dirty. Not
	248	* good.
	249	*
	250	* So logfs makes sure the master inode is not written until all other inodes
	251	* have been destroyed. Sadly, this method has another side-effect. The VFS
	252	* will notice one remaining inode and print a frightening warning message.
	253	* Worse, it is impossible to judge whether such a warning was caused by the
	254	* master inode or any other inodes have leaked as well.
	255	*
	256	* Our attempt of solving this is with logfs_new_meta_inode() below. Its
	257	* purpose is to create a new inode that will not trigger the warning if such
	258	* an inode is still in use. An ugly hack, no doubt. Suggections for
	259	* improvement are welcome.
8e22c1a4 AV	260	*
8e22c1a4 AV	261	* AV: that's what ->put_super() is for...
5db53f3e JE	262	*/
	263	struct inode logfs_new_meta_inode(struct super_block sb, u64 ino)
	264	{
	265	struct inode *inode;
	266
8e22c1a4	267	inode = new_inode(sb);
5db53f3e JE	268	if (!inode)
	269	return ERR_PTR(-ENOMEM);
	270
	271	inode->i_mode = S_IFREG;
	272	inode->i_ino = ino;
8e22c1a4 AV	273	inode->i_data.a_ops = &logfs_reg_aops;
8e22c1a4 AV	274	mapping_set_gfp_mask(&inode->i_data, GFP_NOFS);
5db53f3e JE	275
	276	return inode;
	277	}
	278
	279	struct inode logfs_read_meta_inode(struct super_block sb, u64 ino)
	280	{
	281	struct inode *inode;
	282	int err;
	283
	284	inode = logfs_new_meta_inode(sb, ino);
	285	if (IS_ERR(inode))
	286	return inode;
	287
	288	err = logfs_read_inode(inode);
	289	if (err) {
8e22c1a4	290	iput(inode);
5db53f3e JE	291	return ERR_PTR(err);
	292	}
	293	logfs_inode_setops(inode);
	294	return inode;
	295	}
	296
66b89159	297	static int logfs_write_inode(struct inode inode, struct writeback_control wbc)
5db53f3e JE	298	{
	299	int ret;
	300	long flags = WF_LOCK;
	301
	302	/* Can only happen if creat() failed. Safe to skip. */
	303	if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN)
	304	return 0;
	305
0bd90387	306	ret = __logfs_write_inode(inode, NULL, flags);
5db53f3e JE	307	LOGFS_BUG_ON(ret, inode->i_sb);
	308	return ret;
	309	}
	310
f283c86a	311	/* called with inode->i_lock held */
45321ac5	312	static int logfs_drop_inode(struct inode *inode)
5db53f3e JE	313	{
	314	struct logfs_super *super = logfs_super(inode->i_sb);
	315	struct logfs_inode *li = logfs_inode(inode);
	316
	317	spin_lock(&logfs_inode_lock);
	318	list_move(&li->li_freeing_list, &super->s_freeing_list);
	319	spin_unlock(&logfs_inode_lock);
45321ac5	320	return generic_drop_inode(inode);
5db53f3e JE	321	}
	322
	323	static void logfs_set_ino_generation(struct super_block *sb,
	324	struct inode *inode)
	325	{
	326	struct logfs_super *super = logfs_super(sb);
	327	u64 ino;
	328
	329	mutex_lock(&super->s_journal_mutex);
ccc0197b	330	ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1);
5db53f3e JE	331	super->s_last_ino = ino;
	332	super->s_inos_till_wrap--;
	333	if (super->s_inos_till_wrap < 0) {
	334	super->s_last_ino = LOGFS_RESERVED_INOS;
	335	super->s_generation++;
	336	super->s_inos_till_wrap = INOS_PER_WRAP;
	337	}
	338	inode->i_ino = ino;
	339	inode->i_generation = super->s_generation;
	340	mutex_unlock(&super->s_journal_mutex);
	341	}
	342
88176446	343	struct inode logfs_new_inode(struct inode dir, umode_t mode)
5db53f3e JE	344	{
	345	struct super_block *sb = dir->i_sb;
	346	struct inode *inode;
	347
	348	inode = new_inode(sb);
	349	if (!inode)
	350	return ERR_PTR(-ENOMEM);
	351
	352	logfs_init_inode(sb, inode);
	353
	354	/* inherit parent flags */
	355	logfs_inode(inode)->li_flags \|=
	356	logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED;
	357
	358	inode->i_mode = mode;
	359	logfs_set_ino_generation(sb, inode);
	360
ab9a79b9	361	inode_init_owner(inode, dir, mode);
5db53f3e JE	362	logfs_inode_setops(inode);
	363	insert_inode_hash(inode);
	364
	365	return inode;
	366	}
	367
	368	static void logfs_init_once(void *_li)
	369	{
	370	struct logfs_inode *li = _li;
	371	int i;
	372
	373	li->li_flags = 0;
	374	li->li_used_bytes = 0;
	375	li->li_refcount = 1;
	376	for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
	377	li->li_data[i] = 0;
	378	inode_init_once(&li->vfs_inode);
	379	}
	380
	381	static int logfs_sync_fs(struct super_block *sb, int wait)
	382	{
13ced29c	383	logfs_get_wblocks(sb, NULL, WF_LOCK);
c0c79c31	384	logfs_write_anchor(sb);
13ced29c	385	logfs_put_wblocks(sb, NULL, WF_LOCK);
5db53f3e JE	386	return 0;
	387	}
	388
8e22c1a4 AV	389	static void logfs_put_super(struct super_block *sb)
	390	{
	391	struct logfs_super *super = logfs_super(sb);
	392	/* kill the meta-inodes */
8e22c1a4	393	iput(super->s_segfile_inode);
41b93bc1	394	iput(super->s_master_inode);
8e22c1a4 AV	395	iput(super->s_mapping_inode);
	396	}
	397
5db53f3e JE	398	const struct super_operations logfs_super_operations = {
5db53f3e JE	399	.alloc_inode = logfs_alloc_inode,
5db53f3e	400	.destroy_inode = logfs_destroy_inode,
7da08fd1	401	.evict_inode = logfs_evict_inode,
5db53f3e	402	.drop_inode = logfs_drop_inode,
8e22c1a4	403	.put_super = logfs_put_super,
5db53f3e JE	404	.write_inode = logfs_write_inode,
	405	.statfs = logfs_statfs,
	406	.sync_fs = logfs_sync_fs,
	407	};
	408
	409	int logfs_init_inode_cache(void)
	410	{
	411	logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
5d097056 VD	412	sizeof(struct logfs_inode), 0,
5d097056 VD	413	SLAB_RECLAIM_ACCOUNT\|SLAB_ACCOUNT,
5db53f3e JE	414	logfs_init_once);
	415	if (!logfs_inode_cache)
	416	return -ENOMEM;
	417	return 0;
	418	}
	419
	420	void logfs_destroy_inode_cache(void)
	421	{
8c0a8537 KS	422	/*
	423	* Make sure all delayed rcu free inodes are flushed before we
	424	* destroy cache.
	425	*/
	426	rcu_barrier();
5db53f3e JE	427	kmem_cache_destroy(logfs_inode_cache);
5db53f3e JE	428	}