[deliverable/linux.git] / fs / hfsplus / dir.c

/*
 *  linux/fs/hfsplus/dir.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * Handling of directories
 */

#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/random.h>

#include "hfsplus_fs.h"
#include "hfsplus_raw.h"
#include "xattr.h"

static inline void hfsplus_instantiate(struct dentry *dentry,
				       struct inode *inode, u32 cnid)
{
	dentry->d_fsdata = (void *)(unsigned long)cnid;
	d_instantiate(dentry, inode);
}

/* Find the entry inside dir named dentry->d_name */
static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
				     unsigned int flags)
{
	struct inode *inode = NULL;
	struct hfs_find_data fd;
	struct super_block *sb;
	hfsplus_cat_entry entry;
	int err;
	u32 cnid, linkid = 0;
	u16 type;

	sb = dir->i_sb;

	dentry->d_fsdata = NULL;
	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	if (err)
		return ERR_PTR(err);
	hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
again:
	err = hfs_brec_read(&fd, &entry, sizeof(entry));
	if (err) {
		if (err == -ENOENT) {
			hfs_find_exit(&fd);
			/* No such entry */
			inode = NULL;
			goto out;
		}
		goto fail;
	}
	type = be16_to_cpu(entry.type);
	if (type == HFSPLUS_FOLDER) {
		if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
			err = -EIO;
			goto fail;
		}
		cnid = be32_to_cpu(entry.folder.id);
		dentry->d_fsdata = (void *)(unsigned long)cnid;
	} else if (type == HFSPLUS_FILE) {
		if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
			err = -EIO;
			goto fail;
		}
		cnid = be32_to_cpu(entry.file.id);
		if (entry.file.user_info.fdType ==
				cpu_to_be32(HFSP_HARDLINK_TYPE) &&
				entry.file.user_info.fdCreator ==
				cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
				(entry.file.create_date ==
					HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
						create_date ||
				entry.file.create_date ==
					HFSPLUS_I(sb->s_root->d_inode)->
						create_date) &&
				HFSPLUS_SB(sb)->hidden_dir) {
			struct qstr str;
			char name[32];

			if (dentry->d_fsdata) {
				/*
				 * We found a link pointing to another link,
				 * so ignore it and treat it as regular file.
				 */
				cnid = (unsigned long)dentry->d_fsdata;
				linkid = 0;
			} else {
				dentry->d_fsdata = (void *)(unsigned long)cnid;
				linkid =
					be32_to_cpu(entry.file.permissions.dev);
				str.len = sprintf(name, "iNode%d", linkid);
				str.name = name;
				hfsplus_cat_build_key(sb, fd.search_key,
					HFSPLUS_SB(sb)->hidden_dir->i_ino,
					&str);
				goto again;
			}
		} else if (!dentry->d_fsdata)
			dentry->d_fsdata = (void *)(unsigned long)cnid;
	} else {
		pr_err("invalid catalog entry type in lookup\n");
		err = -EIO;
		goto fail;
	}
	hfs_find_exit(&fd);
	inode = hfsplus_iget(dir->i_sb, cnid);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (S_ISREG(inode->i_mode))
		HFSPLUS_I(inode)->linkid = linkid;
out:
	d_add(dentry, inode);
	return NULL;
fail:
	hfs_find_exit(&fd);
	return ERR_PTR(err);
}

static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
{
	struct inode *inode = file_inode(file);
	struct super_block *sb = inode->i_sb;
	int len, err;
	char strbuf[HFSPLUS_MAX_STRLEN + 1];
	hfsplus_cat_entry entry;
	struct hfs_find_data fd;
	struct hfsplus_readdir_data *rd;
	u16 type;

	if (file->f_pos >= inode->i_size)
		return 0;

	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	if (err)
		return err;
	hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err)
		goto out;

	if (ctx->pos == 0) {
		/* This is completely artificial... */
		if (!dir_emit_dot(file, ctx))
			goto out;
		ctx->pos = 1;
	}
	if (ctx->pos == 1) {
		if (fd.entrylength > sizeof(entry) || fd.entrylength < 0) {
			err = -EIO;
			goto out;
		}

		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
			fd.entrylength);
		if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
			pr_err("bad catalog folder thread\n");
			err = -EIO;
			goto out;
		}
		if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) {
			pr_err("truncated catalog thread\n");
			err = -EIO;
			goto out;
		}
		if (!dir_emit(ctx, "..", 2,
			    be32_to_cpu(entry.thread.parentID), DT_DIR))
			goto out;
		ctx->pos = 2;
	}
	if (ctx->pos >= inode->i_size)
		goto out;
	err = hfs_brec_goto(&fd, ctx->pos - 1);
	if (err)
		goto out;
	for (;;) {
		if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) {
			pr_err("walked past end of dir\n");
			err = -EIO;
			goto out;
		}

		if (fd.entrylength > sizeof(entry) || fd.entrylength < 0) {
			err = -EIO;
			goto out;
		}

		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
			fd.entrylength);
		type = be16_to_cpu(entry.type);
		len = HFSPLUS_MAX_STRLEN;
		err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
		if (err)
			goto out;
		if (type == HFSPLUS_FOLDER) {
			if (fd.entrylength <
					sizeof(struct hfsplus_cat_folder)) {
				pr_err("small dir entry\n");
				err = -EIO;
				goto out;
			}
			if (HFSPLUS_SB(sb)->hidden_dir &&
			    HFSPLUS_SB(sb)->hidden_dir->i_ino ==
					be32_to_cpu(entry.folder.id))
				goto next;
			if (!dir_emit(ctx, strbuf, len,
				    be32_to_cpu(entry.folder.id), DT_DIR))
				break;
		} else if (type == HFSPLUS_FILE) {
			if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
				pr_err("small file entry\n");
				err = -EIO;
				goto out;
			}
			if (!dir_emit(ctx, strbuf, len,
				    be32_to_cpu(entry.file.id), DT_REG))
				break;
		} else {
			pr_err("bad catalog entry type\n");
			err = -EIO;
			goto out;
		}
