[linux.git] / fs / adfs / dir.c

/*
 *  linux/fs/adfs/dir.c
 *
 *  Copyright (C) 1999-2000 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  Common directory handling for ADFS
 */
#include "adfs.h"

/*
 * For future.  This should probably be per-directory.
 */
static DEFINE_RWLOCK(adfs_dir_lock);

static int
adfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	struct super_block *sb = inode->i_sb;
	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	struct object_info obj;
	struct adfs_dir dir;
	int ret = 0;

	if (filp->f_pos >> 32)
		goto out;

	ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
	if (ret)
		goto out;

	switch ((unsigned long)filp->f_pos) {
	case 0:
		if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
			goto free_out;
		filp->f_pos += 1;

	case 1:
		if (filldir(dirent, "..", 2, 1, dir.parent_id, DT_DIR) < 0)
			goto free_out;
		filp->f_pos += 1;

	default:
		break;
	}

	read_lock(&adfs_dir_lock);

	ret = ops->setpos(&dir, filp->f_pos - 2);
	if (ret)
		goto unlock_out;
	while (ops->getnext(&dir, &obj) == 0) {
		if (filldir(dirent, obj.name, obj.name_len,
			    filp->f_pos, obj.file_id, DT_UNKNOWN) < 0)
			goto unlock_out;
		filp->f_pos += 1;
	}

unlock_out:
	read_unlock(&adfs_dir_lock);

free_out:
	ops->free(&dir);

out:
	return ret;
}

int
adfs_dir_update(struct super_block *sb, struct object_info *obj, int wait)
{
	int ret = -EINVAL;
#ifdef CONFIG_ADFS_FS_RW
	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	struct adfs_dir dir;

	printk(KERN_INFO "adfs_dir_update: object %06X in dir %06X\n",
		 obj->file_id, obj->parent_id);

	if (!ops->update) {
		ret = -EINVAL;
		goto out;
	}

	ret = ops->read(sb, obj->parent_id, 0, &dir);
	if (ret)
		goto out;

	write_lock(&adfs_dir_lock);
	ret = ops->update(&dir, obj);
	write_unlock(&adfs_dir_lock);

	if (wait) {
		int err = ops->sync(&dir);
		if (!ret)
			ret = err;
	}

	ops->free(&dir);
out:
#endif
	return ret;
}

static int
adfs_match(struct qstr *name, struct object_info *obj)
{
	int i;

	if (name->len != obj->name_len)
		return 0;

	for (i = 0; i < name->len; i++) {
		char c1, c2;

		c1 = name->name[i];
		c2 = obj->name[i];

		if (c1 >= 'A' && c1 <= 'Z')
			c1 += 'a' - 'A';
		if (c2 >= 'A' && c2 <= 'Z')
			c2 += 'a' - 'A';

		if (c1 != c2)
			return 0;
	}
	return 1;
}

static int
adfs_dir_lookup_byname(struct inode *inode, struct qstr *name, struct object_info *obj)
{
	struct super_block *sb = inode->i_sb;
	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	struct adfs_dir dir;
	int ret;

	ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
	if (ret)
		goto out;

	if (ADFS_I(inode)->parent_id != dir.parent_id) {
		adfs_error(sb, "parent directory changed under me! (%lx but got %lx)\n",
			   ADFS_I(inode)->parent_id, dir.parent_id);
		ret = -EIO;
		goto free_out;
	}

	obj->parent_id = inode->i_ino;

	/*
	 * '.' is handled by reserved_lookup() in fs/namei.c
	 */
	if (name->len == 2 && name->name[0] == '.' && name->name[1] == '.') {
		/*
		 * Currently unable to fill in the rest of 'obj',
		 * but this is better than nothing.  We need to
		 * ascend one level to find it's parent.
		 */
		obj->name_len = 0;
		obj->file_id  = obj->parent_id;
		goto free_out;
	}

	read_lock(&adfs_dir_lock);

	ret = ops->setpos(&dir, 0);
	if (ret)
		goto unlock_out;

	ret = -ENOENT;
	while (ops->getnext(&dir, obj) == 0) {
		if (adfs_match(name, obj)) {
			ret = 0;
			break;
		}
	}

unlock_out:
	read_unlock(&adfs_dir_lock);

free_out:
	ops->free(&dir);
out:
	return ret;
}

