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