[net-next-2.6.git] / fs / nilfs2 / namei.c

/*
 * namei.c - NILFS pathname lookup operations.
 *
 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>,
 *                       Ryusuke Konishi <ryusuke@osrg.net>
 */
/*
 *  linux/fs/ext2/namei.c
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/namei.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (davem@caip.rutgers.edu), 1995
 */

#include <linux/pagemap.h>
#include "nilfs.h"
#include "export.h"

#define NILFS_FID_SIZE_NON_CONNECTABLE \
	(offsetof(struct nilfs_fid, parent_gen) / 4)
#define NILFS_FID_SIZE_CONNECTABLE	(sizeof(struct nilfs_fid) / 4)

static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
{
	int err = nilfs_add_link(dentry, inode);
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
	inode_dec_link_count(inode);
	iput(inode);
	return err;
}

/*
 * Methods themselves.
 */

static struct dentry *
nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	struct inode *inode;
	ino_t ino;

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

	ino = nilfs_inode_by_name(dir, &dentry->d_name);
	inode = NULL;
	if (ino) {
		inode = nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino);
		if (IS_ERR(inode))
			return ERR_CAST(inode);
	}
	return d_splice_alias(inode, dentry);
}

/*
 * By the time this is called, we already have created
 * the directory cache entry for the new file, but it
 * is so far negative - it has no inode.
 *
 * If the create succeeds, we fill in the inode information
 * with d_instantiate().
 */
static int nilfs_create(struct inode *dir, struct dentry *dentry, int mode,
			struct nameidata *nd)
{
	struct inode *inode;
	struct nilfs_transaction_info ti;
	int err;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	if (err)
		return err;
	inode = nilfs_new_inode(dir, mode);
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		inode->i_op = &nilfs_file_inode_operations;
		inode->i_fop = &nilfs_file_operations;
		inode->i_mapping->a_ops = &nilfs_aops;
		nilfs_mark_inode_dirty(inode);
		err = nilfs_add_nondir(dentry, inode);
	}
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;
}

static int
nilfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
{
	struct inode *inode;
	struct nilfs_transaction_info ti;
	int err;

	if (!new_valid_dev(rdev))
		return -EINVAL;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	if (err)
		return err;
	inode = nilfs_new_inode(dir, mode);
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		init_special_inode(inode, inode->i_mode, rdev);
		nilfs_mark_inode_dirty(inode);
		err = nilfs_add_nondir(dentry, inode);
	}
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;
}

static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
			 const char *symname)
{
	struct nilfs_transaction_info ti;
	struct super_block *sb = dir->i_sb;
	unsigned l = strlen(symname)+1;
	struct inode *inode;
	int err;

	if (l > sb->s_blocksize)
		return -ENAMETOOLONG;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	if (err)
		return err;

	inode = nilfs_new_inode(dir, S_IFLNK | S_IRWXUGO);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out;

	/* slow symlink */
	inode->i_op = &nilfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &nilfs_aops;
	err = page_symlink(inode, symname, l);
	if (err)
		goto out_fail;

	/* mark_inode_dirty(inode); */
	/* page_symlink() do this */

	err = nilfs_add_nondir(dentry, inode);
out:
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;

out_fail:
	drop_nlink(inode);
	nilfs_mark_inode_dirty(inode);
	iput(inode);
	goto out;
}

static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
		      struct dentry *dentry)
{
	struct inode *inode = old_dentry->d_inode;
	struct nilfs_transaction_info ti;
	int err;

	if (inode->i_nlink >= NILFS_LINK_MAX)
		return -EMLINK;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	if (err)
		return err;

	inode->i_ctime = CURRENT_TIME;
	inode_inc_link_count(inode);
	ihold(inode);

	err = nilfs_add_nondir(dentry, inode);
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;
}

static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	struct inode *inode;
	struct nilfs_transaction_info ti;
	int err;

	if (dir->i_nlink >= NILFS_LINK_MAX)
		return -EMLINK;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	if (err)
		return err;

	inc_nlink(dir);

	inode = nilfs_new_inode(dir, S_IFDIR | mode);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_dir;

	inode->i_op = &nilfs_dir_inode_operations;
	inode->i_fop = &nilfs_dir_operations;
	inode->i_mapping->a_ops = &nilfs_aops;

	inc_nlink(inode);

	err = nilfs_make_empty(inode, dir);
	if (err)
		goto out_fail;

	err = nilfs_add_link(dentry, inode);
	if (err)
		goto out_fail;

	nilfs_mark_inode_dirty(inode);
	d_instantiate(dentry, inode);
