Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /* | |
3 | * Directory operations for Coda filesystem | |
4 | * Original version: (C) 1996 P. Braam and M. Callahan | |
5 | * Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University | |
6 | * | |
7 | * Carnegie Mellon encourages users to contribute improvements to | |
8 | * the Coda project. Contact Peter Braam (coda@cs.cmu.edu). | |
9 | */ | |
10 | ||
11 | #include <linux/types.h> | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/time.h> | |
14 | #include <linux/fs.h> | |
15 | #include <linux/file.h> | |
16 | #include <linux/stat.h> | |
17 | #include <linux/errno.h> | |
18 | #include <linux/string.h> | |
19 | #include <linux/smp_lock.h> | |
20 | ||
21 | #include <asm/uaccess.h> | |
22 | ||
23 | #include <linux/coda.h> | |
24 | #include <linux/coda_linux.h> | |
25 | #include <linux/coda_psdev.h> | |
26 | #include <linux/coda_fs_i.h> | |
27 | #include <linux/coda_cache.h> | |
1da177e4 | 28 | |
c98d8cfb AB |
29 | #include "coda_int.h" |
30 | ||
1da177e4 LT |
31 | /* dir inode-ops */ |
32 | static int coda_create(struct inode *dir, struct dentry *new, int mode, struct nameidata *nd); | |
33 | static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd); | |
34 | static int coda_link(struct dentry *old_dentry, struct inode *dir_inode, | |
35 | struct dentry *entry); | |
36 | static int coda_unlink(struct inode *dir_inode, struct dentry *entry); | |
37 | static int coda_symlink(struct inode *dir_inode, struct dentry *entry, | |
38 | const char *symname); | |
39 | static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, int mode); | |
40 | static int coda_rmdir(struct inode *dir_inode, struct dentry *entry); | |
41 | static int coda_rename(struct inode *old_inode, struct dentry *old_dentry, | |
42 | struct inode *new_inode, struct dentry *new_dentry); | |
43 | ||
44 | /* dir file-ops */ | |
97875253 | 45 | static int coda_readdir(struct file *file, void *buf, filldir_t filldir); |
1da177e4 LT |
46 | |
47 | /* dentry ops */ | |
48 | static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd); | |
49 | static int coda_dentry_delete(struct dentry *); | |
50 | ||
51 | /* support routines */ | |
97875253 JH |
52 | static int coda_venus_readdir(struct file *coda_file, void *buf, |
53 | filldir_t filldir); | |
1da177e4 LT |
54 | |
55 | /* same as fs/bad_inode.c */ | |
56 | static int coda_return_EIO(void) | |
57 | { | |
58 | return -EIO; | |
59 | } | |
60 | #define CODA_EIO_ERROR ((void *) (coda_return_EIO)) | |
61 | ||
e16404ed | 62 | static const struct dentry_operations coda_dentry_operations = |
1da177e4 LT |
63 | { |
64 | .d_revalidate = coda_dentry_revalidate, | |
65 | .d_delete = coda_dentry_delete, | |
66 | }; | |
67 | ||
754661f1 | 68 | const struct inode_operations coda_dir_inode_operations = |
1da177e4 LT |
69 | { |
70 | .create = coda_create, | |
71 | .lookup = coda_lookup, | |
72 | .link = coda_link, | |
73 | .unlink = coda_unlink, | |
74 | .symlink = coda_symlink, | |
75 | .mkdir = coda_mkdir, | |
76 | .rmdir = coda_rmdir, | |
77 | .mknod = CODA_EIO_ERROR, | |
78 | .rename = coda_rename, | |
79 | .permission = coda_permission, | |
80 | .getattr = coda_getattr, | |
81 | .setattr = coda_setattr, | |
82 | }; | |
83 | ||
4b6f5d20 | 84 | const struct file_operations coda_dir_operations = { |
1da177e4 LT |
85 | .llseek = generic_file_llseek, |
86 | .read = generic_read_dir, | |
87 | .readdir = coda_readdir, | |
88 | .open = coda_open, | |
1da177e4 LT |
89 | .release = coda_release, |
90 | .fsync = coda_fsync, | |
91 | }; | |
92 | ||
93 | ||
94 | /* inode operations for directories */ | |
95 | /* access routines: lookup, readlink, permission */ | |
96 | static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struct nameidata *nd) | |
97 | { | |
ed36f723 | 98 | struct inode *inode = NULL; |
1da177e4 | 99 | struct CodaFid resfid = { { 0, } }; |
1da177e4 LT |
100 | int type = 0; |
101 | int error = 0; | |
102 | const char *name = entry->d_name.name; | |
103 | size_t length = entry->d_name.len; | |
ed36f723 JH |
104 | |
105 | if (length > CODA_MAXNAMLEN) { | |
106 | printk(KERN_ERR "name too long: lookup, %s (%*s)\n", | |
1da177e4 LT |
107 | coda_i2s(dir), (int)length, name); |
108 | return ERR_PTR(-ENAMETOOLONG); | |
109 | } | |
110 | ||
ed36f723 JH |
111 | /* control object, create inode on the fly */ |
112 | if (coda_isroot(dir) && coda_iscontrol(name, length)) { | |
113 | error = coda_cnode_makectl(&inode, dir->i_sb); | |
114 | type = CODA_NOCACHE; | |
115 | goto exit; | |
116 | } | |
117 | ||
1da177e4 | 118 | lock_kernel(); |
ed36f723 JH |
119 | |
120 | error = venus_lookup(dir->i_sb, coda_i2f(dir), name, length, | |
121 | &type, &resfid); | |
122 | if (!error) | |
123 | error = coda_cnode_make(&inode, &resfid, dir->i_sb); | |
124 | ||
125 | unlock_kernel(); | |
126 | ||
127 | if (error && error != -ENOENT) | |
1da177e4 | 128 | return ERR_PTR(error); |
1da177e4 LT |
129 | |
130 | exit: | |
1da177e4 | 131 | entry->d_op = &coda_dentry_operations; |
ed36f723 JH |
132 | |
133 | if (inode && (type & CODA_NOCACHE)) | |
134 | coda_flag_inode(inode, C_VATTR | C_PURGE); | |
135 | ||
136 | return d_splice_alias(inode, entry); | |
1da177e4 LT |
137 | } |
138 | ||
139 | ||
e6305c43 | 140 | int coda_permission(struct inode *inode, int mask) |
1da177e4 LT |
141 | { |
142 | int error = 0; | |
e6305c43 AV |
143 | |
144 | mask &= MAY_READ | MAY_WRITE | MAY_EXEC; | |
1da177e4 LT |
145 | |
146 | if (!mask) | |
147 | return 0; | |
148 | ||
f696a365 MS |
149 | if ((mask & MAY_EXEC) && !execute_ok(inode)) |
150 | return -EACCES; | |
151 | ||
1da177e4 LT |
152 | lock_kernel(); |
153 | ||
1da177e4 LT |
154 | if (coda_cache_check(inode, mask)) |
155 | goto out; | |
156 | ||
157 | error = venus_access(inode->i_sb, coda_i2f(inode), mask); | |
158 | ||
159 | if (!error) | |
160 | coda_cache_enter(inode, mask); | |
161 | ||
162 | out: | |
163 | unlock_kernel(); | |
d728900c | 164 | return error; |
1da177e4 LT |
165 | } |
166 | ||
167 | ||
d728900c | 168 | static inline void coda_dir_update_mtime(struct inode *dir) |
1da177e4 LT |
169 | { |
170 | #ifdef REQUERY_VENUS_FOR_MTIME | |
171 | /* invalidate the directory cnode's attributes so we refetch the | |
172 | * attributes from venus next time the inode is referenced */ | |
173 | coda_flag_inode(dir, C_VATTR); | |
174 | #else | |
175 | /* optimistically we can also act as if our nose bleeds. The | |
d728900c JH |
176 | * granularity of the mtime is coarse anyways so we might actually be |
177 | * right most of the time. Note: we only do this for directories. */ | |
1da177e4 LT |
178 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; |
179 | #endif | |
d728900c JH |
180 | } |
181 | ||
182 | /* we have to wrap inc_nlink/drop_nlink because sometimes userspace uses a | |
183 | * trick to fool GNU find's optimizations. If we can't be sure of the link | |
184 | * (because of volume mount points) we set i_nlink to 1 which forces find | |
185 | * to consider every child as a possible directory. We should also never | |
186 | * see an increment or decrement for deleted directories where i_nlink == 0 */ | |
187 | static inline void coda_dir_inc_nlink(struct inode *dir) | |
188 | { | |
189 | if (dir->i_nlink >= 2) | |
190 | inc_nlink(dir); | |
191 | } | |
192 | ||
193 | static inline void coda_dir_drop_nlink(struct inode *dir) | |
194 | { | |
195 | if (dir->i_nlink > 2) | |
196 | drop_nlink(dir); | |
1da177e4 LT |
197 | } |
198 | ||
199 | /* creation routines: create, mknod, mkdir, link, symlink */ | |
200 | static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd) | |
201 | { | |
202 | int error=0; | |
203 | const char *name=de->d_name.name; | |
204 | int length=de->d_name.len; | |
205 | struct inode *inode; | |
206 | struct CodaFid newfid; | |
207 | struct coda_vattr attrs; | |
208 | ||
209 | lock_kernel(); | |
1da177e4 LT |
210 | |
211 | if (coda_isroot(dir) && coda_iscontrol(name, length)) { | |
212 | unlock_kernel(); | |
213 | return -EPERM; | |
214 | } | |
215 | ||
216 | error = venus_create(dir->i_sb, coda_i2f(dir), name, length, | |
217 | 0, mode, &newfid, &attrs); | |
218 | ||
219 | if ( error ) { | |
220 | unlock_kernel(); | |
221 | d_drop(de); | |
222 | return error; | |
223 | } | |
224 | ||
225 | inode = coda_iget(dir->i_sb, &newfid, &attrs); | |
226 | if ( IS_ERR(inode) ) { | |
227 | unlock_kernel(); | |
228 | d_drop(de); | |
229 | return PTR_ERR(inode); | |
230 | } | |
231 | ||
232 | /* invalidate the directory cnode's attributes */ | |
d728900c | 233 | coda_dir_update_mtime(dir); |
1da177e4 LT |
234 | unlock_kernel(); |
235 | d_instantiate(de, inode); | |
d728900c | 236 | return 0; |
1da177e4 LT |
237 | } |
238 | ||
239 | static int coda_mkdir(struct inode *dir, struct dentry *de, int mode) | |
240 | { | |
241 | struct inode *inode; | |
242 | struct coda_vattr attrs; | |
243 | const char *name = de->d_name.name; | |
244 | int len = de->d_name.len; | |
245 | int error; | |
246 | struct CodaFid newfid; | |
247 | ||
248 | lock_kernel(); | |
1da177e4 LT |
249 | |
250 | if (coda_isroot(dir) && coda_iscontrol(name, len)) { | |
251 | unlock_kernel(); | |
252 | return -EPERM; | |
253 | } | |
254 | ||
255 | attrs.va_mode = mode; | |
256 | error = venus_mkdir(dir->i_sb, coda_i2f(dir), | |
257 | name, len, &newfid, &attrs); | |
258 | ||
259 | if ( error ) { | |
260 | unlock_kernel(); | |
261 | d_drop(de); | |
262 | return error; | |
263 | } | |
264 | ||
265 | inode = coda_iget(dir->i_sb, &newfid, &attrs); | |
266 | if ( IS_ERR(inode) ) { | |
267 | unlock_kernel(); | |
268 | d_drop(de); | |
269 | return PTR_ERR(inode); | |
270 | } | |
d728900c | 271 | |
1da177e4 | 272 | /* invalidate the directory cnode's attributes */ |
d728900c JH |
273 | coda_dir_inc_nlink(dir); |
274 | coda_dir_update_mtime(dir); | |
1da177e4 LT |
275 | unlock_kernel(); |
276 | d_instantiate(de, inode); | |
d728900c | 277 | return 0; |
1da177e4 LT |
278 | } |
279 | ||
280 | /* try to make de an entry in dir_inodde linked to source_de */ | |
281 | static int coda_link(struct dentry *source_de, struct inode *dir_inode, | |
282 | struct dentry *de) | |
283 | { | |
284 | struct inode *inode = source_de->d_inode; | |
285 | const char * name = de->d_name.name; | |
286 | int len = de->d_name.len; | |
287 | int error; | |
288 | ||
289 | lock_kernel(); | |
1da177e4 LT |
290 | |
291 | if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) { | |
292 | unlock_kernel(); | |
293 | return -EPERM; | |
294 | } | |
295 | ||
296 | error = venus_link(dir_inode->i_sb, coda_i2f(inode), | |
297 | coda_i2f(dir_inode), (const char *)name, len); | |
298 | ||
d728900c | 299 | if (error) { |
1da177e4 LT |
300 | d_drop(de); |
301 | goto out; | |
302 | } | |
303 | ||
d728900c | 304 | coda_dir_update_mtime(dir_inode); |
1da177e4 LT |
305 | atomic_inc(&inode->i_count); |
306 | d_instantiate(de, inode); | |
d8c76e6f | 307 | inc_nlink(inode); |
d728900c | 308 | |
1da177e4 LT |
309 | out: |
310 | unlock_kernel(); | |
311 | return(error); | |
312 | } | |
313 | ||
314 | ||
315 | static int coda_symlink(struct inode *dir_inode, struct dentry *de, | |
316 | const char *symname) | |
317 | { | |
318 | const char *name = de->d_name.name; | |
319 | int len = de->d_name.len; | |
320 | int symlen; | |
3cf01f28 JH |
321 | int error = 0; |
322 | ||
1da177e4 | 323 | lock_kernel(); |
1da177e4 LT |
324 | |
325 | if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) { | |
326 | unlock_kernel(); | |
327 | return -EPERM; | |
328 | } | |
329 | ||
330 | symlen = strlen(symname); | |
331 | if ( symlen > CODA_MAXPATHLEN ) { | |
332 | unlock_kernel(); | |
333 | return -ENAMETOOLONG; | |
334 | } | |
335 | ||
336 | /* | |
337 | * This entry is now negative. Since we do not create | |
d728900c | 338 | * an inode for the entry we have to drop it. |
1da177e4 LT |
339 | */ |
340 | d_drop(de); | |
d728900c | 341 | error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len, |
1da177e4 LT |
342 | symname, symlen); |
343 | ||
344 | /* mtime is no good anymore */ | |
345 | if ( !error ) | |
d728900c | 346 | coda_dir_update_mtime(dir_inode); |
1da177e4 LT |
347 | |
348 | unlock_kernel(); | |
d728900c | 349 | return error; |
1da177e4 LT |
350 | } |
351 | ||
352 | /* destruction routines: unlink, rmdir */ | |
9fe76c76 | 353 | static int coda_unlink(struct inode *dir, struct dentry *de) |
1da177e4 LT |
354 | { |
355 | int error; | |
356 | const char *name = de->d_name.name; | |
357 | int len = de->d_name.len; | |
358 | ||
359 | lock_kernel(); | |
1da177e4 | 360 | |
d728900c JH |
361 | error = venus_remove(dir->i_sb, coda_i2f(dir), name, len); |
362 | if ( error ) { | |
1da177e4 | 363 | unlock_kernel(); |
d728900c JH |
364 | return error; |
365 | } | |
1da177e4 | 366 | |
d728900c | 367 | coda_dir_update_mtime(dir); |
9a53c3a7 | 368 | drop_nlink(de->d_inode); |
1da177e4 | 369 | unlock_kernel(); |
d728900c | 370 | return 0; |
1da177e4 LT |
371 | } |
372 | ||
9fe76c76 | 373 | static int coda_rmdir(struct inode *dir, struct dentry *de) |
1da177e4 LT |
374 | { |
375 | const char *name = de->d_name.name; | |
376 | int len = de->d_name.len; | |
8c6d2152 | 377 | int error; |
1da177e4 LT |
378 | |
379 | lock_kernel(); | |
1da177e4 | 380 | |
1da177e4 | 381 | error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len); |
8c6d2152 JH |
382 | if (!error) { |
383 | /* VFS may delete the child */ | |
384 | if (de->d_inode) | |
385 | de->d_inode->i_nlink = 0; | |
1da177e4 | 386 | |
8c6d2152 JH |
387 | /* fix the link count of the parent */ |
388 | coda_dir_drop_nlink(dir); | |
389 | coda_dir_update_mtime(dir); | |
d728900c | 390 | } |
1da177e4 | 391 | unlock_kernel(); |
8c6d2152 | 392 | return error; |
1da177e4 LT |
393 | } |
394 | ||
395 | /* rename */ | |
d728900c | 396 | static int coda_rename(struct inode *old_dir, struct dentry *old_dentry, |
1da177e4 LT |
397 | struct inode *new_dir, struct dentry *new_dentry) |
398 | { | |
d728900c JH |
399 | const char *old_name = old_dentry->d_name.name; |
400 | const char *new_name = new_dentry->d_name.name; | |
1da177e4 LT |
401 | int old_length = old_dentry->d_name.len; |
402 | int new_length = new_dentry->d_name.len; | |
d728900c | 403 | int error; |
1da177e4 LT |
404 | |
405 | lock_kernel(); | |
1da177e4 | 406 | |
d728900c JH |
407 | error = venus_rename(old_dir->i_sb, coda_i2f(old_dir), |
408 | coda_i2f(new_dir), old_length, new_length, | |
1da177e4 LT |
409 | (const char *) old_name, (const char *)new_name); |
410 | ||
d728900c | 411 | if ( !error ) { |
1da177e4 | 412 | if ( new_dentry->d_inode ) { |
d728900c JH |
413 | if ( S_ISDIR(new_dentry->d_inode->i_mode) ) { |
414 | coda_dir_drop_nlink(old_dir); | |
415 | coda_dir_inc_nlink(new_dir); | |
416 | } | |
417 | coda_dir_update_mtime(old_dir); | |
418 | coda_dir_update_mtime(new_dir); | |
1da177e4 LT |
419 | coda_flag_inode(new_dentry->d_inode, C_VATTR); |
420 | } else { | |
421 | coda_flag_inode(old_dir, C_VATTR); | |
422 | coda_flag_inode(new_dir, C_VATTR); | |
d728900c | 423 | } |
1da177e4 LT |
424 | } |
425 | unlock_kernel(); | |
426 | ||
427 | return error; | |
428 | } | |
429 | ||
430 | ||
431 | /* file operations for directories */ | |
9fe76c76 | 432 | static int coda_readdir(struct file *coda_file, void *buf, filldir_t filldir) |
1da177e4 | 433 | { |
1da177e4 LT |
434 | struct coda_file_info *cfi; |
435 | struct file *host_file; | |
1da177e4 LT |
436 | int ret; |
437 | ||
438 | cfi = CODA_FTOC(coda_file); | |
439 | BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC); | |
440 | host_file = cfi->cfi_container; | |
441 | ||
97875253 JH |
442 | if (!host_file->f_op) |
443 | return -ENOTDIR; | |
444 | ||
445 | if (host_file->f_op->readdir) | |
446 | { | |
447 | /* potemkin case: we were handed a directory inode. | |
448 | * We can't use vfs_readdir because we have to keep the file | |
449 | * position in sync between the coda_file and the host_file. | |
450 | * and as such we need grab the inode mutex. */ | |
451 | struct inode *host_inode = host_file->f_path.dentry->d_inode; | |
452 | ||
453 | mutex_lock(&host_inode->i_mutex); | |
454 | host_file->f_pos = coda_file->f_pos; | |
1da177e4 LT |
455 | |
456 | ret = -ENOENT; | |
457 | if (!IS_DEADDIR(host_inode)) { | |
97875253 | 458 | ret = host_file->f_op->readdir(host_file, buf, filldir); |
1da177e4 LT |
459 | file_accessed(host_file); |
460 | } | |
97875253 JH |
461 | |
462 | coda_file->f_pos = host_file->f_pos; | |
463 | mutex_unlock(&host_inode->i_mutex); | |
1da177e4 | 464 | } |
97875253 JH |
465 | else /* Venus: we must read Venus dirents from a file */ |
466 | ret = coda_venus_readdir(coda_file, buf, filldir); | |
1da177e4 LT |
467 | |
468 | return ret; | |
469 | } | |
470 | ||
471 | static inline unsigned int CDT2DT(unsigned char cdt) | |
472 | { | |
473 | unsigned int dt; | |
474 | ||
475 | switch(cdt) { | |
476 | case CDT_UNKNOWN: dt = DT_UNKNOWN; break; | |
477 | case CDT_FIFO: dt = DT_FIFO; break; | |
478 | case CDT_CHR: dt = DT_CHR; break; | |
479 | case CDT_DIR: dt = DT_DIR; break; | |
480 | case CDT_BLK: dt = DT_BLK; break; | |
481 | case CDT_REG: dt = DT_REG; break; | |
482 | case CDT_LNK: dt = DT_LNK; break; | |
483 | case CDT_SOCK: dt = DT_SOCK; break; | |
484 | case CDT_WHT: dt = DT_WHT; break; | |
485 | default: dt = DT_UNKNOWN; break; | |
486 | } | |
487 | return dt; | |
488 | } | |
489 | ||
490 | /* support routines */ | |
97875253 JH |
491 | static int coda_venus_readdir(struct file *coda_file, void *buf, |
492 | filldir_t filldir) | |
1da177e4 LT |
493 | { |
494 | int result = 0; /* # of entries returned */ | |
97875253 JH |
495 | struct coda_file_info *cfi; |
496 | struct coda_inode_info *cii; | |
497 | struct file *host_file; | |
498 | struct dentry *de; | |
1da177e4 LT |
499 | struct venus_dirent *vdir; |
500 | unsigned long vdir_size = | |
501 | (unsigned long)(&((struct venus_dirent *)0)->d_name); | |
502 | unsigned int type; | |
503 | struct qstr name; | |
504 | ino_t ino; | |
97875253 JH |
505 | int ret; |
506 | ||
507 | cfi = CODA_FTOC(coda_file); | |
508 | BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC); | |
509 | host_file = cfi->cfi_container; | |
510 | ||
511 | de = coda_file->f_path.dentry; | |
512 | cii = ITOC(de->d_inode); | |
1da177e4 | 513 | |
f52720ca | 514 | vdir = kmalloc(sizeof(*vdir), GFP_KERNEL); |
1da177e4 LT |
515 | if (!vdir) return -ENOMEM; |
516 | ||
5f47c7ea | 517 | if (coda_file->f_pos == 0) { |
97875253 | 518 | ret = filldir(buf, ".", 1, 0, de->d_inode->i_ino, DT_DIR); |
5f47c7ea AV |
519 | if (ret < 0) |
520 | goto out; | |
1da177e4 | 521 | result++; |
97875253 | 522 | coda_file->f_pos++; |
5f47c7ea AV |
523 | } |
524 | if (coda_file->f_pos == 1) { | |
97875253 | 525 | ret = filldir(buf, "..", 2, 1, de->d_parent->d_inode->i_ino, DT_DIR); |
5f47c7ea AV |
526 | if (ret < 0) |
527 | goto out; | |
1da177e4 | 528 | result++; |
97875253 | 529 | coda_file->f_pos++; |
5f47c7ea | 530 | } |
1da177e4 LT |
531 | while (1) { |
532 | /* read entries from the directory file */ | |
97875253 | 533 | ret = kernel_read(host_file, coda_file->f_pos - 2, (char *)vdir, |
1da177e4 LT |
534 | sizeof(*vdir)); |
535 | if (ret < 0) { | |
97875253 JH |
536 | printk(KERN_ERR "coda readdir: read dir %s failed %d\n", |
537 | coda_f2s(&cii->c_fid), ret); | |
1da177e4 LT |
538 | break; |
539 | } | |
540 | if (ret == 0) break; /* end of directory file reached */ | |
541 | ||
542 | /* catch truncated reads */ | |
543 | if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) { | |
97875253 JH |
544 | printk(KERN_ERR "coda readdir: short read on %s\n", |
545 | coda_f2s(&cii->c_fid)); | |
1da177e4 LT |
546 | ret = -EBADF; |
547 | break; | |
548 | } | |
549 | /* validate whether the directory file actually makes sense */ | |
550 | if (vdir->d_reclen < vdir_size + vdir->d_namlen) { | |
97875253 JH |
551 | printk(KERN_ERR "coda readdir: invalid dir %s\n", |
552 | coda_f2s(&cii->c_fid)); | |
1da177e4 LT |
553 | ret = -EBADF; |
554 | break; | |
555 | } | |
556 | ||
557 | name.len = vdir->d_namlen; | |
558 | name.name = vdir->d_name; | |
559 | ||
560 | /* Make sure we skip '.' and '..', we already got those */ | |
561 | if (name.name[0] == '.' && (name.len == 1 || | |
562 | (vdir->d_name[1] == '.' && name.len == 2))) | |
563 | vdir->d_fileno = name.len = 0; | |
564 | ||
565 | /* skip null entries */ | |
566 | if (vdir->d_fileno && name.len) { | |
567 | /* try to look up this entry in the dcache, that way | |
568 | * userspace doesn't have to worry about breaking | |
569 | * getcwd by having mismatched inode numbers for | |
570 | * internal volume mountpoints. */ | |
97875253 | 571 | ino = find_inode_number(de, &name); |
1da177e4 LT |
572 | if (!ino) ino = vdir->d_fileno; |
573 | ||
574 | type = CDT2DT(vdir->d_type); | |
97875253 JH |
575 | ret = filldir(buf, name.name, name.len, |
576 | coda_file->f_pos, ino, type); | |
1da177e4 LT |
577 | /* failure means no space for filling in this round */ |
578 | if (ret < 0) break; | |
579 | result++; | |
580 | } | |
581 | /* we'll always have progress because d_reclen is unsigned and | |
582 | * we've already established it is non-zero. */ | |
97875253 JH |
583 | coda_file->f_pos += vdir->d_reclen; |
584 | } | |
5f47c7ea | 585 | out: |
1da177e4 LT |
586 | kfree(vdir); |
587 | return result ? result : ret; | |
588 | } | |
589 | ||
590 | /* called when a cache lookup succeeds */ | |
591 | static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd) | |
592 | { | |
593 | struct inode *inode = de->d_inode; | |
594 | struct coda_inode_info *cii; | |
595 | ||
596 | if (!inode) | |
597 | return 1; | |
598 | lock_kernel(); | |
599 | if (coda_isroot(inode)) | |
600 | goto out; | |
601 | if (is_bad_inode(inode)) | |
602 | goto bad; | |
603 | ||
604 | cii = ITOC(de->d_inode); | |
605 | if (!(cii->c_flags & (C_PURGE | C_FLUSH))) | |
606 | goto out; | |
607 | ||
608 | shrink_dcache_parent(de); | |
609 | ||
610 | /* propagate for a flush */ | |
611 | if (cii->c_flags & C_FLUSH) | |
612 | coda_flag_inode_children(inode, C_FLUSH); | |
613 | ||
614 | if (atomic_read(&de->d_count) > 1) | |
615 | /* pretend it's valid, but don't change the flags */ | |
616 | goto out; | |
617 | ||
618 | /* clear the flags. */ | |
619 | cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH); | |
620 | ||
621 | bad: | |
622 | unlock_kernel(); | |
623 | return 0; | |
624 | out: | |
625 | unlock_kernel(); | |
626 | return 1; | |
627 | } | |
628 | ||
629 | /* | |
630 | * This is the callback from dput() when d_count is going to 0. | |
631 | * We use this to unhash dentries with bad inodes. | |
632 | */ | |
633 | static int coda_dentry_delete(struct dentry * dentry) | |
634 | { | |
635 | int flags; | |
636 | ||
637 | if (!dentry->d_inode) | |
638 | return 0; | |
639 | ||
640 | flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE; | |
641 | if (is_bad_inode(dentry->d_inode) || flags) { | |
642 | return 1; | |
643 | } | |
644 | return 0; | |
645 | } | |
646 | ||
647 | ||
648 | ||
649 | /* | |
650 | * This is called when we want to check if the inode has | |
651 | * changed on the server. Coda makes this easy since the | |
652 | * cache manager Venus issues a downcall to the kernel when this | |
653 | * happens | |
654 | */ | |
655 | int coda_revalidate_inode(struct dentry *dentry) | |
656 | { | |
657 | struct coda_vattr attr; | |
658 | int error = 0; | |
659 | int old_mode; | |
660 | ino_t old_ino; | |
661 | struct inode *inode = dentry->d_inode; | |
662 | struct coda_inode_info *cii = ITOC(inode); | |
663 | ||
664 | lock_kernel(); | |
665 | if ( !cii->c_flags ) | |
666 | goto ok; | |
667 | ||
668 | if (cii->c_flags & (C_VATTR | C_PURGE | C_FLUSH)) { | |
669 | error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr); | |
670 | if ( error ) | |
671 | goto return_bad; | |
672 | ||
673 | /* this inode may be lost if: | |
674 | - it's ino changed | |
675 | - type changes must be permitted for repair and | |
676 | missing mount points. | |
677 | */ | |
678 | old_mode = inode->i_mode; | |
679 | old_ino = inode->i_ino; | |
680 | coda_vattr_to_iattr(inode, &attr); | |
681 | ||
682 | if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) { | |
683 | printk("Coda: inode %ld, fid %s changed type!\n", | |
684 | inode->i_ino, coda_f2s(&(cii->c_fid))); | |
685 | } | |
686 | ||
687 | /* the following can happen when a local fid is replaced | |
688 | with a global one, here we lose and declare the inode bad */ | |
689 | if (inode->i_ino != old_ino) | |
690 | goto return_bad; | |
691 | ||
692 | coda_flag_inode_children(inode, C_FLUSH); | |
693 | cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH); | |
694 | } | |
695 | ||
696 | ok: | |
697 | unlock_kernel(); | |
698 | return 0; | |
699 | ||
700 | return_bad: | |
701 | unlock_kernel(); | |
702 | return -EIO; | |
703 | } |