next:
		ctx->pos++;
		if (ctx->pos >= inode->i_size)
			goto out;
		err = hfs_brec_goto(&fd, 1);
		if (err)
			goto out;
	}
	rd = file->private_data;
	if (!rd) {
		rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL);
		if (!rd) {
			err = -ENOMEM;
			goto out;
		}
		file->private_data = rd;
		rd->file = file;
		list_add(&rd->list, &HFSPLUS_I(inode)->open_dir_list);
	}
	memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
out:
	hfs_find_exit(&fd);
	return err;
}

static int hfsplus_dir_release(struct inode *inode, struct file *file)
{
	struct hfsplus_readdir_data *rd = file->private_data;
	if (rd) {
		mutex_lock(&inode->i_mutex);
		list_del(&rd->list);
		mutex_unlock(&inode->i_mutex);
		kfree(rd);
	}
	return 0;
}

static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
			struct dentry *dst_dentry)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);
	struct inode *inode = src_dentry->d_inode;
	struct inode *src_dir = src_dentry->d_parent->d_inode;
	struct qstr str;
	char name[32];
	u32 cnid, id;
	int res;

	if (HFSPLUS_IS_RSRC(inode))
		return -EPERM;
	if (!S_ISREG(inode->i_mode))
		return -EPERM;

	mutex_lock(&sbi->vh_mutex);
	if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {
		for (;;) {
			get_random_bytes(&id, sizeof(cnid));
			id &= 0x3fffffff;
			str.name = name;
			str.len = sprintf(name, "iNode%d", id);
			res = hfsplus_rename_cat(inode->i_ino,
						 src_dir, &src_dentry->d_name,
						 sbi->hidden_dir, &str);
			if (!res)
				break;
			if (res != -EEXIST)
				goto out;
		}
		HFSPLUS_I(inode)->linkid = id;
		cnid = sbi->next_cnid++;
		src_dentry->d_fsdata = (void *)(unsigned long)cnid;
		res = hfsplus_create_cat(cnid, src_dir,
			&src_dentry->d_name, inode);
		if (res)
			/* panic? */
			goto out;
		sbi->file_count++;
	}
	cnid = sbi->next_cnid++;
	res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);
	if (res)
		goto out;

	inc_nlink(inode);
	hfsplus_instantiate(dst_dentry, inode, cnid);
	ihold(inode);
	inode->i_ctime = CURRENT_TIME_SEC;
	mark_inode_dirty(inode);
	sbi->file_count++;
	hfsplus_mark_mdb_dirty(dst_dir->i_sb);
out:
	mutex_unlock(&sbi->vh_mutex);
	return res;
}

