1 // SPDX-License-Identifier: GPL-2.0
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
8 * Carnegie Mellon encourages users to contribute improvements to
9 * the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/time.h>
16 #include <linux/slab.h>
17 #include <linux/file.h>
18 #include <linux/stat.h>
19 #include <linux/errno.h>
20 #include <linux/string.h>
21 #include <linux/spinlock.h>
22 #include <linux/namei.h>
23 #include <linux/uaccess.h>
25 #include <linux/coda.h>
26 #include "coda_psdev.h"
27 #include "coda_linux.h"
28 #include "coda_cache.h"
32 /* same as fs/bad_inode.c */
33 static int coda_return_EIO(void)
37 #define CODA_EIO_ERROR ((void *) (coda_return_EIO))
39 /* inode operations for directories */
40 /* access routines: lookup, readlink, permission */
41 static struct dentry
*coda_lookup(struct inode
*dir
, struct dentry
*entry
, unsigned int flags
)
43 struct super_block
*sb
= dir
->i_sb
;
44 const char *name
= entry
->d_name
.name
;
45 size_t length
= entry
->d_name
.len
;
49 if (length
> CODA_MAXNAMLEN
) {
50 pr_err("name too long: lookup, %s %zu\n",
51 coda_i2s(dir
), length
);
52 return ERR_PTR(-ENAMETOOLONG
);
55 /* control object, create inode on the fly */
56 if (is_root_inode(dir
) && coda_iscontrol(name
, length
)) {
57 inode
= coda_cnode_makectl(sb
);
60 struct CodaFid fid
= { { 0, } };
61 int error
= venus_lookup(sb
, coda_i2f(dir
), name
, length
,
63 inode
= !error
? coda_cnode_make(&fid
, sb
) : ERR_PTR(error
);
66 if (!IS_ERR(inode
) && (type
& CODA_NOCACHE
))
67 coda_flag_inode(inode
, C_VATTR
| C_PURGE
);
69 if (inode
== ERR_PTR(-ENOENT
))
72 return d_splice_alias(inode
, entry
);
76 int coda_permission(struct mnt_idmap
*idmap
, struct inode
*inode
,
81 if (mask
& MAY_NOT_BLOCK
)
84 mask
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
;
89 if ((mask
& MAY_EXEC
) && !execute_ok(inode
))
92 if (coda_cache_check(inode
, mask
))
95 error
= venus_access(inode
->i_sb
, coda_i2f(inode
), mask
);
98 coda_cache_enter(inode
, mask
);
104 static inline void coda_dir_update_mtime(struct inode
*dir
)
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
);
111 /* optimistically we can also act as if our nose bleeds. The
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. */
114 inode_set_mtime_to_ts(dir
, inode_set_ctime_current(dir
));
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
)
125 if (dir
->i_nlink
>= 2)
129 static inline void coda_dir_drop_nlink(struct inode
*dir
)
131 if (dir
->i_nlink
> 2)
135 /* creation routines: create, mknod, mkdir, link, symlink */
136 static int coda_create(struct mnt_idmap
*idmap
, struct inode
*dir
,
137 struct dentry
*de
, umode_t mode
, bool excl
)
140 const char *name
=de
->d_name
.name
;
141 int length
=de
->d_name
.len
;
143 struct CodaFid newfid
;
144 struct coda_vattr attrs
;
146 if (is_root_inode(dir
) && coda_iscontrol(name
, length
))
149 error
= venus_create(dir
->i_sb
, coda_i2f(dir
), name
, length
,
150 0, mode
, &newfid
, &attrs
);
154 inode
= coda_iget(dir
->i_sb
, &newfid
, &attrs
);
156 error
= PTR_ERR(inode
);
160 /* invalidate the directory cnode's attributes */
161 coda_dir_update_mtime(dir
);
162 d_instantiate(de
, inode
);
169 static int coda_mkdir(struct mnt_idmap
*idmap
, struct inode
*dir
,
170 struct dentry
*de
, umode_t mode
)
173 struct coda_vattr attrs
;
174 const char *name
= de
->d_name
.name
;
175 int len
= de
->d_name
.len
;
177 struct CodaFid newfid
;
179 if (is_root_inode(dir
) && coda_iscontrol(name
, len
))
182 attrs
.va_mode
= mode
;
183 error
= venus_mkdir(dir
->i_sb
, coda_i2f(dir
),
184 name
, len
, &newfid
, &attrs
);
188 inode
= coda_iget(dir
->i_sb
, &newfid
, &attrs
);
190 error
= PTR_ERR(inode
);
194 /* invalidate the directory cnode's attributes */
195 coda_dir_inc_nlink(dir
);
196 coda_dir_update_mtime(dir
);
197 d_instantiate(de
, inode
);
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
,
208 struct inode
*inode
= d_inode(source_de
);
209 const char * name
= de
->d_name
.name
;
210 int len
= de
->d_name
.len
;
213 if (is_root_inode(dir_inode
) && coda_iscontrol(name
, len
))
216 error
= venus_link(dir_inode
->i_sb
, coda_i2f(inode
),
217 coda_i2f(dir_inode
), (const char *)name
, len
);
223 coda_dir_update_mtime(dir_inode
);
225 d_instantiate(de
, inode
);
231 static int coda_symlink(struct mnt_idmap
*idmap
,
232 struct inode
*dir_inode
, struct dentry
*de
,
235 const char *name
= de
->d_name
.name
;
236 int len
= de
->d_name
.len
;
240 if (is_root_inode(dir_inode
) && coda_iscontrol(name
, len
))
243 symlen
= strlen(symname
);
244 if (symlen
> CODA_MAXPATHLEN
)
245 return -ENAMETOOLONG
;
248 * This entry is now negative. Since we do not create
249 * an inode for the entry we have to drop it.
252 error
= venus_symlink(dir_inode
->i_sb
, coda_i2f(dir_inode
), name
, len
,
255 /* mtime is no good anymore */
257 coda_dir_update_mtime(dir_inode
);
262 /* destruction routines: unlink, rmdir */
263 static int coda_unlink(struct inode
*dir
, struct dentry
*de
)
266 const char *name
= de
->d_name
.name
;
267 int len
= de
->d_name
.len
;
269 error
= venus_remove(dir
->i_sb
, coda_i2f(dir
), name
, len
);
273 coda_dir_update_mtime(dir
);
274 drop_nlink(d_inode(de
));
278 static int coda_rmdir(struct inode
*dir
, struct dentry
*de
)
280 const char *name
= de
->d_name
.name
;
281 int len
= de
->d_name
.len
;
284 error
= venus_rmdir(dir
->i_sb
, coda_i2f(dir
), name
, len
);
286 /* VFS may delete the child */
287 if (d_really_is_positive(de
))
288 clear_nlink(d_inode(de
));
290 /* fix the link count of the parent */
291 coda_dir_drop_nlink(dir
);
292 coda_dir_update_mtime(dir
);
298 static int coda_rename(struct mnt_idmap
*idmap
, struct inode
*old_dir
,
299 struct dentry
*old_dentry
, struct inode
*new_dir
,
300 struct dentry
*new_dentry
, unsigned int flags
)
302 const char *old_name
= old_dentry
->d_name
.name
;
303 const char *new_name
= new_dentry
->d_name
.name
;
304 int old_length
= old_dentry
->d_name
.len
;
305 int new_length
= new_dentry
->d_name
.len
;
311 error
= venus_rename(old_dir
->i_sb
, coda_i2f(old_dir
),
312 coda_i2f(new_dir
), old_length
, new_length
,
313 (const char *) old_name
, (const char *)new_name
);
315 if (d_really_is_positive(new_dentry
)) {
316 if (d_is_dir(new_dentry
)) {
317 coda_dir_drop_nlink(old_dir
);
318 coda_dir_inc_nlink(new_dir
);
320 coda_flag_inode(d_inode(new_dentry
), C_VATTR
);
322 coda_dir_update_mtime(old_dir
);
323 coda_dir_update_mtime(new_dir
);
328 static inline unsigned int CDT2DT(unsigned char 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;
347 /* support routines */
348 static int coda_venus_readdir(struct file
*coda_file
, struct dir_context
*ctx
)
350 struct coda_file_info
*cfi
;
351 struct coda_inode_info
*cii
;
352 struct file
*host_file
;
353 struct venus_dirent
*vdir
;
354 unsigned long vdir_size
= offsetof(struct venus_dirent
, d_name
);
360 cfi
= coda_ftoc(coda_file
);
361 host_file
= cfi
->cfi_container
;
363 cii
= ITOC(file_inode(coda_file
));
365 vdir
= kmalloc(sizeof(*vdir
), GFP_KERNEL
);
366 if (!vdir
) return -ENOMEM
;
368 if (!dir_emit_dots(coda_file
, ctx
))
372 loff_t pos
= ctx
->pos
- 2;
374 /* read entries from the directory file */
375 ret
= kernel_read(host_file
, vdir
, sizeof(*vdir
), &pos
);
377 pr_err("%s: read dir %s failed %d\n",
378 __func__
, coda_f2s(&cii
->c_fid
), ret
);
381 if (ret
== 0) break; /* end of directory file reached */
383 /* catch truncated reads */
384 if (ret
< vdir_size
|| ret
< vdir_size
+ vdir
->d_namlen
) {
385 pr_err("%s: short read on %s\n",
386 __func__
, coda_f2s(&cii
->c_fid
));
390 /* validate whether the directory file actually makes sense */
391 if (vdir
->d_reclen
< vdir_size
+ vdir
->d_namlen
) {
392 pr_err("%s: invalid dir %s\n",
393 __func__
, coda_f2s(&cii
->c_fid
));
398 name
.len
= vdir
->d_namlen
;
399 name
.name
= vdir
->d_name
;
401 /* Make sure we skip '.' and '..', we already got those */
402 if (name
.name
[0] == '.' && (name
.len
== 1 ||
403 (name
.name
[1] == '.' && name
.len
== 2)))
404 vdir
->d_fileno
= name
.len
= 0;
406 /* skip null entries */
407 if (vdir
->d_fileno
&& name
.len
) {
408 ino
= vdir
->d_fileno
;
409 type
= CDT2DT(vdir
->d_type
);
410 if (!dir_emit(ctx
, name
.name
, name
.len
, ino
, type
))
413 /* we'll always have progress because d_reclen is unsigned and
414 * we've already established it is non-zero. */
415 ctx
->pos
+= vdir
->d_reclen
;
422 /* file operations for directories */
423 static int coda_readdir(struct file
*coda_file
, struct dir_context
*ctx
)
425 struct coda_file_info
*cfi
;
426 struct file
*host_file
;
429 cfi
= coda_ftoc(coda_file
);
430 host_file
= cfi
->cfi_container
;
432 if (host_file
->f_op
->iterate_shared
) {
433 struct inode
*host_inode
= file_inode(host_file
);
435 if (!IS_DEADDIR(host_inode
)) {
436 inode_lock_shared(host_inode
);
437 ret
= host_file
->f_op
->iterate_shared(host_file
, ctx
);
438 file_accessed(host_file
);
439 inode_unlock_shared(host_inode
);
443 /* Venus: we must read Venus dirents from a file */
444 return coda_venus_readdir(coda_file
, ctx
);
447 /* called when a cache lookup succeeds */
448 static int coda_dentry_revalidate(struct dentry
*de
, unsigned int flags
)
451 struct coda_inode_info
*cii
;
453 if (flags
& LOOKUP_RCU
)
457 if (!inode
|| is_root_inode(inode
))
459 if (is_bad_inode(inode
))
462 cii
= ITOC(d_inode(de
));
463 if (!(cii
->c_flags
& (C_PURGE
| C_FLUSH
)))
466 shrink_dcache_parent(de
);
468 /* propagate for a flush */
469 if (cii
->c_flags
& C_FLUSH
)
470 coda_flag_inode_children(inode
, C_FLUSH
);
473 /* pretend it's valid, but don't change the flags */
476 /* clear the flags. */
477 spin_lock(&cii
->c_lock
);
478 cii
->c_flags
&= ~(C_VATTR
| C_PURGE
| C_FLUSH
);
479 spin_unlock(&cii
->c_lock
);
487 * This is the callback from dput() when d_count is going to 0.
488 * We use this to unhash dentries with bad inodes.
490 static int coda_dentry_delete(const struct dentry
* dentry
)
493 struct coda_inode_info
*cii
;
495 if (d_really_is_negative(dentry
))
498 inode
= d_inode(dentry
);
499 if (!inode
|| is_bad_inode(inode
))
503 if (cii
->c_flags
& C_PURGE
)
512 * This is called when we want to check if the inode has
513 * changed on the server. Coda makes this easy since the
514 * cache manager Venus issues a downcall to the kernel when this
517 int coda_revalidate_inode(struct inode
*inode
)
519 struct coda_vattr attr
;
523 struct coda_inode_info
*cii
= ITOC(inode
);
528 if (cii
->c_flags
& (C_VATTR
| C_PURGE
| C_FLUSH
)) {
529 error
= venus_getattr(inode
->i_sb
, &(cii
->c_fid
), &attr
);
533 /* this inode may be lost if:
535 - type changes must be permitted for repair and
536 missing mount points.
538 old_mode
= inode
->i_mode
;
539 old_ino
= inode
->i_ino
;
540 coda_vattr_to_iattr(inode
, &attr
);
542 if ((old_mode
& S_IFMT
) != (inode
->i_mode
& S_IFMT
)) {
543 pr_warn("inode %ld, fid %s changed type!\n",
544 inode
->i_ino
, coda_f2s(&(cii
->c_fid
)));
547 /* the following can happen when a local fid is replaced
548 with a global one, here we lose and declare the inode bad */
549 if (inode
->i_ino
!= old_ino
)
552 coda_flag_inode_children(inode
, C_FLUSH
);
554 spin_lock(&cii
->c_lock
);
555 cii
->c_flags
&= ~(C_VATTR
| C_PURGE
| C_FLUSH
);
556 spin_unlock(&cii
->c_lock
);
561 const struct dentry_operations coda_dentry_operations
= {
562 .d_revalidate
= coda_dentry_revalidate
,
563 .d_delete
= coda_dentry_delete
,
566 const struct inode_operations coda_dir_inode_operations
= {
567 .create
= coda_create
,
568 .lookup
= coda_lookup
,
570 .unlink
= coda_unlink
,
571 .symlink
= coda_symlink
,
574 .mknod
= CODA_EIO_ERROR
,
575 .rename
= coda_rename
,
576 .permission
= coda_permission
,
577 .getattr
= coda_getattr
,
578 .setattr
= coda_setattr
,
581 WRAP_DIR_ITER(coda_readdir
) // FIXME!
582 const struct file_operations coda_dir_operations
= {
583 .llseek
= generic_file_llseek
,
584 .read
= generic_read_dir
,
585 .iterate_shared
= shared_coda_readdir
,
587 .release
= coda_release
,