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