static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
	struct inode *inode = dentry->d_inode;
	struct qstr str;
	char name[32];
	u32 cnid;
	int res;

	if (HFSPLUS_IS_RSRC(inode))
		return -EPERM;

	mutex_lock(&sbi->vh_mutex);
	cnid = (u32)(unsigned long)dentry->d_fsdata;
	if (inode->i_ino == cnid &&
	    atomic_read(&HFSPLUS_I(inode)->opencnt)) {
		str.name = name;
		str.len = sprintf(name, "temp%lu", inode->i_ino);
		res = hfsplus_rename_cat(inode->i_ino,
					 dir, &dentry->d_name,
					 sbi->hidden_dir, &str);
		if (!res) {
			inode->i_flags |= S_DEAD;
			drop_nlink(inode);
		}
		goto out;
	}
	res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);
	if (res)
		goto out;

	if (inode->i_nlink > 0)
		drop_nlink(inode);
	if (inode->i_ino == cnid)
		clear_nlink(inode);
	if (!inode->i_nlink) {
		if (inode->i_ino != cnid) {
			sbi->file_count--;
			if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) {
				res = hfsplus_delete_cat(inode->i_ino,
							 sbi->hidden_dir,
							 NULL);
				if (!res)
					hfsplus_delete_inode(inode);
			} else
				inode->i_flags |= S_DEAD;
		} else
			hfsplus_delete_inode(inode);
	} else
		sbi->file_count--;
	inode->i_ctime = CURRENT_TIME_SEC;
	mark_inode_dirty(inode);
out:
	mutex_unlock(&sbi->vh_mutex);
	return res;
}

static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
	struct inode *inode = dentry->d_inode;
	int res;

	if (inode->i_size != 2)
		return -ENOTEMPTY;

	mutex_lock(&sbi->vh_mutex);
	res = hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
	if (res)
		goto out;
	clear_nlink(inode);
	inode->i_ctime = CURRENT_TIME_SEC;
	hfsplus_delete_inode(inode);
	mark_inode_dirty(inode);
out:
	mutex_unlock(&sbi->vh_mutex);
	return res;
}

static int hfsplus_symlink(struct inode *dir, struct dentry *dentry,
			   const char *symname)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
	struct inode *inode;
	int res = -ENOSPC;

	mutex_lock(&sbi->vh_mutex);
	inode = hfsplus_new_inode(dir->i_sb, S_IFLNK | S_IRWXUGO);
	if (!inode)
		goto out;

	res = page_symlink(inode, symname, strlen(symname) + 1);
	if (res)
		goto out_err;

	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
	if (res)
		goto out_err;

	res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
	if (res == -EOPNOTSUPP)
		res = 0; /* Operation is not supported. */
	else if (res) {
		/* Try to delete anyway without error analysis. */
		hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
		goto out_err;
	}

	hfsplus_instantiate(dentry, inode, inode->i_ino);
	mark_inode_dirty(inode);
	goto out;

out_err:
	clear_nlink(inode);
	hfsplus_delete_inode(inode);
	iput(inode);
out:
	mutex_unlock(&sbi->vh_mutex);
	return res;
}

static int hfsplus_mknod(struct inode *dir, struct dentry *dentry,
			 umode_t mode, dev_t rdev)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
	struct inode *inode;
	int res = -ENOSPC;

	mutex_lock(&sbi->vh_mutex);
	inode = hfsplus_new_inode(dir->i_sb, mode);
	if (!inode)
		goto out;

	if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode))
		init_special_inode(inode, mode, rdev);

	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
	if (res)
		goto failed_mknod;

	res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
	if (res == -EOPNOTSUPP)
		res = 0; /* Operation is not supported. */
	else if (res) {
		/* Try to delete anyway without error analysis. */
		hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
		goto failed_mknod;
	}

	hfsplus_instantiate(dentry, inode, inode->i_ino);
	mark_inode_dirty(inode);
	goto out;

failed_mknod:
	clear_nlink(inode);
	hfsplus_delete_inode(inode);
	iput(inode);
out:
	mutex_unlock(&sbi->vh_mutex);
	return res;
}

static int hfsplus_create(struct inode *dir, struct dentry *dentry, umode_t mode,
			  bool excl)
{
	return hfsplus_mknod(dir, dentry, mode, 0);
}

static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
	return hfsplus_mknod(dir, dentry, mode | S_IFDIR, 0);
}

static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
			  struct inode *new_dir, struct dentry *new_dentry)
{
	int res;

	/* Unlink destination if it already exists */
	if (new_dentry->d_inode) {
		if (S_ISDIR(new_dentry->d_inode->i_mode))
			res = hfsplus_rmdir(new_dir, new_dentry);
		else
			res = hfsplus_unlink(new_dir, new_dentry);
		if (res)
			return res;
	}

	res = hfsplus_rename_cat((u32)(unsigned long)old_dentry->d_fsdata,
				 old_dir, &old_dentry->d_name,
				 new_dir, &new_dentry->d_name);
	if (!res)
		new_dentry->d_fsdata = old_dentry->d_fsdata;
	return res;
}

const struct inode_operations hfsplus_dir_inode_operations = {
	.lookup			= hfsplus_lookup,
	.create			= hfsplus_create,
	.link			= hfsplus_link,
	.unlink			= hfsplus_unlink,
	.mkdir			= hfsplus_mkdir,
	.rmdir			= hfsplus_rmdir,
	.symlink		= hfsplus_symlink,
	.mknod			= hfsplus_mknod,
	.rename			= hfsplus_rename,
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.listxattr		= hfsplus_listxattr,
	.removexattr		= hfsplus_removexattr,
};