const struct file_operations adfs_dir_operations = {
	.read		= generic_read_dir,
	.llseek		= generic_file_llseek,
	.readdir	= adfs_readdir,
	.fsync		= generic_file_fsync,
};

static int
adfs_hash(const struct dentry *parent, const struct inode *inode,
		struct qstr *qstr)
{
	const unsigned int name_len = ADFS_SB(parent->d_sb)->s_namelen;
	const unsigned char *name;
	unsigned long hash;
	int i;

	if (qstr->len < name_len)
		return 0;

	/*
	 * Truncate the name in place, avoids
	 * having to define a compare function.
	 */
	qstr->len = i = name_len;
	name = qstr->name;
	hash = init_name_hash();
	while (i--) {
		char c;

		c = *name++;
		if (c >= 'A' && c <= 'Z')
			c += 'a' - 'A';

		hash = partial_name_hash(c, hash);
	}
	qstr->hash = end_name_hash(hash);

	return 0;
}

/*
 * Compare two names, taking note of the name length
 * requirements of the underlying filesystem.
 */
static int
adfs_compare(const struct dentry *parent, const struct inode *pinode,
		const struct dentry *dentry, const struct inode *inode,
		unsigned int len, const char *str, const struct qstr *name)
{
	int i;

	if (len != name->len)
		return 1;

	for (i = 0; i < name->len; i++) {
		char a, b;

		a = str[i];
		b = name->name[i];

		if (a >= 'A' && a <= 'Z')
			a += 'a' - 'A';
		if (b >= 'A' && b <= 'Z')
			b += 'a' - 'A';

		if (a != b)
			return 1;
	}
	return 0;
}

const struct dentry_operations adfs_dentry_operations = {
	.d_hash		= adfs_hash,
	.d_compare	= adfs_compare,
};

static struct dentry *
adfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	struct inode *inode = NULL;
	struct object_info obj;
	int error;

	error = adfs_dir_lookup_byname(dir, &dentry->d_name, &obj);
	if (error == 0) {
		error = -EACCES;
		/*
		 * This only returns NULL if get_empty_inode
		 * fails.
		 */
		inode = adfs_iget(dir->i_sb, &obj);
		if (inode)
			error = 0;
	}
	d_add(dentry, inode);
	return ERR_PTR(error);
}

/*
 * directories can handle most operations...
 */