out:
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;

out_fail:
	drop_nlink(inode);
	drop_nlink(inode);
	nilfs_mark_inode_dirty(inode);
	iput(inode);
out_dir:
	drop_nlink(dir);
	nilfs_mark_inode_dirty(dir);
	goto out;
}

static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode;
	struct nilfs_dir_entry *de;
	struct page *page;
	int err;

	err = -ENOENT;
	de = nilfs_find_entry(dir, &dentry->d_name, &page);
	if (!de)
		goto out;

	inode = dentry->d_inode;
	err = -EIO;
	if (le64_to_cpu(de->inode) != inode->i_ino)
		goto out;

	if (!inode->i_nlink) {
		nilfs_warning(inode->i_sb, __func__,
			      "deleting nonexistent file (%lu), %d\n",
			      inode->i_ino, inode->i_nlink);
		inode->i_nlink = 1;
	}
	err = nilfs_delete_entry(de, page);
	if (err)
		goto out;

	inode->i_ctime = dir->i_ctime;
	drop_nlink(inode);
	err = 0;
out:
	return err;
}

static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct nilfs_transaction_info ti;
	int err;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
	if (err)
		return err;

	err = nilfs_do_unlink(dir, dentry);

	if (!err) {
		nilfs_mark_inode_dirty(dir);
		nilfs_mark_inode_dirty(dentry->d_inode);
		err = nilfs_transaction_commit(dir->i_sb);
	} else
		nilfs_transaction_abort(dir->i_sb);

	return err;
}

static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
	struct nilfs_transaction_info ti;
	int err;

	err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
	if (err)
		return err;

	err = -ENOTEMPTY;
	if (nilfs_empty_dir(inode)) {
		err = nilfs_do_unlink(dir, dentry);
		if (!err) {
			inode->i_size = 0;
			drop_nlink(inode);
			nilfs_mark_inode_dirty(inode);
			drop_nlink(dir);
			nilfs_mark_inode_dirty(dir);
		}
	}
	if (!err)
		err = nilfs_transaction_commit(dir->i_sb);
	else
		nilfs_transaction_abort(dir->i_sb);

	return err;
}

static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			struct inode *new_dir,	struct dentry *new_dentry)
{
	struct inode *old_inode = old_dentry->d_inode;
	struct inode *new_inode = new_dentry->d_inode;
	struct page *dir_page = NULL;
	struct nilfs_dir_entry *dir_de = NULL;
	struct page *old_page;
	struct nilfs_dir_entry *old_de;
	struct nilfs_transaction_info ti;
	int err;

	err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
	if (unlikely(err))
		return err;

	err = -ENOENT;
	old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
	if (!old_de)
		goto out;

	if (S_ISDIR(old_inode->i_mode)) {
		err = -EIO;
		dir_de = nilfs_dotdot(old_inode, &dir_page);
		if (!dir_de)
			goto out_old;
	}

	if (new_inode) {
		struct page *new_page;
		struct nilfs_dir_entry *new_de;

		err = -ENOTEMPTY;
		if (dir_de && !nilfs_empty_dir(new_inode))
			goto out_dir;

		err = -ENOENT;
		new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
		if (!new_de)
			goto out_dir;
		inc_nlink(old_inode);
		nilfs_set_link(new_dir, new_de, new_page, old_inode);
		nilfs_mark_inode_dirty(new_dir);
		new_inode->i_ctime = CURRENT_TIME;
		if (dir_de)
			drop_nlink(new_inode);
		drop_nlink(new_inode);
		nilfs_mark_inode_dirty(new_inode);
	} else {
		if (dir_de) {
			err = -EMLINK;
			if (new_dir->i_nlink >= NILFS_LINK_MAX)
				goto out_dir;
		}
		inc_nlink(old_inode);
		err = nilfs_add_link(new_dentry, old_inode);
		if (err) {
			drop_nlink(old_inode);
			nilfs_mark_inode_dirty(old_inode);
			goto out_dir;
		}
		if (dir_de) {
			inc_nlink(new_dir);
			nilfs_mark_inode_dirty(new_dir);
		}
	}

	/*
	 * Like most other Unix systems, set the ctime for inodes on a
	 * rename.
	 */
	old_inode->i_ctime = CURRENT_TIME;

	nilfs_delete_entry(old_de, old_page);
	drop_nlink(old_inode);

	if (dir_de) {
		nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
		drop_nlink(old_dir);
	}
	nilfs_mark_inode_dirty(old_dir);
	nilfs_mark_inode_dirty(old_inode);

	err = nilfs_transaction_commit(old_dir->i_sb);
	return err;

out_dir:
	if (dir_de) {
		kunmap(dir_page);
		page_cache_release(dir_page);
	}
out_old:
	kunmap(old_page);
	page_cache_release(old_page);
out:
	nilfs_transaction_abort(old_dir->i_sb);
	return err;
}