const struct file_operations hfsplus_dir_operations = {
	.fsync		= hfsplus_file_fsync,
	.read		= generic_read_dir,
	.iterate	= hfsplus_readdir,
	.unlocked_ioctl = hfsplus_ioctl,
	.llseek		= generic_file_llseek,
	.release	= hfsplus_dir_release,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfsplus/dir.c
	3	*
	4	* Copyright (C) 2001
	5	* Brad Boyer (flar@allandria.com)
	6	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	7	*
	8	* Handling of directories
	9	*/
	10
	11	#include <linux/errno.h>
	12	#include <linux/fs.h>
1da177e4 LT	13	#include <linux/slab.h>
1da177e4 LT	14	#include <linux/random.h>
1da177e4 LT	15
	16	#include "hfsplus_fs.h"
	17	#include "hfsplus_raw.h"
324ef39a	18	#include "xattr.h"
1da177e4 LT	19
	20	static inline void hfsplus_instantiate(struct dentry *dentry,
	21	struct inode *inode, u32 cnid)
	22	{
	23	dentry->d_fsdata = (void *)(unsigned long)cnid;
	24	d_instantiate(dentry, inode);
	25	}
	26
	27	/* Find the entry inside dir named dentry->d_name */
	28	static struct dentry hfsplus_lookup(struct inode dir, struct dentry *dentry,
00cd8dd3	29	unsigned int flags)
1da177e4 LT	30	{
	31	struct inode *inode = NULL;
	32	struct hfs_find_data fd;
	33	struct super_block *sb;
	34	hfsplus_cat_entry entry;
	35	int err;
	36	u32 cnid, linkid = 0;
	37	u16 type;
	38
	39	sb = dir->i_sb;
d45bce8f	40
1da177e4	41	dentry->d_fsdata = NULL;
5bd9d99d AK	42	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	43	if (err)
	44	return ERR_PTR(err);
1da177e4 LT	45	hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
	46	again:
	47	err = hfs_brec_read(&fd, &entry, sizeof(entry));
	48	if (err) {
	49	if (err == -ENOENT) {
	50	hfs_find_exit(&fd);
	51	/* No such entry */
	52	inode = NULL;
	53	goto out;
	54	}
	55	goto fail;
	56	}
	57	type = be16_to_cpu(entry.type);
	58	if (type == HFSPLUS_FOLDER) {
	59	if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
	60	err = -EIO;
	61	goto fail;
	62	}
	63	cnid = be32_to_cpu(entry.folder.id);
	64	dentry->d_fsdata = (void *)(unsigned long)cnid;
	65	} else if (type == HFSPLUS_FILE) {
	66	if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
	67	err = -EIO;
	68	goto fail;
	69	}
	70	cnid = be32_to_cpu(entry.file.id);
2753cc28 AS	71	if (entry.file.user_info.fdType ==
	72	cpu_to_be32(HFSP_HARDLINK_TYPE) &&
	73	entry.file.user_info.fdCreator ==
	74	cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
	75	(entry.file.create_date ==
	76	HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
	77	create_date \|\|
	78	entry.file.create_date ==
	79	HFSPLUS_I(sb->s_root->d_inode)->
	80	create_date) &&
	81	HFSPLUS_SB(sb)->hidden_dir) {
1da177e4 LT	82	struct qstr str;
	83	char name[32];
	84
	85	if (dentry->d_fsdata) {
af8c85bb RZ	86	/*
	87	* We found a link pointing to another link,
	88	* so ignore it and treat it as regular file.
	89	*/
	90	cnid = (unsigned long)dentry->d_fsdata;
	91	linkid = 0;
	92	} else {
	93	dentry->d_fsdata = (void *)(unsigned long)cnid;
2753cc28 AS	94	linkid =
2753cc28 AS	95	be32_to_cpu(entry.file.permissions.dev);
af8c85bb RZ	96	str.len = sprintf(name, "iNode%d", linkid);
af8c85bb RZ	97	str.name = name;
dd73a01a	98	hfsplus_cat_build_key(sb, fd.search_key,
2753cc28 AS	99	HFSPLUS_SB(sb)->hidden_dir->i_ino,
2753cc28 AS	100	&str);
af8c85bb	101	goto again;
1da177e4	102	}
1da177e4 LT	103	} else if (!dentry->d_fsdata)
	104	dentry->d_fsdata = (void *)(unsigned long)cnid;
	105	} else {
d6142673	106	pr_err("invalid catalog entry type in lookup\n");
1da177e4 LT	107	err = -EIO;
	108	goto fail;
	109	}
	110	hfs_find_exit(&fd);
