[linux-2.6-block.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;
		list_add(&rd->list, &HFS_I(inode)->open_dir_list);
	}
	memcpy(&rd->key, &fd.key, 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) {
		inode_lock(inode);
		list_del(&rd->list);
		inode_unlock(inode);
		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_SEC;
	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)
{
	int res;

	/* 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	= 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;
1da177e4 LT	164	list_add(&rd->list, &HFS_I(inode)->open_dir_list);
	165	}
	166	memcpy(&rd->key, &fd.key, sizeof(struct hfs_cat_key));
	167	out:
	168	hfs_find_exit(&fd);
	169	return err;
	170	}
	171
	172	static int hfs_dir_release(struct inode inode, struct file file)
	173	{
	174	struct hfs_readdir_data *rd = file->private_data;
	175	if (rd) {
5955102c	176	inode_lock(inode);
1da177e4	177	list_del(&rd->list);
5955102c	178	inode_unlock(inode);
1da177e4 LT	179	kfree(rd);
	180	}
	181	return 0;
	182	}
	183
	184	/*
	185	* hfs_create()
	186	*
	187	* This is the create() entry in the inode_operations structure for
	188	* regular HFS directories. The purpose is to create a new file in
	189	* a directory and return a corresponding inode, given the inode for
	190	* the directory and the name (and its length) of the new file.
	191	*/
4acdaf27	192	static int hfs_create(struct inode dir, struct dentry dentry, umode_t mode,
ebfc3b49	193	bool excl)
1da177e4 LT	194	{
	195	struct inode *inode;
	196	int res;
	197
	198	inode = hfs_new_inode(dir, &dentry->d_name, mode);
	199	if (!inode)
13f24485	200	return -ENOMEM;
1da177e4 LT	201
	202	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	203	if (res) {
6d6b77f1	204	clear_nlink(inode);
1da177e4 LT	205	hfs_delete_inode(inode);
	206	iput(inode);
	207	return res;
	208	}
	209	d_instantiate(dentry, inode);
	210	mark_inode_dirty(inode);
	211	return 0;
	212	}
	213
	214	/*
	215	* hfs_mkdir()
	216	*
	217	* This is the mkdir() entry in the inode_operations structure for
	218	* regular HFS directories. The purpose is to create a new directory
	219	* in a directory, given the inode for the parent directory and the
	220	* name (and its length) of the new directory.
	221	*/
18bb1db3	222	static int hfs_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
1da177e4 LT	223	{
	224	struct inode *inode;
	225	int res;
	226
	227	inode = hfs_new_inode(dir, &dentry->d_name, S_IFDIR \| mode);
	228	if (!inode)
13f24485	229	return -ENOMEM;
1da177e4 LT	230
	231	res = hfs_cat_create(inode->i_ino, dir, &dentry->d_name, inode);
	232	if (res) {
6d6b77f1	233	clear_nlink(inode);
1da177e4 LT	234	hfs_delete_inode(inode);
	235	iput(inode);
	236	return res;
	237	}
	238	d_instantiate(dentry, inode);
	239	mark_inode_dirty(inode);
	240	return 0;
	241	}
	242
	243	/*
69102e9b	244	* hfs_remove()
1da177e4	245	*
69102e9b AV	246	* This serves as both unlink() and rmdir() in the inode_operations
	247	* structure for regular HFS directories. The purpose is to delete
	248	* an existing child, given the inode for the parent directory and
	249	* the name (and its length) of the existing directory.
1da177e4	250	*
69102e9b AV	251	* HFS does not have hardlinks, so both rmdir and unlink set the
69102e9b AV	252	* link count to 0. The only difference is the emptiness check.
1da177e4	253	*/
69102e9b	254	static int hfs_remove(struct inode dir, struct dentry dentry)
1da177e4	255	{
2b0143b5	256	struct inode *inode = d_inode(dentry);
1da177e4 LT	257	int res;
1da177e4 LT	258
69102e9b	259	if (S_ISDIR(inode->i_mode) && inode->i_size != 2)
1da177e4 LT	260	return -ENOTEMPTY;
	261	res = hfs_cat_delete(inode->i_ino, dir, &dentry->d_name);
	262	if (res)
	263	return res;
ce71ec36	264	clear_nlink(inode);
1da177e4 LT	265	inode->i_ctime = CURRENT_TIME_SEC;
	266	hfs_delete_inode(inode);
	267	mark_inode_dirty(inode);
	268	return 0;
	269	}
	270
	271	/*
	272	* hfs_rename()
	273	*
	274	* This is the rename() entry in the inode_operations structure for
	275	* regular HFS directories. The purpose is to rename an existing
	276	* file or directory, given the inode for the current directory and
	277	* the name (and its length) of the existing file/directory and the
	278	* inode for the new directory and the name (and its length) of the
	279	* new file/directory.
	280	* XXX: how do you handle must_be dir?
	281	*/
	282	static int hfs_rename(struct inode old_dir, struct dentry old_dentry,
	283	struct inode new_dir, struct dentry new_dentry)
	284	{
	285	int res;
	286
	287	/* Unlink destination if it already exists */
2b0143b5	288	if (d_really_is_positive(new_dentry)) {
69102e9b	289	res = hfs_remove(new_dir, new_dentry);
1da177e4 LT	290	if (res)
	291	return res;
	292	}
	293
2b0143b5	294	res = hfs_cat_move(d_inode(old_dentry)->i_ino,
1da177e4 LT	295	old_dir, &old_dentry->d_name,
	296	new_dir, &new_dentry->d_name);
	297	if (!res)
328b9227	298	hfs_cat_build_key(old_dir->i_sb,
2b0143b5	299	(btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
1da177e4 LT	300	new_dir->i_ino, &new_dentry->d_name);
	301	return res;
	302	}
	303
4b6f5d20	304	const struct file_operations hfs_dir_operations = {
1da177e4	305	.read = generic_read_dir,
002f8bec	306	.iterate = hfs_readdir,
1da177e4 LT	307	.llseek = generic_file_llseek,
	308	.release = hfs_dir_release,
	309	};
	310
92e1d5be	311	const struct inode_operations hfs_dir_inode_operations = {
1da177e4 LT	312	.create = hfs_create,
1da177e4 LT	313	.lookup = hfs_lookup,
69102e9b	314	.unlink = hfs_remove,
1da177e4	315	.mkdir = hfs_mkdir,
69102e9b	316	.rmdir = hfs_remove,
1da177e4 LT	317	.rename = hfs_rename,
	318	.setattr = hfs_inode_setattr,
	319	};