blob: 4e552ba7bd43304121fe36f217c84ebc5f88d2c3 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/file.h>
18#include <linux/stat.h>
19#include <linux/errno.h>
20#include <linux/string.h>
Yoshihisa Abeb5ce1d82010-10-25 02:03:44 -040021#include <linux/spinlock.h>
Nick Piggin34286d62011-01-07 17:49:57 +110022#include <linux/namei.h>
Fabian Frederick834b46c2014-08-08 14:20:33 -070023#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include <linux/coda.h>
David Howells8fc8b9d2019-07-16 16:28:47 -070026#include "coda_psdev.h"
Al Viro31a203d2011-01-12 16:36:09 -050027#include "coda_linux.h"
28#include "coda_cache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Adrian Bunkc98d8cf2006-03-24 03:15:53 -080030#include "coda_int.h"
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032/* same as fs/bad_inode.c */
33static int coda_return_EIO(void)
34{
35 return -EIO;
36}
37#define CODA_EIO_ERROR ((void *) (coda_return_EIO))
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/* inode operations for directories */
40/* access routines: lookup, readlink, permission */
Al Viro00cd8dd2012-06-10 17:13:09 -040041static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
Al Virof4947fb2012-01-10 11:11:49 -050043 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 const char *name = entry->d_name.name;
45 size_t length = entry->d_name.len;
Al Virof4947fb2012-01-10 11:11:49 -050046 struct inode *inode;
47 int type = 0;
Jan Harkesed36f722007-07-19 01:48:49 -070048
49 if (length > CODA_MAXNAMLEN) {
Jan Harkes9a056712019-07-16 16:28:23 -070050 pr_err("name too long: lookup, %s %zu\n",
51 coda_i2s(dir), length);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 return ERR_PTR(-ENAMETOOLONG);
53 }
54
Jan Harkesed36f722007-07-19 01:48:49 -070055 /* control object, create inode on the fly */
Al Viroa7400222014-10-21 15:20:42 -040056 if (is_root_inode(dir) && coda_iscontrol(name, length)) {
Al Virof4947fb2012-01-10 11:11:49 -050057 inode = coda_cnode_makectl(sb);
Jan Harkesed36f722007-07-19 01:48:49 -070058 type = CODA_NOCACHE;
Al Virof4947fb2012-01-10 11:11:49 -050059 } 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 }
65
Al Virof4947fb2012-01-10 11:11:49 -050066 if (!IS_ERR(inode) && (type & CODA_NOCACHE))
Jan Harkesed36f722007-07-19 01:48:49 -070067 coda_flag_inode(inode, C_VATTR | C_PURGE);
68
Al Virof4947fb2012-01-10 11:11:49 -050069 if (inode == ERR_PTR(-ENOENT))
70 inode = NULL;
71
Jan Harkesed36f722007-07-19 01:48:49 -070072 return d_splice_alias(inode, entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
74
75
Christian Brauner4609e1f2023-01-13 12:49:22 +010076int coda_permission(struct mnt_idmap *idmap, struct inode *inode,
Christian Brauner549c7292021-01-21 14:19:43 +010077 int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078{
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -040079 int error;
Al Viroe6305c42008-07-15 21:03:57 -040080
Al Viro10556cb22011-06-20 19:28:19 -040081 if (mask & MAY_NOT_BLOCK)
Nick Pigginb74c79e2011-01-07 17:49:58 +110082 return -ECHILD;
83
Al Viroe6305c42008-07-15 21:03:57 -040084 mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86 if (!mask)
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -040087 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Miklos Szeredif696a362008-07-31 13:41:58 +020089 if ((mask & MAY_EXEC) && !execute_ok(inode))
90 return -EACCES;
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 if (coda_cache_check(inode, mask))
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -040093 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -040095 error = venus_access(inode->i_sb, coda_i2f(inode), mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97 if (!error)
98 coda_cache_enter(inode, mask);
99
Jan Harkesd7289002007-07-19 01:48:43 -0700100 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101}
102
103
Jan Harkesd7289002007-07-19 01:48:43 -0700104static inline void coda_dir_update_mtime(struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
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
Jan Harkesd7289002007-07-19 01:48:43 -0700112 * 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. */
Jeff Layton581a4d02023-10-04 14:52:10 -0400114 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#endif
Jan Harkesd7289002007-07-19 01:48:43 -0700116}
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 */
123static inline void coda_dir_inc_nlink(struct inode *dir)
124{
125 if (dir->i_nlink >= 2)
126 inc_nlink(dir);
127}
128
129static inline void coda_dir_drop_nlink(struct inode *dir)
130{
131 if (dir->i_nlink > 2)
132 drop_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
135/* creation routines: create, mknod, mkdir, link, symlink */
Christian Brauner6c960e62023-01-13 12:49:13 +0100136static int coda_create(struct mnt_idmap *idmap, struct inode *dir,
Christian Brauner549c7292021-01-21 14:19:43 +0100137 struct dentry *de, umode_t mode, bool excl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400139 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 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
Al Viroa7400222014-10-21 15:20:42 -0400146 if (is_root_inode(dir) && coda_iscontrol(name, length))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 error = venus_create(dir->i_sb, coda_i2f(dir), name, length,
150 0, mode, &newfid, &attrs);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400151 if (error)
152 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 inode = coda_iget(dir->i_sb, &newfid, &attrs);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400155 if (IS_ERR(inode)) {
156 error = PTR_ERR(inode);
157 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159
160 /* invalidate the directory cnode's attributes */
Jan Harkesd7289002007-07-19 01:48:43 -0700161 coda_dir_update_mtime(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 d_instantiate(de, inode);
Jan Harkesd7289002007-07-19 01:48:43 -0700163 return 0;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400164err_out:
165 d_drop(de);
166 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Christian Braunerc54bd912023-01-13 12:49:15 +0100169static int coda_mkdir(struct mnt_idmap *idmap, struct inode *dir,
Christian Brauner549c7292021-01-21 14:19:43 +0100170 struct dentry *de, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
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
Al Viroa7400222014-10-21 15:20:42 -0400179 if (is_root_inode(dir) && coda_iscontrol(name, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 attrs.va_mode = mode;
183 error = venus_mkdir(dir->i_sb, coda_i2f(dir),
184 name, len, &newfid, &attrs);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400185 if (error)
186 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 inode = coda_iget(dir->i_sb, &newfid, &attrs);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400189 if (IS_ERR(inode)) {
190 error = PTR_ERR(inode);
191 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 }
Jan Harkesd7289002007-07-19 01:48:43 -0700193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 /* invalidate the directory cnode's attributes */
Jan Harkesd7289002007-07-19 01:48:43 -0700195 coda_dir_inc_nlink(dir);
196 coda_dir_update_mtime(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 d_instantiate(de, inode);
Jan Harkesd7289002007-07-19 01:48:43 -0700198 return 0;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400199err_out:
200 d_drop(de);
201 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204/* try to make de an entry in dir_inodde linked to source_de */
205static int coda_link(struct dentry *source_de, struct inode *dir_inode,
206 struct dentry *de)
207{
David Howells2b0143b2015-03-17 22:25:59 +0000208 struct inode *inode = d_inode(source_de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 const char * name = de->d_name.name;
210 int len = de->d_name.len;
211 int error;
212
Al Viroa7400222014-10-21 15:20:42 -0400213 if (is_root_inode(dir_inode) && coda_iscontrol(name, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 error = venus_link(dir_inode->i_sb, coda_i2f(inode),
217 coda_i2f(dir_inode), (const char *)name, len);
Jan Harkesd7289002007-07-19 01:48:43 -0700218 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 d_drop(de);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400220 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 }
222
Jan Harkesd7289002007-07-19 01:48:43 -0700223 coda_dir_update_mtime(dir_inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -0400224 ihold(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 d_instantiate(de, inode);
Dave Hansend8c76e62006-09-30 23:29:04 -0700226 inc_nlink(inode);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400227 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
229
230
Christian Brauner7a77db92023-01-13 12:49:14 +0100231static int coda_symlink(struct mnt_idmap *idmap,
Christian Brauner549c7292021-01-21 14:19:43 +0100232 struct inode *dir_inode, struct dentry *de,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 const char *symname)
234{
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400235 const char *name = de->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 int len = de->d_name.len;
237 int symlen;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400238 int error;
Jan Harkes3cf01f22007-07-19 01:48:51 -0700239
Al Viroa7400222014-10-21 15:20:42 -0400240 if (is_root_inode(dir_inode) && coda_iscontrol(name, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 symlen = strlen(symname);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400244 if (symlen > CODA_MAXPATHLEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 /*
248 * This entry is now negative. Since we do not create
Jan Harkesd7289002007-07-19 01:48:43 -0700249 * an inode for the entry we have to drop it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 */
251 d_drop(de);
Jan Harkesd7289002007-07-19 01:48:43 -0700252 error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 symname, symlen);
254
255 /* mtime is no good anymore */
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400256 if (!error)
Jan Harkesd7289002007-07-19 01:48:43 -0700257 coda_dir_update_mtime(dir_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Jan Harkesd7289002007-07-19 01:48:43 -0700259 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261
262/* destruction routines: unlink, rmdir */
Harvey Harrison9fe76c72008-04-29 00:58:44 -0700263static int coda_unlink(struct inode *dir, struct dentry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264{
265 int error;
266 const char *name = de->d_name.name;
267 int len = de->d_name.len;
268
Jan Harkesd7289002007-07-19 01:48:43 -0700269 error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400270 if (error)
Jan Harkesd7289002007-07-19 01:48:43 -0700271 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Jan Harkesd7289002007-07-19 01:48:43 -0700273 coda_dir_update_mtime(dir);
David Howells2b0143b2015-03-17 22:25:59 +0000274 drop_nlink(d_inode(de));
Jan Harkesd7289002007-07-19 01:48:43 -0700275 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277
Harvey Harrison9fe76c72008-04-29 00:58:44 -0700278static int coda_rmdir(struct inode *dir, struct dentry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 const char *name = de->d_name.name;
281 int len = de->d_name.len;
Jan Harkes8c6d2152007-07-19 01:48:43 -0700282 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
Jan Harkes8c6d2152007-07-19 01:48:43 -0700285 if (!error) {
286 /* VFS may delete the child */
David Howells2b0143b2015-03-17 22:25:59 +0000287 if (d_really_is_positive(de))
288 clear_nlink(d_inode(de));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Jan Harkes8c6d2152007-07-19 01:48:43 -0700290 /* fix the link count of the parent */
291 coda_dir_drop_nlink(dir);
292 coda_dir_update_mtime(dir);
Jan Harkesd7289002007-07-19 01:48:43 -0700293 }
Jan Harkes8c6d2152007-07-19 01:48:43 -0700294 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
297/* rename */
Christian Braunere18275a2023-01-13 12:49:17 +0100298static int coda_rename(struct mnt_idmap *idmap, struct inode *old_dir,
Christian Brauner549c7292021-01-21 14:19:43 +0100299 struct dentry *old_dentry, struct inode *new_dir,
300 struct dentry *new_dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301{
Jan Harkesd7289002007-07-19 01:48:43 -0700302 const char *old_name = old_dentry->d_name.name;
303 const char *new_name = new_dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 int old_length = old_dentry->d_name.len;
305 int new_length = new_dentry->d_name.len;
Jan Harkesd7289002007-07-19 01:48:43 -0700306 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Miklos Szeredi1cd66c92016-09-27 11:03:58 +0200308 if (flags)
309 return -EINVAL;
310
Jan Harkesd7289002007-07-19 01:48:43 -0700311 error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
312 coda_i2f(new_dir), old_length, new_length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 (const char *) old_name, (const char *)new_name);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400314 if (!error) {
David Howells2b0143b2015-03-17 22:25:59 +0000315 if (d_really_is_positive(new_dentry)) {
David Howellse36cb0b2015-01-29 12:02:35 +0000316 if (d_is_dir(new_dentry)) {
Jan Harkesd7289002007-07-19 01:48:43 -0700317 coda_dir_drop_nlink(old_dir);
318 coda_dir_inc_nlink(new_dir);
319 }
David Howells2b0143b2015-03-17 22:25:59 +0000320 coda_flag_inode(d_inode(new_dentry), C_VATTR);
Jan Harkesd7289002007-07-19 01:48:43 -0700321 }
Jan Harkesb2e36222021-11-08 18:34:42 -0800322 coda_dir_update_mtime(old_dir);
323 coda_dir_update_mtime(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return error;
326}
327
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328static 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 */
Al Viroe924f2512013-05-22 21:15:30 -0400348static int coda_venus_readdir(struct file *coda_file, struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Jan Harkes97875252007-07-19 01:48:47 -0700350 struct coda_file_info *cfi;
351 struct coda_inode_info *cii;
352 struct file *host_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 struct venus_dirent *vdir;
Al Viroee604982011-07-16 17:06:30 -0400354 unsigned long vdir_size = offsetof(struct venus_dirent, d_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 unsigned int type;
356 struct qstr name;
357 ino_t ino;
Jan Harkes97875252007-07-19 01:48:47 -0700358 int ret;
359
Fabian Frederick5bb44812019-07-16 16:29:09 -0700360 cfi = coda_ftoc(coda_file);
Jan Harkes97875252007-07-19 01:48:47 -0700361 host_file = cfi->cfi_container;
362
Al Viro93fe74b2014-12-11 13:19:03 -0500363 cii = ITOC(file_inode(coda_file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Panagiotis Issarisf52720c2006-09-27 01:49:39 -0700365 vdir = kmalloc(sizeof(*vdir), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 if (!vdir) return -ENOMEM;
367
Al Viroe924f2512013-05-22 21:15:30 -0400368 if (!dir_emit_dots(coda_file, ctx))
369 goto out;
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 while (1) {
Christoph Hellwigbdd1d2d2017-09-01 17:39:13 +0200372 loff_t pos = ctx->pos - 2;
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 /* read entries from the directory file */
Christoph Hellwigbdd1d2d2017-09-01 17:39:13 +0200375 ret = kernel_read(host_file, vdir, sizeof(*vdir), &pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 if (ret < 0) {
Fabian Frederick6d6bd942014-06-06 14:36:20 -0700377 pr_err("%s: read dir %s failed %d\n",
378 __func__, coda_f2s(&cii->c_fid), ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 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) {
Fabian Frederick6d6bd942014-06-06 14:36:20 -0700385 pr_err("%s: short read on %s\n",
386 __func__, coda_f2s(&cii->c_fid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 ret = -EBADF;
388 break;
389 }
390 /* validate whether the directory file actually makes sense */
391 if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
Fabian Frederick6d6bd942014-06-06 14:36:20 -0700392 pr_err("%s: invalid dir %s\n",
393 __func__, coda_f2s(&cii->c_fid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 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 ||
Al Viroe924f2512013-05-22 21:15:30 -0400403 (name.name[1] == '.' && name.len == 2)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 vdir->d_fileno = name.len = 0;
405
406 /* skip null entries */
407 if (vdir->d_fileno && name.len) {
Al Viro6b5e1222013-06-19 13:21:03 +0400408 ino = vdir->d_fileno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 type = CDT2DT(vdir->d_type);
Al Viroe924f2512013-05-22 21:15:30 -0400410 if (!dir_emit(ctx, name.name, name.len, ino, type))
411 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413 /* we'll always have progress because d_reclen is unsigned and
414 * we've already established it is non-zero. */
Al Viroe924f2512013-05-22 21:15:30 -0400415 ctx->pos += vdir->d_reclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Al Viro5f47c7e2007-07-20 00:23:31 +0100417out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 kfree(vdir);
Al Viroe924f2512013-05-22 21:15:30 -0400419 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
Fabian Frederickb6250322015-02-17 13:45:25 -0800422/* file operations for directories */
423static 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
Fabian Frederick5bb44812019-07-16 16:29:09 -0700429 cfi = coda_ftoc(coda_file);
Fabian Frederickb6250322015-02-17 13:45:25 -0800430 host_file = cfi->cfi_container;
431
Linus Torvalds3e327152023-08-05 12:25:01 -0700432 if (host_file->f_op->iterate_shared) {
Fabian Frederickb6250322015-02-17 13:45:25 -0800433 struct inode *host_inode = file_inode(host_file);
Fabian Frederickb6250322015-02-17 13:45:25 -0800434 ret = -ENOENT;
435 if (!IS_DEADDIR(host_inode)) {
Linus Torvalds3e327152023-08-05 12:25:01 -0700436 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);
Fabian Frederickb6250322015-02-17 13:45:25 -0800440 }
Fabian Frederickb6250322015-02-17 13:45:25 -0800441 return ret;
442 }
443 /* Venus: we must read Venus dirents from a file */
444 return coda_venus_readdir(coda_file, ctx);
445}
446
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447/* called when a cache lookup succeeds */
Al Viro0b728e12012-06-10 16:03:43 -0400448static int coda_dentry_revalidate(struct dentry *de, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
Nick Piggin34286d62011-01-07 17:49:57 +1100450 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 struct coda_inode_info *cii;
452
Al Viro0b728e12012-06-10 16:03:43 -0400453 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +1100454 return -ECHILD;
455
David Howells2b0143b2015-03-17 22:25:59 +0000456 inode = d_inode(de);
Al Viroa7400222014-10-21 15:20:42 -0400457 if (!inode || is_root_inode(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 goto out;
459 if (is_bad_inode(inode))
460 goto bad;
461
David Howells2b0143b2015-03-17 22:25:59 +0000462 cii = ITOC(d_inode(de));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 if (!(cii->c_flags & (C_PURGE | C_FLUSH)))
464 goto out;
465
466 shrink_dcache_parent(de);
467
468 /* propagate for a flush */
469 if (cii->c_flags & C_FLUSH)
470 coda_flag_inode_children(inode, C_FLUSH);
471
Al Viro84d08fa2013-07-05 18:59:33 +0400472 if (d_count(de) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 /* pretend it's valid, but don't change the flags */
474 goto out;
475
476 /* clear the flags. */
Yoshihisa Abeb5ce1d82010-10-25 02:03:44 -0400477 spin_lock(&cii->c_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
Yoshihisa Abeb5ce1d82010-10-25 02:03:44 -0400479 spin_unlock(&cii->c_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480bad:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return 0;
482out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 return 1;
484}
485
486/*
487 * This is the callback from dput() when d_count is going to 0.
488 * We use this to unhash dentries with bad inodes.
489 */
Nick Pigginfe15ce42011-01-07 17:49:23 +1100490static int coda_dentry_delete(const struct dentry * dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Jan Harkes18319cb2021-11-08 18:34:30 -0800492 struct inode *inode;
493 struct coda_inode_info *cii;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
David Howells2b0143b2015-03-17 22:25:59 +0000495 if (d_really_is_negative(dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return 0;
497
Jan Harkes18319cb2021-11-08 18:34:30 -0800498 inode = d_inode(dentry);
499 if (!inode || is_bad_inode(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 return 1;
Jan Harkes18319cb2021-11-08 18:34:30 -0800501
502 cii = ITOC(inode);
503 if (cii->c_flags & C_PURGE)
504 return 1;
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return 0;
507}
508
509
510
511/*
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
515 * happens
516 */
Al Viro11d100d2013-10-04 18:17:02 -0400517int coda_revalidate_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518{
519 struct coda_vattr attr;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400520 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 int old_mode;
522 ino_t old_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 struct coda_inode_info *cii = ITOC(inode);
524
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400525 if (!cii->c_flags)
526 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 if (cii->c_flags & (C_VATTR | C_PURGE | C_FLUSH)) {
529 error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400530 if (error)
531 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 /* this inode may be lost if:
534 - it's ino changed
535 - type changes must be permitted for repair and
536 missing mount points.
537 */
538 old_mode = inode->i_mode;
539 old_ino = inode->i_ino;
540 coda_vattr_to_iattr(inode, &attr);
541
542 if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
Fabian Frederickf38cfb252014-06-06 14:36:19 -0700543 pr_warn("inode %ld, fid %s changed type!\n",
Fabian Frederickd9b4b312014-06-06 14:36:18 -0700544 inode->i_ino, coda_f2s(&(cii->c_fid)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 }
546
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)
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400550 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 coda_flag_inode_children(inode, C_FLUSH);
Yoshihisa Abeb5ce1d82010-10-25 02:03:44 -0400553
554 spin_lock(&cii->c_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
Yoshihisa Abeb5ce1d82010-10-25 02:03:44 -0400556 spin_unlock(&cii->c_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559}
Fabian Frederickb6250322015-02-17 13:45:25 -0800560
561const struct dentry_operations coda_dentry_operations = {
562 .d_revalidate = coda_dentry_revalidate,
563 .d_delete = coda_dentry_delete,
564};
565
566const struct inode_operations coda_dir_inode_operations = {
567 .create = coda_create,
568 .lookup = coda_lookup,
569 .link = coda_link,
570 .unlink = coda_unlink,
571 .symlink = coda_symlink,
572 .mkdir = coda_mkdir,
573 .rmdir = coda_rmdir,
574 .mknod = CODA_EIO_ERROR,
575 .rename = coda_rename,
576 .permission = coda_permission,
577 .getattr = coda_getattr,
578 .setattr = coda_setattr,
579};
580
Linus Torvalds3e327152023-08-05 12:25:01 -0700581WRAP_DIR_ITER(coda_readdir) // FIXME!
Fabian Frederickb6250322015-02-17 13:45:25 -0800582const struct file_operations coda_dir_operations = {
583 .llseek = generic_file_llseek,
584 .read = generic_read_dir,
Linus Torvalds3e327152023-08-05 12:25:01 -0700585 .iterate_shared = shared_coda_readdir,
Fabian Frederickb6250322015-02-17 13:45:25 -0800586 .open = coda_open,
587 .release = coda_release,
588 .fsync = coda_fsync,
589};