63525391 DH	111	inode = hfsplus_iget(dir->i_sb, cnid);
	112	if (IS_ERR(inode))
	113	return ERR_CAST(inode);
1da177e4	114	if (S_ISREG(inode->i_mode))
f6089ff8	115	HFSPLUS_I(inode)->linkid = linkid;
1da177e4 LT	116	out:
	117	d_add(dentry, inode);
	118	return NULL;
	119	fail:
	120	hfs_find_exit(&fd);
	121	return ERR_PTR(err);
	122	}
	123
e72514e7	124	static int hfsplus_readdir(struct file file, struct dir_context ctx)
1da177e4	125	{
e72514e7	126	struct inode *inode = file_inode(file);
1da177e4 LT	127	struct super_block *sb = inode->i_sb;
	128	int len, err;
	129	char strbuf[HFSPLUS_MAX_STRLEN + 1];
	130	hfsplus_cat_entry entry;
	131	struct hfs_find_data fd;
	132	struct hfsplus_readdir_data *rd;
	133	u16 type;
	134
e72514e7	135	if (file->f_pos >= inode->i_size)
1da177e4 LT	136	return 0;
1da177e4 LT	137
5bd9d99d AK	138	err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
	139	if (err)
	140	return err;
1da177e4	141	hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
324ef39a	142	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
1da177e4 LT	143	if (err)
	144	goto out;
	145
e72514e7	146	if (ctx->pos == 0) {
1da177e4	147	/* This is completely artificial... */
e72514e7	148	if (!dir_emit_dot(file, ctx))
1da177e4	149	goto out;
e72514e7 AV	150	ctx->pos = 1;
	151	}
	152	if (ctx->pos == 1) {
6f24f892 GKH	153	if (fd.entrylength > sizeof(entry) \|\| fd.entrylength < 0) {
	154	err = -EIO;
	155	goto out;
	156	}
	157
2753cc28 AS	158	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
2753cc28 AS	159	fd.entrylength);
1da177e4	160	if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
d6142673	161	pr_err("bad catalog folder thread\n");
1da177e4 LT	162	err = -EIO;
	163	goto out;
	164	}
	165	if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) {
d6142673	166	pr_err("truncated catalog thread\n");
1da177e4 LT	167	err = -EIO;
	168	goto out;
	169	}
e72514e7	170	if (!dir_emit(ctx, "..", 2,
1da177e4 LT	171	be32_to_cpu(entry.thread.parentID), DT_DIR))
1da177e4 LT	172	goto out;
e72514e7	173	ctx->pos = 2;
1da177e4	174	}
e72514e7 AV	175	if (ctx->pos >= inode->i_size)
	176	goto out;
	177	err = hfs_brec_goto(&fd, ctx->pos - 1);
	178	if (err)
	179	goto out;
1da177e4 LT	180	for (;;) {
1da177e4 LT	181	if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) {
d6142673	182	pr_err("walked past end of dir\n");
1da177e4 LT	183	err = -EIO;
	184	goto out;
	185	}
6f24f892 GKH	186
	187	if (fd.entrylength > sizeof(entry) \|\| fd.entrylength < 0) {
	188	err = -EIO;
	189	goto out;
	190	}
	191
2753cc28 AS	192	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
2753cc28 AS	193	fd.entrylength);
1da177e4 LT	194	type = be16_to_cpu(entry.type);
	195	len = HFSPLUS_MAX_STRLEN;
	196	err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
	197	if (err)
	198	goto out;
	199	if (type == HFSPLUS_FOLDER) {
2753cc28 AS	200	if (fd.entrylength <
2753cc28 AS	201	sizeof(struct hfsplus_cat_folder)) {
d6142673	202	pr_err("small dir entry\n");
1da177e4 LT	203	err = -EIO;
	204	goto out;
	205	}
dd73a01a CH	206	if (HFSPLUS_SB(sb)->hidden_dir &&
	207	HFSPLUS_SB(sb)->hidden_dir->i_ino ==
	208	be32_to_cpu(entry.folder.id))
1da177e4	209	goto next;
e72514e7	210	if (!dir_emit(ctx, strbuf, len,
1da177e4 LT	211	be32_to_cpu(entry.folder.id), DT_DIR))
	212	break;
	213	} else if (type == HFSPLUS_FILE) {
	214	if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
d6142673	215	pr_err("small file entry\n");
1da177e4 LT	216	err = -EIO;
	217	goto out;
	218	}
