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