[mirror_ubuntu-artful-kernel.git] / fs / hfs / dir.c

/*
 *  linux/fs/hfs/dir.c
 *
 * Copyright (C) 1995-1997  Paul H. Hargrove
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 * This file may be distributed under the terms of the GNU General Public License.
 *
 * This file contains directory-related functions independent of which
 * scheme is being used to represent forks.
 *
 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
 */

#include "hfs_fs.h"
#include "btree.h"

/*
 * hfs_lookup()
 */
static struct dentry *hfs_lookup(struct inode *dir, struct dentry *dentry,
				 unsigned int flags)
{
	hfs_cat_rec rec;
	struct hfs_find_data fd;
	struct inode *inode = NULL;
	int res;

	res = hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd);
	if (res)
		return ERR_PTR(res);
	hfs_cat_build_key(dir->i_sb, fd.search_key, dir->i_ino, &dentry->d_name);
	res = hfs_brec_read(&fd, &rec, sizeof(rec));
	if (res) {
		hfs_find_exit(&fd);
		if (res == -ENOENT) {
			/* No such entry */
			inode = NULL;
			goto done;
		}
		return ERR_PTR(res);
	}
	inode = hfs_iget(dir->i_sb, &fd.search_key->cat, &rec);
	hfs_find_exit(&fd);
	if (!inode)
		return ERR_PTR(-EACCES);
done:
	d_add(dentry, inode);
	return NULL;
}

/*
 * hfs_readdir
 */
static int hfs_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[HFS_MAX_NAMELEN];
	union hfs_cat_rec entry;
	struct hfs_find_data fd;
	struct hfs_readdir_data *rd;
	u16 type;

	if (ctx->pos >= inode->i_size)
		return 0;

	err = hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
	if (err)
		return err;
	hfs_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
	err = hfs_brec_find(&fd);
	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 (entry.type != HFS_CDR_THD) {
			pr_err("bad catalog folder thread\n");
			err = -EIO;
			goto out;
		}
		//if (fd.entrylength < HFS_MIN_THREAD_SZ) {
		//	pr_err("truncated catalog thread\n");
		//	err = -EIO;
		//	goto out;
		//}
		if (!dir_emit(ctx, "..", 2,
			    be32_to_cpu(entry.thread.ParID), 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.ParID) != 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 = entry.type;
		len = hfs_mac2asc(sb, strbuf, &fd.key->cat.CName);
		if (type == HFS_CDR_DIR) {
			if (fd.entrylength < sizeof(struct hfs_cat_dir)) {
				pr_err("small dir entry\n");
				err = -EIO;
				goto out;
			}
			if (!dir_emit(ctx, strbuf, len,
				    be32_to_cpu(entry.dir.DirID), DT_DIR))
				break;
		} else if (type == HFS_CDR_FIL) {
			if (fd.entrylength < sizeof(struct hfs_cat_file)) {
				pr_err("small file entry\n");
				err = -EIO;
				goto out;
			}
			if (!dir_emit(ctx, strbuf, len,
				    be32_to_cpu(entry.file.FlNum), DT_REG))
				break;
		} else {
			pr_err("bad catalog entry type %d\n", type);
			err = -EIO;
			goto out;
		}
		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 hfs_readdir_data), GFP_KERNEL);
		if (!rd) {
			err = -ENOMEM;
			goto out;
		}
		file->private_data = rd;
		rd->file = file;
		spin_lock(&HFS_I(inode)->open_dir_lock);
		list_add(&rd->list, &HFS_I(inode)->open_dir_list);
		spin_unlock(&HFS_I(inode)->open_dir_lock);
	}
	/*
	 * Can be done after the list insertion; exclusion with
	 * hfs_delete_cat() is provided by directory lock.
	 */
	memcpy(&rd->key, &fd.key->cat, sizeof(struct hfs_cat_key));
out:
	hfs_find_exit(&fd);
	return err;
}

static int hfs_dir_release(struct inode *inode, struct file *file)
{
	struct hfs_readdir_data *rd = file->private_data;
	if (rd) {
		spin_lock(&HFS_I(inode)->open_dir_lock);
		list_del(&rd->list);
		spin_unlock(&HFS_I(inode)->open_dir_lock);
		kfree(rd);
	}
	return 0;
}