e72514e7	219	if (!dir_emit(ctx, strbuf, len,
1da177e4 LT	220	be32_to_cpu(entry.file.id), DT_REG))
	221	break;
	222	} else {
d6142673	223	pr_err("bad catalog entry type\n");
1da177e4 LT	224	err = -EIO;
	225	goto out;
	226	}
20b7643d	227	next:
e72514e7 AV	228	ctx->pos++;
e72514e7 AV	229	if (ctx->pos >= inode->i_size)
1da177e4 LT	230	goto out;
	231	err = hfs_brec_goto(&fd, 1);
	232	if (err)
	233	goto out;
	234	}
e72514e7	235	rd = file->private_data;
1da177e4 LT	236	if (!rd) {
	237	rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL);
	238	if (!rd) {
	239	err = -ENOMEM;
	240	goto out;
	241	}
e72514e7 AV	242	file->private_data = rd;
e72514e7 AV	243	rd->file = file;
6af502de	244	list_add(&rd->list, &HFSPLUS_I(inode)->open_dir_list);
1da177e4 LT	245	}
	246	memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
	247	out:
	248	hfs_find_exit(&fd);
	249	return err;
	250	}
	251
	252	static int hfsplus_dir_release(struct inode inode, struct file file)
	253	{
	254	struct hfsplus_readdir_data *rd = file->private_data;
	255	if (rd) {
89755dca	256	mutex_lock(&inode->i_mutex);
1da177e4	257	list_del(&rd->list);
89755dca	258	mutex_unlock(&inode->i_mutex);
1da177e4 LT	259	kfree(rd);
	260	}
	261	return 0;
	262	}
	263
1da177e4 LT	264	static int hfsplus_link(struct dentry src_dentry, struct inode dst_dir,
	265	struct dentry *dst_dentry)
	266	{
dd73a01a	267	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);
1da177e4 LT	268	struct inode *inode = src_dentry->d_inode;
	269	struct inode *src_dir = src_dentry->d_parent->d_inode;
	270	struct qstr str;
	271	char name[32];
	272	u32 cnid, id;
	273	int res;
	274
	275	if (HFSPLUS_IS_RSRC(inode))
	276	return -EPERM;
f6089ff8 CH	277	if (!S_ISREG(inode->i_mode))
f6089ff8 CH	278	return -EPERM;
1da177e4	279
7ac9fb9c	280	mutex_lock(&sbi->vh_mutex);
1da177e4 LT	281	if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {
	282	for (;;) {
	283	get_random_bytes(&id, sizeof(cnid));
	284	id &= 0x3fffffff;
	285	str.name = name;
	286	str.len = sprintf(name, "iNode%d", id);
	287	res = hfsplus_rename_cat(inode->i_ino,
	288	src_dir, &src_dentry->d_name,
dd73a01a	289	sbi->hidden_dir, &str);
1da177e4 LT	290	if (!res)
	291	break;
	292	if (res != -EEXIST)
7ac9fb9c	293	goto out;
1da177e4	294	}
f6089ff8	295	HFSPLUS_I(inode)->linkid = id;
dd73a01a	296	cnid = sbi->next_cnid++;
1da177e4	297	src_dentry->d_fsdata = (void *)(unsigned long)cnid;
2753cc28 AS	298	res = hfsplus_create_cat(cnid, src_dir,
2753cc28 AS	299	&src_dentry->d_name, inode);
1da177e4 LT	300	if (res)
1da177e4 LT	301	/* panic? */
7ac9fb9c	302	goto out;
dd73a01a	303	sbi->file_count++;
1da177e4	304	}
dd73a01a	305	cnid = sbi->next_cnid++;
1da177e4 LT	306	res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);
1da177e4 LT	307	if (res)
7ac9fb9c	308	goto out;
1da177e4	309
d8c76e6f	310	inc_nlink(inode);
1da177e4	311	hfsplus_instantiate(dst_dentry, inode, cnid);
7de9c6ee	312	ihold(inode);
1da177e4 LT	313	inode->i_ctime = CURRENT_TIME_SEC;
1da177e4 LT	314	mark_inode_dirty(inode);
dd73a01a	315	sbi->file_count++;
9e6c5829	316	hfsplus_mark_mdb_dirty(dst_dir->i_sb);
7ac9fb9c CH	317	out:
	318	mutex_unlock(&sbi->vh_mutex);
	319	return res;