/*
 * Export operations
 */
static struct dentry *nilfs_get_parent(struct dentry *child)
{
	unsigned long ino;
	struct inode *inode;
	struct qstr dotdot = {.name = "..", .len = 2};
	struct nilfs_root *root;

	ino = nilfs_inode_by_name(child->d_inode, &dotdot);
	if (!ino)
		return ERR_PTR(-ENOENT);

	root = NILFS_I(child->d_inode)->i_root;

	inode = nilfs_iget(child->d_inode->i_sb, root, ino);
	if (IS_ERR(inode))
		return ERR_CAST(inode);

	return d_obtain_alias(inode);
}

static struct dentry *nilfs_get_dentry(struct super_block *sb, u64 cno,
				       u64 ino, u32 gen)
{
	struct nilfs_root *root;
	struct inode *inode;

	if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
		return ERR_PTR(-ESTALE);

	root = nilfs_lookup_root(NILFS_SB(sb)->s_nilfs, cno);
	if (!root)
		return ERR_PTR(-ESTALE);

	inode = nilfs_iget(sb, root, ino);
	nilfs_put_root(root);

	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (gen && inode->i_generation != gen) {
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return d_obtain_alias(inode);
}

static struct dentry *nilfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
					 int fh_len, int fh_type)
{
	struct nilfs_fid *fid = (struct nilfs_fid *)fh;

	if ((fh_len != NILFS_FID_SIZE_NON_CONNECTABLE &&
	     fh_len != NILFS_FID_SIZE_CONNECTABLE) ||
	    (fh_type != FILEID_NILFS_WITH_PARENT &&
	     fh_type != FILEID_NILFS_WITHOUT_PARENT))
		return NULL;

	return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
}

static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
					 int fh_len, int fh_type)
{
	struct nilfs_fid *fid = (struct nilfs_fid *)fh;

	if (fh_len != NILFS_FID_SIZE_CONNECTABLE ||
	    fh_type != FILEID_NILFS_WITH_PARENT)
		return NULL;

	return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
}

static int nilfs_encode_fh(struct dentry *dentry, __u32 *fh, int *lenp,
			   int connectable)
{
	struct nilfs_fid *fid = (struct nilfs_fid *)fh;
	struct inode *inode = dentry->d_inode;
	struct nilfs_root *root = NILFS_I(inode)->i_root;
	int type;

	if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE ||
	    (connectable && *lenp < NILFS_FID_SIZE_CONNECTABLE))
		return 255;

	fid->cno = root->cno;
	fid->ino = inode->i_ino;
	fid->gen = inode->i_generation;

	if (connectable && !S_ISDIR(inode->i_mode)) {
		struct inode *parent;

		spin_lock(&dentry->d_lock);
		parent = dentry->d_parent->d_inode;
		fid->parent_ino = parent->i_ino;
		fid->parent_gen = parent->i_generation;
		spin_unlock(&dentry->d_lock);

		type = FILEID_NILFS_WITH_PARENT;
		*lenp = NILFS_FID_SIZE_CONNECTABLE;
	} else {
		type = FILEID_NILFS_WITHOUT_PARENT;
		*lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
	}

	return type;
}

const struct inode_operations nilfs_dir_inode_operations = {
	.create		= nilfs_create,
	.lookup		= nilfs_lookup,
	.link		= nilfs_link,
	.unlink		= nilfs_unlink,
	.symlink	= nilfs_symlink,
	.mkdir		= nilfs_mkdir,
	.rmdir		= nilfs_rmdir,
	.mknod		= nilfs_mknod,
	.rename		= nilfs_rename,
	.setattr	= nilfs_setattr,
	.permission	= nilfs_permission,
};

const struct inode_operations nilfs_special_inode_operations = {
	.setattr	= nilfs_setattr,
	.permission	= nilfs_permission,
};

const struct inode_operations nilfs_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
	.permission     = nilfs_permission,
};