/*
 * hfs_create()
 *
 * This is the create() entry in the inode_operations structure for
 * regular HFS directories.  The purpose is to create a new file in
 * a directory and return a corresponding inode, given the inode for
 * the directory and the name (and its length) of the new file.
 */
static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
		      bool excl)
{
	struct inode *inode;
	int res;

	inode = hfs_new_inode(dir, &dentry->d_name, mode);
	if (!inode)
		return -ENOMEM;

	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	if (res) {
		clear_nlink(inode);
		hfs_delete_inode(inode);
		iput(inode);
		return res;
	}
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
	return 0;
}

/*
 * hfs_mkdir()
 *
 * This is the mkdir() entry in the inode_operations structure for
 * regular HFS directories.  The purpose is to create a new directory
 * in a directory, given the inode for the parent directory and the
 * name (and its length) of the new directory.
 */
static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
	struct inode *inode;
	int res;

	inode = hfs_new_inode(dir, &dentry->d_name, S_IFDIR | mode);
	if (!inode)
		return -ENOMEM;

	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	if (res) {
		clear_nlink(inode);
		hfs_delete_inode(inode);
		iput(inode);
		return res;
	}
	d_instantiate(dentry, inode);
	mark_inode_dirty(inode);
	return 0;
}

/*
 * hfs_remove()
 *
 * This serves as both unlink() and rmdir() in the inode_operations
 * structure for regular HFS directories.  The purpose is to delete
 * an existing child, given the inode for the parent directory and
 * the name (and its length) of the existing directory.
 *
 * HFS does not have hardlinks, so both rmdir and unlink set the
 * link count to 0.  The only difference is the emptiness check.
 */
static int hfs_remove(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = d_inode(dentry);
	int res;

	if (S_ISDIR(inode->i_mode) && inode->i_size != 2)
		return -ENOTEMPTY;
	res = hfs_cat_delete(inode->i_ino, dir, &dentry->d_name);
	if (res)
		return res;
	clear_nlink(inode);
	inode->i_ctime = current_time(inode);
	hfs_delete_inode(inode);
	mark_inode_dirty(inode);
	return 0;
}

/*
 * hfs_rename()
 *
 * This is the rename() entry in the inode_operations structure for
 * regular HFS directories.  The purpose is to rename an existing
 * file or directory, given the inode for the current directory and
 * the name (and its length) of the existing file/directory and the
 * inode for the new directory and the name (and its length) of the
 * new file/directory.
 * XXX: how do you handle must_be dir?
 */
static int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
		      struct inode *new_dir, struct dentry *new_dentry,
		      unsigned int flags)
{
	int res;

	if (flags & ~RENAME_NOREPLACE)
		return -EINVAL;

	/* Unlink destination if it already exists */
	if (d_really_is_positive(new_dentry)) {
		res = hfs_remove(new_dir, new_dentry);
		if (res)
			return res;
	}

	res = hfs_cat_move(d_inode(old_dentry)->i_ino,
			   old_dir, &old_dentry->d_name,
			   new_dir, &new_dentry->d_name);
	if (!res)
		hfs_cat_build_key(old_dir->i_sb,
				  (btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
				  new_dir->i_ino, &new_dentry->d_name);
	return res;
}

const struct file_operations hfs_dir_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= hfs_readdir,
	.llseek		= generic_file_llseek,
	.release	= hfs_dir_release,
};

