Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 93420b40bb19433c3bc01c37c6c908ae7ce13228

Authored by Al Viro
1 parent 02e5180d99
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

switch nfs_lookup_check_intent() away from nameidata 

just pass the flags

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 1 changed file with 5 additions and 5 deletions Inline Diff

1 /* 1 /*
2 * linux/fs/nfs/dir.c 2 * linux/fs/nfs/dir.c
3 * 3 *
4 * Copyright (C) 1992 Rick Sladkey 4 * Copyright (C) 1992 Rick Sladkey
5 * 5 *
6 * nfs directory handling functions 6 * nfs directory handling functions
7 * 7 *
8 * 10 Apr 1996 Added silly rename for unlink --okir 8 * 10 Apr 1996 Added silly rename for unlink --okir
9 * 28 Sep 1996 Improved directory cache --okir 9 * 28 Sep 1996 Improved directory cache --okir
10 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de 10 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de
11 * Re-implemented silly rename for unlink, newly implemented 11 * Re-implemented silly rename for unlink, newly implemented
12 * silly rename for nfs_rename() following the suggestions 12 * silly rename for nfs_rename() following the suggestions
13 * of Olaf Kirch (okir) found in this file. 13 * of Olaf Kirch (okir) found in this file.
14 * Following Linus comments on my original hack, this version 14 * Following Linus comments on my original hack, this version
15 * depends only on the dcache stuff and doesn't touch the inode 15 * depends only on the dcache stuff and doesn't touch the inode
16 * layer (iput() and friends). 16 * layer (iput() and friends).
17 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM 17 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM
18 */ 18 */
19 19
20 #include <linux/time.h> 20 #include <linux/time.h>
21 #include <linux/errno.h> 21 #include <linux/errno.h>
22 #include <linux/stat.h> 22 #include <linux/stat.h>
23 #include <linux/fcntl.h> 23 #include <linux/fcntl.h>
24 #include <linux/string.h> 24 #include <linux/string.h>
25 #include <linux/kernel.h> 25 #include <linux/kernel.h>
26 #include <linux/slab.h> 26 #include <linux/slab.h>
27 #include <linux/mm.h> 27 #include <linux/mm.h>
28 #include <linux/sunrpc/clnt.h> 28 #include <linux/sunrpc/clnt.h>
29 #include <linux/nfs_fs.h> 29 #include <linux/nfs_fs.h>
30 #include <linux/nfs_mount.h> 30 #include <linux/nfs_mount.h>
31 #include <linux/pagemap.h> 31 #include <linux/pagemap.h>
32 #include <linux/pagevec.h> 32 #include <linux/pagevec.h>
33 #include <linux/namei.h> 33 #include <linux/namei.h>
34 #include <linux/mount.h> 34 #include <linux/mount.h>
35 #include <linux/sched.h> 35 #include <linux/sched.h>
36 #include <linux/kmemleak.h> 36 #include <linux/kmemleak.h>
37 #include <linux/xattr.h> 37 #include <linux/xattr.h>
38 38
39 #include "delegation.h" 39 #include "delegation.h"
40 #include "iostat.h" 40 #include "iostat.h"
41 #include "internal.h" 41 #include "internal.h"
42 #include "fscache.h" 42 #include "fscache.h"
43 43
44 /* #define NFS_DEBUG_VERBOSE 1 */ 44 /* #define NFS_DEBUG_VERBOSE 1 */
45 45
46 static int nfs_opendir(struct inode *, struct file *); 46 static int nfs_opendir(struct inode *, struct file *);
47 static int nfs_closedir(struct inode *, struct file *); 47 static int nfs_closedir(struct inode *, struct file *);
48 static int nfs_readdir(struct file *, void *, filldir_t); 48 static int nfs_readdir(struct file *, void *, filldir_t);
49 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 49 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
50 static int nfs_create(struct inode *, struct dentry *, umode_t, struct nameidata *); 50 static int nfs_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
51 static int nfs_mkdir(struct inode *, struct dentry *, umode_t); 51 static int nfs_mkdir(struct inode *, struct dentry *, umode_t);
52 static int nfs_rmdir(struct inode *, struct dentry *); 52 static int nfs_rmdir(struct inode *, struct dentry *);
53 static int nfs_unlink(struct inode *, struct dentry *); 53 static int nfs_unlink(struct inode *, struct dentry *);
54 static int nfs_symlink(struct inode *, struct dentry *, const char *); 54 static int nfs_symlink(struct inode *, struct dentry *, const char *);
55 static int nfs_link(struct dentry *, struct inode *, struct dentry *); 55 static int nfs_link(struct dentry *, struct inode *, struct dentry *);
56 static int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t); 56 static int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
57 static int nfs_rename(struct inode *, struct dentry *, 57 static int nfs_rename(struct inode *, struct dentry *,
58 struct inode *, struct dentry *); 58 struct inode *, struct dentry *);
59 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int); 59 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
60 static loff_t nfs_llseek_dir(struct file *, loff_t, int); 60 static loff_t nfs_llseek_dir(struct file *, loff_t, int);
61 static void nfs_readdir_clear_array(struct page*); 61 static void nfs_readdir_clear_array(struct page*);
62 62
63 const struct file_operations nfs_dir_operations = { 63 const struct file_operations nfs_dir_operations = {
64 .llseek = nfs_llseek_dir, 64 .llseek = nfs_llseek_dir,
65 .read = generic_read_dir, 65 .read = generic_read_dir,
66 .readdir = nfs_readdir, 66 .readdir = nfs_readdir,
67 .open = nfs_opendir, 67 .open = nfs_opendir,
68 .release = nfs_closedir, 68 .release = nfs_closedir,
69 .fsync = nfs_fsync_dir, 69 .fsync = nfs_fsync_dir,
70 }; 70 };
71 71
72 const struct inode_operations nfs_dir_inode_operations = { 72 const struct inode_operations nfs_dir_inode_operations = {
73 .create = nfs_create, 73 .create = nfs_create,
74 .lookup = nfs_lookup, 74 .lookup = nfs_lookup,
75 .link = nfs_link, 75 .link = nfs_link,
76 .unlink = nfs_unlink, 76 .unlink = nfs_unlink,
77 .symlink = nfs_symlink, 77 .symlink = nfs_symlink,
78 .mkdir = nfs_mkdir, 78 .mkdir = nfs_mkdir,
79 .rmdir = nfs_rmdir, 79 .rmdir = nfs_rmdir,
80 .mknod = nfs_mknod, 80 .mknod = nfs_mknod,
81 .rename = nfs_rename, 81 .rename = nfs_rename,
82 .permission = nfs_permission, 82 .permission = nfs_permission,
83 .getattr = nfs_getattr, 83 .getattr = nfs_getattr,
84 .setattr = nfs_setattr, 84 .setattr = nfs_setattr,
85 }; 85 };
86 86
87 const struct address_space_operations nfs_dir_aops = { 87 const struct address_space_operations nfs_dir_aops = {
88 .freepage = nfs_readdir_clear_array, 88 .freepage = nfs_readdir_clear_array,
89 }; 89 };
90 90
91 #ifdef CONFIG_NFS_V3 91 #ifdef CONFIG_NFS_V3
92 const struct inode_operations nfs3_dir_inode_operations = { 92 const struct inode_operations nfs3_dir_inode_operations = {
93 .create = nfs_create, 93 .create = nfs_create,
94 .lookup = nfs_lookup, 94 .lookup = nfs_lookup,
95 .link = nfs_link, 95 .link = nfs_link,
96 .unlink = nfs_unlink, 96 .unlink = nfs_unlink,
97 .symlink = nfs_symlink, 97 .symlink = nfs_symlink,
98 .mkdir = nfs_mkdir, 98 .mkdir = nfs_mkdir,
99 .rmdir = nfs_rmdir, 99 .rmdir = nfs_rmdir,
100 .mknod = nfs_mknod, 100 .mknod = nfs_mknod,
101 .rename = nfs_rename, 101 .rename = nfs_rename,
102 .permission = nfs_permission, 102 .permission = nfs_permission,
103 .getattr = nfs_getattr, 103 .getattr = nfs_getattr,
104 .setattr = nfs_setattr, 104 .setattr = nfs_setattr,
105 .listxattr = nfs3_listxattr, 105 .listxattr = nfs3_listxattr,
106 .getxattr = nfs3_getxattr, 106 .getxattr = nfs3_getxattr,
107 .setxattr = nfs3_setxattr, 107 .setxattr = nfs3_setxattr,
108 .removexattr = nfs3_removexattr, 108 .removexattr = nfs3_removexattr,
109 }; 109 };
110 #endif /* CONFIG_NFS_V3 */ 110 #endif /* CONFIG_NFS_V3 */
111 111
112 #ifdef CONFIG_NFS_V4 112 #ifdef CONFIG_NFS_V4
113 113
114 static int nfs_atomic_open(struct inode *, struct dentry *, 114 static int nfs_atomic_open(struct inode *, struct dentry *,
115 struct file *, unsigned, umode_t, 115 struct file *, unsigned, umode_t,
116 int *); 116 int *);
117 const struct inode_operations nfs4_dir_inode_operations = { 117 const struct inode_operations nfs4_dir_inode_operations = {
118 .create = nfs_create, 118 .create = nfs_create,
119 .lookup = nfs_lookup, 119 .lookup = nfs_lookup,
120 .atomic_open = nfs_atomic_open, 120 .atomic_open = nfs_atomic_open,
121 .link = nfs_link, 121 .link = nfs_link,
122 .unlink = nfs_unlink, 122 .unlink = nfs_unlink,
123 .symlink = nfs_symlink, 123 .symlink = nfs_symlink,
124 .mkdir = nfs_mkdir, 124 .mkdir = nfs_mkdir,
125 .rmdir = nfs_rmdir, 125 .rmdir = nfs_rmdir,
126 .mknod = nfs_mknod, 126 .mknod = nfs_mknod,
127 .rename = nfs_rename, 127 .rename = nfs_rename,
128 .permission = nfs_permission, 128 .permission = nfs_permission,
129 .getattr = nfs_getattr, 129 .getattr = nfs_getattr,
130 .setattr = nfs_setattr, 130 .setattr = nfs_setattr,
131 .getxattr = generic_getxattr, 131 .getxattr = generic_getxattr,
132 .setxattr = generic_setxattr, 132 .setxattr = generic_setxattr,
133 .listxattr = generic_listxattr, 133 .listxattr = generic_listxattr,
134 .removexattr = generic_removexattr, 134 .removexattr = generic_removexattr,
135 }; 135 };
136 136
137 #endif /* CONFIG_NFS_V4 */ 137 #endif /* CONFIG_NFS_V4 */
138 138
139 static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred) 139 static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
140 { 140 {
141 struct nfs_open_dir_context *ctx; 141 struct nfs_open_dir_context *ctx;
142 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 142 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
143 if (ctx != NULL) { 143 if (ctx != NULL) {
144 ctx->duped = 0; 144 ctx->duped = 0;
145 ctx->attr_gencount = NFS_I(dir)->attr_gencount; 145 ctx->attr_gencount = NFS_I(dir)->attr_gencount;
146 ctx->dir_cookie = 0; 146 ctx->dir_cookie = 0;
147 ctx->dup_cookie = 0; 147 ctx->dup_cookie = 0;
148 ctx->cred = get_rpccred(cred); 148 ctx->cred = get_rpccred(cred);
149 return ctx; 149 return ctx;
150 } 150 }
151 return ERR_PTR(-ENOMEM); 151 return ERR_PTR(-ENOMEM);
152 } 152 }
153 153
154 static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx) 154 static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)
155 { 155 {
156 put_rpccred(ctx->cred); 156 put_rpccred(ctx->cred);
157 kfree(ctx); 157 kfree(ctx);
158 } 158 }
159 159
160 /* 160 /*
161 * Open file 161 * Open file
162 */ 162 */
163 static int 163 static int
164 nfs_opendir(struct inode *inode, struct file *filp) 164 nfs_opendir(struct inode *inode, struct file *filp)
165 { 165 {
166 int res = 0; 166 int res = 0;
167 struct nfs_open_dir_context *ctx; 167 struct nfs_open_dir_context *ctx;
168 struct rpc_cred *cred; 168 struct rpc_cred *cred;
169 169
170 dfprintk(FILE, "NFS: open dir(%s/%s)\n", 170 dfprintk(FILE, "NFS: open dir(%s/%s)\n",
171 filp->f_path.dentry->d_parent->d_name.name, 171 filp->f_path.dentry->d_parent->d_name.name,
172 filp->f_path.dentry->d_name.name); 172 filp->f_path.dentry->d_name.name);
173 173
174 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 174 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
175 175
176 cred = rpc_lookup_cred(); 176 cred = rpc_lookup_cred();
177 if (IS_ERR(cred)) 177 if (IS_ERR(cred))
178 return PTR_ERR(cred); 178 return PTR_ERR(cred);
179 ctx = alloc_nfs_open_dir_context(inode, cred); 179 ctx = alloc_nfs_open_dir_context(inode, cred);
180 if (IS_ERR(ctx)) { 180 if (IS_ERR(ctx)) {
181 res = PTR_ERR(ctx); 181 res = PTR_ERR(ctx);
182 goto out; 182 goto out;
183 } 183 }
184 filp->private_data = ctx; 184 filp->private_data = ctx;
185 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 185 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
186 /* This is a mountpoint, so d_revalidate will never 186 /* This is a mountpoint, so d_revalidate will never
187 * have been called, so we need to refresh the 187 * have been called, so we need to refresh the
188 * inode (for close-open consistency) ourselves. 188 * inode (for close-open consistency) ourselves.
189 */ 189 */
190 __nfs_revalidate_inode(NFS_SERVER(inode), inode); 190 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
191 } 191 }
192 out: 192 out:
193 put_rpccred(cred); 193 put_rpccred(cred);
194 return res; 194 return res;
195 } 195 }
196 196
197 static int 197 static int
198 nfs_closedir(struct inode *inode, struct file *filp) 198 nfs_closedir(struct inode *inode, struct file *filp)
199 { 199 {
200 put_nfs_open_dir_context(filp->private_data); 200 put_nfs_open_dir_context(filp->private_data);
201 return 0; 201 return 0;
202 } 202 }
203 203
204 struct nfs_cache_array_entry { 204 struct nfs_cache_array_entry {
205 u64 cookie; 205 u64 cookie;
206 u64 ino; 206 u64 ino;
207 struct qstr string; 207 struct qstr string;
208 unsigned char d_type; 208 unsigned char d_type;
209 }; 209 };
210 210
211 struct nfs_cache_array { 211 struct nfs_cache_array {
212 int size; 212 int size;
213 int eof_index; 213 int eof_index;
214 u64 last_cookie; 214 u64 last_cookie;
215 struct nfs_cache_array_entry array[0]; 215 struct nfs_cache_array_entry array[0];
216 }; 216 };
217 217
218 typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int); 218 typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
219 typedef struct { 219 typedef struct {
220 struct file *file; 220 struct file *file;
221 struct page *page; 221 struct page *page;
222 unsigned long page_index; 222 unsigned long page_index;
223 u64 *dir_cookie; 223 u64 *dir_cookie;
224 u64 last_cookie; 224 u64 last_cookie;
225 loff_t current_index; 225 loff_t current_index;
226 decode_dirent_t decode; 226 decode_dirent_t decode;
227 227
228 unsigned long timestamp; 228 unsigned long timestamp;
229 unsigned long gencount; 229 unsigned long gencount;
230 unsigned int cache_entry_index; 230 unsigned int cache_entry_index;
231 unsigned int plus:1; 231 unsigned int plus:1;
232 unsigned int eof:1; 232 unsigned int eof:1;
233 } nfs_readdir_descriptor_t; 233 } nfs_readdir_descriptor_t;
234 234
235 /* 235 /*
236 * The caller is responsible for calling nfs_readdir_release_array(page) 236 * The caller is responsible for calling nfs_readdir_release_array(page)
237 */ 237 */
238 static 238 static
239 struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 239 struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
240 { 240 {
241 void *ptr; 241 void *ptr;
242 if (page == NULL) 242 if (page == NULL)
243 return ERR_PTR(-EIO); 243 return ERR_PTR(-EIO);
244 ptr = kmap(page); 244 ptr = kmap(page);
245 if (ptr == NULL) 245 if (ptr == NULL)
246 return ERR_PTR(-ENOMEM); 246 return ERR_PTR(-ENOMEM);
247 return ptr; 247 return ptr;
248 } 248 }
249 249
250 static 250 static
251 void nfs_readdir_release_array(struct page *page) 251 void nfs_readdir_release_array(struct page *page)
252 { 252 {
253 kunmap(page); 253 kunmap(page);
254 } 254 }
255 255
256 /* 256 /*
257 * we are freeing strings created by nfs_add_to_readdir_array() 257 * we are freeing strings created by nfs_add_to_readdir_array()
258 */ 258 */
259 static 259 static
260 void nfs_readdir_clear_array(struct page *page) 260 void nfs_readdir_clear_array(struct page *page)
261 { 261 {
262 struct nfs_cache_array *array; 262 struct nfs_cache_array *array;
263 int i; 263 int i;
264 264
265 array = kmap_atomic(page); 265 array = kmap_atomic(page);
266 for (i = 0; i < array->size; i++) 266 for (i = 0; i < array->size; i++)
267 kfree(array->array[i].string.name); 267 kfree(array->array[i].string.name);
268 kunmap_atomic(array); 268 kunmap_atomic(array);
269 } 269 }
270 270
271 /* 271 /*
272 * the caller is responsible for freeing qstr.name 272 * the caller is responsible for freeing qstr.name
273 * when called by nfs_readdir_add_to_array, the strings will be freed in 273 * when called by nfs_readdir_add_to_array, the strings will be freed in
274 * nfs_clear_readdir_array() 274 * nfs_clear_readdir_array()
275 */ 275 */
276 static 276 static
277 int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 277 int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
278 { 278 {
279 string->len = len; 279 string->len = len;
280 string->name = kmemdup(name, len, GFP_KERNEL); 280 string->name = kmemdup(name, len, GFP_KERNEL);
281 if (string->name == NULL) 281 if (string->name == NULL)
282 return -ENOMEM; 282 return -ENOMEM;
283 /* 283 /*
284 * Avoid a kmemleak false positive. The pointer to the name is stored 284 * Avoid a kmemleak false positive. The pointer to the name is stored
285 * in a page cache page which kmemleak does not scan. 285 * in a page cache page which kmemleak does not scan.
286 */ 286 */
287 kmemleak_not_leak(string->name); 287 kmemleak_not_leak(string->name);
288 string->hash = full_name_hash(name, len); 288 string->hash = full_name_hash(name, len);
289 return 0; 289 return 0;
290 } 290 }
291 291
292 static 292 static
293 int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 293 int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
294 { 294 {
295 struct nfs_cache_array *array = nfs_readdir_get_array(page); 295 struct nfs_cache_array *array = nfs_readdir_get_array(page);
296 struct nfs_cache_array_entry *cache_entry; 296 struct nfs_cache_array_entry *cache_entry;
297 int ret; 297 int ret;
298 298
299 if (IS_ERR(array)) 299 if (IS_ERR(array))
300 return PTR_ERR(array); 300 return PTR_ERR(array);
301 301
302 cache_entry = &array->array[array->size]; 302 cache_entry = &array->array[array->size];
303 303
304 /* Check that this entry lies within the page bounds */ 304 /* Check that this entry lies within the page bounds */
305 ret = -ENOSPC; 305 ret = -ENOSPC;
306 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE) 306 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
307 goto out; 307 goto out;
308 308
309 cache_entry->cookie = entry->prev_cookie; 309 cache_entry->cookie = entry->prev_cookie;
310 cache_entry->ino = entry->ino; 310 cache_entry->ino = entry->ino;
311 cache_entry->d_type = entry->d_type; 311 cache_entry->d_type = entry->d_type;
312 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 312 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
313 if (ret) 313 if (ret)
314 goto out; 314 goto out;
315 array->last_cookie = entry->cookie; 315 array->last_cookie = entry->cookie;
316 array->size++; 316 array->size++;
317 if (entry->eof != 0) 317 if (entry->eof != 0)
318 array->eof_index = array->size; 318 array->eof_index = array->size;
319 out: 319 out:
320 nfs_readdir_release_array(page); 320 nfs_readdir_release_array(page);
321 return ret; 321 return ret;
322 } 322 }
323 323
324 static 324 static
325 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 325 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
326 { 326 {
327 loff_t diff = desc->file->f_pos - desc->current_index; 327 loff_t diff = desc->file->f_pos - desc->current_index;
328 unsigned int index; 328 unsigned int index;
329 329
330 if (diff < 0) 330 if (diff < 0)
331 goto out_eof; 331 goto out_eof;
332 if (diff >= array->size) { 332 if (diff >= array->size) {
333 if (array->eof_index >= 0) 333 if (array->eof_index >= 0)
334 goto out_eof; 334 goto out_eof;
335 return -EAGAIN; 335 return -EAGAIN;
336 } 336 }
337 337
338 index = (unsigned int)diff; 338 index = (unsigned int)diff;
339 *desc->dir_cookie = array->array[index].cookie; 339 *desc->dir_cookie = array->array[index].cookie;
340 desc->cache_entry_index = index; 340 desc->cache_entry_index = index;
341 return 0; 341 return 0;
342 out_eof: 342 out_eof:
343 desc->eof = 1; 343 desc->eof = 1;
344 return -EBADCOOKIE; 344 return -EBADCOOKIE;
345 } 345 }
346 346
347 static 347 static
348 int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 348 int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
349 { 349 {
350 int i; 350 int i;
351 loff_t new_pos; 351 loff_t new_pos;
352 int status = -EAGAIN; 352 int status = -EAGAIN;
353 353
354 for (i = 0; i < array->size; i++) { 354 for (i = 0; i < array->size; i++) {
355 if (array->array[i].cookie == *desc->dir_cookie) { 355 if (array->array[i].cookie == *desc->dir_cookie) {
356 struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode); 356 struct nfs_inode *nfsi = NFS_I(desc->file->f_path.dentry->d_inode);
357 struct nfs_open_dir_context *ctx = desc->file->private_data; 357 struct nfs_open_dir_context *ctx = desc->file->private_data;
358 358
359 new_pos = desc->current_index + i; 359 new_pos = desc->current_index + i;
360 if (ctx->attr_gencount != nfsi->attr_gencount 360 if (ctx->attr_gencount != nfsi->attr_gencount
361 || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) { 361 || (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))) {
362 ctx->duped = 0; 362 ctx->duped = 0;
363 ctx->attr_gencount = nfsi->attr_gencount; 363 ctx->attr_gencount = nfsi->attr_gencount;
364 } else if (new_pos < desc->file->f_pos) { 364 } else if (new_pos < desc->file->f_pos) {
365 if (ctx->duped > 0 365 if (ctx->duped > 0
366 && ctx->dup_cookie == *desc->dir_cookie) { 366 && ctx->dup_cookie == *desc->dir_cookie) {
367 if (printk_ratelimit()) { 367 if (printk_ratelimit()) {
368 pr_notice("NFS: directory %s/%s contains a readdir loop." 368 pr_notice("NFS: directory %s/%s contains a readdir loop."
369 "Please contact your server vendor. " 369 "Please contact your server vendor. "
370 "The file: %s has duplicate cookie %llu\n", 370 "The file: %s has duplicate cookie %llu\n",
371 desc->file->f_dentry->d_parent->d_name.name, 371 desc->file->f_dentry->d_parent->d_name.name,
372 desc->file->f_dentry->d_name.name, 372 desc->file->f_dentry->d_name.name,
373 array->array[i].string.name, 373 array->array[i].string.name,
374 *desc->dir_cookie); 374 *desc->dir_cookie);
375 } 375 }
376 status = -ELOOP; 376 status = -ELOOP;
377 goto out; 377 goto out;
378 } 378 }
379 ctx->dup_cookie = *desc->dir_cookie; 379 ctx->dup_cookie = *desc->dir_cookie;
380 ctx->duped = -1; 380 ctx->duped = -1;
381 } 381 }
382 desc->file->f_pos = new_pos; 382 desc->file->f_pos = new_pos;
383 desc->cache_entry_index = i; 383 desc->cache_entry_index = i;
384 return 0; 384 return 0;
385 } 385 }
386 } 386 }
387 if (array->eof_index >= 0) { 387 if (array->eof_index >= 0) {
388 status = -EBADCOOKIE; 388 status = -EBADCOOKIE;
389 if (*desc->dir_cookie == array->last_cookie) 389 if (*desc->dir_cookie == array->last_cookie)
390 desc->eof = 1; 390 desc->eof = 1;
391 } 391 }
392 out: 392 out:
393 return status; 393 return status;
394 } 394 }
395 395
396 static 396 static
397 int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 397 int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
398 { 398 {
399 struct nfs_cache_array *array; 399 struct nfs_cache_array *array;
400 int status; 400 int status;
401 401
402 array = nfs_readdir_get_array(desc->page); 402 array = nfs_readdir_get_array(desc->page);
403 if (IS_ERR(array)) { 403 if (IS_ERR(array)) {
404 status = PTR_ERR(array); 404 status = PTR_ERR(array);
405 goto out; 405 goto out;
406 } 406 }
407 407
408 if (*desc->dir_cookie == 0) 408 if (*desc->dir_cookie == 0)
409 status = nfs_readdir_search_for_pos(array, desc); 409 status = nfs_readdir_search_for_pos(array, desc);
410 else 410 else
411 status = nfs_readdir_search_for_cookie(array, desc); 411 status = nfs_readdir_search_for_cookie(array, desc);
412 412
413 if (status == -EAGAIN) { 413 if (status == -EAGAIN) {
414 desc->last_cookie = array->last_cookie; 414 desc->last_cookie = array->last_cookie;
415 desc->current_index += array->size; 415 desc->current_index += array->size;
416 desc->page_index++; 416 desc->page_index++;
417 } 417 }
418 nfs_readdir_release_array(desc->page); 418 nfs_readdir_release_array(desc->page);
419 out: 419 out:
420 return status; 420 return status;
421 } 421 }
422 422
423 /* Fill a page with xdr information before transferring to the cache page */ 423 /* Fill a page with xdr information before transferring to the cache page */
424 static 424 static
425 int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 425 int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
426 struct nfs_entry *entry, struct file *file, struct inode *inode) 426 struct nfs_entry *entry, struct file *file, struct inode *inode)
427 { 427 {
428 struct nfs_open_dir_context *ctx = file->private_data; 428 struct nfs_open_dir_context *ctx = file->private_data;
429 struct rpc_cred *cred = ctx->cred; 429 struct rpc_cred *cred = ctx->cred;
430 unsigned long timestamp, gencount; 430 unsigned long timestamp, gencount;
431 int error; 431 int error;
432 432
433 again: 433 again:
434 timestamp = jiffies; 434 timestamp = jiffies;
435 gencount = nfs_inc_attr_generation_counter(); 435 gencount = nfs_inc_attr_generation_counter();
436 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages, 436 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
437 NFS_SERVER(inode)->dtsize, desc->plus); 437 NFS_SERVER(inode)->dtsize, desc->plus);
438 if (error < 0) { 438 if (error < 0) {
439 /* We requested READDIRPLUS, but the server doesn't grok it */ 439 /* We requested READDIRPLUS, but the server doesn't grok it */
440 if (error == -ENOTSUPP && desc->plus) { 440 if (error == -ENOTSUPP && desc->plus) {
441 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 441 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
442 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 442 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
443 desc->plus = 0; 443 desc->plus = 0;
444 goto again; 444 goto again;
445 } 445 }
446 goto error; 446 goto error;
447 } 447 }
448 desc->timestamp = timestamp; 448 desc->timestamp = timestamp;
449 desc->gencount = gencount; 449 desc->gencount = gencount;
450 error: 450 error:
451 return error; 451 return error;
452 } 452 }
453 453
454 static int xdr_decode(nfs_readdir_descriptor_t *desc, 454 static int xdr_decode(nfs_readdir_descriptor_t *desc,
455 struct nfs_entry *entry, struct xdr_stream *xdr) 455 struct nfs_entry *entry, struct xdr_stream *xdr)
456 { 456 {
457 int error; 457 int error;
458 458
459 error = desc->decode(xdr, entry, desc->plus); 459 error = desc->decode(xdr, entry, desc->plus);
460 if (error) 460 if (error)
461 return error; 461 return error;
462 entry->fattr->time_start = desc->timestamp; 462 entry->fattr->time_start = desc->timestamp;
463 entry->fattr->gencount = desc->gencount; 463 entry->fattr->gencount = desc->gencount;
464 return 0; 464 return 0;
465 } 465 }
466 466
467 static 467 static
468 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 468 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
469 { 469 {
470 if (dentry->d_inode == NULL) 470 if (dentry->d_inode == NULL)
471 goto different; 471 goto different;
472 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0) 472 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
473 goto different; 473 goto different;
474 return 1; 474 return 1;
475 different: 475 different:
476 return 0; 476 return 0;
477 } 477 }
478 478
479 static 479 static
480 bool nfs_use_readdirplus(struct inode *dir, struct file *filp) 480 bool nfs_use_readdirplus(struct inode *dir, struct file *filp)
481 { 481 {
482 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS)) 482 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
483 return false; 483 return false;
484 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags)) 484 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
485 return true; 485 return true;
486 if (filp->f_pos == 0) 486 if (filp->f_pos == 0)
487 return true; 487 return true;
488 return false; 488 return false;
489 } 489 }
490 490
491 /* 491 /*
492 * This function is called by the lookup code to request the use of 492 * This function is called by the lookup code to request the use of
493 * readdirplus to accelerate any future lookups in the same 493 * readdirplus to accelerate any future lookups in the same
494 * directory. 494 * directory.
495 */ 495 */
496 static 496 static
497 void nfs_advise_use_readdirplus(struct inode *dir) 497 void nfs_advise_use_readdirplus(struct inode *dir)
498 { 498 {
499 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags); 499 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);
500 } 500 }
501 501
502 static 502 static
503 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry) 503 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
504 { 504 {
505 struct qstr filename = QSTR_INIT(entry->name, entry->len); 505 struct qstr filename = QSTR_INIT(entry->name, entry->len);
506 struct dentry *dentry; 506 struct dentry *dentry;
507 struct dentry *alias; 507 struct dentry *alias;
508 struct inode *dir = parent->d_inode; 508 struct inode *dir = parent->d_inode;
509 struct inode *inode; 509 struct inode *inode;
510 510
511 if (filename.name[0] == '.') { 511 if (filename.name[0] == '.') {
512 if (filename.len == 1) 512 if (filename.len == 1)
513 return; 513 return;
514 if (filename.len == 2 && filename.name[1] == '.') 514 if (filename.len == 2 && filename.name[1] == '.')
515 return; 515 return;
516 } 516 }
517 filename.hash = full_name_hash(filename.name, filename.len); 517 filename.hash = full_name_hash(filename.name, filename.len);
518 518
519 dentry = d_lookup(parent, &filename); 519 dentry = d_lookup(parent, &filename);
520 if (dentry != NULL) { 520 if (dentry != NULL) {
521 if (nfs_same_file(dentry, entry)) { 521 if (nfs_same_file(dentry, entry)) {
522 nfs_refresh_inode(dentry->d_inode, entry->fattr); 522 nfs_refresh_inode(dentry->d_inode, entry->fattr);
523 goto out; 523 goto out;
524 } else { 524 } else {
525 d_drop(dentry); 525 d_drop(dentry);
526 dput(dentry); 526 dput(dentry);
527 } 527 }
528 } 528 }
529 529
530 dentry = d_alloc(parent, &filename); 530 dentry = d_alloc(parent, &filename);
531 if (dentry == NULL) 531 if (dentry == NULL)
532 return; 532 return;
533 533
534 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 534 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
535 if (IS_ERR(inode)) 535 if (IS_ERR(inode))
536 goto out; 536 goto out;
537 537
538 alias = d_materialise_unique(dentry, inode); 538 alias = d_materialise_unique(dentry, inode);
539 if (IS_ERR(alias)) 539 if (IS_ERR(alias))
540 goto out; 540 goto out;
541 else if (alias) { 541 else if (alias) {
542 nfs_set_verifier(alias, nfs_save_change_attribute(dir)); 542 nfs_set_verifier(alias, nfs_save_change_attribute(dir));
543 dput(alias); 543 dput(alias);
544 } else 544 } else
545 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 545 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
546 546
547 out: 547 out:
548 dput(dentry); 548 dput(dentry);
549 } 549 }
550 550
551 /* Perform conversion from xdr to cache array */ 551 /* Perform conversion from xdr to cache array */
552 static 552 static
553 int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, 553 int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
554 struct page **xdr_pages, struct page *page, unsigned int buflen) 554 struct page **xdr_pages, struct page *page, unsigned int buflen)
555 { 555 {
556 struct xdr_stream stream; 556 struct xdr_stream stream;
557 struct xdr_buf buf; 557 struct xdr_buf buf;
558 struct page *scratch; 558 struct page *scratch;
559 struct nfs_cache_array *array; 559 struct nfs_cache_array *array;
560 unsigned int count = 0; 560 unsigned int count = 0;
561 int status; 561 int status;
562 562
563 scratch = alloc_page(GFP_KERNEL); 563 scratch = alloc_page(GFP_KERNEL);
564 if (scratch == NULL) 564 if (scratch == NULL)
565 return -ENOMEM; 565 return -ENOMEM;
566 566
567 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen); 567 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
568 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 568 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
569 569
570 do { 570 do {
571 status = xdr_decode(desc, entry, &stream); 571 status = xdr_decode(desc, entry, &stream);
572 if (status != 0) { 572 if (status != 0) {
573 if (status == -EAGAIN) 573 if (status == -EAGAIN)
574 status = 0; 574 status = 0;
575 break; 575 break;
576 } 576 }
577 577
578 count++; 578 count++;
579 579
580 if (desc->plus != 0) 580 if (desc->plus != 0)
581 nfs_prime_dcache(desc->file->f_path.dentry, entry); 581 nfs_prime_dcache(desc->file->f_path.dentry, entry);
582 582
583 status = nfs_readdir_add_to_array(entry, page); 583 status = nfs_readdir_add_to_array(entry, page);
584 if (status != 0) 584 if (status != 0)
585 break; 585 break;
586 } while (!entry->eof); 586 } while (!entry->eof);
587 587
588 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) { 588 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
589 array = nfs_readdir_get_array(page); 589 array = nfs_readdir_get_array(page);
590 if (!IS_ERR(array)) { 590 if (!IS_ERR(array)) {
591 array->eof_index = array->size; 591 array->eof_index = array->size;
592 status = 0; 592 status = 0;
593 nfs_readdir_release_array(page); 593 nfs_readdir_release_array(page);
594 } else 594 } else
595 status = PTR_ERR(array); 595 status = PTR_ERR(array);
596 } 596 }
597 597
598 put_page(scratch); 598 put_page(scratch);
599 return status; 599 return status;
600 } 600 }
601 601
602 static 602 static
603 void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages) 603 void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
604 { 604 {
605 unsigned int i; 605 unsigned int i;
606 for (i = 0; i < npages; i++) 606 for (i = 0; i < npages; i++)
607 put_page(pages[i]); 607 put_page(pages[i]);
608 } 608 }
609 609
610 static 610 static
611 void nfs_readdir_free_large_page(void *ptr, struct page **pages, 611 void nfs_readdir_free_large_page(void *ptr, struct page **pages,
612 unsigned int npages) 612 unsigned int npages)
613 { 613 {
614 nfs_readdir_free_pagearray(pages, npages); 614 nfs_readdir_free_pagearray(pages, npages);
615 } 615 }
616 616
617 /* 617 /*
618 * nfs_readdir_large_page will allocate pages that must be freed with a call 618 * nfs_readdir_large_page will allocate pages that must be freed with a call
619 * to nfs_readdir_free_large_page 619 * to nfs_readdir_free_large_page
620 */ 620 */
621 static 621 static
622 int nfs_readdir_large_page(struct page **pages, unsigned int npages) 622 int nfs_readdir_large_page(struct page **pages, unsigned int npages)
623 { 623 {
624 unsigned int i; 624 unsigned int i;
625 625
626 for (i = 0; i < npages; i++) { 626 for (i = 0; i < npages; i++) {
627 struct page *page = alloc_page(GFP_KERNEL); 627 struct page *page = alloc_page(GFP_KERNEL);
628 if (page == NULL) 628 if (page == NULL)
629 goto out_freepages; 629 goto out_freepages;
630 pages[i] = page; 630 pages[i] = page;
631 } 631 }
632 return 0; 632 return 0;
633 633
634 out_freepages: 634 out_freepages:
635 nfs_readdir_free_pagearray(pages, i); 635 nfs_readdir_free_pagearray(pages, i);
636 return -ENOMEM; 636 return -ENOMEM;
637 } 637 }
638 638
639 static 639 static
640 int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 640 int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
641 { 641 {
642 struct page *pages[NFS_MAX_READDIR_PAGES]; 642 struct page *pages[NFS_MAX_READDIR_PAGES];
643 void *pages_ptr = NULL; 643 void *pages_ptr = NULL;
644 struct nfs_entry entry; 644 struct nfs_entry entry;
645 struct file *file = desc->file; 645 struct file *file = desc->file;
646 struct nfs_cache_array *array; 646 struct nfs_cache_array *array;
647 int status = -ENOMEM; 647 int status = -ENOMEM;
648 unsigned int array_size = ARRAY_SIZE(pages); 648 unsigned int array_size = ARRAY_SIZE(pages);
649 649
650 entry.prev_cookie = 0; 650 entry.prev_cookie = 0;
651 entry.cookie = desc->last_cookie; 651 entry.cookie = desc->last_cookie;
652 entry.eof = 0; 652 entry.eof = 0;
653 entry.fh = nfs_alloc_fhandle(); 653 entry.fh = nfs_alloc_fhandle();
654 entry.fattr = nfs_alloc_fattr(); 654 entry.fattr = nfs_alloc_fattr();
655 entry.server = NFS_SERVER(inode); 655 entry.server = NFS_SERVER(inode);
656 if (entry.fh == NULL || entry.fattr == NULL) 656 if (entry.fh == NULL || entry.fattr == NULL)
657 goto out; 657 goto out;
658 658
659 array = nfs_readdir_get_array(page); 659 array = nfs_readdir_get_array(page);
660 if (IS_ERR(array)) { 660 if (IS_ERR(array)) {
661 status = PTR_ERR(array); 661 status = PTR_ERR(array);
662 goto out; 662 goto out;
663 } 663 }
664 memset(array, 0, sizeof(struct nfs_cache_array)); 664 memset(array, 0, sizeof(struct nfs_cache_array));
665 array->eof_index = -1; 665 array->eof_index = -1;
666 666
667 status = nfs_readdir_large_page(pages, array_size); 667 status = nfs_readdir_large_page(pages, array_size);
668 if (status < 0) 668 if (status < 0)
669 goto out_release_array; 669 goto out_release_array;
670 do { 670 do {
671 unsigned int pglen; 671 unsigned int pglen;
672 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode); 672 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
673 673
674 if (status < 0) 674 if (status < 0)
675 break; 675 break;
676 pglen = status; 676 pglen = status;
677 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen); 677 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
678 if (status < 0) { 678 if (status < 0) {
679 if (status == -ENOSPC) 679 if (status == -ENOSPC)
680 status = 0; 680 status = 0;
681 break; 681 break;
682 } 682 }
683 } while (array->eof_index < 0); 683 } while (array->eof_index < 0);
684 684
685 nfs_readdir_free_large_page(pages_ptr, pages, array_size); 685 nfs_readdir_free_large_page(pages_ptr, pages, array_size);
686 out_release_array: 686 out_release_array:
687 nfs_readdir_release_array(page); 687 nfs_readdir_release_array(page);
688 out: 688 out:
689 nfs_free_fattr(entry.fattr); 689 nfs_free_fattr(entry.fattr);
690 nfs_free_fhandle(entry.fh); 690 nfs_free_fhandle(entry.fh);
691 return status; 691 return status;
692 } 692 }
693 693
694 /* 694 /*
695 * Now we cache directories properly, by converting xdr information 695 * Now we cache directories properly, by converting xdr information
696 * to an array that can be used for lookups later. This results in 696 * to an array that can be used for lookups later. This results in
697 * fewer cache pages, since we can store more information on each page. 697 * fewer cache pages, since we can store more information on each page.
698 * We only need to convert from xdr once so future lookups are much simpler 698 * We only need to convert from xdr once so future lookups are much simpler
699 */ 699 */
700 static 700 static
701 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 701 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
702 { 702 {
703 struct inode *inode = desc->file->f_path.dentry->d_inode; 703 struct inode *inode = desc->file->f_path.dentry->d_inode;
704 int ret; 704 int ret;
705 705
706 ret = nfs_readdir_xdr_to_array(desc, page, inode); 706 ret = nfs_readdir_xdr_to_array(desc, page, inode);
707 if (ret < 0) 707 if (ret < 0)
708 goto error; 708 goto error;
709 SetPageUptodate(page); 709 SetPageUptodate(page);
710 710
711 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 711 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
712 /* Should never happen */ 712 /* Should never happen */
713 nfs_zap_mapping(inode, inode->i_mapping); 713 nfs_zap_mapping(inode, inode->i_mapping);
714 } 714 }
715 unlock_page(page); 715 unlock_page(page);
716 return 0; 716 return 0;
717 error: 717 error:
718 unlock_page(page); 718 unlock_page(page);
719 return ret; 719 return ret;
720 } 720 }
721 721
722 static 722 static
723 void cache_page_release(nfs_readdir_descriptor_t *desc) 723 void cache_page_release(nfs_readdir_descriptor_t *desc)
724 { 724 {
725 if (!desc->page->mapping) 725 if (!desc->page->mapping)
726 nfs_readdir_clear_array(desc->page); 726 nfs_readdir_clear_array(desc->page);
727 page_cache_release(desc->page); 727 page_cache_release(desc->page);
728 desc->page = NULL; 728 desc->page = NULL;
729 } 729 }
730 730
731 static 731 static
732 struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 732 struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
733 { 733 {
734 return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping, 734 return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping,
735 desc->page_index, (filler_t *)nfs_readdir_filler, desc); 735 desc->page_index, (filler_t *)nfs_readdir_filler, desc);
736 } 736 }
737 737
738 /* 738 /*
739 * Returns 0 if desc->dir_cookie was found on page desc->page_index 739 * Returns 0 if desc->dir_cookie was found on page desc->page_index
740 */ 740 */
741 static 741 static
742 int find_cache_page(nfs_readdir_descriptor_t *desc) 742 int find_cache_page(nfs_readdir_descriptor_t *desc)
743 { 743 {
744 int res; 744 int res;
745 745
746 desc->page = get_cache_page(desc); 746 desc->page = get_cache_page(desc);
747 if (IS_ERR(desc->page)) 747 if (IS_ERR(desc->page))
748 return PTR_ERR(desc->page); 748 return PTR_ERR(desc->page);
749 749
750 res = nfs_readdir_search_array(desc); 750 res = nfs_readdir_search_array(desc);
751 if (res != 0) 751 if (res != 0)
752 cache_page_release(desc); 752 cache_page_release(desc);
753 return res; 753 return res;
754 } 754 }
755 755
756 /* Search for desc->dir_cookie from the beginning of the page cache */ 756 /* Search for desc->dir_cookie from the beginning of the page cache */
757 static inline 757 static inline
758 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 758 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
759 { 759 {
760 int res; 760 int res;
761 761
762 if (desc->page_index == 0) { 762 if (desc->page_index == 0) {
763 desc->current_index = 0; 763 desc->current_index = 0;
764 desc->last_cookie = 0; 764 desc->last_cookie = 0;
765 } 765 }
766 do { 766 do {
767 res = find_cache_page(desc); 767 res = find_cache_page(desc);
768 } while (res == -EAGAIN); 768 } while (res == -EAGAIN);
769 return res; 769 return res;
770 } 770 }
771 771
772 /* 772 /*
773 * Once we've found the start of the dirent within a page: fill 'er up... 773 * Once we've found the start of the dirent within a page: fill 'er up...
774 */ 774 */
775 static 775 static
776 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent, 776 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent,
777 filldir_t filldir) 777 filldir_t filldir)
778 { 778 {
779 struct file *file = desc->file; 779 struct file *file = desc->file;
780 int i = 0; 780 int i = 0;
781 int res = 0; 781 int res = 0;
782 struct nfs_cache_array *array = NULL; 782 struct nfs_cache_array *array = NULL;
783 struct nfs_open_dir_context *ctx = file->private_data; 783 struct nfs_open_dir_context *ctx = file->private_data;
784 784
785 array = nfs_readdir_get_array(desc->page); 785 array = nfs_readdir_get_array(desc->page);
786 if (IS_ERR(array)) { 786 if (IS_ERR(array)) {
787 res = PTR_ERR(array); 787 res = PTR_ERR(array);
788 goto out; 788 goto out;
789 } 789 }
790 790
791 for (i = desc->cache_entry_index; i < array->size; i++) { 791 for (i = desc->cache_entry_index; i < array->size; i++) {
792 struct nfs_cache_array_entry *ent; 792 struct nfs_cache_array_entry *ent;
793 793
794 ent = &array->array[i]; 794 ent = &array->array[i];
795 if (filldir(dirent, ent->string.name, ent->string.len, 795 if (filldir(dirent, ent->string.name, ent->string.len,
796 file->f_pos, nfs_compat_user_ino64(ent->ino), 796 file->f_pos, nfs_compat_user_ino64(ent->ino),
797 ent->d_type) < 0) { 797 ent->d_type) < 0) {
798 desc->eof = 1; 798 desc->eof = 1;
799 break; 799 break;
800 } 800 }
801 file->f_pos++; 801 file->f_pos++;
802 if (i < (array->size-1)) 802 if (i < (array->size-1))
803 *desc->dir_cookie = array->array[i+1].cookie; 803 *desc->dir_cookie = array->array[i+1].cookie;
804 else 804 else
805 *desc->dir_cookie = array->last_cookie; 805 *desc->dir_cookie = array->last_cookie;
806 if (ctx->duped != 0) 806 if (ctx->duped != 0)
807 ctx->duped = 1; 807 ctx->duped = 1;
808 } 808 }
809 if (array->eof_index >= 0) 809 if (array->eof_index >= 0)
810 desc->eof = 1; 810 desc->eof = 1;
811 811
812 nfs_readdir_release_array(desc->page); 812 nfs_readdir_release_array(desc->page);
813 out: 813 out:
814 cache_page_release(desc); 814 cache_page_release(desc);
815 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 815 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
816 (unsigned long long)*desc->dir_cookie, res); 816 (unsigned long long)*desc->dir_cookie, res);
817 return res; 817 return res;
818 } 818 }
819 819
820 /* 820 /*
821 * If we cannot find a cookie in our cache, we suspect that this is 821 * If we cannot find a cookie in our cache, we suspect that this is
822 * because it points to a deleted file, so we ask the server to return 822 * because it points to a deleted file, so we ask the server to return
823 * whatever it thinks is the next entry. We then feed this to filldir. 823 * whatever it thinks is the next entry. We then feed this to filldir.
824 * If all goes well, we should then be able to find our way round the 824 * If all goes well, we should then be able to find our way round the
825 * cache on the next call to readdir_search_pagecache(); 825 * cache on the next call to readdir_search_pagecache();
826 * 826 *
827 * NOTE: we cannot add the anonymous page to the pagecache because 827 * NOTE: we cannot add the anonymous page to the pagecache because
828 * the data it contains might not be page aligned. Besides, 828 * the data it contains might not be page aligned. Besides,
829 * we should already have a complete representation of the 829 * we should already have a complete representation of the
830 * directory in the page cache by the time we get here. 830 * directory in the page cache by the time we get here.
831 */ 831 */
832 static inline 832 static inline
833 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent, 833 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
834 filldir_t filldir) 834 filldir_t filldir)
835 { 835 {
836 struct page *page = NULL; 836 struct page *page = NULL;
837 int status; 837 int status;
838 struct inode *inode = desc->file->f_path.dentry->d_inode; 838 struct inode *inode = desc->file->f_path.dentry->d_inode;
839 struct nfs_open_dir_context *ctx = desc->file->private_data; 839 struct nfs_open_dir_context *ctx = desc->file->private_data;
840 840
841 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 841 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
842 (unsigned long long)*desc->dir_cookie); 842 (unsigned long long)*desc->dir_cookie);
843 843
844 page = alloc_page(GFP_HIGHUSER); 844 page = alloc_page(GFP_HIGHUSER);
845 if (!page) { 845 if (!page) {
846 status = -ENOMEM; 846 status = -ENOMEM;
847 goto out; 847 goto out;
848 } 848 }
849 849
850 desc->page_index = 0; 850 desc->page_index = 0;
851 desc->last_cookie = *desc->dir_cookie; 851 desc->last_cookie = *desc->dir_cookie;
852 desc->page = page; 852 desc->page = page;
853 ctx->duped = 0; 853 ctx->duped = 0;
854 854
855 status = nfs_readdir_xdr_to_array(desc, page, inode); 855 status = nfs_readdir_xdr_to_array(desc, page, inode);
856 if (status < 0) 856 if (status < 0)
857 goto out_release; 857 goto out_release;
858 858
859 status = nfs_do_filldir(desc, dirent, filldir); 859 status = nfs_do_filldir(desc, dirent, filldir);
860 860
861 out: 861 out:
862 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 862 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
863 __func__, status); 863 __func__, status);
864 return status; 864 return status;
865 out_release: 865 out_release:
866 cache_page_release(desc); 866 cache_page_release(desc);
867 goto out; 867 goto out;
868 } 868 }
869 869
870 /* The file offset position represents the dirent entry number. A 870 /* The file offset position represents the dirent entry number. A
871 last cookie cache takes care of the common case of reading the 871 last cookie cache takes care of the common case of reading the
872 whole directory. 872 whole directory.
873 */ 873 */
874 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 874 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
875 { 875 {
876 struct dentry *dentry = filp->f_path.dentry; 876 struct dentry *dentry = filp->f_path.dentry;
877 struct inode *inode = dentry->d_inode; 877 struct inode *inode = dentry->d_inode;
878 nfs_readdir_descriptor_t my_desc, 878 nfs_readdir_descriptor_t my_desc,
879 *desc = &my_desc; 879 *desc = &my_desc;
880 struct nfs_open_dir_context *dir_ctx = filp->private_data; 880 struct nfs_open_dir_context *dir_ctx = filp->private_data;
881 int res; 881 int res;
882 882
883 dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n", 883 dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
884 dentry->d_parent->d_name.name, dentry->d_name.name, 884 dentry->d_parent->d_name.name, dentry->d_name.name,
885 (long long)filp->f_pos); 885 (long long)filp->f_pos);
886 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 886 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
887 887
888 /* 888 /*
889 * filp->f_pos points to the dirent entry number. 889 * filp->f_pos points to the dirent entry number.
890 * *desc->dir_cookie has the cookie for the next entry. We have 890 * *desc->dir_cookie has the cookie for the next entry. We have
891 * to either find the entry with the appropriate number or 891 * to either find the entry with the appropriate number or
892 * revalidate the cookie. 892 * revalidate the cookie.
893 */ 893 */
894 memset(desc, 0, sizeof(*desc)); 894 memset(desc, 0, sizeof(*desc));
895 895
896 desc->file = filp; 896 desc->file = filp;
897 desc->dir_cookie = &dir_ctx->dir_cookie; 897 desc->dir_cookie = &dir_ctx->dir_cookie;
898 desc->decode = NFS_PROTO(inode)->decode_dirent; 898 desc->decode = NFS_PROTO(inode)->decode_dirent;
899 desc->plus = nfs_use_readdirplus(inode, filp) ? 1 : 0; 899 desc->plus = nfs_use_readdirplus(inode, filp) ? 1 : 0;
900 900
901 nfs_block_sillyrename(dentry); 901 nfs_block_sillyrename(dentry);
902 res = nfs_revalidate_mapping(inode, filp->f_mapping); 902 res = nfs_revalidate_mapping(inode, filp->f_mapping);
903 if (res < 0) 903 if (res < 0)
904 goto out; 904 goto out;
905 905
906 do { 906 do {
907 res = readdir_search_pagecache(desc); 907 res = readdir_search_pagecache(desc);
908 908
909 if (res == -EBADCOOKIE) { 909 if (res == -EBADCOOKIE) {
910 res = 0; 910 res = 0;
911 /* This means either end of directory */ 911 /* This means either end of directory */
912 if (*desc->dir_cookie && desc->eof == 0) { 912 if (*desc->dir_cookie && desc->eof == 0) {
913 /* Or that the server has 'lost' a cookie */ 913 /* Or that the server has 'lost' a cookie */
914 res = uncached_readdir(desc, dirent, filldir); 914 res = uncached_readdir(desc, dirent, filldir);
915 if (res == 0) 915 if (res == 0)
916 continue; 916 continue;
917 } 917 }
918 break; 918 break;
919 } 919 }
920 if (res == -ETOOSMALL && desc->plus) { 920 if (res == -ETOOSMALL && desc->plus) {
921 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 921 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
922 nfs_zap_caches(inode); 922 nfs_zap_caches(inode);
923 desc->page_index = 0; 923 desc->page_index = 0;
924 desc->plus = 0; 924 desc->plus = 0;
925 desc->eof = 0; 925 desc->eof = 0;
926 continue; 926 continue;
927 } 927 }
928 if (res < 0) 928 if (res < 0)
929 break; 929 break;
930 930
931 res = nfs_do_filldir(desc, dirent, filldir); 931 res = nfs_do_filldir(desc, dirent, filldir);
932 if (res < 0) 932 if (res < 0)
933 break; 933 break;
934 } while (!desc->eof); 934 } while (!desc->eof);
935 out: 935 out:
936 nfs_unblock_sillyrename(dentry); 936 nfs_unblock_sillyrename(dentry);
937 if (res > 0) 937 if (res > 0)
938 res = 0; 938 res = 0;
939 dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n", 939 dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
940 dentry->d_parent->d_name.name, dentry->d_name.name, 940 dentry->d_parent->d_name.name, dentry->d_name.name,
941 res); 941 res);
942 return res; 942 return res;
943 } 943 }
944 944
945 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 945 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
946 { 946 {
947 struct dentry *dentry = filp->f_path.dentry; 947 struct dentry *dentry = filp->f_path.dentry;
948 struct inode *inode = dentry->d_inode; 948 struct inode *inode = dentry->d_inode;
949 struct nfs_open_dir_context *dir_ctx = filp->private_data; 949 struct nfs_open_dir_context *dir_ctx = filp->private_data;
950 950
951 dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n", 951 dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
952 dentry->d_parent->d_name.name, 952 dentry->d_parent->d_name.name,
953 dentry->d_name.name, 953 dentry->d_name.name,
954 offset, origin); 954 offset, origin);
955 955
956 mutex_lock(&inode->i_mutex); 956 mutex_lock(&inode->i_mutex);
957 switch (origin) { 957 switch (origin) {
958 case 1: 958 case 1:
959 offset += filp->f_pos; 959 offset += filp->f_pos;
960 case 0: 960 case 0:
961 if (offset >= 0) 961 if (offset >= 0)
962 break; 962 break;
963 default: 963 default:
964 offset = -EINVAL; 964 offset = -EINVAL;
965 goto out; 965 goto out;
966 } 966 }
967 if (offset != filp->f_pos) { 967 if (offset != filp->f_pos) {
968 filp->f_pos = offset; 968 filp->f_pos = offset;
969 dir_ctx->dir_cookie = 0; 969 dir_ctx->dir_cookie = 0;
970 dir_ctx->duped = 0; 970 dir_ctx->duped = 0;
971 } 971 }
972 out: 972 out:
973 mutex_unlock(&inode->i_mutex); 973 mutex_unlock(&inode->i_mutex);
974 return offset; 974 return offset;
975 } 975 }
976 976
977 /* 977 /*
978 * All directory operations under NFS are synchronous, so fsync() 978 * All directory operations under NFS are synchronous, so fsync()
979 * is a dummy operation. 979 * is a dummy operation.
980 */ 980 */
981 static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end, 981 static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
982 int datasync) 982 int datasync)
983 { 983 {
984 struct dentry *dentry = filp->f_path.dentry; 984 struct dentry *dentry = filp->f_path.dentry;
985 struct inode *inode = dentry->d_inode; 985 struct inode *inode = dentry->d_inode;
986 986
987 dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n", 987 dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
988 dentry->d_parent->d_name.name, dentry->d_name.name, 988 dentry->d_parent->d_name.name, dentry->d_name.name,
989 datasync); 989 datasync);
990 990
991 mutex_lock(&inode->i_mutex); 991 mutex_lock(&inode->i_mutex);
992 nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC); 992 nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
993 mutex_unlock(&inode->i_mutex); 993 mutex_unlock(&inode->i_mutex);
994 return 0; 994 return 0;
995 } 995 }
996 996
997 /** 997 /**
998 * nfs_force_lookup_revalidate - Mark the directory as having changed 998 * nfs_force_lookup_revalidate - Mark the directory as having changed
999 * @dir - pointer to directory inode 999 * @dir - pointer to directory inode
1000 * 1000 *
1001 * This forces the revalidation code in nfs_lookup_revalidate() to do a 1001 * This forces the revalidation code in nfs_lookup_revalidate() to do a
1002 * full lookup on all child dentries of 'dir' whenever a change occurs 1002 * full lookup on all child dentries of 'dir' whenever a change occurs
1003 * on the server that might have invalidated our dcache. 1003 * on the server that might have invalidated our dcache.
1004 * 1004 *
1005 * The caller should be holding dir->i_lock 1005 * The caller should be holding dir->i_lock
1006 */ 1006 */
1007 void nfs_force_lookup_revalidate(struct inode *dir) 1007 void nfs_force_lookup_revalidate(struct inode *dir)
1008 { 1008 {
1009 NFS_I(dir)->cache_change_attribute++; 1009 NFS_I(dir)->cache_change_attribute++;
1010 } 1010 }
1011 1011
1012 /* 1012 /*
1013 * A check for whether or not the parent directory has changed. 1013 * A check for whether or not the parent directory has changed.
1014 * In the case it has, we assume that the dentries are untrustworthy 1014 * In the case it has, we assume that the dentries are untrustworthy
1015 * and may need to be looked up again. 1015 * and may need to be looked up again.
1016 */ 1016 */
1017 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 1017 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
1018 { 1018 {
1019 if (IS_ROOT(dentry)) 1019 if (IS_ROOT(dentry))
1020 return 1; 1020 return 1;
1021 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 1021 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
1022 return 0; 1022 return 0;
1023 if (!nfs_verify_change_attribute(dir, dentry->d_time)) 1023 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1024 return 0; 1024 return 0;
1025 /* Revalidate nfsi->cache_change_attribute before we declare a match */ 1025 /* Revalidate nfsi->cache_change_attribute before we declare a match */
1026 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 1026 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1027 return 0; 1027 return 0;
1028 if (!nfs_verify_change_attribute(dir, dentry->d_time)) 1028 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1029 return 0; 1029 return 0;
1030 return 1; 1030 return 1;
1031 } 1031 }
1032 1032
1033 /* 1033 /*
1034 * Return the intent data that applies to this particular path component 1034 * Return the intent data that applies to this particular path component
1035 * 1035 *
1036 * Note that the current set of intents only apply to the very last 1036 * Note that the current set of intents only apply to the very last
1037 * component of the path and none of them is set before that last 1037 * component of the path and none of them is set before that last
1038 * component. 1038 * component.
1039 */ 1039 */
1040 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, 1040 static inline unsigned int nfs_lookup_check_intent(unsigned int flags,
1041 unsigned int mask) 1041 unsigned int mask)
1042 { 1042 {
1043 return nd->flags & mask; 1043 return flags & mask;
1044 } 1044 }
1045 1045
1046 /* 1046 /*
1047 * Use intent information to check whether or not we're going to do 1047 * Use intent information to check whether or not we're going to do
1048 * an O_EXCL create using this path component. 1048 * an O_EXCL create using this path component.
1049 */ 1049 */
1050 static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 1050 static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
1051 { 1051 {
1052 if (NFS_PROTO(dir)->version == 2) 1052 if (NFS_PROTO(dir)->version == 2)
1053 return 0; 1053 return 0;
1054 return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL); 1054 return nd && nfs_lookup_check_intent(nd->flags, LOOKUP_EXCL);
1055 } 1055 }
1056 1056
1057 /* 1057 /*
1058 * Inode and filehandle revalidation for lookups. 1058 * Inode and filehandle revalidation for lookups.
1059 * 1059 *
1060 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 1060 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1061 * or if the intent information indicates that we're about to open this 1061 * or if the intent information indicates that we're about to open this
1062 * particular file and the "nocto" mount flag is not set. 1062 * particular file and the "nocto" mount flag is not set.
1063 * 1063 *
1064 */ 1064 */
1065 static inline 1065 static inline
1066 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 1066 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
1067 { 1067 {
1068 struct nfs_server *server = NFS_SERVER(inode); 1068 struct nfs_server *server = NFS_SERVER(inode);
1069 1069
1070 if (IS_AUTOMOUNT(inode)) 1070 if (IS_AUTOMOUNT(inode))
1071 return 0; 1071 return 0;
1072 if (nd != NULL) { 1072 if (nd != NULL) {
1073 /* VFS wants an on-the-wire revalidation */ 1073 /* VFS wants an on-the-wire revalidation */
1074 if (nd->flags & LOOKUP_REVAL) 1074 if (nd->flags & LOOKUP_REVAL)
1075 goto out_force; 1075 goto out_force;
1076 /* This is an open(2) */ 1076 /* This is an open(2) */
1077 if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 1077 if (nfs_lookup_check_intent(nd->flags, LOOKUP_OPEN) != 0 &&
1078 !(server->flags & NFS_MOUNT_NOCTO) && 1078 !(server->flags & NFS_MOUNT_NOCTO) &&
1079 (S_ISREG(inode->i_mode) || 1079 (S_ISREG(inode->i_mode) ||
1080 S_ISDIR(inode->i_mode))) 1080 S_ISDIR(inode->i_mode)))
1081 goto out_force; 1081 goto out_force;
1082 return 0; 1082 return 0;
1083 } 1083 }
1084 return nfs_revalidate_inode(server, inode); 1084 return nfs_revalidate_inode(server, inode);
1085 out_force: 1085 out_force:
1086 return __nfs_revalidate_inode(server, inode); 1086 return __nfs_revalidate_inode(server, inode);
1087 } 1087 }
1088 1088
1089 /* 1089 /*
1090 * We judge how long we want to trust negative 1090 * We judge how long we want to trust negative
1091 * dentries by looking at the parent inode mtime. 1091 * dentries by looking at the parent inode mtime.
1092 * 1092 *
1093 * If parent mtime has changed, we revalidate, else we wait for a 1093 * If parent mtime has changed, we revalidate, else we wait for a
1094 * period corresponding to the parent's attribute cache timeout value. 1094 * period corresponding to the parent's attribute cache timeout value.
1095 */ 1095 */
1096 static inline 1096 static inline
1097 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 1097 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
1098 struct nameidata *nd) 1098 struct nameidata *nd)
1099 { 1099 {
1100 /* Don't revalidate a negative dentry if we're creating a new file */ 1100 /* Don't revalidate a negative dentry if we're creating a new file */
1101 if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 1101 if (nd != NULL && nfs_lookup_check_intent(nd->flags, LOOKUP_CREATE) != 0)
1102 return 0; 1102 return 0;
1103 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 1103 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1104 return 1; 1104 return 1;
1105 return !nfs_check_verifier(dir, dentry); 1105 return !nfs_check_verifier(dir, dentry);
1106 } 1106 }
1107 1107
1108 /* 1108 /*
1109 * This is called every time the dcache has a lookup hit, 1109 * This is called every time the dcache has a lookup hit,
1110 * and we should check whether we can really trust that 1110 * and we should check whether we can really trust that
1111 * lookup. 1111 * lookup.
1112 * 1112 *
1113 * NOTE! The hit can be a negative hit too, don't assume 1113 * NOTE! The hit can be a negative hit too, don't assume
1114 * we have an inode! 1114 * we have an inode!
1115 * 1115 *
1116 * If the parent directory is seen to have changed, we throw out the 1116 * If the parent directory is seen to have changed, we throw out the
1117 * cached dentry and do a new lookup. 1117 * cached dentry and do a new lookup.
1118 */ 1118 */
1119 static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd) 1119 static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
1120 { 1120 {
1121 struct inode *dir; 1121 struct inode *dir;
1122 struct inode *inode; 1122 struct inode *inode;
1123 struct dentry *parent; 1123 struct dentry *parent;
1124 struct nfs_fh *fhandle = NULL; 1124 struct nfs_fh *fhandle = NULL;
1125 struct nfs_fattr *fattr = NULL; 1125 struct nfs_fattr *fattr = NULL;
1126 int error; 1126 int error;
1127 1127
1128 if (nd->flags & LOOKUP_RCU) 1128 if (nd->flags & LOOKUP_RCU)
1129 return -ECHILD; 1129 return -ECHILD;
1130 1130
1131 parent = dget_parent(dentry); 1131 parent = dget_parent(dentry);
1132 dir = parent->d_inode; 1132 dir = parent->d_inode;
1133 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 1133 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
1134 inode = dentry->d_inode; 1134 inode = dentry->d_inode;
1135 1135
1136 if (!inode) { 1136 if (!inode) {
1137 if (nfs_neg_need_reval(dir, dentry, nd)) 1137 if (nfs_neg_need_reval(dir, dentry, nd))
1138 goto out_bad; 1138 goto out_bad;
1139 goto out_valid_noent; 1139 goto out_valid_noent;
1140 } 1140 }
1141 1141
1142 if (is_bad_inode(inode)) { 1142 if (is_bad_inode(inode)) {
1143 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 1143 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
1144 __func__, dentry->d_parent->d_name.name, 1144 __func__, dentry->d_parent->d_name.name,
1145 dentry->d_name.name); 1145 dentry->d_name.name);
1146 goto out_bad; 1146 goto out_bad;
1147 } 1147 }
1148 1148
1149 if (nfs_have_delegation(inode, FMODE_READ)) 1149 if (nfs_have_delegation(inode, FMODE_READ))
1150 goto out_set_verifier; 1150 goto out_set_verifier;
1151 1151
1152 /* Force a full look up iff the parent directory has changed */ 1152 /* Force a full look up iff the parent directory has changed */
1153 if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) { 1153 if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
1154 if (nfs_lookup_verify_inode(inode, nd)) 1154 if (nfs_lookup_verify_inode(inode, nd))
1155 goto out_zap_parent; 1155 goto out_zap_parent;
1156 goto out_valid; 1156 goto out_valid;
1157 } 1157 }
1158 1158
1159 if (NFS_STALE(inode)) 1159 if (NFS_STALE(inode))
1160 goto out_bad; 1160 goto out_bad;
1161 1161
1162 error = -ENOMEM; 1162 error = -ENOMEM;
1163 fhandle = nfs_alloc_fhandle(); 1163 fhandle = nfs_alloc_fhandle();
1164 fattr = nfs_alloc_fattr(); 1164 fattr = nfs_alloc_fattr();
1165 if (fhandle == NULL || fattr == NULL) 1165 if (fhandle == NULL || fattr == NULL)
1166 goto out_error; 1166 goto out_error;
1167 1167
1168 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1168 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1169 if (error) 1169 if (error)
1170 goto out_bad; 1170 goto out_bad;
1171 if (nfs_compare_fh(NFS_FH(inode), fhandle)) 1171 if (nfs_compare_fh(NFS_FH(inode), fhandle))
1172 goto out_bad; 1172 goto out_bad;
1173 if ((error = nfs_refresh_inode(inode, fattr)) != 0) 1173 if ((error = nfs_refresh_inode(inode, fattr)) != 0)
1174 goto out_bad; 1174 goto out_bad;
1175 1175
1176 nfs_free_fattr(fattr); 1176 nfs_free_fattr(fattr);
1177 nfs_free_fhandle(fhandle); 1177 nfs_free_fhandle(fhandle);
1178 out_set_verifier: 1178 out_set_verifier:
1179 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1179 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1180 out_valid: 1180 out_valid:
1181 /* Success: notify readdir to use READDIRPLUS */ 1181 /* Success: notify readdir to use READDIRPLUS */
1182 nfs_advise_use_readdirplus(dir); 1182 nfs_advise_use_readdirplus(dir);
1183 out_valid_noent: 1183 out_valid_noent:
1184 dput(parent); 1184 dput(parent);
1185 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 1185 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
1186 __func__, dentry->d_parent->d_name.name, 1186 __func__, dentry->d_parent->d_name.name,
1187 dentry->d_name.name); 1187 dentry->d_name.name);
1188 return 1; 1188 return 1;
1189 out_zap_parent: 1189 out_zap_parent:
1190 nfs_zap_caches(dir); 1190 nfs_zap_caches(dir);
1191 out_bad: 1191 out_bad:
1192 nfs_mark_for_revalidate(dir); 1192 nfs_mark_for_revalidate(dir);
1193 if (inode && S_ISDIR(inode->i_mode)) { 1193 if (inode && S_ISDIR(inode->i_mode)) {
1194 /* Purge readdir caches. */ 1194 /* Purge readdir caches. */
1195 nfs_zap_caches(inode); 1195 nfs_zap_caches(inode);
1196 /* If we have submounts, don't unhash ! */ 1196 /* If we have submounts, don't unhash ! */
1197 if (have_submounts(dentry)) 1197 if (have_submounts(dentry))
1198 goto out_valid; 1198 goto out_valid;
1199 if (dentry->d_flags & DCACHE_DISCONNECTED) 1199 if (dentry->d_flags & DCACHE_DISCONNECTED)
1200 goto out_valid; 1200 goto out_valid;
1201 shrink_dcache_parent(dentry); 1201 shrink_dcache_parent(dentry);
1202 } 1202 }
1203 d_drop(dentry); 1203 d_drop(dentry);
1204 nfs_free_fattr(fattr); 1204 nfs_free_fattr(fattr);
1205 nfs_free_fhandle(fhandle); 1205 nfs_free_fhandle(fhandle);
1206 dput(parent); 1206 dput(parent);
1207 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 1207 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
1208 __func__, dentry->d_parent->d_name.name, 1208 __func__, dentry->d_parent->d_name.name,
1209 dentry->d_name.name); 1209 dentry->d_name.name);
1210 return 0; 1210 return 0;
1211 out_error: 1211 out_error:
1212 nfs_free_fattr(fattr); 1212 nfs_free_fattr(fattr);
1213 nfs_free_fhandle(fhandle); 1213 nfs_free_fhandle(fhandle);
1214 dput(parent); 1214 dput(parent);
1215 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n", 1215 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
1216 __func__, dentry->d_parent->d_name.name, 1216 __func__, dentry->d_parent->d_name.name,
1217 dentry->d_name.name, error); 1217 dentry->d_name.name, error);
1218 return error; 1218 return error;
1219 } 1219 }
1220 1220
1221 /* 1221 /*
1222 * This is called from dput() when d_count is going to 0. 1222 * This is called from dput() when d_count is going to 0.
1223 */ 1223 */
1224 static int nfs_dentry_delete(const struct dentry *dentry) 1224 static int nfs_dentry_delete(const struct dentry *dentry)
1225 { 1225 {
1226 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 1226 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
1227 dentry->d_parent->d_name.name, dentry->d_name.name, 1227 dentry->d_parent->d_name.name, dentry->d_name.name,
1228 dentry->d_flags); 1228 dentry->d_flags);
1229 1229
1230 /* Unhash any dentry with a stale inode */ 1230 /* Unhash any dentry with a stale inode */
1231 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 1231 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1232 return 1; 1232 return 1;
1233 1233
1234 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1234 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1235 /* Unhash it, so that ->d_iput() would be called */ 1235 /* Unhash it, so that ->d_iput() would be called */
1236 return 1; 1236 return 1;
1237 } 1237 }
1238 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 1238 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1239 /* Unhash it, so that ancestors of killed async unlink 1239 /* Unhash it, so that ancestors of killed async unlink
1240 * files will be cleaned up during umount */ 1240 * files will be cleaned up during umount */
1241 return 1; 1241 return 1;
1242 } 1242 }
1243 return 0; 1243 return 0;
1244 1244
1245 } 1245 }
1246 1246
1247 static void nfs_drop_nlink(struct inode *inode) 1247 static void nfs_drop_nlink(struct inode *inode)
1248 { 1248 {
1249 spin_lock(&inode->i_lock); 1249 spin_lock(&inode->i_lock);
1250 if (inode->i_nlink > 0) 1250 if (inode->i_nlink > 0)
1251 drop_nlink(inode); 1251 drop_nlink(inode);
1252 spin_unlock(&inode->i_lock); 1252 spin_unlock(&inode->i_lock);
1253 } 1253 }
1254 1254
1255 /* 1255 /*
1256 * Called when the dentry loses inode. 1256 * Called when the dentry loses inode.
1257 * We use it to clean up silly-renamed files. 1257 * We use it to clean up silly-renamed files.
1258 */ 1258 */
1259 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 1259 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1260 { 1260 {
1261 if (S_ISDIR(inode->i_mode)) 1261 if (S_ISDIR(inode->i_mode))
1262 /* drop any readdir cache as it could easily be old */ 1262 /* drop any readdir cache as it could easily be old */
1263 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 1263 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1264 1264
1265 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1265 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1266 drop_nlink(inode); 1266 drop_nlink(inode);
1267 nfs_complete_unlink(dentry, inode); 1267 nfs_complete_unlink(dentry, inode);
1268 } 1268 }
1269 iput(inode); 1269 iput(inode);
1270 } 1270 }
1271 1271
1272 static void nfs_d_release(struct dentry *dentry) 1272 static void nfs_d_release(struct dentry *dentry)
1273 { 1273 {
1274 /* free cached devname value, if it survived that far */ 1274 /* free cached devname value, if it survived that far */
1275 if (unlikely(dentry->d_fsdata)) { 1275 if (unlikely(dentry->d_fsdata)) {
1276 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1276 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1277 WARN_ON(1); 1277 WARN_ON(1);
1278 else 1278 else
1279 kfree(dentry->d_fsdata); 1279 kfree(dentry->d_fsdata);
1280 } 1280 }
1281 } 1281 }
1282 1282
1283 const struct dentry_operations nfs_dentry_operations = { 1283 const struct dentry_operations nfs_dentry_operations = {
1284 .d_revalidate = nfs_lookup_revalidate, 1284 .d_revalidate = nfs_lookup_revalidate,
1285 .d_delete = nfs_dentry_delete, 1285 .d_delete = nfs_dentry_delete,
1286 .d_iput = nfs_dentry_iput, 1286 .d_iput = nfs_dentry_iput,
1287 .d_automount = nfs_d_automount, 1287 .d_automount = nfs_d_automount,
1288 .d_release = nfs_d_release, 1288 .d_release = nfs_d_release,
1289 }; 1289 };
1290 1290
1291 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 1291 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
1292 { 1292 {
1293 struct dentry *res; 1293 struct dentry *res;
1294 struct dentry *parent; 1294 struct dentry *parent;
1295 struct inode *inode = NULL; 1295 struct inode *inode = NULL;
1296 struct nfs_fh *fhandle = NULL; 1296 struct nfs_fh *fhandle = NULL;
1297 struct nfs_fattr *fattr = NULL; 1297 struct nfs_fattr *fattr = NULL;
1298 int error; 1298 int error;
1299 1299
1300 dfprintk(VFS, "NFS: lookup(%s/%s)\n", 1300 dfprintk(VFS, "NFS: lookup(%s/%s)\n",
1301 dentry->d_parent->d_name.name, dentry->d_name.name); 1301 dentry->d_parent->d_name.name, dentry->d_name.name);
1302 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 1302 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
1303 1303
1304 res = ERR_PTR(-ENAMETOOLONG); 1304 res = ERR_PTR(-ENAMETOOLONG);
1305 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 1305 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1306 goto out; 1306 goto out;
1307 1307
1308 /* 1308 /*
1309 * If we're doing an exclusive create, optimize away the lookup 1309 * If we're doing an exclusive create, optimize away the lookup
1310 * but don't hash the dentry. 1310 * but don't hash the dentry.
1311 */ 1311 */
1312 if (nfs_is_exclusive_create(dir, nd)) { 1312 if (nfs_is_exclusive_create(dir, nd)) {
1313 d_instantiate(dentry, NULL); 1313 d_instantiate(dentry, NULL);
1314 res = NULL; 1314 res = NULL;
1315 goto out; 1315 goto out;
1316 } 1316 }
1317 1317
1318 res = ERR_PTR(-ENOMEM); 1318 res = ERR_PTR(-ENOMEM);
1319 fhandle = nfs_alloc_fhandle(); 1319 fhandle = nfs_alloc_fhandle();
1320 fattr = nfs_alloc_fattr(); 1320 fattr = nfs_alloc_fattr();
1321 if (fhandle == NULL || fattr == NULL) 1321 if (fhandle == NULL || fattr == NULL)
1322 goto out; 1322 goto out;
1323 1323
1324 parent = dentry->d_parent; 1324 parent = dentry->d_parent;
1325 /* Protect against concurrent sillydeletes */ 1325 /* Protect against concurrent sillydeletes */
1326 nfs_block_sillyrename(parent); 1326 nfs_block_sillyrename(parent);
1327 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1327 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1328 if (error == -ENOENT) 1328 if (error == -ENOENT)
1329 goto no_entry; 1329 goto no_entry;
1330 if (error < 0) { 1330 if (error < 0) {
1331 res = ERR_PTR(error); 1331 res = ERR_PTR(error);
1332 goto out_unblock_sillyrename; 1332 goto out_unblock_sillyrename;
1333 } 1333 }
1334 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1334 inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1335 res = ERR_CAST(inode); 1335 res = ERR_CAST(inode);
1336 if (IS_ERR(res)) 1336 if (IS_ERR(res))
1337 goto out_unblock_sillyrename; 1337 goto out_unblock_sillyrename;
1338 1338
1339 /* Success: notify readdir to use READDIRPLUS */ 1339 /* Success: notify readdir to use READDIRPLUS */
1340 nfs_advise_use_readdirplus(dir); 1340 nfs_advise_use_readdirplus(dir);
1341 1341
1342 no_entry: 1342 no_entry:
1343 res = d_materialise_unique(dentry, inode); 1343 res = d_materialise_unique(dentry, inode);
1344 if (res != NULL) { 1344 if (res != NULL) {
1345 if (IS_ERR(res)) 1345 if (IS_ERR(res))
1346 goto out_unblock_sillyrename; 1346 goto out_unblock_sillyrename;
1347 dentry = res; 1347 dentry = res;
1348 } 1348 }
1349 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1349 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1350 out_unblock_sillyrename: 1350 out_unblock_sillyrename:
1351 nfs_unblock_sillyrename(parent); 1351 nfs_unblock_sillyrename(parent);
1352 out: 1352 out:
1353 nfs_free_fattr(fattr); 1353 nfs_free_fattr(fattr);
1354 nfs_free_fhandle(fhandle); 1354 nfs_free_fhandle(fhandle);
1355 return res; 1355 return res;
1356 } 1356 }
1357 1357
1358 #ifdef CONFIG_NFS_V4 1358 #ifdef CONFIG_NFS_V4
1359 static int nfs4_lookup_revalidate(struct dentry *, struct nameidata *); 1359 static int nfs4_lookup_revalidate(struct dentry *, struct nameidata *);
1360 1360
1361 const struct dentry_operations nfs4_dentry_operations = { 1361 const struct dentry_operations nfs4_dentry_operations = {
1362 .d_revalidate = nfs4_lookup_revalidate, 1362 .d_revalidate = nfs4_lookup_revalidate,
1363 .d_delete = nfs_dentry_delete, 1363 .d_delete = nfs_dentry_delete,
1364 .d_iput = nfs_dentry_iput, 1364 .d_iput = nfs_dentry_iput,
1365 .d_automount = nfs_d_automount, 1365 .d_automount = nfs_d_automount,
1366 .d_release = nfs_d_release, 1366 .d_release = nfs_d_release,
1367 }; 1367 };
1368 1368
1369 static fmode_t flags_to_mode(int flags) 1369 static fmode_t flags_to_mode(int flags)
1370 { 1370 {
1371 fmode_t res = (__force fmode_t)flags & FMODE_EXEC; 1371 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1372 if ((flags & O_ACCMODE) != O_WRONLY) 1372 if ((flags & O_ACCMODE) != O_WRONLY)
1373 res |= FMODE_READ; 1373 res |= FMODE_READ;
1374 if ((flags & O_ACCMODE) != O_RDONLY) 1374 if ((flags & O_ACCMODE) != O_RDONLY)
1375 res |= FMODE_WRITE; 1375 res |= FMODE_WRITE;
1376 return res; 1376 return res;
1377 } 1377 }
1378 1378
1379 static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags) 1379 static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
1380 { 1380 {
1381 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags)); 1381 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
1382 } 1382 }
1383 1383
1384 static int do_open(struct inode *inode, struct file *filp) 1384 static int do_open(struct inode *inode, struct file *filp)
1385 { 1385 {
1386 nfs_fscache_set_inode_cookie(inode, filp); 1386 nfs_fscache_set_inode_cookie(inode, filp);
1387 return 0; 1387 return 0;
1388 } 1388 }
1389 1389
1390 static int nfs_finish_open(struct nfs_open_context *ctx, 1390 static int nfs_finish_open(struct nfs_open_context *ctx,
1391 struct dentry *dentry, 1391 struct dentry *dentry,
1392 struct file *file, unsigned open_flags, 1392 struct file *file, unsigned open_flags,
1393 int *opened) 1393 int *opened)
1394 { 1394 {
1395 int err; 1395 int err;
1396 1396
1397 if (ctx->dentry != dentry) { 1397 if (ctx->dentry != dentry) {
1398 dput(ctx->dentry); 1398 dput(ctx->dentry);
1399 ctx->dentry = dget(dentry); 1399 ctx->dentry = dget(dentry);
1400 } 1400 }
1401 1401
1402 /* If the open_intent is for execute, we have an extra check to make */ 1402 /* If the open_intent is for execute, we have an extra check to make */
1403 if (ctx->mode & FMODE_EXEC) { 1403 if (ctx->mode & FMODE_EXEC) {
1404 err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags); 1404 err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
1405 if (err < 0) 1405 if (err < 0)
1406 goto out; 1406 goto out;
1407 } 1407 }
1408 1408
1409 err = finish_open(file, dentry, do_open, opened); 1409 err = finish_open(file, dentry, do_open, opened);
1410 if (err) 1410 if (err)
1411 goto out; 1411 goto out;
1412 nfs_file_set_open_context(file, ctx); 1412 nfs_file_set_open_context(file, ctx);
1413 1413
1414 out: 1414 out:
1415 put_nfs_open_context(ctx); 1415 put_nfs_open_context(ctx);
1416 return err; 1416 return err;
1417 } 1417 }
1418 1418
1419 static int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 1419 static int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1420 struct file *file, unsigned open_flags, 1420 struct file *file, unsigned open_flags,
1421 umode_t mode, int *opened) 1421 umode_t mode, int *opened)
1422 { 1422 {
1423 struct nfs_open_context *ctx; 1423 struct nfs_open_context *ctx;
1424 struct dentry *res; 1424 struct dentry *res;
1425 struct iattr attr = { .ia_valid = ATTR_OPEN }; 1425 struct iattr attr = { .ia_valid = ATTR_OPEN };
1426 struct inode *inode; 1426 struct inode *inode;
1427 int err; 1427 int err;
1428 1428
1429 /* Expect a negative dentry */ 1429 /* Expect a negative dentry */
1430 BUG_ON(dentry->d_inode); 1430 BUG_ON(dentry->d_inode);
1431 1431
1432 dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n", 1432 dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n",
1433 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1433 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1434 1434
1435 /* NFS only supports OPEN on regular files */ 1435 /* NFS only supports OPEN on regular files */
1436 if ((open_flags & O_DIRECTORY)) { 1436 if ((open_flags & O_DIRECTORY)) {
1437 if (!d_unhashed(dentry)) { 1437 if (!d_unhashed(dentry)) {
1438 /* 1438 /*
1439 * Hashed negative dentry with O_DIRECTORY: dentry was 1439 * Hashed negative dentry with O_DIRECTORY: dentry was
1440 * revalidated and is fine, no need to perform lookup 1440 * revalidated and is fine, no need to perform lookup
1441 * again 1441 * again
1442 */ 1442 */
1443 return -ENOENT; 1443 return -ENOENT;
1444 } 1444 }
1445 goto no_open; 1445 goto no_open;
1446 } 1446 }
1447 1447
1448 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 1448 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1449 return -ENAMETOOLONG; 1449 return -ENAMETOOLONG;
1450 1450
1451 if (open_flags & O_CREAT) { 1451 if (open_flags & O_CREAT) {
1452 attr.ia_valid |= ATTR_MODE; 1452 attr.ia_valid |= ATTR_MODE;
1453 attr.ia_mode = mode & ~current_umask(); 1453 attr.ia_mode = mode & ~current_umask();
1454 } 1454 }
1455 if (open_flags & O_TRUNC) { 1455 if (open_flags & O_TRUNC) {
1456 attr.ia_valid |= ATTR_SIZE; 1456 attr.ia_valid |= ATTR_SIZE;
1457 attr.ia_size = 0; 1457 attr.ia_size = 0;
1458 } 1458 }
1459 1459
1460 ctx = create_nfs_open_context(dentry, open_flags); 1460 ctx = create_nfs_open_context(dentry, open_flags);
1461 err = PTR_ERR(ctx); 1461 err = PTR_ERR(ctx);
1462 if (IS_ERR(ctx)) 1462 if (IS_ERR(ctx))
1463 goto out; 1463 goto out;
1464 1464
1465 nfs_block_sillyrename(dentry->d_parent); 1465 nfs_block_sillyrename(dentry->d_parent);
1466 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1466 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
1467 d_drop(dentry); 1467 d_drop(dentry);
1468 if (IS_ERR(inode)) { 1468 if (IS_ERR(inode)) {
1469 nfs_unblock_sillyrename(dentry->d_parent); 1469 nfs_unblock_sillyrename(dentry->d_parent);
1470 put_nfs_open_context(ctx); 1470 put_nfs_open_context(ctx);
1471 err = PTR_ERR(inode); 1471 err = PTR_ERR(inode);
1472 switch (err) { 1472 switch (err) {
1473 case -ENOENT: 1473 case -ENOENT:
1474 d_add(dentry, NULL); 1474 d_add(dentry, NULL);
1475 break; 1475 break;
1476 case -EISDIR: 1476 case -EISDIR:
1477 case -ENOTDIR: 1477 case -ENOTDIR:
1478 goto no_open; 1478 goto no_open;
1479 case -ELOOP: 1479 case -ELOOP:
1480 if (!(open_flags & O_NOFOLLOW)) 1480 if (!(open_flags & O_NOFOLLOW))
1481 goto no_open; 1481 goto no_open;
1482 break; 1482 break;
1483 /* case -EINVAL: */ 1483 /* case -EINVAL: */
1484 default: 1484 default:
1485 break; 1485 break;
1486 } 1486 }
1487 goto out; 1487 goto out;
1488 } 1488 }
1489 res = d_add_unique(dentry, inode); 1489 res = d_add_unique(dentry, inode);
1490 if (res != NULL) 1490 if (res != NULL)
1491 dentry = res; 1491 dentry = res;
1492 1492
1493 nfs_unblock_sillyrename(dentry->d_parent); 1493 nfs_unblock_sillyrename(dentry->d_parent);
1494 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1494 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1495 1495
1496 err = nfs_finish_open(ctx, dentry, file, open_flags, opened); 1496 err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
1497 1497
1498 dput(res); 1498 dput(res);
1499 out: 1499 out:
1500 return err; 1500 return err;
1501 1501
1502 no_open: 1502 no_open:
1503 res = nfs_lookup(dir, dentry, NULL); 1503 res = nfs_lookup(dir, dentry, NULL);
1504 err = PTR_ERR(res); 1504 err = PTR_ERR(res);
1505 if (IS_ERR(res)) 1505 if (IS_ERR(res))
1506 goto out; 1506 goto out;
1507 1507
1508 return finish_no_open(file, res); 1508 return finish_no_open(file, res);
1509 } 1509 }
1510 1510
1511 static int nfs4_lookup_revalidate(struct dentry *dentry, struct nameidata *nd) 1511 static int nfs4_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
1512 { 1512 {
1513 struct dentry *parent = NULL; 1513 struct dentry *parent = NULL;
1514 struct inode *inode; 1514 struct inode *inode;
1515 struct inode *dir; 1515 struct inode *dir;
1516 int ret = 0; 1516 int ret = 0;
1517 1517
1518 if (nd->flags & LOOKUP_RCU) 1518 if (nd->flags & LOOKUP_RCU)
1519 return -ECHILD; 1519 return -ECHILD;
1520 1520
1521 if (!(nd->flags & LOOKUP_OPEN) || (nd->flags & LOOKUP_DIRECTORY)) 1521 if (!(nd->flags & LOOKUP_OPEN) || (nd->flags & LOOKUP_DIRECTORY))
1522 goto no_open; 1522 goto no_open;
1523 if (d_mountpoint(dentry)) 1523 if (d_mountpoint(dentry))
1524 goto no_open; 1524 goto no_open;
1525 1525
1526 inode = dentry->d_inode; 1526 inode = dentry->d_inode;
1527 parent = dget_parent(dentry); 1527 parent = dget_parent(dentry);
1528 dir = parent->d_inode; 1528 dir = parent->d_inode;
1529 1529
1530 /* We can't create new files in nfs_open_revalidate(), so we 1530 /* We can't create new files in nfs_open_revalidate(), so we
1531 * optimize away revalidation of negative dentries. 1531 * optimize away revalidation of negative dentries.
1532 */ 1532 */
1533 if (inode == NULL) { 1533 if (inode == NULL) {
1534 if (!nfs_neg_need_reval(dir, dentry, nd)) 1534 if (!nfs_neg_need_reval(dir, dentry, nd))
1535 ret = 1; 1535 ret = 1;
1536 goto out; 1536 goto out;
1537 } 1537 }
1538 1538
1539 /* NFS only supports OPEN on regular files */ 1539 /* NFS only supports OPEN on regular files */
1540 if (!S_ISREG(inode->i_mode)) 1540 if (!S_ISREG(inode->i_mode))
1541 goto no_open_dput; 1541 goto no_open_dput;
1542 /* We cannot do exclusive creation on a positive dentry */ 1542 /* We cannot do exclusive creation on a positive dentry */
1543 if (nd && nd->flags & LOOKUP_EXCL) 1543 if (nd && nd->flags & LOOKUP_EXCL)
1544 goto no_open_dput; 1544 goto no_open_dput;
1545 1545
1546 /* Let f_op->open() actually open (and revalidate) the file */ 1546 /* Let f_op->open() actually open (and revalidate) the file */
1547 ret = 1; 1547 ret = 1;
1548 1548
1549 out: 1549 out:
1550 dput(parent); 1550 dput(parent);
1551 return ret; 1551 return ret;
1552 1552
1553 no_open_dput: 1553 no_open_dput:
1554 dput(parent); 1554 dput(parent);
1555 no_open: 1555 no_open:
1556 return nfs_lookup_revalidate(dentry, nd); 1556 return nfs_lookup_revalidate(dentry, nd);
1557 } 1557 }
1558 1558
1559 #endif /* CONFIG_NFSV4 */ 1559 #endif /* CONFIG_NFSV4 */
1560 1560
1561 /* 1561 /*
1562 * Code common to create, mkdir, and mknod. 1562 * Code common to create, mkdir, and mknod.
1563 */ 1563 */
1564 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 1564 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
1565 struct nfs_fattr *fattr) 1565 struct nfs_fattr *fattr)
1566 { 1566 {
1567 struct dentry *parent = dget_parent(dentry); 1567 struct dentry *parent = dget_parent(dentry);
1568 struct inode *dir = parent->d_inode; 1568 struct inode *dir = parent->d_inode;
1569 struct inode *inode; 1569 struct inode *inode;
1570 int error = -EACCES; 1570 int error = -EACCES;
1571 1571
1572 d_drop(dentry); 1572 d_drop(dentry);
1573 1573
1574 /* We may have been initialized further down */ 1574 /* We may have been initialized further down */
1575 if (dentry->d_inode) 1575 if (dentry->d_inode)
1576 goto out; 1576 goto out;
1577 if (fhandle->size == 0) { 1577 if (fhandle->size == 0) {
1578 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1578 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
1579 if (error) 1579 if (error)
1580 goto out_error; 1580 goto out_error;
1581 } 1581 }
1582 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1582 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1583 if (!(fattr->valid & NFS_ATTR_FATTR)) { 1583 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1584 struct nfs_server *server = NFS_SB(dentry->d_sb); 1584 struct nfs_server *server = NFS_SB(dentry->d_sb);
1585 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 1585 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
1586 if (error < 0) 1586 if (error < 0)
1587 goto out_error; 1587 goto out_error;
1588 } 1588 }
1589 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1589 inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
1590 error = PTR_ERR(inode); 1590 error = PTR_ERR(inode);
1591 if (IS_ERR(inode)) 1591 if (IS_ERR(inode))
1592 goto out_error; 1592 goto out_error;
1593 d_add(dentry, inode); 1593 d_add(dentry, inode);
1594 out: 1594 out:
1595 dput(parent); 1595 dput(parent);
1596 return 0; 1596 return 0;
1597 out_error: 1597 out_error:
1598 nfs_mark_for_revalidate(dir); 1598 nfs_mark_for_revalidate(dir);
1599 dput(parent); 1599 dput(parent);
1600 return error; 1600 return error;
1601 } 1601 }
1602 1602
1603 /* 1603 /*
1604 * Following a failed create operation, we drop the dentry rather 1604 * Following a failed create operation, we drop the dentry rather
1605 * than retain a negative dentry. This avoids a problem in the event 1605 * than retain a negative dentry. This avoids a problem in the event
1606 * that the operation succeeded on the server, but an error in the 1606 * that the operation succeeded on the server, but an error in the
1607 * reply path made it appear to have failed. 1607 * reply path made it appear to have failed.
1608 */ 1608 */
1609 static int nfs_create(struct inode *dir, struct dentry *dentry, 1609 static int nfs_create(struct inode *dir, struct dentry *dentry,
1610 umode_t mode, struct nameidata *nd) 1610 umode_t mode, struct nameidata *nd)
1611 { 1611 {
1612 struct iattr attr; 1612 struct iattr attr;
1613 int error; 1613 int error;
1614 int open_flags = O_CREAT|O_EXCL; 1614 int open_flags = O_CREAT|O_EXCL;
1615 1615
1616 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1616 dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
1617 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1617 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1618 1618
1619 attr.ia_mode = mode; 1619 attr.ia_mode = mode;
1620 attr.ia_valid = ATTR_MODE; 1620 attr.ia_valid = ATTR_MODE;
1621 1621
1622 if (nd && !(nd->flags & LOOKUP_EXCL)) 1622 if (nd && !(nd->flags & LOOKUP_EXCL))
1623 open_flags = O_CREAT; 1623 open_flags = O_CREAT;
1624 1624
1625 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags); 1625 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
1626 if (error != 0) 1626 if (error != 0)
1627 goto out_err; 1627 goto out_err;
1628 return 0; 1628 return 0;
1629 out_err: 1629 out_err:
1630 d_drop(dentry); 1630 d_drop(dentry);
1631 return error; 1631 return error;
1632 } 1632 }
1633 1633
1634 /* 1634 /*
1635 * See comments for nfs_proc_create regarding failed operations. 1635 * See comments for nfs_proc_create regarding failed operations.
1636 */ 1636 */
1637 static int 1637 static int
1638 nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev) 1638 nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1639 { 1639 {
1640 struct iattr attr; 1640 struct iattr attr;
1641 int status; 1641 int status;
1642 1642
1643 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 1643 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
1644 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1644 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1645 1645
1646 if (!new_valid_dev(rdev)) 1646 if (!new_valid_dev(rdev))
1647 return -EINVAL; 1647 return -EINVAL;
1648 1648
1649 attr.ia_mode = mode; 1649 attr.ia_mode = mode;
1650 attr.ia_valid = ATTR_MODE; 1650 attr.ia_valid = ATTR_MODE;
1651 1651
1652 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 1652 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
1653 if (status != 0) 1653 if (status != 0)
1654 goto out_err; 1654 goto out_err;
1655 return 0; 1655 return 0;
1656 out_err: 1656 out_err:
1657 d_drop(dentry); 1657 d_drop(dentry);
1658 return status; 1658 return status;
1659 } 1659 }
1660 1660
1661 /* 1661 /*
1662 * See comments for nfs_proc_create regarding failed operations. 1662 * See comments for nfs_proc_create regarding failed operations.
1663 */ 1663 */
1664 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1664 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1665 { 1665 {
1666 struct iattr attr; 1666 struct iattr attr;
1667 int error; 1667 int error;
1668 1668
1669 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 1669 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
1670 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1670 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1671 1671
1672 attr.ia_valid = ATTR_MODE; 1672 attr.ia_valid = ATTR_MODE;
1673 attr.ia_mode = mode | S_IFDIR; 1673 attr.ia_mode = mode | S_IFDIR;
1674 1674
1675 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 1675 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
1676 if (error != 0) 1676 if (error != 0)
1677 goto out_err; 1677 goto out_err;
1678 return 0; 1678 return 0;
1679 out_err: 1679 out_err:
1680 d_drop(dentry); 1680 d_drop(dentry);
1681 return error; 1681 return error;
1682 } 1682 }
1683 1683
1684 static void nfs_dentry_handle_enoent(struct dentry *dentry) 1684 static void nfs_dentry_handle_enoent(struct dentry *dentry)
1685 { 1685 {
1686 if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1686 if (dentry->d_inode != NULL && !d_unhashed(dentry))
1687 d_delete(dentry); 1687 d_delete(dentry);
1688 } 1688 }
1689 1689
1690 static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 1690 static int nfs_rmdir(struct inode *dir, struct dentry *dentry)
1691 { 1691 {
1692 int error; 1692 int error;
1693 1693
1694 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 1694 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
1695 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1695 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
1696 1696
1697 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1697 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1698 /* Ensure the VFS deletes this inode */ 1698 /* Ensure the VFS deletes this inode */
1699 if (error == 0 && dentry->d_inode != NULL) 1699 if (error == 0 && dentry->d_inode != NULL)
1700 clear_nlink(dentry->d_inode); 1700 clear_nlink(dentry->d_inode);
1701 else if (error == -ENOENT) 1701 else if (error == -ENOENT)
1702 nfs_dentry_handle_enoent(dentry); 1702 nfs_dentry_handle_enoent(dentry);
1703 1703
1704 return error; 1704 return error;
1705 } 1705 }
1706 1706
1707 /* 1707 /*
1708 * Remove a file after making sure there are no pending writes, 1708 * Remove a file after making sure there are no pending writes,
1709 * and after checking that the file has only one user. 1709 * and after checking that the file has only one user.
1710 * 1710 *
1711 * We invalidate the attribute cache and free the inode prior to the operation 1711 * We invalidate the attribute cache and free the inode prior to the operation
1712 * to avoid possible races if the server reuses the inode. 1712 * to avoid possible races if the server reuses the inode.
1713 */ 1713 */
1714 static int nfs_safe_remove(struct dentry *dentry) 1714 static int nfs_safe_remove(struct dentry *dentry)
1715 { 1715 {
1716 struct inode *dir = dentry->d_parent->d_inode; 1716 struct inode *dir = dentry->d_parent->d_inode;
1717 struct inode *inode = dentry->d_inode; 1717 struct inode *inode = dentry->d_inode;
1718 int error = -EBUSY; 1718 int error = -EBUSY;
1719 1719
1720 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 1720 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
1721 dentry->d_parent->d_name.name, dentry->d_name.name); 1721 dentry->d_parent->d_name.name, dentry->d_name.name);
1722 1722
1723 /* If the dentry was sillyrenamed, we simply call d_delete() */ 1723 /* If the dentry was sillyrenamed, we simply call d_delete() */
1724 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1724 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1725 error = 0; 1725 error = 0;
1726 goto out; 1726 goto out;
1727 } 1727 }
1728 1728
1729 if (inode != NULL) { 1729 if (inode != NULL) {
1730 nfs_inode_return_delegation(inode); 1730 nfs_inode_return_delegation(inode);
1731 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1731 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1732 /* The VFS may want to delete this inode */ 1732 /* The VFS may want to delete this inode */
1733 if (error == 0) 1733 if (error == 0)
1734 nfs_drop_nlink(inode); 1734 nfs_drop_nlink(inode);
1735 nfs_mark_for_revalidate(inode); 1735 nfs_mark_for_revalidate(inode);
1736 } else 1736 } else
1737 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1737 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
1738 if (error == -ENOENT) 1738 if (error == -ENOENT)
1739 nfs_dentry_handle_enoent(dentry); 1739 nfs_dentry_handle_enoent(dentry);
1740 out: 1740 out:
1741 return error; 1741 return error;
1742 } 1742 }
1743 1743
1744 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 1744 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode
1745 * belongs to an active ".nfs..." file and we return -EBUSY. 1745 * belongs to an active ".nfs..." file and we return -EBUSY.
1746 * 1746 *
1747 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 1747 * If sillyrename() returns 0, we do nothing, otherwise we unlink.
1748 */ 1748 */
1749 static int nfs_unlink(struct inode *dir, struct dentry *dentry) 1749 static int nfs_unlink(struct inode *dir, struct dentry *dentry)
1750 { 1750 {
1751 int error; 1751 int error;
1752 int need_rehash = 0; 1752 int need_rehash = 0;
1753 1753
1754 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 1754 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
1755 dir->i_ino, dentry->d_name.name); 1755 dir->i_ino, dentry->d_name.name);
1756 1756
1757 spin_lock(&dentry->d_lock); 1757 spin_lock(&dentry->d_lock);
1758 if (dentry->d_count > 1) { 1758 if (dentry->d_count > 1) {
1759 spin_unlock(&dentry->d_lock); 1759 spin_unlock(&dentry->d_lock);
1760 /* Start asynchronous writeout of the inode */ 1760 /* Start asynchronous writeout of the inode */
1761 write_inode_now(dentry->d_inode, 0); 1761 write_inode_now(dentry->d_inode, 0);
1762 error = nfs_sillyrename(dir, dentry); 1762 error = nfs_sillyrename(dir, dentry);
1763 return error; 1763 return error;
1764 } 1764 }
1765 if (!d_unhashed(dentry)) { 1765 if (!d_unhashed(dentry)) {
1766 __d_drop(dentry); 1766 __d_drop(dentry);
1767 need_rehash = 1; 1767 need_rehash = 1;
1768 } 1768 }
1769 spin_unlock(&dentry->d_lock); 1769 spin_unlock(&dentry->d_lock);
1770 error = nfs_safe_remove(dentry); 1770 error = nfs_safe_remove(dentry);
1771 if (!error || error == -ENOENT) { 1771 if (!error || error == -ENOENT) {
1772 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1772 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1773 } else if (need_rehash) 1773 } else if (need_rehash)
1774 d_rehash(dentry); 1774 d_rehash(dentry);
1775 return error; 1775 return error;
1776 } 1776 }
1777 1777
1778 /* 1778 /*
1779 * To create a symbolic link, most file systems instantiate a new inode, 1779 * To create a symbolic link, most file systems instantiate a new inode,
1780 * add a page to it containing the path, then write it out to the disk 1780 * add a page to it containing the path, then write it out to the disk
1781 * using prepare_write/commit_write. 1781 * using prepare_write/commit_write.
1782 * 1782 *
1783 * Unfortunately the NFS client can't create the in-core inode first 1783 * Unfortunately the NFS client can't create the in-core inode first
1784 * because it needs a file handle to create an in-core inode (see 1784 * because it needs a file handle to create an in-core inode (see
1785 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1785 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the
1786 * symlink request has completed on the server. 1786 * symlink request has completed on the server.
1787 * 1787 *
1788 * So instead we allocate a raw page, copy the symname into it, then do 1788 * So instead we allocate a raw page, copy the symname into it, then do
1789 * the SYMLINK request with the page as the buffer. If it succeeds, we 1789 * the SYMLINK request with the page as the buffer. If it succeeds, we
1790 * now have a new file handle and can instantiate an in-core NFS inode 1790 * now have a new file handle and can instantiate an in-core NFS inode
1791 * and move the raw page into its mapping. 1791 * and move the raw page into its mapping.
1792 */ 1792 */
1793 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 1793 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1794 { 1794 {
1795 struct pagevec lru_pvec; 1795 struct pagevec lru_pvec;
1796 struct page *page; 1796 struct page *page;
1797 char *kaddr; 1797 char *kaddr;
1798 struct iattr attr; 1798 struct iattr attr;
1799 unsigned int pathlen = strlen(symname); 1799 unsigned int pathlen = strlen(symname);
1800 int error; 1800 int error;
1801 1801
1802 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 1802 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
1803 dir->i_ino, dentry->d_name.name, symname); 1803 dir->i_ino, dentry->d_name.name, symname);
1804 1804
1805 if (pathlen > PAGE_SIZE) 1805 if (pathlen > PAGE_SIZE)
1806 return -ENAMETOOLONG; 1806 return -ENAMETOOLONG;
1807 1807
1808 attr.ia_mode = S_IFLNK | S_IRWXUGO; 1808 attr.ia_mode = S_IFLNK | S_IRWXUGO;
1809 attr.ia_valid = ATTR_MODE; 1809 attr.ia_valid = ATTR_MODE;
1810 1810
1811 page = alloc_page(GFP_HIGHUSER); 1811 page = alloc_page(GFP_HIGHUSER);
1812 if (!page) 1812 if (!page)
1813 return -ENOMEM; 1813 return -ENOMEM;
1814 1814
1815 kaddr = kmap_atomic(page); 1815 kaddr = kmap_atomic(page);
1816 memcpy(kaddr, symname, pathlen); 1816 memcpy(kaddr, symname, pathlen);
1817 if (pathlen < PAGE_SIZE) 1817 if (pathlen < PAGE_SIZE)
1818 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1818 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
1819 kunmap_atomic(kaddr); 1819 kunmap_atomic(kaddr);
1820 1820
1821 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1821 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
1822 if (error != 0) { 1822 if (error != 0) {
1823 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1823 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
1824 dir->i_sb->s_id, dir->i_ino, 1824 dir->i_sb->s_id, dir->i_ino,
1825 dentry->d_name.name, symname, error); 1825 dentry->d_name.name, symname, error);
1826 d_drop(dentry); 1826 d_drop(dentry);
1827 __free_page(page); 1827 __free_page(page);
1828 return error; 1828 return error;
1829 } 1829 }
1830 1830
1831 /* 1831 /*
1832 * No big deal if we can't add this page to the page cache here. 1832 * No big deal if we can't add this page to the page cache here.
1833 * READLINK will get the missing page from the server if needed. 1833 * READLINK will get the missing page from the server if needed.
1834 */ 1834 */
1835 pagevec_init(&lru_pvec, 0); 1835 pagevec_init(&lru_pvec, 0);
1836 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1836 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0,
1837 GFP_KERNEL)) { 1837 GFP_KERNEL)) {
1838 pagevec_add(&lru_pvec, page); 1838 pagevec_add(&lru_pvec, page);
1839 pagevec_lru_add_file(&lru_pvec); 1839 pagevec_lru_add_file(&lru_pvec);
1840 SetPageUptodate(page); 1840 SetPageUptodate(page);
1841 unlock_page(page); 1841 unlock_page(page);
1842 } else 1842 } else
1843 __free_page(page); 1843 __free_page(page);
1844 1844
1845 return 0; 1845 return 0;
1846 } 1846 }
1847 1847
1848 static int 1848 static int
1849 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1849 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1850 { 1850 {
1851 struct inode *inode = old_dentry->d_inode; 1851 struct inode *inode = old_dentry->d_inode;
1852 int error; 1852 int error;
1853 1853
1854 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 1854 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
1855 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1855 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1856 dentry->d_parent->d_name.name, dentry->d_name.name); 1856 dentry->d_parent->d_name.name, dentry->d_name.name);
1857 1857
1858 nfs_inode_return_delegation(inode); 1858 nfs_inode_return_delegation(inode);
1859 1859
1860 d_drop(dentry); 1860 d_drop(dentry);
1861 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1861 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
1862 if (error == 0) { 1862 if (error == 0) {
1863 ihold(inode); 1863 ihold(inode);
1864 d_add(dentry, inode); 1864 d_add(dentry, inode);
1865 } 1865 }
1866 return error; 1866 return error;
1867 } 1867 }
1868 1868
1869 /* 1869 /*
1870 * RENAME 1870 * RENAME
1871 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 1871 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1872 * different file handle for the same inode after a rename (e.g. when 1872 * different file handle for the same inode after a rename (e.g. when
1873 * moving to a different directory). A fail-safe method to do so would 1873 * moving to a different directory). A fail-safe method to do so would
1874 * be to look up old_dir/old_name, create a link to new_dir/new_name and 1874 * be to look up old_dir/old_name, create a link to new_dir/new_name and
1875 * rename the old file using the sillyrename stuff. This way, the original 1875 * rename the old file using the sillyrename stuff. This way, the original
1876 * file in old_dir will go away when the last process iput()s the inode. 1876 * file in old_dir will go away when the last process iput()s the inode.
1877 * 1877 *
1878 * FIXED. 1878 * FIXED.
1879 * 1879 *
1880 * It actually works quite well. One needs to have the possibility for 1880 * It actually works quite well. One needs to have the possibility for
1881 * at least one ".nfs..." file in each directory the file ever gets 1881 * at least one ".nfs..." file in each directory the file ever gets
1882 * moved or linked to which happens automagically with the new 1882 * moved or linked to which happens automagically with the new
1883 * implementation that only depends on the dcache stuff instead of 1883 * implementation that only depends on the dcache stuff instead of
1884 * using the inode layer 1884 * using the inode layer
1885 * 1885 *
1886 * Unfortunately, things are a little more complicated than indicated 1886 * Unfortunately, things are a little more complicated than indicated
1887 * above. For a cross-directory move, we want to make sure we can get 1887 * above. For a cross-directory move, we want to make sure we can get
1888 * rid of the old inode after the operation. This means there must be 1888 * rid of the old inode after the operation. This means there must be
1889 * no pending writes (if it's a file), and the use count must be 1. 1889 * no pending writes (if it's a file), and the use count must be 1.
1890 * If these conditions are met, we can drop the dentries before doing 1890 * If these conditions are met, we can drop the dentries before doing
1891 * the rename. 1891 * the rename.
1892 */ 1892 */
1893 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1893 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1894 struct inode *new_dir, struct dentry *new_dentry) 1894 struct inode *new_dir, struct dentry *new_dentry)
1895 { 1895 {
1896 struct inode *old_inode = old_dentry->d_inode; 1896 struct inode *old_inode = old_dentry->d_inode;
1897 struct inode *new_inode = new_dentry->d_inode; 1897 struct inode *new_inode = new_dentry->d_inode;
1898 struct dentry *dentry = NULL, *rehash = NULL; 1898 struct dentry *dentry = NULL, *rehash = NULL;
1899 int error = -EBUSY; 1899 int error = -EBUSY;
1900 1900
1901 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 1901 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
1902 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1902 old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
1903 new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 1903 new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
1904 new_dentry->d_count); 1904 new_dentry->d_count);
1905 1905
1906 /* 1906 /*
1907 * For non-directories, check whether the target is busy and if so, 1907 * For non-directories, check whether the target is busy and if so,
1908 * make a copy of the dentry and then do a silly-rename. If the 1908 * make a copy of the dentry and then do a silly-rename. If the
1909 * silly-rename succeeds, the copied dentry is hashed and becomes 1909 * silly-rename succeeds, the copied dentry is hashed and becomes
1910 * the new target. 1910 * the new target.
1911 */ 1911 */
1912 if (new_inode && !S_ISDIR(new_inode->i_mode)) { 1912 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1913 /* 1913 /*
1914 * To prevent any new references to the target during the 1914 * To prevent any new references to the target during the
1915 * rename, we unhash the dentry in advance. 1915 * rename, we unhash the dentry in advance.
1916 */ 1916 */
1917 if (!d_unhashed(new_dentry)) { 1917 if (!d_unhashed(new_dentry)) {
1918 d_drop(new_dentry); 1918 d_drop(new_dentry);
1919 rehash = new_dentry; 1919 rehash = new_dentry;
1920 } 1920 }
1921 1921
1922 if (new_dentry->d_count > 2) { 1922 if (new_dentry->d_count > 2) {
1923 int err; 1923 int err;
1924 1924
1925 /* copy the target dentry's name */ 1925 /* copy the target dentry's name */
1926 dentry = d_alloc(new_dentry->d_parent, 1926 dentry = d_alloc(new_dentry->d_parent,
1927 &new_dentry->d_name); 1927 &new_dentry->d_name);
1928 if (!dentry) 1928 if (!dentry)
1929 goto out; 1929 goto out;
1930 1930
1931 /* silly-rename the existing target ... */ 1931 /* silly-rename the existing target ... */
1932 err = nfs_sillyrename(new_dir, new_dentry); 1932 err = nfs_sillyrename(new_dir, new_dentry);
1933 if (err) 1933 if (err)
1934 goto out; 1934 goto out;
1935 1935
1936 new_dentry = dentry; 1936 new_dentry = dentry;
1937 rehash = NULL; 1937 rehash = NULL;
1938 new_inode = NULL; 1938 new_inode = NULL;
1939 } 1939 }
1940 } 1940 }
1941 1941
1942 nfs_inode_return_delegation(old_inode); 1942 nfs_inode_return_delegation(old_inode);
1943 if (new_inode != NULL) 1943 if (new_inode != NULL)
1944 nfs_inode_return_delegation(new_inode); 1944 nfs_inode_return_delegation(new_inode);
1945 1945
1946 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1946 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,
1947 new_dir, &new_dentry->d_name); 1947 new_dir, &new_dentry->d_name);
1948 nfs_mark_for_revalidate(old_inode); 1948 nfs_mark_for_revalidate(old_inode);
1949 out: 1949 out:
1950 if (rehash) 1950 if (rehash)
1951 d_rehash(rehash); 1951 d_rehash(rehash);
1952 if (!error) { 1952 if (!error) {
1953 if (new_inode != NULL) 1953 if (new_inode != NULL)
1954 nfs_drop_nlink(new_inode); 1954 nfs_drop_nlink(new_inode);
1955 d_move(old_dentry, new_dentry); 1955 d_move(old_dentry, new_dentry);
1956 nfs_set_verifier(new_dentry, 1956 nfs_set_verifier(new_dentry,
1957 nfs_save_change_attribute(new_dir)); 1957 nfs_save_change_attribute(new_dir));
1958 } else if (error == -ENOENT) 1958 } else if (error == -ENOENT)
1959 nfs_dentry_handle_enoent(old_dentry); 1959 nfs_dentry_handle_enoent(old_dentry);
1960 1960
1961 /* new dentry created? */ 1961 /* new dentry created? */
1962 if (dentry) 1962 if (dentry)
1963 dput(dentry); 1963 dput(dentry);
1964 return error; 1964 return error;
1965 } 1965 }
1966 1966
1967 static DEFINE_SPINLOCK(nfs_access_lru_lock); 1967 static DEFINE_SPINLOCK(nfs_access_lru_lock);
1968 static LIST_HEAD(nfs_access_lru_list); 1968 static LIST_HEAD(nfs_access_lru_list);
1969 static atomic_long_t nfs_access_nr_entries; 1969 static atomic_long_t nfs_access_nr_entries;
1970 1970
1971 static void nfs_access_free_entry(struct nfs_access_entry *entry) 1971 static void nfs_access_free_entry(struct nfs_access_entry *entry)
1972 { 1972 {
1973 put_rpccred(entry->cred); 1973 put_rpccred(entry->cred);
1974 kfree(entry); 1974 kfree(entry);
1975 smp_mb__before_atomic_dec(); 1975 smp_mb__before_atomic_dec();
1976 atomic_long_dec(&nfs_access_nr_entries); 1976 atomic_long_dec(&nfs_access_nr_entries);
1977 smp_mb__after_atomic_dec(); 1977 smp_mb__after_atomic_dec();
1978 } 1978 }
1979 1979
1980 static void nfs_access_free_list(struct list_head *head) 1980 static void nfs_access_free_list(struct list_head *head)
1981 { 1981 {
1982 struct nfs_access_entry *cache; 1982 struct nfs_access_entry *cache;
1983 1983
1984 while (!list_empty(head)) { 1984 while (!list_empty(head)) {
1985 cache = list_entry(head->next, struct nfs_access_entry, lru); 1985 cache = list_entry(head->next, struct nfs_access_entry, lru);
1986 list_del(&cache->lru); 1986 list_del(&cache->lru);
1987 nfs_access_free_entry(cache); 1987 nfs_access_free_entry(cache);
1988 } 1988 }
1989 } 1989 }
1990 1990
1991 int nfs_access_cache_shrinker(struct shrinker *shrink, 1991 int nfs_access_cache_shrinker(struct shrinker *shrink,
1992 struct shrink_control *sc) 1992 struct shrink_control *sc)
1993 { 1993 {
1994 LIST_HEAD(head); 1994 LIST_HEAD(head);
1995 struct nfs_inode *nfsi, *next; 1995 struct nfs_inode *nfsi, *next;
1996 struct nfs_access_entry *cache; 1996 struct nfs_access_entry *cache;
1997 int nr_to_scan = sc->nr_to_scan; 1997 int nr_to_scan = sc->nr_to_scan;
1998 gfp_t gfp_mask = sc->gfp_mask; 1998 gfp_t gfp_mask = sc->gfp_mask;
1999 1999
2000 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 2000 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2001 return (nr_to_scan == 0) ? 0 : -1; 2001 return (nr_to_scan == 0) ? 0 : -1;
2002 2002
2003 spin_lock(&nfs_access_lru_lock); 2003 spin_lock(&nfs_access_lru_lock);
2004 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 2004 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
2005 struct inode *inode; 2005 struct inode *inode;
2006 2006
2007 if (nr_to_scan-- == 0) 2007 if (nr_to_scan-- == 0)
2008 break; 2008 break;
2009 inode = &nfsi->vfs_inode; 2009 inode = &nfsi->vfs_inode;
2010 spin_lock(&inode->i_lock); 2010 spin_lock(&inode->i_lock);
2011 if (list_empty(&nfsi->access_cache_entry_lru)) 2011 if (list_empty(&nfsi->access_cache_entry_lru))
2012 goto remove_lru_entry; 2012 goto remove_lru_entry;
2013 cache = list_entry(nfsi->access_cache_entry_lru.next, 2013 cache = list_entry(nfsi->access_cache_entry_lru.next,
2014 struct nfs_access_entry, lru); 2014 struct nfs_access_entry, lru);
2015 list_move(&cache->lru, &head); 2015 list_move(&cache->lru, &head);
2016 rb_erase(&cache->rb_node, &nfsi->access_cache); 2016 rb_erase(&cache->rb_node, &nfsi->access_cache);
2017 if (!list_empty(&nfsi->access_cache_entry_lru)) 2017 if (!list_empty(&nfsi->access_cache_entry_lru))
2018 list_move_tail(&nfsi->access_cache_inode_lru, 2018 list_move_tail(&nfsi->access_cache_inode_lru,
2019 &nfs_access_lru_list); 2019 &nfs_access_lru_list);
2020 else { 2020 else {
2021 remove_lru_entry: 2021 remove_lru_entry:
2022 list_del_init(&nfsi->access_cache_inode_lru); 2022 list_del_init(&nfsi->access_cache_inode_lru);
2023 smp_mb__before_clear_bit(); 2023 smp_mb__before_clear_bit();
2024 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 2024 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
2025 smp_mb__after_clear_bit(); 2025 smp_mb__after_clear_bit();
2026 } 2026 }
2027 spin_unlock(&inode->i_lock); 2027 spin_unlock(&inode->i_lock);
2028 } 2028 }
2029 spin_unlock(&nfs_access_lru_lock); 2029 spin_unlock(&nfs_access_lru_lock);
2030 nfs_access_free_list(&head); 2030 nfs_access_free_list(&head);
2031 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 2031 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure;
2032 } 2032 }
2033 2033
2034 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 2034 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
2035 { 2035 {
2036 struct rb_root *root_node = &nfsi->access_cache; 2036 struct rb_root *root_node = &nfsi->access_cache;
2037 struct rb_node *n; 2037 struct rb_node *n;
2038 struct nfs_access_entry *entry; 2038 struct nfs_access_entry *entry;
2039 2039
2040 /* Unhook entries from the cache */ 2040 /* Unhook entries from the cache */
2041 while ((n = rb_first(root_node)) != NULL) { 2041 while ((n = rb_first(root_node)) != NULL) {
2042 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2042 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2043 rb_erase(n, root_node); 2043 rb_erase(n, root_node);
2044 list_move(&entry->lru, head); 2044 list_move(&entry->lru, head);
2045 } 2045 }
2046 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 2046 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
2047 } 2047 }
2048 2048
2049 void nfs_access_zap_cache(struct inode *inode) 2049 void nfs_access_zap_cache(struct inode *inode)
2050 { 2050 {
2051 LIST_HEAD(head); 2051 LIST_HEAD(head);
2052 2052
2053 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 2053 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2054 return; 2054 return;
2055 /* Remove from global LRU init */ 2055 /* Remove from global LRU init */
2056 spin_lock(&nfs_access_lru_lock); 2056 spin_lock(&nfs_access_lru_lock);
2057 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2057 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2058 list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2058 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
2059 2059
2060 spin_lock(&inode->i_lock); 2060 spin_lock(&inode->i_lock);
2061 __nfs_access_zap_cache(NFS_I(inode), &head); 2061 __nfs_access_zap_cache(NFS_I(inode), &head);
2062 spin_unlock(&inode->i_lock); 2062 spin_unlock(&inode->i_lock);
2063 spin_unlock(&nfs_access_lru_lock); 2063 spin_unlock(&nfs_access_lru_lock);
2064 nfs_access_free_list(&head); 2064 nfs_access_free_list(&head);
2065 } 2065 }
2066 2066
2067 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 2067 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2068 { 2068 {
2069 struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 2069 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2070 struct nfs_access_entry *entry; 2070 struct nfs_access_entry *entry;
2071 2071
2072 while (n != NULL) { 2072 while (n != NULL) {
2073 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2073 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2074 2074
2075 if (cred < entry->cred) 2075 if (cred < entry->cred)
2076 n = n->rb_left; 2076 n = n->rb_left;
2077 else if (cred > entry->cred) 2077 else if (cred > entry->cred)
2078 n = n->rb_right; 2078 n = n->rb_right;
2079 else 2079 else
2080 return entry; 2080 return entry;
2081 } 2081 }
2082 return NULL; 2082 return NULL;
2083 } 2083 }
2084 2084
2085 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 2085 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2086 { 2086 {
2087 struct nfs_inode *nfsi = NFS_I(inode); 2087 struct nfs_inode *nfsi = NFS_I(inode);
2088 struct nfs_access_entry *cache; 2088 struct nfs_access_entry *cache;
2089 int err = -ENOENT; 2089 int err = -ENOENT;
2090 2090
2091 spin_lock(&inode->i_lock); 2091 spin_lock(&inode->i_lock);
2092 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2092 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2093 goto out_zap; 2093 goto out_zap;
2094 cache = nfs_access_search_rbtree(inode, cred); 2094 cache = nfs_access_search_rbtree(inode, cred);
2095 if (cache == NULL) 2095 if (cache == NULL)
2096 goto out; 2096 goto out;
2097 if (!nfs_have_delegated_attributes(inode) && 2097 if (!nfs_have_delegated_attributes(inode) &&
2098 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 2098 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
2099 goto out_stale; 2099 goto out_stale;
2100 res->jiffies = cache->jiffies; 2100 res->jiffies = cache->jiffies;
2101 res->cred = cache->cred; 2101 res->cred = cache->cred;
2102 res->mask = cache->mask; 2102 res->mask = cache->mask;
2103 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 2103 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
2104 err = 0; 2104 err = 0;
2105 out: 2105 out:
2106 spin_unlock(&inode->i_lock); 2106 spin_unlock(&inode->i_lock);
2107 return err; 2107 return err;
2108 out_stale: 2108 out_stale:
2109 rb_erase(&cache->rb_node, &nfsi->access_cache); 2109 rb_erase(&cache->rb_node, &nfsi->access_cache);
2110 list_del(&cache->lru); 2110 list_del(&cache->lru);
2111 spin_unlock(&inode->i_lock); 2111 spin_unlock(&inode->i_lock);
2112 nfs_access_free_entry(cache); 2112 nfs_access_free_entry(cache);
2113 return -ENOENT; 2113 return -ENOENT;
2114 out_zap: 2114 out_zap:
2115 spin_unlock(&inode->i_lock); 2115 spin_unlock(&inode->i_lock);
2116 nfs_access_zap_cache(inode); 2116 nfs_access_zap_cache(inode);
2117 return -ENOENT; 2117 return -ENOENT;
2118 } 2118 }
2119 2119
2120 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 2120 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2121 { 2121 {
2122 struct nfs_inode *nfsi = NFS_I(inode); 2122 struct nfs_inode *nfsi = NFS_I(inode);
2123 struct rb_root *root_node = &nfsi->access_cache; 2123 struct rb_root *root_node = &nfsi->access_cache;
2124 struct rb_node **p = &root_node->rb_node; 2124 struct rb_node **p = &root_node->rb_node;
2125 struct rb_node *parent = NULL; 2125 struct rb_node *parent = NULL;
2126 struct nfs_access_entry *entry; 2126 struct nfs_access_entry *entry;
2127 2127
2128 spin_lock(&inode->i_lock); 2128 spin_lock(&inode->i_lock);
2129 while (*p != NULL) { 2129 while (*p != NULL) {
2130 parent = *p; 2130 parent = *p;
2131 entry = rb_entry(parent, struct nfs_access_entry, rb_node); 2131 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2132 2132
2133 if (set->cred < entry->cred) 2133 if (set->cred < entry->cred)
2134 p = &parent->rb_left; 2134 p = &parent->rb_left;
2135 else if (set->cred > entry->cred) 2135 else if (set->cred > entry->cred)
2136 p = &parent->rb_right; 2136 p = &parent->rb_right;
2137 else 2137 else
2138 goto found; 2138 goto found;
2139 } 2139 }
2140 rb_link_node(&set->rb_node, parent, p); 2140 rb_link_node(&set->rb_node, parent, p);
2141 rb_insert_color(&set->rb_node, root_node); 2141 rb_insert_color(&set->rb_node, root_node);
2142 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2142 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2143 spin_unlock(&inode->i_lock); 2143 spin_unlock(&inode->i_lock);
2144 return; 2144 return;
2145 found: 2145 found:
2146 rb_replace_node(parent, &set->rb_node, root_node); 2146 rb_replace_node(parent, &set->rb_node, root_node);
2147 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2147 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2148 list_del(&entry->lru); 2148 list_del(&entry->lru);
2149 spin_unlock(&inode->i_lock); 2149 spin_unlock(&inode->i_lock);
2150 nfs_access_free_entry(entry); 2150 nfs_access_free_entry(entry);
2151 } 2151 }
2152 2152
2153 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 2153 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
2154 { 2154 {
2155 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 2155 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2156 if (cache == NULL) 2156 if (cache == NULL)
2157 return; 2157 return;
2158 RB_CLEAR_NODE(&cache->rb_node); 2158 RB_CLEAR_NODE(&cache->rb_node);
2159 cache->jiffies = set->jiffies; 2159 cache->jiffies = set->jiffies;
2160 cache->cred = get_rpccred(set->cred); 2160 cache->cred = get_rpccred(set->cred);
2161 cache->mask = set->mask; 2161 cache->mask = set->mask;
2162 2162
2163 nfs_access_add_rbtree(inode, cache); 2163 nfs_access_add_rbtree(inode, cache);
2164 2164
2165 /* Update accounting */ 2165 /* Update accounting */
2166 smp_mb__before_atomic_inc(); 2166 smp_mb__before_atomic_inc();
2167 atomic_long_inc(&nfs_access_nr_entries); 2167 atomic_long_inc(&nfs_access_nr_entries);
2168 smp_mb__after_atomic_inc(); 2168 smp_mb__after_atomic_inc();
2169 2169
2170 /* Add inode to global LRU list */ 2170 /* Add inode to global LRU list */
2171 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2171 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
2172 spin_lock(&nfs_access_lru_lock); 2172 spin_lock(&nfs_access_lru_lock);
2173 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2173 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2174 list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 2174 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2175 &nfs_access_lru_list); 2175 &nfs_access_lru_list);
2176 spin_unlock(&nfs_access_lru_lock); 2176 spin_unlock(&nfs_access_lru_lock);
2177 } 2177 }
2178 } 2178 }
2179 2179
2180 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 2180 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2181 { 2181 {
2182 struct nfs_access_entry cache; 2182 struct nfs_access_entry cache;
2183 int status; 2183 int status;
2184 2184
2185 status = nfs_access_get_cached(inode, cred, &cache); 2185 status = nfs_access_get_cached(inode, cred, &cache);
2186 if (status == 0) 2186 if (status == 0)
2187 goto out; 2187 goto out;
2188 2188
2189 /* Be clever: ask server to check for all possible rights */ 2189 /* Be clever: ask server to check for all possible rights */
2190 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 2190 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2191 cache.cred = cred; 2191 cache.cred = cred;
2192 cache.jiffies = jiffies; 2192 cache.jiffies = jiffies;
2193 status = NFS_PROTO(inode)->access(inode, &cache); 2193 status = NFS_PROTO(inode)->access(inode, &cache);
2194 if (status != 0) { 2194 if (status != 0) {
2195 if (status == -ESTALE) { 2195 if (status == -ESTALE) {
2196 nfs_zap_caches(inode); 2196 nfs_zap_caches(inode);
2197 if (!S_ISDIR(inode->i_mode)) 2197 if (!S_ISDIR(inode->i_mode))
2198 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2198 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2199 } 2199 }
2200 return status; 2200 return status;
2201 } 2201 }
2202 nfs_access_add_cache(inode, &cache); 2202 nfs_access_add_cache(inode, &cache);
2203 out: 2203 out:
2204 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2204 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2205 return 0; 2205 return 0;
2206 return -EACCES; 2206 return -EACCES;
2207 } 2207 }
2208 2208
2209 static int nfs_open_permission_mask(int openflags) 2209 static int nfs_open_permission_mask(int openflags)
2210 { 2210 {
2211 int mask = 0; 2211 int mask = 0;
2212 2212
2213 if ((openflags & O_ACCMODE) != O_WRONLY) 2213 if ((openflags & O_ACCMODE) != O_WRONLY)
2214 mask |= MAY_READ; 2214 mask |= MAY_READ;
2215 if ((openflags & O_ACCMODE) != O_RDONLY) 2215 if ((openflags & O_ACCMODE) != O_RDONLY)
2216 mask |= MAY_WRITE; 2216 mask |= MAY_WRITE;
2217 if (openflags & __FMODE_EXEC) 2217 if (openflags & __FMODE_EXEC)
2218 mask |= MAY_EXEC; 2218 mask |= MAY_EXEC;
2219 return mask; 2219 return mask;
2220 } 2220 }
2221 2221
2222 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2222 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2223 { 2223 {
2224 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2224 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2225 } 2225 }
2226 2226
2227 int nfs_permission(struct inode *inode, int mask) 2227 int nfs_permission(struct inode *inode, int mask)
2228 { 2228 {
2229 struct rpc_cred *cred; 2229 struct rpc_cred *cred;
2230 int res = 0; 2230 int res = 0;
2231 2231
2232 if (mask & MAY_NOT_BLOCK) 2232 if (mask & MAY_NOT_BLOCK)
2233 return -ECHILD; 2233 return -ECHILD;
2234 2234
2235 nfs_inc_stats(inode, NFSIOS_VFSACCESS); 2235 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2236 2236
2237 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2237 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
2238 goto out; 2238 goto out;
2239 /* Is this sys_access() ? */ 2239 /* Is this sys_access() ? */
2240 if (mask & (MAY_ACCESS | MAY_CHDIR)) 2240 if (mask & (MAY_ACCESS | MAY_CHDIR))
2241 goto force_lookup; 2241 goto force_lookup;
2242 2242
2243 switch (inode->i_mode & S_IFMT) { 2243 switch (inode->i_mode & S_IFMT) {
2244 case S_IFLNK: 2244 case S_IFLNK:
2245 goto out; 2245 goto out;
2246 case S_IFREG: 2246 case S_IFREG:
2247 /* NFSv4 has atomic_open... */ 2247 /* NFSv4 has atomic_open... */
2248 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 2248 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)
2249 && (mask & MAY_OPEN) 2249 && (mask & MAY_OPEN)
2250 && !(mask & MAY_EXEC)) 2250 && !(mask & MAY_EXEC))
2251 goto out; 2251 goto out;
2252 break; 2252 break;
2253 case S_IFDIR: 2253 case S_IFDIR:
2254 /* 2254 /*
2255 * Optimize away all write operations, since the server 2255 * Optimize away all write operations, since the server
2256 * will check permissions when we perform the op. 2256 * will check permissions when we perform the op.
2257 */ 2257 */
2258 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 2258 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2259 goto out; 2259 goto out;
2260 } 2260 }
2261 2261
2262 force_lookup: 2262 force_lookup:
2263 if (!NFS_PROTO(inode)->access) 2263 if (!NFS_PROTO(inode)->access)
2264 goto out_notsup; 2264 goto out_notsup;
2265 2265
2266 cred = rpc_lookup_cred(); 2266 cred = rpc_lookup_cred();
2267 if (!IS_ERR(cred)) { 2267 if (!IS_ERR(cred)) {
2268 res = nfs_do_access(inode, cred, mask); 2268 res = nfs_do_access(inode, cred, mask);
2269 put_rpccred(cred); 2269 put_rpccred(cred);
2270 } else 2270 } else
2271 res = PTR_ERR(cred); 2271 res = PTR_ERR(cred);
2272 out: 2272 out:
2273 if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2273 if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2274 res = -EACCES; 2274 res = -EACCES;
2275 2275
2276 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 2276 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",
2277 inode->i_sb->s_id, inode->i_ino, mask, res); 2277 inode->i_sb->s_id, inode->i_ino, mask, res);
2278 return res; 2278 return res;
2279 out_notsup: 2279 out_notsup:
2280 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 2280 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2281 if (res == 0) 2281 if (res == 0)
2282 res = generic_permission(inode, mask); 2282 res = generic_permission(inode, mask);
2283 goto out; 2283 goto out;
2284 } 2284 }
2285 2285
2286 /* 2286 /*
2287 * Local variables: 2287 * Local variables:
2288 * version-control: t 2288 * version-control: t
2289 * kept-new-versions: 5 2289 * kept-new-versions: 5
2290 * End: 2290 * End:
2291 */ 2291 */
2292 2292