const struct export_operations nilfs_export_ops = {
	.encode_fh = nilfs_encode_fh,
	.fh_to_dentry = nilfs_fh_to_dentry,
	.fh_to_parent = nilfs_fh_to_parent,
	.get_parent = nilfs_get_parent,
};
Commit	Line	Data
d2500652 RK	1	/*
	2	* namei.c - NILFS pathname lookup operations.
	3	*
	4	* Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*
	20	* Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>,
	21	* Ryusuke Konishi <ryusuke@osrg.net>
	22	*/
	23	/*
	24	* linux/fs/ext2/namei.c
	25	*
	26	* Copyright (C) 1992, 1993, 1994, 1995
	27	* Remy Card (card@masi.ibp.fr)
	28	* Laboratoire MASI - Institut Blaise Pascal
	29	* Universite Pierre et Marie Curie (Paris VI)
	30	*
	31	* from
	32	*
	33	* linux/fs/minix/namei.c
	34	*
	35	* Copyright (C) 1991, 1992 Linus Torvalds
	36	*
	37	* Big-endian to little-endian byte-swapping/bitmaps by
	38	* David S. Miller (davem@caip.rutgers.edu), 1995
	39	*/
	40
	41	#include <linux/pagemap.h>
	42	#include "nilfs.h"
8e656fd5	43	#include "export.h"
d2500652	44
8e656fd5 RK	45	#define NILFS_FID_SIZE_NON_CONNECTABLE \
	46	(offsetof(struct nilfs_fid, parent_gen) / 4)
	47	#define NILFS_FID_SIZE_CONNECTABLE (sizeof(struct nilfs_fid) / 4)
d2500652 RK	48
	49	static inline int nilfs_add_nondir(struct dentry dentry, struct inode inode)
	50	{
	51	int err = nilfs_add_link(dentry, inode);
	52	if (!err) {
	53	d_instantiate(dentry, inode);
	54	return 0;
	55	}
	56	inode_dec_link_count(inode);
	57	iput(inode);
	58	return err;
	59	}
	60
	61	/*
	62	* Methods themselves.
	63	*/
	64
	65	static struct dentry *
	66	nilfs_lookup(struct inode dir, struct dentry dentry, struct nameidata *nd)
	67	{
	68	struct inode *inode;
	69	ino_t ino;
	70
	71	if (dentry->d_name.len > NILFS_NAME_LEN)
	72	return ERR_PTR(-ENAMETOOLONG);
	73
0319003d	74	ino = nilfs_inode_by_name(dir, &dentry->d_name);
d2500652 RK	75	inode = NULL;
d2500652 RK	76	if (ino) {
4d8d9293	77	inode = nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino);
d2500652 RK	78	if (IS_ERR(inode))
	79	return ERR_CAST(inode);
	80	}
	81	return d_splice_alias(inode, dentry);
	82	}
	83