const struct inode_operations hfs_dir_inode_operations = {
	.create		= hfs_create,
	.lookup		= hfs_lookup,
	.unlink		= hfs_remove,
	.mkdir		= hfs_mkdir,
	.rmdir		= hfs_remove,
	.rename		= hfs_rename,
	.setattr	= hfs_inode_setattr,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfs/dir.c
	3	*
	4	* Copyright (C) 1995-1997 Paul H. Hargrove
	5	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	6	* This file may be distributed under the terms of the GNU General Public License.
	7	*
	8	* This file contains directory-related functions independent of which
	9	* scheme is being used to represent forks.
	10	*
	11	* Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
	12	*/
	13
	14	#include "hfs_fs.h"
	15	#include "btree.h"
	16
	17	/*
	18	* hfs_lookup()
	19	*/
	20	static struct dentry hfs_lookup(struct inode dir, struct dentry *dentry,
00cd8dd3	21	unsigned int flags)
1da177e4 LT	22	{
	23	hfs_cat_rec rec;
	24	struct hfs_find_data fd;
	25	struct inode *inode = NULL;
	26	int res;
	27
9509f178 AK	28	res = hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd);
	29	if (res)
	30	return ERR_PTR(res);
328b9227	31	hfs_cat_build_key(dir->i_sb, fd.search_key, dir->i_ino, &dentry->d_name);
1da177e4 LT	32	res = hfs_brec_read(&fd, &rec, sizeof(rec));
	33	if (res) {
	34	hfs_find_exit(&fd);
	35	if (res == -ENOENT) {
	36	/* No such entry */
	37	inode = NULL;
	38	goto done;
	39	}
	40	return ERR_PTR(res);
	41	}
	42	inode = hfs_iget(dir->i_sb, &fd.search_key->cat, &rec);
	43	hfs_find_exit(&fd);
	44	if (!inode)
	45	return ERR_PTR(-EACCES);
	46	done:
	47	d_add(dentry, inode);
	48	return NULL;
	49	}
	50
	51	/*
	52	* hfs_readdir
	53	*/
