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