d2500652 RK	84	/*
	85	* By the time this is called, we already have created
	86	* the directory cache entry for the new file, but it
	87	* is so far negative - it has no inode.
	88	*
	89	* If the create succeeds, we fill in the inode information
	90	* with d_instantiate().
	91	*/
	92	static int nilfs_create(struct inode dir, struct dentry dentry, int mode,
	93	struct nameidata *nd)
	94	{
	95	struct inode *inode;
	96	struct nilfs_transaction_info ti;
47420c79	97	int err;
d2500652 RK	98
	99	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	100	if (err)
	101	return err;
	102	inode = nilfs_new_inode(dir, mode);
	103	err = PTR_ERR(inode);
	104	if (!IS_ERR(inode)) {
	105	inode->i_op = &nilfs_file_inode_operations;
	106	inode->i_fop = &nilfs_file_operations;
	107	inode->i_mapping->a_ops = &nilfs_aops;
abdb318b	108	nilfs_mark_inode_dirty(inode);
d2500652 RK	109	err = nilfs_add_nondir(dentry, inode);
d2500652 RK	110	}
47420c79 RK	111	if (!err)
	112	err = nilfs_transaction_commit(dir->i_sb);
	113	else
	114	nilfs_transaction_abort(dir->i_sb);
	115
	116	return err;
d2500652 RK	117	}
	118
	119	static int
	120	nilfs_mknod(struct inode dir, struct dentry dentry, int mode, dev_t rdev)
	121	{
	122	struct inode *inode;
	123	struct nilfs_transaction_info ti;
47420c79	124	int err;
d2500652 RK	125
	126	if (!new_valid_dev(rdev))
	127	return -EINVAL;
	128
	129	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	130	if (err)
	131	return err;
	132	inode = nilfs_new_inode(dir, mode);
	133	err = PTR_ERR(inode);
	134	if (!IS_ERR(inode)) {
	135	init_special_inode(inode, inode->i_mode, rdev);
abdb318b	136	nilfs_mark_inode_dirty(inode);
d2500652 RK	137	err = nilfs_add_nondir(dentry, inode);
d2500652 RK	138	}
47420c79 RK	139	if (!err)
	140	err = nilfs_transaction_commit(dir->i_sb);
	141	else
	142	nilfs_transaction_abort(dir->i_sb);
	143
	144	return err;
d2500652 RK	145	}
	146
	147	static int nilfs_symlink(struct inode dir, struct dentry dentry,
	148	const char *symname)
	149	{
	150	struct nilfs_transaction_info ti;
	151	struct super_block *sb = dir->i_sb;
	152	unsigned l = strlen(symname)+1;
	153	struct inode *inode;
47420c79	154	int err;
d2500652 RK	155
	156	if (l > sb->s_blocksize)
	157	return -ENAMETOOLONG;
	158
	159	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	160	if (err)
	161	return err;
	162
	163	inode = nilfs_new_inode(dir, S_IFLNK \| S_IRWXUGO);
	164	err = PTR_ERR(inode);
	165	if (IS_ERR(inode))
	166	goto out;
	167
	168	/* slow symlink */
	169	inode->i_op = &nilfs_symlink_inode_operations;
	170	inode->i_mapping->a_ops = &nilfs_aops;
	171	err = page_symlink(inode, symname, l);
	172	if (err)
	173	goto out_fail;
	174
	175	/* mark_inode_dirty(inode); */
9ca941d4	176	/* page_symlink() do this */
d2500652 RK	177
	178	err = nilfs_add_nondir(dentry, inode);
	179	out:
47420c79 RK	180	if (!err)
	181	err = nilfs_transaction_commit(dir->i_sb);
	182	else
	183	nilfs_transaction_abort(dir->i_sb);
	184
	185	return err;
d2500652 RK	186
d2500652 RK	187	out_fail:
565de406	188	drop_nlink(inode);
abdb318b	189	nilfs_mark_inode_dirty(inode);
d2500652 RK	190	iput(inode);
	191	goto out;
	192	}
	193
	194	static int nilfs_link(struct dentry old_dentry, struct inode dir,
	195	struct dentry *dentry)
	196	{
	197	struct inode *inode = old_dentry->d_inode;
	198	struct nilfs_transaction_info ti;
47420c79	199	int err;
d2500652 RK	200
	201	if (inode->i_nlink >= NILFS_LINK_MAX)
	202	return -EMLINK;
	203
	204	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	205	if (err)
	206	return err;
	207
	208	inode->i_ctime = CURRENT_TIME;
	209	inode_inc_link_count(inode);
7de9c6ee	210	ihold(inode);
d2500652 RK	211
d2500652 RK	212	err = nilfs_add_nondir(dentry, inode);
47420c79 RK	213	if (!err)
	214	err = nilfs_transaction_commit(dir->i_sb);
	215	else
	216	nilfs_transaction_abort(dir->i_sb);
	217
	218	return err;
d2500652 RK	219	}
	220
	221	static int nilfs_mkdir(struct inode dir, struct dentry dentry, int mode)
	222	{
	223	struct inode *inode;
	224	struct nilfs_transaction_info ti;
47420c79	225	int err;
d2500652 RK	226
	227	if (dir->i_nlink >= NILFS_LINK_MAX)
	228	return -EMLINK;
	229
	230	err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
	231	if (err)
	232	return err;
	233
565de406	234	inc_nlink(dir);
d2500652 RK	235
	236	inode = nilfs_new_inode(dir, S_IFDIR \| mode);
	237	err = PTR_ERR(inode);
	238	if (IS_ERR(inode))
	239	goto out_dir;
	240
	241	inode->i_op = &nilfs_dir_inode_operations;
	242	inode->i_fop = &nilfs_dir_operations;
	243	inode->i_mapping->a_ops = &nilfs_aops;
	244
565de406	245	inc_nlink(inode);
d2500652 RK	246
	247	err = nilfs_make_empty(inode, dir);
	248	if (err)
	249	goto out_fail;
	250
	251	err = nilfs_add_link(dentry, inode);
	252	if (err)
	253	goto out_fail;
	254
abdb318b	255	nilfs_mark_inode_dirty(inode);
d2500652 RK	256	d_instantiate(dentry, inode);
d2500652 RK	257	out:
47420c79 RK	258	if (!err)
	259	err = nilfs_transaction_commit(dir->i_sb);
	260	else
	261	nilfs_transaction_abort(dir->i_sb);
	262
	263	return err;
d2500652 RK	264
d2500652 RK	265	out_fail:
565de406	266	drop_nlink(inode);
565de406	267	drop_nlink(inode);
abdb318b	268	nilfs_mark_inode_dirty(inode);
d2500652 RK	269	iput(inode);
d2500652 RK	270	out_dir:
565de406	271	drop_nlink(dir);
abdb318b	272	nilfs_mark_inode_dirty(dir);
d2500652 RK	273	goto out;
	274	}
	275
