[linux-2.6-block.git] / fs / nilfs2 / namei.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * namei.c - NILFS pathname lookup operations.
 *
 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
 *
 * Modified for NILFS by Amagai Yoshiji and Ryusuke Konishi.
 */
/*
 *  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_new(dentry, inode);
		return 0;
	}
	inode_dec_link_count(inode);
	unlock_new_inode(inode);
	iput(inode);
	return err;
}

/*
 * Methods themselves.
 */

static struct dentry *
nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
{
	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 = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL;
	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, umode_t mode,
			bool excl)
{
	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, umode_t mode, dev_t rdev)
{
	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)) {
		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 int 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 | 0777);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out;

	/* slow symlink */
	inode->i_op = &nilfs_symlink_inode_operations;
	inode_nohighmem(inode);
	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);
	unlock_new_inode(inode);
	iput(inode);
	goto out;
}

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

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

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

	err = nilfs_add_link(dentry, inode);
	if (!err) {
		d_instantiate(dentry, inode);
		err = nilfs_transaction_commit(dir->i_sb);
	} else {
		inode_dec_link_count(inode);
		iput(inode);
		nilfs_transaction_abort(dir->i_sb);
	}

	return err;
}

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

	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_new(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);
	unlock_new_inode(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 = d_inode(dentry);
	err = -EIO;
	if (le64_to_cpu(de->inode) != inode->i_ino)
		goto out;

	if (!inode->i_nlink) {
		nilfs_msg(inode->i_sb, KERN_WARNING,
			  "deleting nonexistent file (ino=%lu), %d",
			  inode->i_ino, inode->i_nlink);
		set_nlink(inode, 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(d_inode(dentry));
		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 = d_inode(dentry);
	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,
			unsigned int flags)
{
	struct inode *old_inode = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
	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;

	if (flags & ~RENAME_NOREPLACE)
		return -EINVAL;

	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;
		nilfs_set_link(new_dir, new_de, new_page, old_inode);
		nilfs_mark_inode_dirty(new_dir);
		new_inode->i_ctime = current_time(new_inode);
		if (dir_de)
			drop_nlink(new_inode);
		drop_nlink(new_inode);
		nilfs_mark_inode_dirty(new_inode);
	} else {
		err = nilfs_add_link(new_dentry, old_inode);
		if (err)
			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(old_inode);

	nilfs_delete_entry(old_de, old_page);

	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);
		put_page(dir_page);
	}
out_old:
	kunmap(old_page);
	put_page(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 = QSTR_INIT("..", 2);
	struct nilfs_root *root;

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

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

	inode = nilfs_iget(child->d_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(sb->s_fs_info, 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_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 inode *inode, __u32 *fh, int *lenp,
			   struct inode *parent)
{
	struct nilfs_fid *fid = (struct nilfs_fid *)fh;
	struct nilfs_root *root = NILFS_I(inode)->i_root;
	int type;

	if (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE) {
		*lenp = NILFS_FID_SIZE_CONNECTABLE;
		return FILEID_INVALID;
	}
	if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE) {
		*lenp = NILFS_FID_SIZE_NON_CONNECTABLE;
		return FILEID_INVALID;
	}

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

	if (parent) {
		fid->parent_ino = parent->i_ino;
		fid->parent_gen = parent->i_generation;
		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,
	.fiemap		= nilfs_fiemap,
};

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

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