002f8bec	54	static int hfs_readdir(struct file file, struct dir_context ctx)
1da177e4	55	{
002f8bec	56	struct inode *inode = file_inode(file);
1da177e4 LT	57	struct super_block *sb = inode->i_sb;
1da177e4 LT	58	int len, err;
328b9227	59	char strbuf[HFS_MAX_NAMELEN];
1da177e4 LT	60	union hfs_cat_rec entry;
	61	struct hfs_find_data fd;
	62	struct hfs_readdir_data *rd;
	63	u16 type;
	64
002f8bec	65	if (ctx->pos >= inode->i_size)
1da177e4 LT	66	return 0;
1da177e4 LT	67
9509f178 AK	68	err = hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
	69	if (err)
	70	return err;
328b9227	71	hfs_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
1da177e4 LT	72	err = hfs_brec_find(&fd);
	73	if (err)
	74	goto out;
	75
002f8bec	76	if (ctx->pos == 0) {
1da177e4	77	/* This is completely artificial... */
002f8bec	78	if (!dir_emit_dot(file, ctx))
1da177e4	79	goto out;
002f8bec AV	80	ctx->pos = 1;
	81	}
	82	if (ctx->pos == 1) {
ec81aecb AW	83	if (fd.entrylength > sizeof(entry) \|\| fd.entrylength < 0) {
	84	err = -EIO;
	85	goto out;
	86	}
	87
1da177e4 LT	88	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
1da177e4 LT	89	if (entry.type != HFS_CDR_THD) {
d6142673	90	pr_err("bad catalog folder thread\n");
1da177e4 LT	91	err = -EIO;
	92	goto out;
	93	}
	94	//if (fd.entrylength < HFS_MIN_THREAD_SZ) {
d6142673	95	// pr_err("truncated catalog thread\n");
1da177e4 LT	96	// err = -EIO;
	97	// goto out;
	98	//}
002f8bec	99	if (!dir_emit(ctx, "..", 2,
1da177e4 LT	100	be32_to_cpu(entry.thread.ParID), DT_DIR))
1da177e4 LT	101	goto out;
002f8bec	102	ctx->pos = 2;
1da177e4	103	}
002f8bec AV	104	if (ctx->pos >= inode->i_size)
	105	goto out;
	106	err = hfs_brec_goto(&fd, ctx->pos - 1);
	107	if (err)
	108	goto out;
1da177e4 LT	109
	110	for (;;) {
	111	if (be32_to_cpu(fd.key->cat.ParID) != inode->i_ino) {
d6142673	112	pr_err("walked past end of dir\n");
1da177e4 LT	113	err = -EIO;
	114	goto out;
	115	}
ec81aecb AW	116
	117	if (fd.entrylength > sizeof(entry) \|\| fd.entrylength < 0) {
	118	err = -EIO;
	119	goto out;
	120	}
	121
1da177e4 LT	122	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
1da177e4 LT	123	type = entry.type;
328b9227	124	len = hfs_mac2asc(sb, strbuf, &fd.key->cat.CName);
1da177e4 LT	125	if (type == HFS_CDR_DIR) {
1da177e4 LT	126	if (fd.entrylength < sizeof(struct hfs_cat_dir)) {
d6142673	127	pr_err("small dir entry\n");
1da177e4 LT	128	err = -EIO;
	129	goto out;
	130	}
002f8bec	131	if (!dir_emit(ctx, strbuf, len,
1da177e4 LT	132	be32_to_cpu(entry.dir.DirID), DT_DIR))
	133	break;
	134	} else if (type == HFS_CDR_FIL) {
	135	if (fd.entrylength < sizeof(struct hfs_cat_file)) {
d6142673	136	pr_err("small file entry\n");
1da177e4 LT	137	err = -EIO;
	138	goto out;
	139	}
002f8bec	140	if (!dir_emit(ctx, strbuf, len,
1da177e4 LT	141	be32_to_cpu(entry.file.FlNum), DT_REG))
	142	break;
	143	} else {
d6142673	144	pr_err("bad catalog entry type %d\n", type);
1da177e4 LT	145	err = -EIO;
	146	goto out;
	147	}
002f8bec AV	148	ctx->pos++;
002f8bec AV	149	if (ctx->pos >= inode->i_size)
1da177e4 LT	150	goto out;
	151	err = hfs_brec_goto(&fd, 1);
	152	if (err)
	153	goto out;
	154	}
002f8bec	155	rd = file->private_data;
1da177e4 LT	156	if (!rd) {
	157	rd = kmalloc(sizeof(struct hfs_readdir_data), GFP_KERNEL);
	158	if (!rd) {
	159	err = -ENOMEM;
	160	goto out;
	161	}
002f8bec AV	162	file->private_data = rd;
002f8bec AV	163	rd->file = file;
9717a91b	164	spin_lock(&HFS_I(inode)->open_dir_lock);
1da177e4	165	list_add(&rd->list, &HFS_I(inode)->open_dir_list);
9717a91b	166	spin_unlock(&HFS_I(inode)->open_dir_lock);
1da177e4	167	}
9717a91b AV	168	/*
	169	* Can be done after the list insertion; exclusion with
	170	* hfs_delete_cat() is provided by directory lock.
	171	*/
eec11535	172	memcpy(&rd->key, &fd.key->cat, sizeof(struct hfs_cat_key));
1da177e4 LT	173	out:
	174	hfs_find_exit(&fd);
	175	return err;
	176	}
	177
	178	static int hfs_dir_release(struct inode inode, struct file file)
	179	{
	180	struct hfs_readdir_data *rd = file->private_data;
	181	if (rd) {
9717a91b	182	spin_lock(&HFS_I(inode)->open_dir_lock);
1da177e4	183	list_del(&rd->list);
9717a91b	184	spin_unlock(&HFS_I(inode)->open_dir_lock);
1da177e4 LT	185	kfree(rd);
	186	}
	187	return 0;
	188	}
	189
	190	/*
	191	* hfs_create()
	192	*
	193	* This is the create() entry in the inode_operations structure for
	194	* regular HFS directories. The purpose is to create a new file in
	195	* a directory and return a corresponding inode, given the inode for
	196	* the directory and the name (and its length) of the new file.
	197	*/
4acdaf27	198	static int hfs_create(struct inode dir, struct dentry dentry, umode_t mode,
ebfc3b49	199	bool excl)
1da177e4 LT	200	{
	201	struct inode *inode;
	202	int res;
	203
	204	inode = hfs_new_inode(dir, &dentry->d_name, mode);
	205	if (!inode)
13f24485	206	return -ENOMEM;
1da177e4 LT	207
	208	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	209	if (res) {
6d6b77f1	210	clear_nlink(inode);
1da177e4 LT	211	hfs_delete_inode(inode);
	212	iput(inode);
	213	return res;
	214	}
	215	d_instantiate(dentry, inode);
	216	mark_inode_dirty(inode);
	217	return 0;
	218	}
	219
	220	/*
	221	* hfs_mkdir()
	222	*
	223	* This is the mkdir() entry in the inode_operations structure for
	224	* regular HFS directories. The purpose is to create a new directory
	225	* in a directory, given the inode for the parent directory and the
	226	* name (and its length) of the new directory.
	227	*/