4cd76c3c	276	static int nilfs_do_unlink(struct inode dir, struct dentry dentry)
d2500652 RK	277	{
	278	struct inode *inode;
	279	struct nilfs_dir_entry *de;
	280	struct page *page;
47420c79	281	int err;
d2500652	282
d2500652	283	err = -ENOENT;
0319003d	284	de = nilfs_find_entry(dir, &dentry->d_name, &page);
d2500652 RK	285	if (!de)
	286	goto out;
	287
	288	inode = dentry->d_inode;
	289	err = -EIO;
	290	if (le64_to_cpu(de->inode) != inode->i_ino)
	291	goto out;
	292
	293	if (!inode->i_nlink) {
	294	nilfs_warning(inode->i_sb, __func__,
	295	"deleting nonexistent file (%lu), %d\n",
	296	inode->i_ino, inode->i_nlink);
	297	inode->i_nlink = 1;
	298	}
	299	err = nilfs_delete_entry(de, page);
	300	if (err)
	301	goto out;
	302
	303	inode->i_ctime = dir->i_ctime;
565de406	304	drop_nlink(inode);
d2500652 RK	305	err = 0;
d2500652 RK	306	out:
4cd76c3c JS	307	return err;
	308	}
	309
	310	static int nilfs_unlink(struct inode dir, struct dentry dentry)
	311	{
	312	struct nilfs_transaction_info ti;
	313	int err;
	314
	315	err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
	316	if (err)
	317	return err;
	318
	319	err = nilfs_do_unlink(dir, dentry);
	320
	321	if (!err) {
abdb318b JS	322	nilfs_mark_inode_dirty(dir);
abdb318b JS	323	nilfs_mark_inode_dirty(dentry->d_inode);
47420c79	324	err = nilfs_transaction_commit(dir->i_sb);
4cd76c3c	325	} else
47420c79 RK	326	nilfs_transaction_abort(dir->i_sb);
	327
	328	return err;
d2500652 RK	329	}
	330
	331	static int nilfs_rmdir(struct inode dir, struct dentry dentry)
	332	{
	333	struct inode *inode = dentry->d_inode;
	334	struct nilfs_transaction_info ti;
47420c79	335	int err;
d2500652 RK	336
	337	err = nilfs_transaction_begin(dir->i_sb, &ti, 0);
	338	if (err)
	339	return err;
	340
	341	err = -ENOTEMPTY;
	342	if (nilfs_empty_dir(inode)) {
4cd76c3c	343	err = nilfs_do_unlink(dir, dentry);
d2500652 RK	344	if (!err) {
d2500652 RK	345	inode->i_size = 0;
565de406	346	drop_nlink(inode);
abdb318b	347	nilfs_mark_inode_dirty(inode);
565de406	348	drop_nlink(dir);
abdb318b	349	nilfs_mark_inode_dirty(dir);
d2500652 RK	350	}
d2500652 RK	351	}
47420c79 RK	352	if (!err)
	353	err = nilfs_transaction_commit(dir->i_sb);
	354	else
	355	nilfs_transaction_abort(dir->i_sb);
	356
	357	return err;
d2500652 RK	358	}
	359
	360	static int nilfs_rename(struct inode old_dir, struct dentry old_dentry,
	361	struct inode new_dir, struct dentry new_dentry)
	362	{
	363	struct inode *old_inode = old_dentry->d_inode;
	364	struct inode *new_inode = new_dentry->d_inode;
	365	struct page *dir_page = NULL;
	366	struct nilfs_dir_entry *dir_de = NULL;
	367	struct page *old_page;
	368	struct nilfs_dir_entry *old_de;
	369	struct nilfs_transaction_info ti;
	370	int err;
	371
	372	err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
	373	if (unlikely(err))
	374	return err;
	375
	376	err = -ENOENT;
0319003d	377	old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page);
d2500652 RK	378	if (!old_de)
	379	goto out;
	380
	381	if (S_ISDIR(old_inode->i_mode)) {
	382	err = -EIO;
	383	dir_de = nilfs_dotdot(old_inode, &dir_page);
	384	if (!dir_de)
	385	goto out_old;
	386	}
	387
	388	if (new_inode) {
	389	struct page *new_page;
	390	struct nilfs_dir_entry *new_de;
	391
	392	err = -ENOTEMPTY;
	393	if (dir_de && !nilfs_empty_dir(new_inode))
	394	goto out_dir;
	395
	396	err = -ENOENT;
0319003d	397	new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page);
d2500652 RK	398	if (!new_de)
d2500652 RK	399	goto out_dir;
565de406	400	inc_nlink(old_inode);
d2500652	401	nilfs_set_link(new_dir, new_de, new_page, old_inode);
abdb318b	402	nilfs_mark_inode_dirty(new_dir);
d2500652 RK	403	new_inode->i_ctime = CURRENT_TIME;
	404	if (dir_de)
	405	drop_nlink(new_inode);
