fs/logfs/dir.c - kernel/msm-4.9 - Gitiles

 /*
  * fs/logfs/dir.c	- directory-related 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>

 /*
  * Atomic dir operations
  *
  * Directory operations are by default not atomic.  Dentries and Inodes are
  * created/removed/altered in separate operations.  Therefore we need to do
  * a small amount of journaling.
  *
  * Create, link, mkdir, mknod and symlink all share the same function to do
  * the work: __logfs_create.  This function works in two atomic steps:
  * 1. allocate inode (remember in journal)
  * 2. allocate dentry (clear journal)
  *
  * As we can only get interrupted between the two, when the inode we just
  * created is simply stored in the anchor.  On next mount, if we were
  * interrupted, we delete the inode.  From a users point of view the
  * operation never happened.
  *
  * Unlink and rmdir also share the same function: unlink.  Again, this
  * function works in two atomic steps
  * 1. remove dentry (remember inode in journal)
  * 2. unlink inode (clear journal)
  *
  * And again, on the next mount, if we were interrupted, we delete the inode.
  * From a users point of view the operation succeeded.
  *
  * Rename is the real pain to deal with, harder than all the other methods
  * combined.  Depending on the circumstances we can run into three cases.
  * A "target rename" where the target dentry already existed, a "local
  * rename" where both parent directories are identical or a "cross-directory
  * rename" in the remaining case.
  *
  * Local rename is atomic, as the old dentry is simply rewritten with a new
  * name.
  *
  * Cross-directory rename works in two steps, similar to __logfs_create and
  * logfs_unlink:
  * 1. Write new dentry (remember old dentry in journal)
  * 2. Remove old dentry (clear journal)
  *
  * Here we remember a dentry instead of an inode.  On next mount, if we were
  * interrupted, we delete the dentry.  From a users point of view, the
  * operation succeeded.
  *
  * Target rename works in three atomic steps:
  * 1. Attach old inode to new dentry (remember old dentry and new inode)
  * 2. Remove old dentry (still remember the new inode)
  * 3. Remove victim inode
  *
  * Here we remember both an inode an a dentry.  If we get interrupted
  * between steps 1 and 2, we delete both the dentry and the inode.  If
  * we get interrupted between steps 2 and 3, we delete just the inode.
  * In either case, the remaining objects are deleted on next mount.  From
  * a users point of view, the operation succeeded.
  */

 static int write_dir(struct inode *dir, struct logfs_disk_dentry *dd,
 		loff_t pos)
 {
 	return logfs_inode_write(dir, dd, sizeof(*dd), pos, WF_LOCK, NULL);
 }

 static int write_inode(struct inode *inode)
 {
 	return __logfs_write_inode(inode, NULL, WF_LOCK);
 }

 static s64 dir_seek_data(struct inode *inode, s64 pos)
 {
 	s64 new_pos = logfs_seek_data(inode, pos);

 	return max(pos, new_pos - 1);
 }

 static int beyond_eof(struct inode *inode, loff_t bix)
 {
 	loff_t pos = bix << inode->i_sb->s_blocksize_bits;
 	return pos >= i_size_read(inode);
 }

 /*
  * Prime value was chosen to be roughly 256 + 26.  r5 hash uses 11,
  * so short names (len <= 9) don't even occupy the complete 32bit name
  * space.  A prime >256 ensures short names quickly spread the 32bit
  * name space.  Add about 26 for the estimated amount of information
  * of each character and pick a prime nearby, preferably a bit-sparse
  * one.
  */
 static u32 hash_32(const char *s, int len, u32 seed)
 {
 	u32 hash = seed;
 	int i;

 	for (i = 0; i < len; i++)
 		hash = hash * 293 + s[i];
 	return hash;
 }

 /*
  * We have to satisfy several conflicting requirements here.  Small
  * directories should stay fairly compact and not require too many
  * indirect blocks.  The number of possible locations for a given hash
  * should be small to make lookup() fast.  And we should try hard not
  * to overflow the 32bit name space or nfs and 32bit host systems will
  * be unhappy.
  *
  * So we use the following scheme.  First we reduce the hash to 0..15
  * and try a direct block.  If that is occupied we reduce the hash to
  * 16..255 and try an indirect block.  Same for 2x and 3x indirect
  * blocks.  Lastly we reduce the hash to 0x800_0000 .. 0xffff_ffff,
  * but use buckets containing eight entries instead of a single one.
  *
  * Using 16 entries should allow for a reasonable amount of hash
  * collisions, so the 32bit name space can be packed fairly tight
  * before overflowing.  Oh and currently we don't overflow but return
  * and error.
  *
  * How likely are collisions?  Doing the appropriate math is beyond me
  * and the Bronstein textbook.  But running a test program to brute
  * force collisions for a couple of days showed that on average the
  * first collision occurs after 598M entries, with 290M being the
  * smallest result.  Obviously 21 entries could already cause a
  * collision if all entries are carefully chosen.
  */
 static pgoff_t hash_index(u32 hash, int round)
 {
 	u32 i0_blocks = I0_BLOCKS;
 	u32 i1_blocks = I1_BLOCKS;
 	u32 i2_blocks = I2_BLOCKS;
 	u32 i3_blocks = I3_BLOCKS;

 	switch (round) {
 	case 0:
 		return hash % i0_blocks;
 	case 1:
 		return i0_blocks + hash % (i1_blocks - i0_blocks);
 	case 2:
 		return i1_blocks + hash % (i2_blocks - i1_blocks);
 	case 3:
 		return i2_blocks + hash % (i3_blocks - i2_blocks);
 	case 4 ... 19:
 		return i3_blocks + 16 * (hash % (((1<<31) - i3_blocks) / 16))
 			+ round - 4;
 	}
 	BUG();
 }

 static struct page *logfs_get_dd_page(struct inode *dir, struct dentry *dentry)
 {
 	struct qstr *name = &dentry->d_name;
 	struct page *page;
 	struct logfs_disk_dentry *dd;
 	u32 hash = hash_32(name->name, name->len, 0);
 	pgoff_t index;
 	int round;

 	if (name->len > LOGFS_MAX_NAMELEN)
 		return ERR_PTR(-ENAMETOOLONG);

 	for (round = 0; round < 20; round++) {
 		index = hash_index(hash, round);

 		if (beyond_eof(dir, index))
 			return NULL;
 		if (!logfs_exist_block(dir, index))
 			continue;
 		page = read_cache_page(dir->i_mapping, index,
 				(filler_t *)logfs_readpage, NULL);
 		if (IS_ERR(page))
 			return page;
 		dd = kmap_atomic(page);
 		BUG_ON(dd->namelen == 0);

 		if (name->len != be16_to_cpu(dd->namelen) ||
 				memcmp(name->name, dd->name, name->len)) {
 			kunmap_atomic(dd);
 			page_cache_release(page);
 			continue;
 		}

 		kunmap_atomic(dd);
 		return page;
 	}
 	return NULL;
 }

 static int logfs_remove_inode(struct inode *inode)
 {
 	int ret;

 	drop_nlink(inode);
 	ret = write_inode(inode);
 	LOGFS_BUG_ON(ret, inode->i_sb);
 	return ret;
 }

 static void abort_transaction(struct inode *inode, struct logfs_transaction *ta)
 {
 	if (logfs_inode(inode)->li_block)
 		logfs_inode(inode)->li_block->ta = NULL;
 	kfree(ta);
 }

 static int logfs_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct logfs_super *super = logfs_super(dir->i_sb);
 	struct inode *inode = d_inode(dentry);
 	struct logfs_transaction *ta;
 	struct page *page;
 	pgoff_t index;
 	int ret;

 	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
 	if (!ta)
 		return -ENOMEM;

 	ta->state = UNLINK_1;
 	ta->ino = inode->i_ino;

 	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;

 	page = logfs_get_dd_page(dir, dentry);
 	if (!page) {
 		kfree(ta);
 		return -ENOENT;
 	}
 	if (IS_ERR(page)) {
 		kfree(ta);
 		return PTR_ERR(page);
 	}
 	index = page->index;
 	page_cache_release(page);

 	mutex_lock(&super->s_dirop_mutex);
 	logfs_add_transaction(dir, ta);

 	ret = logfs_delete(dir, index, NULL);
 	if (!ret)
 		ret = write_inode(dir);

 	if (ret) {
 		abort_transaction(dir, ta);
 		printk(KERN_ERR"LOGFS: unable to delete inode\n");
 		goto out;
 	}

 	ta->state = UNLINK_2;
 	logfs_add_transaction(inode, ta);
 	ret = logfs_remove_inode(inode);
 out:
 	mutex_unlock(&super->s_dirop_mutex);
 	return ret;
 }

 static inline int logfs_empty_dir(struct inode *dir)
 {
 	u64 data;

 	data = logfs_seek_data(dir, 0) << dir->i_sb->s_blocksize_bits;
 	return data >= i_size_read(dir);
 }

 static int logfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
 	struct inode *inode = d_inode(dentry);

 	if (!logfs_empty_dir(inode))
 		return -ENOTEMPTY;

 	return logfs_unlink(dir, dentry);
 }

 /* FIXME: readdir currently has it's own dir_walk code.  I don't see a good
  * way to combine the two copies */
 static int logfs_readdir(struct file *file, struct dir_context *ctx)
 {
 	struct inode *dir = file_inode(file);
 	loff_t pos;
 	struct page *page;
 	struct logfs_disk_dentry *dd;

 	if (ctx->pos < 0)
 		return -EINVAL;

 	if (!dir_emit_dots(file, ctx))
 		return 0;

 	pos = ctx->pos - 2;
 	BUG_ON(pos < 0);
 	for (;; pos++, ctx->pos++) {
 		bool full;
 		if (beyond_eof(dir, pos))
 			break;
 		if (!logfs_exist_block(dir, pos)) {
 			/* deleted dentry */
 			pos = dir_seek_data(dir, pos);
 			continue;
 		}
 		page = read_cache_page(dir->i_mapping, pos,
 				(filler_t *)logfs_readpage, NULL);
 		if (IS_ERR(page))
 			return PTR_ERR(page);
 		dd = kmap(page);
 		BUG_ON(dd->namelen == 0);

 		full = !dir_emit(ctx, (char *)dd->name,
 				be16_to_cpu(dd->namelen),
 				be64_to_cpu(dd->ino), dd->type);
 		kunmap(page);
 		page_cache_release(page);
 		if (full)
 			break;
 	}
 	return 0;
 }

 static void logfs_set_name(struct logfs_disk_dentry *dd, struct qstr *name)
 {
 	dd->namelen = cpu_to_be16(name->len);
 	memcpy(dd->name, name->name, name->len);
 }

 static struct dentry *logfs_lookup(struct inode *dir, struct dentry *dentry,
 		unsigned int flags)
 {
 	struct page *page;
 	struct logfs_disk_dentry *dd;
 	pgoff_t index;
 	u64 ino = 0;
 	struct inode *inode;

 	page = logfs_get_dd_page(dir, dentry);
 	if (IS_ERR(page))
 		return ERR_CAST(page);
 	if (!page) {
 		d_add(dentry, NULL);
 		return NULL;
 	}
 	index = page->index;
 	dd = kmap_atomic(page);
 	ino = be64_to_cpu(dd->ino);
 	kunmap_atomic(dd);
 	page_cache_release(page);

 	inode = logfs_iget(dir->i_sb, ino);
 	if (IS_ERR(inode))
 		printk(KERN_ERR"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n",
 				ino, dir->i_ino, index);
 	return d_splice_alias(inode, dentry);
 }

 static void grow_dir(struct inode *dir, loff_t index)
 {
 	index = (index + 1) << dir->i_sb->s_blocksize_bits;
 	if (i_size_read(dir) < index)
 		i_size_write(dir, index);
 }

 static int logfs_write_dir(struct inode *dir, struct dentry *dentry,
 		struct inode *inode)
 {
 	struct page *page;
 	struct logfs_disk_dentry *dd;
 	u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0);
 	pgoff_t index;
 	int round, err;

 	for (round = 0; round < 20; round++) {
 		index = hash_index(hash, round);

 		if (logfs_exist_block(dir, index))
 			continue;
 		page = find_or_create_page(dir->i_mapping, index, GFP_KERNEL);
 		if (!page)
 			return -ENOMEM;

 		dd = kmap_atomic(page);
 		memset(dd, 0, sizeof(*dd));
 		dd->ino = cpu_to_be64(inode->i_ino);
 		dd->type = logfs_type(inode);
 		logfs_set_name(dd, &dentry->d_name);
 		kunmap_atomic(dd);

 		err = logfs_write_buf(dir, page, WF_LOCK);
 		unlock_page(page);
 		page_cache_release(page);
 		if (!err)
 			grow_dir(dir, index);
 		return err;
 	}
 	/* FIXME: Is there a better return value?  In most cases neither
 	 * the filesystem nor the directory are full.  But we have had
 	 * too many collisions for this particular hash and no fallback.
 	 */
 	return -ENOSPC;
 }

 static int __logfs_create(struct inode *dir, struct dentry *dentry,
 		struct inode *inode, const char *dest, long destlen)
 {
 	struct logfs_super *super = logfs_super(dir->i_sb);
 	struct logfs_inode *li = logfs_inode(inode);
 	struct logfs_transaction *ta;
 	int ret;

 	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
 	if (!ta) {
 		drop_nlink(inode);
 		iput(inode);
 		return -ENOMEM;
 	}

 	ta->state = CREATE_1;
 	ta->ino = inode->i_ino;
 	mutex_lock(&super->s_dirop_mutex);
 	logfs_add_transaction(inode, ta);

 	if (dest) {
 		/* symlink */
 		ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL);
 		if (!ret)
 			ret = write_inode(inode);
 	} else {
 		/* creat/mkdir/mknod */
 		ret = write_inode(inode);
 	}
 	if (ret) {
 		abort_transaction(inode, ta);
 		li->li_flags |= LOGFS_IF_STILLBORN;
 		/* FIXME: truncate symlink */
 		drop_nlink(inode);
 		iput(inode);
 		goto out;
 	}

 	ta->state = CREATE_2;
 	logfs_add_transaction(dir, ta);
 	ret = logfs_write_dir(dir, dentry, inode);
 	/* sync directory */
 	if (!ret)
 		ret = write_inode(dir);

 	if (ret) {
 		logfs_del_transaction(dir, ta);
 		ta->state = CREATE_2;
 		logfs_add_transaction(inode, ta);
 		logfs_remove_inode(inode);
 		iput(inode);
 		goto out;
 	}
 	d_instantiate(dentry, inode);
 out:
 	mutex_unlock(&super->s_dirop_mutex);
 	return ret;
 }

 static int logfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
 	struct inode *inode;

 	/*
 	 * FIXME: why do we have to fill in S_IFDIR, while the mode is
 	 * correct for mknod, creat, etc.?  Smells like the vfs *should*
 	 * do it for us but for some reason fails to do so.
 	 */
 	inode = logfs_new_inode(dir, S_IFDIR | mode);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);

 	inode->i_op = &logfs_dir_iops;
 	inode->i_fop = &logfs_dir_fops;

 	return __logfs_create(dir, dentry, inode, NULL, 0);
 }

 static int logfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 		bool excl)
 {
 	struct inode *inode;

 	inode = logfs_new_inode(dir, mode);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);

 	inode->i_op = &logfs_reg_iops;
 	inode->i_fop = &logfs_reg_fops;
 	inode->i_mapping->a_ops = &logfs_reg_aops;

 	return __logfs_create(dir, dentry, inode, NULL, 0);
 }

 static int logfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 		dev_t rdev)
 {
 	struct inode *inode;

 	if (dentry->d_name.len > LOGFS_MAX_NAMELEN)
 		return -ENAMETOOLONG;

 	inode = logfs_new_inode(dir, mode);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);

 	init_special_inode(inode, mode, rdev);

 	return __logfs_create(dir, dentry, inode, NULL, 0);
 }

 static int logfs_symlink(struct inode *dir, struct dentry *dentry,
 		const char *target)
 {
 	struct inode *inode;
 	size_t destlen = strlen(target) + 1;

 	if (destlen > dir->i_sb->s_blocksize)
 		return -ENAMETOOLONG;

 	inode = logfs_new_inode(dir, S_IFLNK | 0777);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);

 	inode->i_op = &page_symlink_inode_operations;
 	inode_nohighmem(inode);
 	inode->i_mapping->a_ops = &logfs_reg_aops;

 	return __logfs_create(dir, dentry, inode, target, destlen);
 }

 static int logfs_link(struct dentry *old_dentry, struct inode *dir,
 		struct dentry *dentry)
 {
 	struct inode *inode = d_inode(old_dentry);

 	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	ihold(inode);
 	inc_nlink(inode);
 	mark_inode_dirty_sync(inode);

 	return __logfs_create(dir, dentry, inode, NULL, 0);
 }

 static int logfs_get_dd(struct inode *dir, struct dentry *dentry,
 		struct logfs_disk_dentry *dd, loff_t *pos)
 {
 	struct page *page;
 	void *map;

 	page = logfs_get_dd_page(dir, dentry);
 	if (IS_ERR(page))
 		return PTR_ERR(page);
 	*pos = page->index;
 	map = kmap_atomic(page);
 	memcpy(dd, map, sizeof(*dd));
 	kunmap_atomic(map);
 	page_cache_release(page);
 	return 0;
 }

 static int logfs_delete_dd(struct inode *dir, loff_t pos)
 {
 	/*
 	 * Getting called with pos somewhere beyond eof is either a goofup
 	 * within this file or means someone maliciously edited the
 	 * (crc-protected) journal.
 	 */
 	BUG_ON(beyond_eof(dir, pos));
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
 	return logfs_delete(dir, pos, NULL);
 }

 /*
  * Cross-directory rename, target does not exist.  Just a little nasty.
  * Create a new dentry in the target dir, then remove the old dentry,
  * all the while taking care to remember our operation in the journal.
  */
 static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry,
 			      struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct logfs_super *super = logfs_super(old_dir->i_sb);
 	struct logfs_disk_dentry dd;
 	struct logfs_transaction *ta;
 	loff_t pos;
 	int err;

 	/* 1. locate source dd */
 	err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
 	if (err)
 		return err;

 	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
 	if (!ta)
 		return -ENOMEM;

 	ta->state = CROSS_RENAME_1;
 	ta->dir = old_dir->i_ino;
 	ta->pos = pos;

 	/* 2. write target dd */
 	mutex_lock(&super->s_dirop_mutex);
 	logfs_add_transaction(new_dir, ta);
 	err = logfs_write_dir(new_dir, new_dentry, d_inode(old_dentry));
 	if (!err)
 		err = write_inode(new_dir);

 	if (err) {
 		super->s_rename_dir = 0;
 		super->s_rename_pos = 0;
 		abort_transaction(new_dir, ta);
 		goto out;
 	}

 	/* 3. remove source dd */
 	ta->state = CROSS_RENAME_2;
 	logfs_add_transaction(old_dir, ta);
 	err = logfs_delete_dd(old_dir, pos);
 	if (!err)
 		err = write_inode(old_dir);
 	LOGFS_BUG_ON(err, old_dir->i_sb);
 out:
 	mutex_unlock(&super->s_dirop_mutex);
 	return err;
 }

 static int logfs_replace_inode(struct inode *dir, struct dentry *dentry,
 		struct logfs_disk_dentry *dd, struct inode *inode)
 {
 	loff_t pos;
 	int err;

 	err = logfs_get_dd(dir, dentry, dd, &pos);
 	if (err)
 		return err;
 	dd->ino = cpu_to_be64(inode->i_ino);
 	dd->type = logfs_type(inode);

 	err = write_dir(dir, dd, pos);
 	if (err)
 		return err;
 	log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos,
 			dd->name, be64_to_cpu(dd->ino));
 	return write_inode(dir);
 }

 /* Target dentry exists - the worst case.  We need to attach the source
  * inode to the target dentry, then remove the orphaned target inode and
  * source dentry.
  */
 static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry,
 			       struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct logfs_super *super = logfs_super(old_dir->i_sb);
 	struct inode *old_inode = d_inode(old_dentry);
 	struct inode *new_inode = d_inode(new_dentry);
 	int isdir = S_ISDIR(old_inode->i_mode);
 	struct logfs_disk_dentry dd;
 	struct logfs_transaction *ta;
 	loff_t pos;
 	int err;

 	BUG_ON(isdir != S_ISDIR(new_inode->i_mode));
 	if (isdir) {
 		if (!logfs_empty_dir(new_inode))
 			return -ENOTEMPTY;
 	}

 	/* 1. locate source dd */
 	err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
 	if (err)
 		return err;

 	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
 	if (!ta)
 		return -ENOMEM;

 	ta->state = TARGET_RENAME_1;
 	ta->dir = old_dir->i_ino;
 	ta->pos = pos;
 	ta->ino = new_inode->i_ino;

 	/* 2. attach source inode to target dd */
 	mutex_lock(&super->s_dirop_mutex);
 	logfs_add_transaction(new_dir, ta);
 	err = logfs_replace_inode(new_dir, new_dentry, &dd, old_inode);
 	if (err) {
 		super->s_rename_dir = 0;
 		super->s_rename_pos = 0;
 		super->s_victim_ino = 0;
 		abort_transaction(new_dir, ta);
 		goto out;
 	}

 	/* 3. remove source dd */
 	ta->state = TARGET_RENAME_2;
 	logfs_add_transaction(old_dir, ta);
 	err = logfs_delete_dd(old_dir, pos);
 	if (!err)
 		err = write_inode(old_dir);
 	LOGFS_BUG_ON(err, old_dir->i_sb);

 	/* 4. remove target inode */
 	ta->state = TARGET_RENAME_3;
 	logfs_add_transaction(new_inode, ta);
 	err = logfs_remove_inode(new_inode);

 out:
 	mutex_unlock(&super->s_dirop_mutex);
 	return err;
 }

 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 			struct inode *new_dir, struct dentry *new_dentry)
 {
 	if (d_really_is_positive(new_dentry))
 		return logfs_rename_target(old_dir, old_dentry,
 					   new_dir, new_dentry);
 	return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
 }

 /* No locking done here, as this is called before .get_sb() returns. */
 int logfs_replay_journal(struct super_block *sb)
 {
 	struct logfs_super *super = logfs_super(sb);
 	struct inode *inode;
 	u64 ino, pos;
 	int err;

 	if (super->s_victim_ino) {
 		/* delete victim inode */
 		ino = super->s_victim_ino;
 		printk(KERN_INFO"LogFS: delete unmapped inode #%llx\n", ino);
 		inode = logfs_iget(sb, ino);
 		if (IS_ERR(inode))
 			goto fail;

 		LOGFS_BUG_ON(i_size_read(inode) > 0, sb);
 		super->s_victim_ino = 0;
 		err = logfs_remove_inode(inode);
 		iput(inode);
 		if (err) {
 			super->s_victim_ino = ino;
 			goto fail;
 		}
 	}
 	if (super->s_rename_dir) {
 		/* delete old dd from rename */
 		ino = super->s_rename_dir;
 		pos = super->s_rename_pos;
 		printk(KERN_INFO"LogFS: delete unbacked dentry (%llx, %llx)\n",
 				ino, pos);
 		inode = logfs_iget(sb, ino);
 		if (IS_ERR(inode))
 			goto fail;

 		super->s_rename_dir = 0;
 		super->s_rename_pos = 0;
 		err = logfs_delete_dd(inode, pos);
 		iput(inode);
 		if (err) {
 			super->s_rename_dir = ino;
 			super->s_rename_pos = pos;
 			goto fail;
 		}
 	}
 	return 0;
 fail:
 	LOGFS_BUG(sb);
 	return -EIO;
 }

 const struct inode_operations logfs_dir_iops = {
 	.create		= logfs_create,
 	.link		= logfs_link,
 	.lookup		= logfs_lookup,
 	.mkdir		= logfs_mkdir,
 	.mknod		= logfs_mknod,
 	.rename		= logfs_rename,
 	.rmdir		= logfs_rmdir,
 	.symlink	= logfs_symlink,
 	.unlink		= logfs_unlink,
 };
 const struct file_operations logfs_dir_fops = {
 	.fsync		= logfs_fsync,
 	.unlocked_ioctl	= logfs_ioctl,
 	.iterate	= logfs_readdir,
 	.read		= generic_read_dir,
 	.llseek		= default_llseek,
 };
	/*
	* fs/logfs/dir.c - directory-related 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>

	/*
	* Atomic dir operations
	*
	* Directory operations are by default not atomic. Dentries and Inodes are
	* created/removed/altered in separate operations. Therefore we need to do
	* a small amount of journaling.
	*
	* Create, link, mkdir, mknod and symlink all share the same function to do
	* the work: __logfs_create. This function works in two atomic steps:
	* 1. allocate inode (remember in journal)
	* 2. allocate dentry (clear journal)
	*
	* As we can only get interrupted between the two, when the inode we just
	* created is simply stored in the anchor. On next mount, if we were
	* interrupted, we delete the inode. From a users point of view the
	* operation never happened.
	*
	* Unlink and rmdir also share the same function: unlink. Again, this
	* function works in two atomic steps
	* 1. remove dentry (remember inode in journal)
	* 2. unlink inode (clear journal)
	*
	* And again, on the next mount, if we were interrupted, we delete the inode.
	* From a users point of view the operation succeeded.
	*
	* Rename is the real pain to deal with, harder than all the other methods
	* combined. Depending on the circumstances we can run into three cases.
	* A "target rename" where the target dentry already existed, a "local
	* rename" where both parent directories are identical or a "cross-directory
	* rename" in the remaining case.
	*
	* Local rename is atomic, as the old dentry is simply rewritten with a new
	* name.
	*
	* Cross-directory rename works in two steps, similar to __logfs_create and
	* logfs_unlink:
	* 1. Write new dentry (remember old dentry in journal)
	* 2. Remove old dentry (clear journal)
	*
	* Here we remember a dentry instead of an inode. On next mount, if we were
	* interrupted, we delete the dentry. From a users point of view, the
	* operation succeeded.
	*
	* Target rename works in three atomic steps:
	* 1. Attach old inode to new dentry (remember old dentry and new inode)
	* 2. Remove old dentry (still remember the new inode)
	* 3. Remove victim inode
	*
	* Here we remember both an inode an a dentry. If we get interrupted
	* between steps 1 and 2, we delete both the dentry and the inode. If
	* we get interrupted between steps 2 and 3, we delete just the inode.
	* In either case, the remaining objects are deleted on next mount. From
	* a users point of view, the operation succeeded.
	*/

	static int write_dir(struct inode dir, struct logfs_disk_dentry dd,
	loff_t pos)
	{
	return logfs_inode_write(dir, dd, sizeof(*dd), pos, WF_LOCK, NULL);
	}

	static int write_inode(struct inode *inode)
	{
	return __logfs_write_inode(inode, NULL, WF_LOCK);
	}

	static s64 dir_seek_data(struct inode *inode, s64 pos)
	{
	s64 new_pos = logfs_seek_data(inode, pos);

	return max(pos, new_pos - 1);
	}

	static int beyond_eof(struct inode *inode, loff_t bix)
	{
	loff_t pos = bix << inode->i_sb->s_blocksize_bits;
	return pos >= i_size_read(inode);
	}

	/*
	* Prime value was chosen to be roughly 256 + 26. r5 hash uses 11,
	* so short names (len <= 9) don't even occupy the complete 32bit name
	* space. A prime >256 ensures short names quickly spread the 32bit
	* name space. Add about 26 for the estimated amount of information
	* of each character and pick a prime nearby, preferably a bit-sparse
	* one.
	*/
	static u32 hash_32(const char *s, int len, u32 seed)
	{
	u32 hash = seed;
	int i;

	for (i = 0; i < len; i++)
	hash = hash * 293 + s[i];
	return hash;
	}

	/*
	* We have to satisfy several conflicting requirements here. Small
	* directories should stay fairly compact and not require too many
	* indirect blocks. The number of possible locations for a given hash
	* should be small to make lookup() fast. And we should try hard not
	* to overflow the 32bit name space or nfs and 32bit host systems will
	* be unhappy.
	*
	* So we use the following scheme. First we reduce the hash to 0..15
	* and try a direct block. If that is occupied we reduce the hash to
	* 16..255 and try an indirect block. Same for 2x and 3x indirect
	* blocks. Lastly we reduce the hash to 0x800_0000 .. 0xffff_ffff,
	* but use buckets containing eight entries instead of a single one.
	*
	* Using 16 entries should allow for a reasonable amount of hash
	* collisions, so the 32bit name space can be packed fairly tight
	* before overflowing. Oh and currently we don't overflow but return
	* and error.
	*
	* How likely are collisions? Doing the appropriate math is beyond me
	* and the Bronstein textbook. But running a test program to brute
	* force collisions for a couple of days showed that on average the
	* first collision occurs after 598M entries, with 290M being the
	* smallest result. Obviously 21 entries could already cause a
	* collision if all entries are carefully chosen.
	*/
	static pgoff_t hash_index(u32 hash, int round)
	{
	u32 i0_blocks = I0_BLOCKS;
	u32 i1_blocks = I1_BLOCKS;
	u32 i2_blocks = I2_BLOCKS;
	u32 i3_blocks = I3_BLOCKS;

	switch (round) {
	case 0:
	return hash % i0_blocks;
	case 1:
	return i0_blocks + hash % (i1_blocks - i0_blocks);
	case 2:
	return i1_blocks + hash % (i2_blocks - i1_blocks);
	case 3:
	return i2_blocks + hash % (i3_blocks - i2_blocks);
	case 4 ... 19:
	return i3_blocks + 16 * (hash % (((1<<31) - i3_blocks) / 16))
	+ round - 4;
	}
	BUG();
	}

	static struct page logfs_get_dd_page(struct inode dir, struct dentry *dentry)
	{
	struct qstr *name = &dentry->d_name;
	struct page *page;
	struct logfs_disk_dentry *dd;
	u32 hash = hash_32(name->name, name->len, 0);
	pgoff_t index;
	int round;

	if (name->len > LOGFS_MAX_NAMELEN)
	return ERR_PTR(-ENAMETOOLONG);

	for (round = 0; round < 20; round++) {
	index = hash_index(hash, round);

	if (beyond_eof(dir, index))
	return NULL;
	if (!logfs_exist_block(dir, index))
	continue;
	page = read_cache_page(dir->i_mapping, index,
	(filler_t *)logfs_readpage, NULL);
	if (IS_ERR(page))
	return page;
	dd = kmap_atomic(page);
	BUG_ON(dd->namelen == 0);

	if (name->len != be16_to_cpu(dd->namelen) \|\|
	memcmp(name->name, dd->name, name->len)) {
	kunmap_atomic(dd);
	page_cache_release(page);
	continue;
	}

	kunmap_atomic(dd);
	return page;
	}
	return NULL;
	}

	static int logfs_remove_inode(struct inode *inode)
	{
	int ret;

	drop_nlink(inode);
	ret = write_inode(inode);
	LOGFS_BUG_ON(ret, inode->i_sb);
	return ret;
	}

	static void abort_transaction(struct inode inode, struct logfs_transaction ta)
	{
	if (logfs_inode(inode)->li_block)
	logfs_inode(inode)->li_block->ta = NULL;
	kfree(ta);
	}

	static int logfs_unlink(struct inode dir, struct dentry dentry)
	{
	struct logfs_super *super = logfs_super(dir->i_sb);
	struct inode *inode = d_inode(dentry);
	struct logfs_transaction *ta;
	struct page *page;
	pgoff_t index;
	int ret;

	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
	if (!ta)
	return -ENOMEM;

	ta->state = UNLINK_1;
	ta->ino = inode->i_ino;

	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;

	page = logfs_get_dd_page(dir, dentry);
	if (!page) {
	kfree(ta);
	return -ENOENT;
	}
	if (IS_ERR(page)) {
	kfree(ta);
	return PTR_ERR(page);
	}
	index = page->index;
	page_cache_release(page);

	mutex_lock(&super->s_dirop_mutex);
	logfs_add_transaction(dir, ta);

	ret = logfs_delete(dir, index, NULL);
	if (!ret)
	ret = write_inode(dir);

	if (ret) {
	abort_transaction(dir, ta);
	printk(KERN_ERR"LOGFS: unable to delete inode\n");
	goto out;
	}

	ta->state = UNLINK_2;
	logfs_add_transaction(inode, ta);
	ret = logfs_remove_inode(inode);
	out:
	mutex_unlock(&super->s_dirop_mutex);
	return ret;
	}

	static inline int logfs_empty_dir(struct inode *dir)
	{
	u64 data;

	data = logfs_seek_data(dir, 0) << dir->i_sb->s_blocksize_bits;
	return data >= i_size_read(dir);
	}

	static int logfs_rmdir(struct inode dir, struct dentry dentry)
	{
	struct inode *inode = d_inode(dentry);

	if (!logfs_empty_dir(inode))
	return -ENOTEMPTY;

	return logfs_unlink(dir, dentry);
	}

	/* FIXME: readdir currently has it's own dir_walk code. I don't see a good
	* way to combine the two copies */
	static int logfs_readdir(struct file file, struct dir_context ctx)
	{
	struct inode *dir = file_inode(file);
	loff_t pos;
	struct page *page;
	struct logfs_disk_dentry *dd;

	if (ctx->pos < 0)
	return -EINVAL;

	if (!dir_emit_dots(file, ctx))
	return 0;

	pos = ctx->pos - 2;
	BUG_ON(pos < 0);
	for (;; pos++, ctx->pos++) {
	bool full;
	if (beyond_eof(dir, pos))
	break;
	if (!logfs_exist_block(dir, pos)) {
	/* deleted dentry */
	pos = dir_seek_data(dir, pos);
	continue;
	}
	page = read_cache_page(dir->i_mapping, pos,
	(filler_t *)logfs_readpage, NULL);
	if (IS_ERR(page))
	return PTR_ERR(page);
	dd = kmap(page);
	BUG_ON(dd->namelen == 0);

	full = !dir_emit(ctx, (char *)dd->name,
	be16_to_cpu(dd->namelen),
	be64_to_cpu(dd->ino), dd->type);
	kunmap(page);
	page_cache_release(page);
	if (full)
	break;
	}
	return 0;
	}

	static void logfs_set_name(struct logfs_disk_dentry dd, struct qstr name)
	{
	dd->namelen = cpu_to_be16(name->len);
	memcpy(dd->name, name->name, name->len);
	}

	static struct dentry logfs_lookup(struct inode dir, struct dentry *dentry,
	unsigned int flags)
	{
	struct page *page;
	struct logfs_disk_dentry *dd;
	pgoff_t index;
	u64 ino = 0;
	struct inode *inode;

	page = logfs_get_dd_page(dir, dentry);
	if (IS_ERR(page))
	return ERR_CAST(page);
	if (!page) {
	d_add(dentry, NULL);
	return NULL;
	}
	index = page->index;
	dd = kmap_atomic(page);
	ino = be64_to_cpu(dd->ino);
	kunmap_atomic(dd);
	page_cache_release(page);

	inode = logfs_iget(dir->i_sb, ino);
	if (IS_ERR(inode))
	printk(KERN_ERR"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n",
	ino, dir->i_ino, index);
	return d_splice_alias(inode, dentry);
	}

	static void grow_dir(struct inode *dir, loff_t index)
	{
	index = (index + 1) << dir->i_sb->s_blocksize_bits;
	if (i_size_read(dir) < index)
	i_size_write(dir, index);
	}

	static int logfs_write_dir(struct inode dir, struct dentry dentry,
	struct inode *inode)
	{
	struct page *page;
	struct logfs_disk_dentry *dd;
	u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0);
	pgoff_t index;
	int round, err;

	for (round = 0; round < 20; round++) {
	index = hash_index(hash, round);

	if (logfs_exist_block(dir, index))
	continue;
	page = find_or_create_page(dir->i_mapping, index, GFP_KERNEL);
	if (!page)
	return -ENOMEM;

	dd = kmap_atomic(page);
	memset(dd, 0, sizeof(*dd));
	dd->ino = cpu_to_be64(inode->i_ino);
	dd->type = logfs_type(inode);
	logfs_set_name(dd, &dentry->d_name);
	kunmap_atomic(dd);

	err = logfs_write_buf(dir, page, WF_LOCK);
	unlock_page(page);
	page_cache_release(page);
	if (!err)
	grow_dir(dir, index);
	return err;
	}
	/* FIXME: Is there a better return value? In most cases neither
	* the filesystem nor the directory are full. But we have had
	* too many collisions for this particular hash and no fallback.
	*/
	return -ENOSPC;
	}

	static int __logfs_create(struct inode dir, struct dentry dentry,
	struct inode inode, const char dest, long destlen)
	{
	struct logfs_super *super = logfs_super(dir->i_sb);
	struct logfs_inode *li = logfs_inode(inode);
	struct logfs_transaction *ta;
	int ret;

	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
	if (!ta) {
	drop_nlink(inode);
	iput(inode);
	return -ENOMEM;
	}

	ta->state = CREATE_1;
	ta->ino = inode->i_ino;
	mutex_lock(&super->s_dirop_mutex);
	logfs_add_transaction(inode, ta);

	if (dest) {
	/* symlink */
	ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL);
	if (!ret)
	ret = write_inode(inode);
	} else {
	/* creat/mkdir/mknod */
	ret = write_inode(inode);
	}
	if (ret) {
	abort_transaction(inode, ta);
	li->li_flags \|= LOGFS_IF_STILLBORN;
	/* FIXME: truncate symlink */
	drop_nlink(inode);
	iput(inode);
	goto out;
	}

	ta->state = CREATE_2;
	logfs_add_transaction(dir, ta);
	ret = logfs_write_dir(dir, dentry, inode);
	/* sync directory */
	if (!ret)
	ret = write_inode(dir);

	if (ret) {
	logfs_del_transaction(dir, ta);
	ta->state = CREATE_2;
	logfs_add_transaction(inode, ta);
	logfs_remove_inode(inode);
	iput(inode);
	goto out;
	}
	d_instantiate(dentry, inode);
	out:
	mutex_unlock(&super->s_dirop_mutex);
	return ret;
	}

	static int logfs_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
	{
	struct inode *inode;

	/*
	* FIXME: why do we have to fill in S_IFDIR, while the mode is
	* correct for mknod, creat, etc.? Smells like the vfs should
	* do it for us but for some reason fails to do so.
	*/
	inode = logfs_new_inode(dir, S_IFDIR \| mode);
	if (IS_ERR(inode))
	return PTR_ERR(inode);

	inode->i_op = &logfs_dir_iops;
	inode->i_fop = &logfs_dir_fops;

	return __logfs_create(dir, dentry, inode, NULL, 0);
	}

	static int logfs_create(struct inode dir, struct dentry dentry, umode_t mode,
	bool excl)
	{
	struct inode *inode;

	inode = logfs_new_inode(dir, mode);
	if (IS_ERR(inode))
	return PTR_ERR(inode);

	inode->i_op = &logfs_reg_iops;
	inode->i_fop = &logfs_reg_fops;
	inode->i_mapping->a_ops = &logfs_reg_aops;

	return __logfs_create(dir, dentry, inode, NULL, 0);
	}

	static int logfs_mknod(struct inode dir, struct dentry dentry, umode_t mode,
	dev_t rdev)
	{
	struct inode *inode;

	if (dentry->d_name.len > LOGFS_MAX_NAMELEN)
	return -ENAMETOOLONG;

	inode = logfs_new_inode(dir, mode);
	if (IS_ERR(inode))
	return PTR_ERR(inode);

	init_special_inode(inode, mode, rdev);

	return __logfs_create(dir, dentry, inode, NULL, 0);
	}

	static int logfs_symlink(struct inode dir, struct dentry dentry,
	const char *target)
	{
	struct inode *inode;
	size_t destlen = strlen(target) + 1;

	if (destlen > dir->i_sb->s_blocksize)
	return -ENAMETOOLONG;

	inode = logfs_new_inode(dir, S_IFLNK \| 0777);
	if (IS_ERR(inode))
	return PTR_ERR(inode);

	inode->i_op = &page_symlink_inode_operations;
	inode_nohighmem(inode);
	inode->i_mapping->a_ops = &logfs_reg_aops;

	return __logfs_create(dir, dentry, inode, target, destlen);
	}

	static int logfs_link(struct dentry old_dentry, struct inode dir,
	struct dentry *dentry)
	{
	struct inode *inode = d_inode(old_dentry);

	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
	ihold(inode);
	inc_nlink(inode);
	mark_inode_dirty_sync(inode);

	return __logfs_create(dir, dentry, inode, NULL, 0);
	}

	static int logfs_get_dd(struct inode dir, struct dentry dentry,
	struct logfs_disk_dentry dd, loff_t pos)
	{
	struct page *page;
	void *map;

	page = logfs_get_dd_page(dir, dentry);
	if (IS_ERR(page))
	return PTR_ERR(page);
	*pos = page->index;
	map = kmap_atomic(page);
	memcpy(dd, map, sizeof(*dd));
	kunmap_atomic(map);
	page_cache_release(page);
	return 0;
	}

	static int logfs_delete_dd(struct inode *dir, loff_t pos)
	{
	/*
	* Getting called with pos somewhere beyond eof is either a goofup
	* within this file or means someone maliciously edited the
	* (crc-protected) journal.
	*/
	BUG_ON(beyond_eof(dir, pos));
	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
	log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
	return logfs_delete(dir, pos, NULL);
	}

	/*
	* Cross-directory rename, target does not exist. Just a little nasty.
	* Create a new dentry in the target dir, then remove the old dentry,
	* all the while taking care to remember our operation in the journal.
	*/
	static int logfs_rename_cross(struct inode old_dir, struct dentry old_dentry,
	struct inode new_dir, struct dentry new_dentry)
	{
	struct logfs_super *super = logfs_super(old_dir->i_sb);
	struct logfs_disk_dentry dd;
	struct logfs_transaction *ta;
	loff_t pos;
	int err;

	/* 1. locate source dd */
	err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
	if (err)
	return err;

	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
	if (!ta)
	return -ENOMEM;

	ta->state = CROSS_RENAME_1;
	ta->dir = old_dir->i_ino;
	ta->pos = pos;

	/* 2. write target dd */
	mutex_lock(&super->s_dirop_mutex);
	logfs_add_transaction(new_dir, ta);
	err = logfs_write_dir(new_dir, new_dentry, d_inode(old_dentry));
	if (!err)
	err = write_inode(new_dir);

	if (err) {
	super->s_rename_dir = 0;
	super->s_rename_pos = 0;
	abort_transaction(new_dir, ta);
	goto out;
	}

	/* 3. remove source dd */
	ta->state = CROSS_RENAME_2;
	logfs_add_transaction(old_dir, ta);
	err = logfs_delete_dd(old_dir, pos);
	if (!err)
	err = write_inode(old_dir);
	LOGFS_BUG_ON(err, old_dir->i_sb);
	out:
	mutex_unlock(&super->s_dirop_mutex);
	return err;
	}

	static int logfs_replace_inode(struct inode dir, struct dentry dentry,
	struct logfs_disk_dentry dd, struct inode inode)
	{
	loff_t pos;
	int err;

	err = logfs_get_dd(dir, dentry, dd, &pos);
	if (err)
	return err;
	dd->ino = cpu_to_be64(inode->i_ino);
	dd->type = logfs_type(inode);

	err = write_dir(dir, dd, pos);
	if (err)
	return err;
	log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos,
	dd->name, be64_to_cpu(dd->ino));
	return write_inode(dir);
	}

	/* Target dentry exists - the worst case. We need to attach the source
	* inode to the target dentry, then remove the orphaned target inode and
	* source dentry.
	*/
	static int logfs_rename_target(struct inode old_dir, struct dentry old_dentry,
	struct inode new_dir, struct dentry new_dentry)
	{
	struct logfs_super *super = logfs_super(old_dir->i_sb);
	struct inode *old_inode = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
	int isdir = S_ISDIR(old_inode->i_mode);
	struct logfs_disk_dentry dd;
	struct logfs_transaction *ta;
	loff_t pos;
	int err;

	BUG_ON(isdir != S_ISDIR(new_inode->i_mode));
	if (isdir) {
	if (!logfs_empty_dir(new_inode))
	return -ENOTEMPTY;
	}

	/* 1. locate source dd */
	err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
	if (err)
	return err;

	ta = kzalloc(sizeof(*ta), GFP_KERNEL);
	if (!ta)
	return -ENOMEM;

	ta->state = TARGET_RENAME_1;
	ta->dir = old_dir->i_ino;
	ta->pos = pos;
	ta->ino = new_inode->i_ino;

	/* 2. attach source inode to target dd */
	mutex_lock(&super->s_dirop_mutex);
	logfs_add_transaction(new_dir, ta);
	err = logfs_replace_inode(new_dir, new_dentry, &dd, old_inode);
	if (err) {
	super->s_rename_dir = 0;
	super->s_rename_pos = 0;
	super->s_victim_ino = 0;
	abort_transaction(new_dir, ta);
	goto out;
	}

	/* 3. remove source dd */
	ta->state = TARGET_RENAME_2;
	logfs_add_transaction(old_dir, ta);
	err = logfs_delete_dd(old_dir, pos);
	if (!err)
	err = write_inode(old_dir);
	LOGFS_BUG_ON(err, old_dir->i_sb);

	/* 4. remove target inode */
	ta->state = TARGET_RENAME_3;
	logfs_add_transaction(new_inode, ta);
	err = logfs_remove_inode(new_inode);

	out:
	mutex_unlock(&super->s_dirop_mutex);
	return err;
	}

	static int logfs_rename(struct inode old_dir, struct dentry old_dentry,
	struct inode new_dir, struct dentry new_dentry)
	{
	if (d_really_is_positive(new_dentry))
	return logfs_rename_target(old_dir, old_dentry,
	new_dir, new_dentry);
	return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
	}

	/* No locking done here, as this is called before .get_sb() returns. */
	int logfs_replay_journal(struct super_block *sb)
	{
	struct logfs_super *super = logfs_super(sb);
	struct inode *inode;
	u64 ino, pos;
	int err;

	if (super->s_victim_ino) {
	/* delete victim inode */
	ino = super->s_victim_ino;
	printk(KERN_INFO"LogFS: delete unmapped inode #%llx\n", ino);
	inode = logfs_iget(sb, ino);
	if (IS_ERR(inode))
	goto fail;

	LOGFS_BUG_ON(i_size_read(inode) > 0, sb);
	super->s_victim_ino = 0;
	err = logfs_remove_inode(inode);
	iput(inode);
	if (err) {
	super->s_victim_ino = ino;
	goto fail;
	}
	}
	if (super->s_rename_dir) {
	/* delete old dd from rename */
	ino = super->s_rename_dir;
	pos = super->s_rename_pos;
	printk(KERN_INFO"LogFS: delete unbacked dentry (%llx, %llx)\n",
	ino, pos);
	inode = logfs_iget(sb, ino);
	if (IS_ERR(inode))
	goto fail;

	super->s_rename_dir = 0;
	super->s_rename_pos = 0;
	err = logfs_delete_dd(inode, pos);
	iput(inode);
	if (err) {
	super->s_rename_dir = ino;
	super->s_rename_pos = pos;
	goto fail;
	}
	}
	return 0;
	fail:
	LOGFS_BUG(sb);
	return -EIO;
	}

	const struct inode_operations logfs_dir_iops = {
	.create = logfs_create,
	.link = logfs_link,
	.lookup = logfs_lookup,
	.mkdir = logfs_mkdir,
	.mknod = logfs_mknod,
	.rename = logfs_rename,
	.rmdir = logfs_rmdir,
	.symlink = logfs_symlink,
	.unlink = logfs_unlink,
	};
	const struct file_operations logfs_dir_fops = {
	.fsync = logfs_fsync,
	.unlocked_ioctl = logfs_ioctl,
	.iterate = logfs_readdir,
	.read = generic_read_dir,
	.llseek = default_llseek,
	};