1da177e4 LT	320	}
	321
	322	static int hfsplus_unlink(struct inode dir, struct dentry dentry)
	323	{
dd73a01a	324	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
1da177e4 LT	325	struct inode *inode = dentry->d_inode;
	326	struct qstr str;
	327	char name[32];
	328	u32 cnid;
	329	int res;
	330
	331	if (HFSPLUS_IS_RSRC(inode))
	332	return -EPERM;
	333
7ac9fb9c	334	mutex_lock(&sbi->vh_mutex);
1da177e4 LT	335	cnid = (u32)(unsigned long)dentry->d_fsdata;
1da177e4 LT	336	if (inode->i_ino == cnid &&
6af502de	337	atomic_read(&HFSPLUS_I(inode)->opencnt)) {
1da177e4 LT	338	str.name = name;
	339	str.len = sprintf(name, "temp%lu", inode->i_ino);
	340	res = hfsplus_rename_cat(inode->i_ino,
	341	dir, &dentry->d_name,
dd73a01a	342	sbi->hidden_dir, &str);
85b8fe8c	343	if (!res) {
1da177e4	344	inode->i_flags \|= S_DEAD;
85b8fe8c CH	345	drop_nlink(inode);
85b8fe8c CH	346	}
7ac9fb9c	347	goto out;
1da177e4 LT	348	}
	349	res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);
	350	if (res)
7ac9fb9c	351	goto out;
1da177e4	352
af8c85bb	353	if (inode->i_nlink > 0)
9a53c3a7	354	drop_nlink(inode);
76b0c26a RZ	355	if (inode->i_ino == cnid)
	356	clear_nlink(inode);
	357	if (!inode->i_nlink) {
	358	if (inode->i_ino != cnid) {
dd73a01a	359	sbi->file_count--;
6af502de	360	if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) {
76b0c26a	361	res = hfsplus_delete_cat(inode->i_ino,
dd73a01a	362	sbi->hidden_dir,
76b0c26a RZ	363	NULL);
	364	if (!res)
	365	hfsplus_delete_inode(inode);
	366	} else
	367	inode->i_flags \|= S_DEAD;
1da177e4	368	} else
76b0c26a	369	hfsplus_delete_inode(inode);
af8c85bb	370	} else
dd73a01a	371	sbi->file_count--;
1da177e4 LT	372	inode->i_ctime = CURRENT_TIME_SEC;
1da177e4 LT	373	mark_inode_dirty(inode);
7ac9fb9c CH	374	out:
7ac9fb9c CH	375	mutex_unlock(&sbi->vh_mutex);
1da177e4 LT	376	return res;
	377	}
	378
1da177e4 LT	379	static int hfsplus_rmdir(struct inode dir, struct dentry dentry)
1da177e4 LT	380	{
7ac9fb9c CH	381	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
7ac9fb9c CH	382	struct inode *inode = dentry->d_inode;
1da177e4 LT	383	int res;
1da177e4 LT	384
1da177e4 LT	385	if (inode->i_size != 2)
1da177e4 LT	386	return -ENOTEMPTY;
7ac9fb9c CH	387
7ac9fb9c CH	388	mutex_lock(&sbi->vh_mutex);
1da177e4 LT	389	res = hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
1da177e4 LT	390	if (res)
7ac9fb9c	391	goto out;
ce71ec36	392	clear_nlink(inode);
1da177e4 LT	393	inode->i_ctime = CURRENT_TIME_SEC;
	394	hfsplus_delete_inode(inode);
	395	mark_inode_dirty(inode);
7ac9fb9c CH	396	out:
	397	mutex_unlock(&sbi->vh_mutex);
	398	return res;
1da177e4 LT	399	}
	400
	401	static int hfsplus_symlink(struct inode dir, struct dentry dentry,
	402	const char *symname)
	403	{
7ac9fb9c	404	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
1da177e4	405	struct inode *inode;
7ac9fb9c	406	int res = -ENOSPC;
1da177e4	407
7ac9fb9c	408	mutex_lock(&sbi->vh_mutex);
f17c89bf	409	inode = hfsplus_new_inode(dir->i_sb, S_IFLNK \| S_IRWXUGO);
1da177e4	410	if (!inode)
7ac9fb9c	411	goto out;
1da177e4 LT	412
1da177e4 LT	413	res = page_symlink(inode, symname, strlen(symname) + 1);
f17c89bf CH	414	if (res)
f17c89bf CH	415	goto out_err;
1da177e4	416
1da177e4	417	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
f17c89bf CH	418	if (res)
f17c89bf CH	419	goto out_err;
1da177e4	420
324ef39a VD	421	res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
	422	if (res == -EOPNOTSUPP)
	423	res = 0; /* Operation is not supported. */
	424	else if (res) {
	425	/* Try to delete anyway without error analysis. */
	426	hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
	427	goto out_err;
	428	}
	429
f17c89bf CH	430	hfsplus_instantiate(dentry, inode, inode->i_ino);
f17c89bf CH	431	mark_inode_dirty(inode);
7ac9fb9c	432	goto out;
1da177e4	433
f17c89bf	434	out_err:
6d6b77f1	435	clear_nlink(inode);
f17c89bf CH	436	hfsplus_delete_inode(inode);
f17c89bf CH	437	iput(inode);
7ac9fb9c CH	438	out:
7ac9fb9c CH	439	mutex_unlock(&sbi->vh_mutex);
1da177e4 LT	440	return res;
	441	}
	442
	443	static int hfsplus_mknod(struct inode dir, struct dentry dentry,
1a67aafb	444	umode_t mode, dev_t rdev)
1da177e4	445	{
7ac9fb9c	446	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
1da177e4	447	struct inode *inode;
7ac9fb9c	448	int res = -ENOSPC;
1da177e4	449
7ac9fb9c	450	mutex_lock(&sbi->vh_mutex);
30d3abbe	451	inode = hfsplus_new_inode(dir->i_sb, mode);
1da177e4	452	if (!inode)
7ac9fb9c	453	goto out;
1da177e4	454
90e61690 CH	455	if (S_ISBLK(mode) \|\| S_ISCHR(mode) \|\| S_ISFIFO(mode) \|\| S_ISSOCK(mode))
	456	init_special_inode(inode, mode, rdev);
	457
1da177e4	458	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
324ef39a VD	459	if (res)
	460	goto failed_mknod;
	461
	462	res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
	463	if (res == -EOPNOTSUPP)
	464	res = 0; /* Operation is not supported. */
	465	else if (res) {
	466	/* Try to delete anyway without error analysis. */
	467	hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
	468	goto failed_mknod;
1da177e4	469	}
30d3abbe	470
1da177e4 LT	471	hfsplus_instantiate(dentry, inode, inode->i_ino);
1da177e4 LT	472	mark_inode_dirty(inode);
324ef39a VD	473	goto out;
	474
	475	failed_mknod:
	476	clear_nlink(inode);
	477	hfsplus_delete_inode(inode);
	478	iput(inode);
7ac9fb9c CH	479	out:
	480	mutex_unlock(&sbi->vh_mutex);
	481	return res;
1da177e4 LT	482	}
1da177e4 LT	483
4acdaf27	484	static int hfsplus_create(struct inode dir, struct dentry dentry, umode_t mode,
ebfc3b49	485	bool excl)
30d3abbe CH	486	{
	487	return hfsplus_mknod(dir, dentry, mode, 0);
	488	}
	489
