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