const struct inode_operations adfs_dir_inode_operations = {
	.lookup		= adfs_lookup,
	.setattr	= adfs_notify_change,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/adfs/dir.c
	3	*
	4	* Copyright (C) 1999-2000 Russell King
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* Common directory handling for ADFS
	11	*/
1da177e4 LT	12	#include "adfs.h"
	13
	14	/*
	15	* For future. This should probably be per-directory.
	16	*/
	17	static DEFINE_RWLOCK(adfs_dir_lock);
	18
	19	static int
	20	adfs_readdir(struct file filp, void dirent, filldir_t filldir)
	21	{
514653e2	22	struct inode *inode = filp->f_path.dentry->d_inode;
1da177e4 LT	23	struct super_block *sb = inode->i_sb;
	24	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	25	struct object_info obj;
	26	struct adfs_dir dir;
	27	int ret = 0;
	28
1da177e4 LT	29	if (filp->f_pos >> 32)
	30	goto out;
	31
	32	ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
	33	if (ret)
	34	goto out;
	35
	36	switch ((unsigned long)filp->f_pos) {
	37	case 0:
	38	if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
	39	goto free_out;
	40	filp->f_pos += 1;
	41
	42	case 1:
	43	if (filldir(dirent, "..", 2, 1, dir.parent_id, DT_DIR) < 0)
	44	goto free_out;
	45	filp->f_pos += 1;
	46
	47	default:
	48	break;
	49	}
	50
	51	read_lock(&adfs_dir_lock);
	52
	53	ret = ops->setpos(&dir, filp->f_pos - 2);
	54	if (ret)
	55	goto unlock_out;
	56	while (ops->getnext(&dir, &obj) == 0) {
	57	if (filldir(dirent, obj.name, obj.name_len,
	58	filp->f_pos, obj.file_id, DT_UNKNOWN) < 0)
	59	goto unlock_out;
	60	filp->f_pos += 1;
	61	}
	62
	63	unlock_out:
	64	read_unlock(&adfs_dir_lock);
	65
	66	free_out:
	67	ops->free(&dir);
	68
	69	out:
1da177e4 LT	70	return ret;
	71	}
	72
	73	int
ffdc9064	74	adfs_dir_update(struct super_block sb, struct object_info obj, int wait)
1da177e4 LT	75	{
	76	int ret = -EINVAL;
	77	#ifdef CONFIG_ADFS_FS_RW
	78	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	79	struct adfs_dir dir;
	80
	81	printk(KERN_INFO "adfs_dir_update: object %06X in dir %06X\n",
	82	obj->file_id, obj->parent_id);
	83
	84	if (!ops->update) {
	85	ret = -EINVAL;
	86	goto out;
	87	}
	88
	89	ret = ops->read(sb, obj->parent_id, 0, &dir);
	90	if (ret)
	91	goto out;
	92
	93	write_lock(&adfs_dir_lock);
	94	ret = ops->update(&dir, obj);
	95	write_unlock(&adfs_dir_lock);
	96
ffdc9064 AV	97	if (wait) {
	98	int err = ops->sync(&dir);
	99	if (!ret)
	100	ret = err;
	101	}
	102
1da177e4 LT	103	ops->free(&dir);
	104	out:
	105	#endif
	106	return ret;
	107	}
	108
	109	static int
	110	adfs_match(struct qstr name, struct object_info obj)
	111	{
	112	int i;
	113
	114	if (name->len != obj->name_len)
	115	return 0;
	116
	117	for (i = 0; i < name->len; i++) {
	118	char c1, c2;
	119
	120	c1 = name->name[i];
	121	c2 = obj->name[i];
	122
	123	if (c1 >= 'A' && c1 <= 'Z')
	124	c1 += 'a' - 'A';
	125	if (c2 >= 'A' && c2 <= 'Z')
	126	c2 += 'a' - 'A';
	127
	128	if (c1 != c2)
	129	return 0;
	130	}
	131	return 1;
	132	}
	133
	134	static int
	135	adfs_dir_lookup_byname(struct inode inode, struct qstr name, struct object_info *obj)
	136	{
	137	struct super_block *sb = inode->i_sb;
	138	struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
	139	struct adfs_dir dir;
	140	int ret;
	141
	142	ret = ops->read(sb, inode->i_ino, inode->i_size, &dir);
	143	if (ret)
	144	goto out;
	145
	146	if (ADFS_I(inode)->parent_id != dir.parent_id) {
	147	adfs_error(sb, "parent directory changed under me! (%lx but got %lx)\n",
	148	ADFS_I(inode)->parent_id, dir.parent_id);
	149	ret = -EIO;
	150	goto free_out;
	151	}
	152
	153	obj->parent_id = inode->i_ino;
	154
	155	/*
	156	* '.' is handled by reserved_lookup() in fs/namei.c
	157	*/
	158	if (name->len == 2 && name->name[0] == '.' && name->name[1] == '.') {
	159	/*
	160	* Currently unable to fill in the rest of 'obj',
	161	* but this is better than nothing. We need to
	162	* ascend one level to find it's parent.
	163	*/
	164	obj->name_len = 0;
	165	obj->file_id = obj->parent_id;
	166	goto free_out;
167	}
168
169	read_lock(&adfs_dir_lock);
170
171	ret = ops->setpos(&dir, 0);
172	if (ret)
173	goto unlock_out;
174
175	ret = -ENOENT;
176	while (ops->getnext(&dir, obj) == 0) {
177	if (adfs_match(name, obj)) {
178	ret = 0;
179	break;
180	}
181	}
182
183	unlock_out:
184	read_unlock(&adfs_dir_lock);
185
186	free_out:
187	ops->free(&dir);
188	out:
189	return ret;
190	}
191
4b6f5d20	192	const struct file_operations adfs_dir_operations = {
1da177e4	193	.read = generic_read_dir,
59af1584	194	.llseek = generic_file_llseek,
1da177e4	195	.readdir = adfs_readdir,
1b061d92	196	.fsync = generic_file_fsync,
1da177e4 LT	197	};
	198
	199	static int
b1e6a015 NP	200	adfs_hash(const struct dentry parent, const struct inode inode,
b1e6a015 NP	201	struct qstr *qstr)
1da177e4 LT	202	{
	203	const unsigned int name_len = ADFS_SB(parent->d_sb)->s_namelen;
	204	const unsigned char *name;
	205	unsigned long hash;
	206	int i;
	207
	208	if (qstr->len < name_len)
	209	return 0;
	210
	211	/*
	212	* Truncate the name in place, avoids
	213	* having to define a compare function.
	214	*/
	215	qstr->len = i = name_len;
	216	name = qstr->name;
	217	hash = init_name_hash();
	218	while (i--) {
	219	char c;
	220
	221	c = *name++;
	222	if (c >= 'A' && c <= 'Z')
	223	c += 'a' - 'A';
	224
	225	hash = partial_name_hash(c, hash);
	226	}
	227	qstr->hash = end_name_hash(hash);
	228
	229	return 0;
	230	}
	231
	232	/*
	233	* Compare two names, taking note of the name length
	234	* requirements of the underlying filesystem.
	235	*/
	236	static int
621e155a NP	237	adfs_compare(const struct dentry parent, const struct inode pinode,
	238	const struct dentry dentry, const struct inode inode,
	239	unsigned int len, const char str, const struct qstr name)
1da177e4 LT	240	{
	241	int i;
	242
621e155a	243	if (len != name->len)
1da177e4 LT	244	return 1;
	245
	246	for (i = 0; i < name->len; i++) {
	247	char a, b;
	248
621e155a	249	a = str[i];
1da177e4 LT	250	b = name->name[i];
	251
	252	if (a >= 'A' && a <= 'Z')
	253	a += 'a' - 'A';
	254	if (b >= 'A' && b <= 'Z')
	255	b += 'a' - 'A';
	256
	257	if (a != b)
	258	return 1;
	259	}
	260	return 0;
	261	}
	262
e16404ed	263	const struct dentry_operations adfs_dentry_operations = {
1da177e4 LT	264	.d_hash = adfs_hash,
	265	.d_compare = adfs_compare,
	266	};
	267
	268	static struct dentry *
	269	adfs_lookup(struct inode dir, struct dentry dentry, struct nameidata *nd)
	270	{
	271	struct inode *inode = NULL;
	272	struct object_info obj;
	273	int error;
	274
1da177e4 LT	275	error = adfs_dir_lookup_byname(dir, &dentry->d_name, &obj);
	276	if (error == 0) {
	277	error = -EACCES;
	278	/*
	279	* This only returns NULL if get_empty_inode
	280	* fails.
	281	*/
	282	inode = adfs_iget(dir->i_sb, &obj);
	283	if (inode)
	284	error = 0;
	285	}
1da177e4 LT	286	d_add(dentry, inode);
	287	return ERR_PTR(error);
	288	}
	289
	290	/*
	291	* directories can handle most operations...
	292	*/
754661f1	293	const struct inode_operations adfs_dir_inode_operations = {
1da177e4 LT	294	.lookup = adfs_lookup,
	295	.setattr = adfs_notify_change,
	296	};