18bb1db3	490	static int hfsplus_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
30d3abbe CH	491	{
	492	return hfsplus_mknod(dir, dentry, mode \| S_IFDIR, 0);
	493	}
	494
1da177e4 LT	495	static int hfsplus_rename(struct inode old_dir, struct dentry old_dentry,
	496	struct inode new_dir, struct dentry new_dentry)
	497	{
	498	int res;
	499
	500	/* Unlink destination if it already exists */
	501	if (new_dentry->d_inode) {
e3911785	502	if (S_ISDIR(new_dentry->d_inode->i_mode))
40de9a7c	503	res = hfsplus_rmdir(new_dir, new_dentry);
e3911785	504	else
40de9a7c	505	res = hfsplus_unlink(new_dir, new_dentry);
1da177e4 LT	506	if (res)
	507	return res;
	508	}
	509
	510	res = hfsplus_rename_cat((u32)(unsigned long)old_dentry->d_fsdata,
	511	old_dir, &old_dentry->d_name,
	512	new_dir, &new_dentry->d_name);
	513	if (!res)
	514	new_dentry->d_fsdata = old_dentry->d_fsdata;
	515	return res;
	516	}
	517
92e1d5be	518	const struct inode_operations hfsplus_dir_inode_operations = {
324ef39a VD	519	.lookup = hfsplus_lookup,
	520	.create = hfsplus_create,
	521	.link = hfsplus_link,
	522	.unlink = hfsplus_unlink,
	523	.mkdir = hfsplus_mkdir,
	524	.rmdir = hfsplus_rmdir,
	525	.symlink = hfsplus_symlink,
	526	.mknod = hfsplus_mknod,
	527	.rename = hfsplus_rename,
	528	.setxattr = generic_setxattr,
	529	.getxattr = generic_getxattr,
	530	.listxattr = hfsplus_listxattr,
	531	.removexattr = hfsplus_removexattr,
1da177e4 LT	532	};
1da177e4 LT	533
4b6f5d20	534	const struct file_operations hfsplus_dir_operations = {
eb29d66d	535	.fsync = hfsplus_file_fsync,
1da177e4	536	.read = generic_read_dir,
e72514e7	537	.iterate = hfsplus_readdir,
7cc4bcc6	538	.unlocked_ioctl = hfsplus_ioctl,
1da177e4 LT	539	.llseek = generic_file_llseek,
	540	.release = hfsplus_dir_release,
	541	};