565de406	406	drop_nlink(new_inode);
abdb318b	407	nilfs_mark_inode_dirty(new_inode);
d2500652 RK	408	} else {
	409	if (dir_de) {
	410	err = -EMLINK;
	411	if (new_dir->i_nlink >= NILFS_LINK_MAX)
	412	goto out_dir;
	413	}
565de406	414	inc_nlink(old_inode);
d2500652 RK	415	err = nilfs_add_link(new_dentry, old_inode);
d2500652 RK	416	if (err) {
565de406	417	drop_nlink(old_inode);
abdb318b	418	nilfs_mark_inode_dirty(old_inode);
d2500652 RK	419	goto out_dir;
d2500652 RK	420	}
565de406 JS	421	if (dir_de) {
565de406 JS	422	inc_nlink(new_dir);
abdb318b	423	nilfs_mark_inode_dirty(new_dir);
565de406	424	}
d2500652 RK	425	}
	426
	427	/*
	428	* Like most other Unix systems, set the ctime for inodes on a
	429	* rename.
d2500652 RK	430	*/
	431	old_inode->i_ctime = CURRENT_TIME;
	432
	433	nilfs_delete_entry(old_de, old_page);
43f8bc26	434	drop_nlink(old_inode);
d2500652 RK	435
	436	if (dir_de) {
	437	nilfs_set_link(old_inode, dir_de, dir_page, new_dir);
565de406	438	drop_nlink(old_dir);
d2500652	439	}
abdb318b JS	440	nilfs_mark_inode_dirty(old_dir);
abdb318b JS	441	nilfs_mark_inode_dirty(old_inode);
d2500652	442
47420c79	443	err = nilfs_transaction_commit(old_dir->i_sb);
d2500652 RK	444	return err;
	445
	446	out_dir:
	447	if (dir_de) {
	448	kunmap(dir_page);
	449	page_cache_release(dir_page);
	450	}
	451	out_old:
	452	kunmap(old_page);
	453	page_cache_release(old_page);
	454	out:
47420c79	455	nilfs_transaction_abort(old_dir->i_sb);
d2500652 RK	456	return err;
	457	}
	458