18bb1db3	228	static int hfs_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
1da177e4 LT	229	{
	230	struct inode *inode;
	231	int res;
	232
	233	inode = hfs_new_inode(dir, &dentry->d_name, S_IFDIR \| mode);
	234	if (!inode)
13f24485	235	return -ENOMEM;
1da177e4 LT	236
	237	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	238	if (res) {
6d6b77f1	239	clear_nlink(inode);
1da177e4 LT	240	hfs_delete_inode(inode);
	241	iput(inode);
	242	return res;
	243	}
	244	d_instantiate(dentry, inode);
	245	mark_inode_dirty(inode);
	246	return 0;
	247	}
	248
	249	/*
69102e9b	250	* hfs_remove()
1da177e4	251	*
69102e9b AV	252	* This serves as both unlink() and rmdir() in the inode_operations
	253	* structure for regular HFS directories. The purpose is to delete
	254	* an existing child, given the inode for the parent directory and
	255	* the name (and its length) of the existing directory.
1da177e4	256	*
69102e9b AV	257	* HFS does not have hardlinks, so both rmdir and unlink set the
69102e9b AV	258	* link count to 0. The only difference is the emptiness check.
1da177e4	259	*/
69102e9b	260	static int hfs_remove(struct inode dir, struct dentry dentry)
1da177e4	261	{
2b0143b5	262	struct inode *inode = d_inode(dentry);
1da177e4 LT	263	int res;
1da177e4 LT	264
69102e9b	265	if (S_ISDIR(inode->i_mode) && inode->i_size != 2)
1da177e4 LT	266	return -ENOTEMPTY;
	267	res = hfs_cat_delete(inode->i_ino, dir, &dentry->d_name);
	268	if (res)
	269	return res;
ce71ec36	270	clear_nlink(inode);
02027d42	271	inode->i_ctime = current_time(inode);
1da177e4 LT	272	hfs_delete_inode(inode);
	273	mark_inode_dirty(inode);
	274	return 0;
	275	}
	276
	277	/*
	278	* hfs_rename()
	279	*
	280	* This is the rename() entry in the inode_operations structure for
	281	* regular HFS directories. The purpose is to rename an existing
	282	* file or directory, given the inode for the current directory and
	283	* the name (and its length) of the existing file/directory and the
	284	* inode for the new directory and the name (and its length) of the
	285	* new file/directory.
	286	* XXX: how do you handle must_be dir?
	287	*/
	288	static int hfs_rename(struct inode old_dir, struct dentry old_dentry,
f03b8ad8 MS	289	struct inode new_dir, struct dentry new_dentry,
f03b8ad8 MS	290	unsigned int flags)
1da177e4 LT	291	{
	292	int res;
	293
f03b8ad8 MS	294	if (flags & ~RENAME_NOREPLACE)
	295	return -EINVAL;
	296
1da177e4	297	/* Unlink destination if it already exists */
2b0143b5	298	if (d_really_is_positive(new_dentry)) {
69102e9b	299	res = hfs_remove(new_dir, new_dentry);
1da177e4 LT	300	if (res)
	301	return res;
	302	}
	303
2b0143b5	304	res = hfs_cat_move(d_inode(old_dentry)->i_ino,
1da177e4 LT	305	old_dir, &old_dentry->d_name,
	306	new_dir, &new_dentry->d_name);
	307	if (!res)
328b9227	308	hfs_cat_build_key(old_dir->i_sb,
2b0143b5	309	(btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
1da177e4 LT	310	new_dir->i_ino, &new_dentry->d_name);
	311	return res;
	312	}
	313
4b6f5d20	314	const struct file_operations hfs_dir_operations = {
1da177e4	315	.read = generic_read_dir,
9717a91b	316	.iterate_shared = hfs_readdir,
1da177e4 LT	317	.llseek = generic_file_llseek,
	318	.release = hfs_dir_release,
	319	};
	320
92e1d5be	321	const struct inode_operations hfs_dir_inode_operations = {
1da177e4 LT	322	.create = hfs_create,
1da177e4 LT	323	.lookup = hfs_lookup,
69102e9b	324	.unlink = hfs_remove,
1da177e4	325	.mkdir = hfs_mkdir,
69102e9b	326	.rmdir = hfs_remove,
1da177e4 LT	327	.rename = hfs_rename,
	328	.setattr = hfs_inode_setattr,
	329	};