8e656fd5 RK	459	/*
	460	* Export operations
	461	*/
	462	static struct dentry nilfs_get_parent(struct dentry child)
	463	{
	464	unsigned long ino;
	465	struct inode *inode;
	466	struct qstr dotdot = {.name = "..", .len = 2};
	467	struct nilfs_root *root;
	468
	469	ino = nilfs_inode_by_name(child->d_inode, &dotdot);
	470	if (!ino)
	471	return ERR_PTR(-ENOENT);
	472
	473	root = NILFS_I(child->d_inode)->i_root;
	474
	475	inode = nilfs_iget(child->d_inode->i_sb, root, ino);
	476	if (IS_ERR(inode))
	477	return ERR_CAST(inode);
	478
	479	return d_obtain_alias(inode);
	480	}
	481
	482	static struct dentry nilfs_get_dentry(struct super_block sb, u64 cno,
	483	u64 ino, u32 gen)
	484	{
	485	struct nilfs_root *root;
	486	struct inode *inode;
	487
	488	if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO)
	489	return ERR_PTR(-ESTALE);
	490
	491	root = nilfs_lookup_root(NILFS_SB(sb)->s_nilfs, cno);
	492	if (!root)
	493	return ERR_PTR(-ESTALE);
	494
	495	inode = nilfs_iget(sb, root, ino);
	496	nilfs_put_root(root);
	497
	498	if (IS_ERR(inode))
	499	return ERR_CAST(inode);
	500	if (gen && inode->i_generation != gen) {
	501	iput(inode);
	502	return ERR_PTR(-ESTALE);
	503	}
	504	return d_obtain_alias(inode);
	505	}
	506
	507	static struct dentry nilfs_fh_to_dentry(struct super_block sb, struct fid *fh,
	508	int fh_len, int fh_type)
	509	{
	510	struct nilfs_fid fid = (struct nilfs_fid )fh;
	511
	512	if ((fh_len != NILFS_FID_SIZE_NON_CONNECTABLE &&
	513	fh_len != NILFS_FID_SIZE_CONNECTABLE) \|\|
	514	(fh_type != FILEID_NILFS_WITH_PARENT &&
	515	fh_type != FILEID_NILFS_WITHOUT_PARENT))
	516	return NULL;
	517
	518	return nilfs_get_dentry(sb, fid->cno, fid->ino, fid->gen);
	519	}
	520
	521	static struct dentry nilfs_fh_to_parent(struct super_block sb, struct fid *fh,
	522	int fh_len, int fh_type)
523	{
524	struct nilfs_fid fid = (struct nilfs_fid )fh;
525
526	if (fh_len != NILFS_FID_SIZE_CONNECTABLE \|\|
527	fh_type != FILEID_NILFS_WITH_PARENT)
528	return NULL;
529
530	return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
531	}
532
533	static int nilfs_encode_fh(struct dentry dentry, __u32 fh, int *lenp,
534	int connectable)
535	{
536	struct nilfs_fid fid = (struct nilfs_fid )fh;
537	struct inode *inode = dentry->d_inode;
538	struct nilfs_root *root = NILFS_I(inode)->i_root;
539	int type;
540
541	if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE \|\|
542	(connectable && *lenp < NILFS_FID_SIZE_CONNECTABLE))
543	return 255;
544
545	fid->cno = root->cno;
546	fid->ino = inode->i_ino;
547	fid->gen = inode->i_generation;
548
549	if (connectable && !S_ISDIR(inode->i_mode)) {
550	struct inode *parent;
551
552	spin_lock(&dentry->d_lock);
553	parent = dentry->d_parent->d_inode;
554	fid->parent_ino = parent->i_ino;
555	fid->parent_gen = parent->i_generation;
556	spin_unlock(&dentry->d_lock);
557
558	type = FILEID_NILFS_WITH_PARENT;
559	*lenp = NILFS_FID_SIZE_CONNECTABLE;
560	} else {
561	type = FILEID_NILFS_WITHOUT_PARENT;
562	*lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
563	}
564
565	return type;
566	}
567
6e1d5dcc	568	const struct inode_operations nilfs_dir_inode_operations = {
d2500652 RK	569	.create = nilfs_create,
	570	.lookup = nilfs_lookup,
	571	.link = nilfs_link,
	572	.unlink = nilfs_unlink,
	573	.symlink = nilfs_symlink,
	574	.mkdir = nilfs_mkdir,
	575	.rmdir = nilfs_rmdir,
	576	.mknod = nilfs_mknod,
	577	.rename = nilfs_rename,
	578	.setattr = nilfs_setattr,
	579	.permission = nilfs_permission,
	580	};
	581
6e1d5dcc	582	const struct inode_operations nilfs_special_inode_operations = {
d2500652 RK	583	.setattr = nilfs_setattr,
	584	.permission = nilfs_permission,
	585	};
	586
6e1d5dcc	587	const struct inode_operations nilfs_symlink_inode_operations = {
d2500652 RK	588	.readlink = generic_readlink,
	589	.follow_link = page_follow_link_light,
	590	.put_link = page_put_link,
dc3d3b81	591	.permission = nilfs_permission,
d2500652	592	};
8e656fd5 RK	593
	594	const struct export_operations nilfs_export_ops = {
	595	.encode_fh = nilfs_encode_fh,
	596	.fh_to_dentry = nilfs_fh_to_dentry,
	597	.fh_to_parent = nilfs_fh_to_parent,
	598	.get_parent = nilfs_get_parent,
	599	};