blob: fb499a3f21b58ed341bbe17933bd5e191c850212 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/dir.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs directory handling functions
7 *
8 * 10 Apr 1996 Added silly rename for unlink --okir
9 * 28 Sep 1996 Improved directory cache --okir
10 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de
11 * Re-implemented silly rename for unlink, newly implemented
12 * silly rename for nfs_rename() following the suggestions
13 * of Olaf Kirch (okir) found in this file.
14 * Following Linus comments on my original hack, this version
15 * depends only on the dcache stuff and doesn't touch the inode
16 * layer (iput() and friends).
17 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM
18 */
19
Bryan Schumakerddda8e02012-07-30 16:05:23 -040020#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/time.h>
22#include <linux/errno.h>
23#include <linux/stat.h>
24#include <linux/fcntl.h>
25#include <linux/string.h>
26#include <linux/kernel.h>
27#include <linux/slab.h>
28#include <linux/mm.h>
29#include <linux/sunrpc/clnt.h>
30#include <linux/nfs_fs.h>
31#include <linux/nfs_mount.h>
32#include <linux/pagemap.h>
Chuck Lever873101b2006-08-22 20:06:23 -040033#include <linux/pagevec.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/namei.h>
David Howells54ceac42006-08-22 20:06:13 -040035#include <linux/mount.h>
Mel Gormana0b8cab32013-07-03 15:02:32 -070036#include <linux/swap.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040037#include <linux/sched.h>
Catalin Marinas04e4bd12010-11-11 12:53:47 +000038#include <linux/kmemleak.h>
Aneesh Kumar K.V64c2ce82010-12-09 11:35:25 +000039#include <linux/xattr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include "delegation.h"
Chuck Lever91d5b472006-03-20 13:44:14 -050042#include "iostat.h"
Adrian Bunk4c30d562007-11-21 15:04:31 -080043#include "internal.h"
Trond Myklebustcd9a1c02010-09-17 10:56:50 -040044#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Trond Myklebustf4ce1292013-08-19 18:59:33 -040046#include "nfstrace.h"
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/* #define NFS_DEBUG_VERBOSE 1 */
49
50static int nfs_opendir(struct inode *, struct file *);
Bryan Schumaker480c2002011-03-23 14:48:29 -040051static int nfs_closedir(struct inode *, struct file *);
Al Viro23db8622013-05-17 16:34:50 -040052static int nfs_readdir(struct file *, struct dir_context *);
Josef Bacik02c24a82011-07-16 20:44:56 -040053static int nfs_fsync_dir(struct file *, loff_t, loff_t, int);
Trond Myklebustf0dd2132005-06-22 17:16:29 +000054static loff_t nfs_llseek_dir(struct file *, loff_t, int);
Trond Myklebust11de3b12010-12-01 14:17:06 -050055static void nfs_readdir_clear_array(struct page*);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080057const struct file_operations nfs_dir_operations = {
Trond Myklebustf0dd2132005-06-22 17:16:29 +000058 .llseek = nfs_llseek_dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 .read = generic_read_dir,
Al Viro9ac3d3e2016-04-28 19:52:56 -040060 .iterate_shared = nfs_readdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 .open = nfs_opendir,
Bryan Schumaker480c2002011-03-23 14:48:29 -040062 .release = nfs_closedir,
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 .fsync = nfs_fsync_dir,
64};
65
Trond Myklebust11de3b12010-12-01 14:17:06 -050066const struct address_space_operations nfs_dir_aops = {
67 .freepage = nfs_readdir_clear_array,
Bryan Schumakerd1bacf92010-09-24 14:48:42 -040068};
69
Trond Myklebust0c030802011-07-30 12:45:35 -040070static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)
Bryan Schumaker480c2002011-03-23 14:48:29 -040071{
Trond Myklebust311324a2014-02-07 17:02:08 -050072 struct nfs_inode *nfsi = NFS_I(dir);
Bryan Schumaker480c2002011-03-23 14:48:29 -040073 struct nfs_open_dir_context *ctx;
74 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
75 if (ctx != NULL) {
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -040076 ctx->duped = 0;
Trond Myklebust311324a2014-02-07 17:02:08 -050077 ctx->attr_gencount = nfsi->attr_gencount;
Bryan Schumaker480c2002011-03-23 14:48:29 -040078 ctx->dir_cookie = 0;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -040079 ctx->dup_cookie = 0;
Bryan Schumaker480c2002011-03-23 14:48:29 -040080 ctx->cred = get_rpccred(cred);
Trond Myklebust311324a2014-02-07 17:02:08 -050081 spin_lock(&dir->i_lock);
82 list_add(&ctx->list, &nfsi->open_files);
83 spin_unlock(&dir->i_lock);
Trond Myklebust0c030802011-07-30 12:45:35 -040084 return ctx;
85 }
86 return ERR_PTR(-ENOMEM);
Bryan Schumaker480c2002011-03-23 14:48:29 -040087}
88
Trond Myklebust311324a2014-02-07 17:02:08 -050089static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)
Bryan Schumaker480c2002011-03-23 14:48:29 -040090{
Trond Myklebust311324a2014-02-07 17:02:08 -050091 spin_lock(&dir->i_lock);
92 list_del(&ctx->list);
93 spin_unlock(&dir->i_lock);
Bryan Schumaker480c2002011-03-23 14:48:29 -040094 put_rpccred(ctx->cred);
95 kfree(ctx);
96}
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098/*
99 * Open file
100 */
101static int
102nfs_opendir(struct inode *inode, struct file *filp)
103{
Bryan Schumaker480c2002011-03-23 14:48:29 -0400104 int res = 0;
105 struct nfs_open_dir_context *ctx;
106 struct rpc_cred *cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Al Viro6de14722013-09-16 10:53:17 -0400108 dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);
Chuck Levercc0dd2d2008-06-11 17:55:42 -0400109
110 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500111
Bryan Schumaker480c2002011-03-23 14:48:29 -0400112 cred = rpc_lookup_cred();
113 if (IS_ERR(cred))
114 return PTR_ERR(cred);
Trond Myklebust0c030802011-07-30 12:45:35 -0400115 ctx = alloc_nfs_open_dir_context(inode, cred);
Bryan Schumaker480c2002011-03-23 14:48:29 -0400116 if (IS_ERR(ctx)) {
117 res = PTR_ERR(ctx);
118 goto out;
119 }
120 filp->private_data = ctx;
Neil Brownf5a73672010-08-10 10:20:05 -0400121 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) {
122 /* This is a mountpoint, so d_revalidate will never
123 * have been called, so we need to refresh the
124 * inode (for close-open consistency) ourselves.
125 */
126 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
127 }
Bryan Schumaker480c2002011-03-23 14:48:29 -0400128out:
129 put_rpccred(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return res;
131}
132
Bryan Schumaker480c2002011-03-23 14:48:29 -0400133static int
134nfs_closedir(struct inode *inode, struct file *filp)
135{
Al Viroa4555892014-10-21 20:11:25 -0400136 put_nfs_open_dir_context(file_inode(filp), filp->private_data);
Bryan Schumaker480c2002011-03-23 14:48:29 -0400137 return 0;
138}
139
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400140struct nfs_cache_array_entry {
141 u64 cookie;
142 u64 ino;
143 struct qstr string;
Trond Myklebust0b26a0b2010-11-20 14:26:44 -0500144 unsigned char d_type;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400145};
146
147struct nfs_cache_array {
Al Viro9ac3d3e2016-04-28 19:52:56 -0400148 atomic_t refcount;
Chuck Lever88b8e132012-03-01 17:00:23 -0500149 int size;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400150 int eof_index;
151 u64 last_cookie;
152 struct nfs_cache_array_entry array[0];
153};
154
Chuck Lever573c4e12010-12-14 14:58:11 +0000155typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156typedef struct {
157 struct file *file;
158 struct page *page;
Al Viro23db8622013-05-17 16:34:50 -0400159 struct dir_context *ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 unsigned long page_index;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000161 u64 *dir_cookie;
Trond Myklebust0aded702010-11-30 21:56:32 -0500162 u64 last_cookie;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000163 loff_t current_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 decode_dirent_t decode;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400165
Neil Brown1f4eab72007-04-16 09:35:27 +1000166 unsigned long timestamp;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400167 unsigned long gencount;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400168 unsigned int cache_entry_index;
169 unsigned int plus:1;
170 unsigned int eof:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171} nfs_readdir_descriptor_t;
172
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400173/*
174 * The caller is responsible for calling nfs_readdir_release_array(page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 */
176static
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400177struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500179 void *ptr;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400180 if (page == NULL)
181 return ERR_PTR(-EIO);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500182 ptr = kmap(page);
183 if (ptr == NULL)
184 return ERR_PTR(-ENOMEM);
185 return ptr;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400186}
187
188static
189void nfs_readdir_release_array(struct page *page)
190{
191 kunmap(page);
192}
193
194/*
195 * we are freeing strings created by nfs_add_to_readdir_array()
196 */
197static
Trond Myklebust11de3b12010-12-01 14:17:06 -0500198void nfs_readdir_clear_array(struct page *page)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400199{
Trond Myklebust11de3b12010-12-01 14:17:06 -0500200 struct nfs_cache_array *array;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400201 int i;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500202
Cong Wang2b86ce22011-11-25 23:14:33 +0800203 array = kmap_atomic(page);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400204 if (atomic_dec_and_test(&array->refcount))
205 for (i = 0; i < array->size; i++)
206 kfree(array->array[i].string.name);
Cong Wang2b86ce22011-11-25 23:14:33 +0800207 kunmap_atomic(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400208}
209
Al Viro9ac3d3e2016-04-28 19:52:56 -0400210static bool grab_page(struct page *page)
211{
212 struct nfs_cache_array *array = kmap_atomic(page);
213 bool res = atomic_inc_not_zero(&array->refcount);
214 kunmap_atomic(array);
215 return res;
216}
217
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400218/*
219 * the caller is responsible for freeing qstr.name
220 * when called by nfs_readdir_add_to_array, the strings will be freed in
221 * nfs_clear_readdir_array()
222 */
223static
Trond Myklebust4a201d62010-10-23 14:53:23 -0400224int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400225{
226 string->len = len;
227 string->name = kmemdup(name, len, GFP_KERNEL);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400228 if (string->name == NULL)
229 return -ENOMEM;
Catalin Marinas04e4bd12010-11-11 12:53:47 +0000230 /*
231 * Avoid a kmemleak false positive. The pointer to the name is stored
232 * in a page cache page which kmemleak does not scan.
233 */
234 kmemleak_not_leak(string->name);
Linus Torvalds8387ff22016-06-10 07:51:30 -0700235 string->hash = full_name_hash(NULL, name, len);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400236 return 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400237}
238
239static
240int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
241{
242 struct nfs_cache_array *array = nfs_readdir_get_array(page);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400243 struct nfs_cache_array_entry *cache_entry;
244 int ret;
245
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400246 if (IS_ERR(array))
247 return PTR_ERR(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400248
Trond Myklebust4a201d62010-10-23 14:53:23 -0400249 cache_entry = &array->array[array->size];
Trond Myklebust30200932010-11-20 15:18:22 -0500250
251 /* Check that this entry lies within the page bounds */
252 ret = -ENOSPC;
253 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
254 goto out;
255
Trond Myklebust4a201d62010-10-23 14:53:23 -0400256 cache_entry->cookie = entry->prev_cookie;
257 cache_entry->ino = entry->ino;
Trond Myklebust0b26a0b2010-11-20 14:26:44 -0500258 cache_entry->d_type = entry->d_type;
Trond Myklebust4a201d62010-10-23 14:53:23 -0400259 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
260 if (ret)
261 goto out;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400262 array->last_cookie = entry->cookie;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500263 array->size++;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500264 if (entry->eof != 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400265 array->eof_index = array->size;
Trond Myklebust4a201d62010-10-23 14:53:23 -0400266out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400267 nfs_readdir_release_array(page);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400268 return ret;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400269}
270
271static
272int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
273{
Al Viro23db8622013-05-17 16:34:50 -0400274 loff_t diff = desc->ctx->pos - desc->current_index;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400275 unsigned int index;
276
277 if (diff < 0)
278 goto out_eof;
279 if (diff >= array->size) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500280 if (array->eof_index >= 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400281 goto out_eof;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400282 return -EAGAIN;
283 }
284
285 index = (unsigned int)diff;
286 *desc->dir_cookie = array->array[index].cookie;
287 desc->cache_entry_index = index;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400288 return 0;
289out_eof:
290 desc->eof = 1;
291 return -EBADCOOKIE;
292}
293
Jeff Layton4db72b42014-01-28 13:47:46 -0500294static bool
295nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi)
296{
297 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
298 return false;
299 smp_rmb();
300 return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags);
301}
302
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400303static
304int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
305{
306 int i;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400307 loff_t new_pos;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400308 int status = -EAGAIN;
309
310 for (i = 0; i < array->size; i++) {
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400311 if (array->array[i].cookie == *desc->dir_cookie) {
Al Viro496ad9a2013-01-23 17:07:38 -0500312 struct nfs_inode *nfsi = NFS_I(file_inode(desc->file));
Trond Myklebust0c030802011-07-30 12:45:35 -0400313 struct nfs_open_dir_context *ctx = desc->file->private_data;
314
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400315 new_pos = desc->current_index + i;
Jeff Layton4db72b42014-01-28 13:47:46 -0500316 if (ctx->attr_gencount != nfsi->attr_gencount ||
317 !nfs_readdir_inode_mapping_valid(nfsi)) {
Trond Myklebust0c030802011-07-30 12:45:35 -0400318 ctx->duped = 0;
319 ctx->attr_gencount = nfsi->attr_gencount;
Al Viro23db8622013-05-17 16:34:50 -0400320 } else if (new_pos < desc->ctx->pos) {
Trond Myklebust0c030802011-07-30 12:45:35 -0400321 if (ctx->duped > 0
322 && ctx->dup_cookie == *desc->dir_cookie) {
323 if (printk_ratelimit()) {
Al Viro6de14722013-09-16 10:53:17 -0400324 pr_notice("NFS: directory %pD2 contains a readdir loop."
Trond Myklebust0c030802011-07-30 12:45:35 -0400325 "Please contact your server vendor. "
Jeff Layton9581a4a2014-04-05 08:45:57 -0400326 "The file: %.*s has duplicate cookie %llu\n",
327 desc->file, array->array[i].string.len,
328 array->array[i].string.name, *desc->dir_cookie);
Trond Myklebust0c030802011-07-30 12:45:35 -0400329 }
330 status = -ELOOP;
331 goto out;
332 }
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400333 ctx->dup_cookie = *desc->dir_cookie;
Trond Myklebust0c030802011-07-30 12:45:35 -0400334 ctx->duped = -1;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400335 }
Al Viro23db8622013-05-17 16:34:50 -0400336 desc->ctx->pos = new_pos;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400337 desc->cache_entry_index = i;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500338 return 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400339 }
340 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500341 if (array->eof_index >= 0) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500342 status = -EBADCOOKIE;
Trond Myklebust18fb5fe2010-12-07 12:41:58 -0500343 if (*desc->dir_cookie == array->last_cookie)
344 desc->eof = 1;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500345 }
Trond Myklebust0c030802011-07-30 12:45:35 -0400346out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400347 return status;
348}
349
350static
351int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
352{
353 struct nfs_cache_array *array;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500354 int status;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400355
356 array = nfs_readdir_get_array(desc->page);
357 if (IS_ERR(array)) {
358 status = PTR_ERR(array);
359 goto out;
360 }
361
362 if (*desc->dir_cookie == 0)
363 status = nfs_readdir_search_for_pos(array, desc);
364 else
365 status = nfs_readdir_search_for_cookie(array, desc);
366
Trond Myklebust47c716c2010-12-07 12:44:56 -0500367 if (status == -EAGAIN) {
Trond Myklebust0aded702010-11-30 21:56:32 -0500368 desc->last_cookie = array->last_cookie;
Trond Myklebuste47c0852011-03-23 08:43:09 -0400369 desc->current_index += array->size;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500370 desc->page_index++;
371 }
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400372 nfs_readdir_release_array(desc->page);
373out:
374 return status;
375}
376
377/* Fill a page with xdr information before transferring to the cache page */
378static
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400379int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400380 struct nfs_entry *entry, struct file *file, struct inode *inode)
381{
Bryan Schumaker480c2002011-03-23 14:48:29 -0400382 struct nfs_open_dir_context *ctx = file->private_data;
383 struct rpc_cred *cred = ctx->cred;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400384 unsigned long timestamp, gencount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 int error;
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 again:
388 timestamp = jiffies;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400389 gencount = nfs_inc_attr_generation_counter();
Miklos Szeredibe62a1a2016-03-26 16:14:39 -0400390 error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 NFS_SERVER(inode)->dtsize, desc->plus);
392 if (error < 0) {
393 /* We requested READDIRPLUS, but the server doesn't grok it */
394 if (error == -ENOTSUPP && desc->plus) {
395 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
Benny Halevy3a10c302008-01-23 08:58:59 +0200396 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 desc->plus = 0;
398 goto again;
399 }
400 goto error;
401 }
Neil Brown1f4eab72007-04-16 09:35:27 +1000402 desc->timestamp = timestamp;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400403 desc->gencount = gencount;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400404error:
405 return error;
406}
407
Chuck Lever573c4e12010-12-14 14:58:11 +0000408static int xdr_decode(nfs_readdir_descriptor_t *desc,
409 struct nfs_entry *entry, struct xdr_stream *xdr)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400410{
Chuck Lever573c4e12010-12-14 14:58:11 +0000411 int error;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400412
Chuck Lever573c4e12010-12-14 14:58:11 +0000413 error = desc->decode(xdr, entry, desc->plus);
414 if (error)
415 return error;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400416 entry->fattr->time_start = desc->timestamp;
417 entry->fattr->gencount = desc->gencount;
418 return 0;
419}
420
Trond Myklebustfa923362015-02-23 18:51:32 -0500421/* Match file and dirent using either filehandle or fileid
422 * Note: caller is responsible for checking the fsid
423 */
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400424static
425int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
426{
Trond Myklebustd8fdb472016-06-17 16:48:27 -0400427 struct inode *inode;
Trond Myklebustfa923362015-02-23 18:51:32 -0500428 struct nfs_inode *nfsi;
429
David Howells2b0143b2015-03-17 22:25:59 +0000430 if (d_really_is_negative(dentry))
431 return 0;
Trond Myklebustfa923362015-02-23 18:51:32 -0500432
Trond Myklebustd8fdb472016-06-17 16:48:27 -0400433 inode = d_inode(dentry);
434 if (is_bad_inode(inode) || NFS_STALE(inode))
435 return 0;
436
437 nfsi = NFS_I(inode);
Trond Myklebust7dc72d52016-09-22 13:38:52 -0400438 if (entry->fattr->fileid != nfsi->fileid)
439 return 0;
440 if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0)
441 return 0;
442 return 1;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400443}
444
445static
Al Viro23db8622013-05-17 16:34:50 -0400446bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400447{
448 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
449 return false;
450 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
451 return true;
Al Viro23db8622013-05-17 16:34:50 -0400452 if (ctx->pos == 0)
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400453 return true;
454 return false;
455}
456
457/*
Trond Myklebust63519fb2016-11-19 11:21:54 -0500458 * This function is called by the lookup and getattr code to request the
459 * use of readdirplus to accelerate any future lookups in the same
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400460 * directory.
461 */
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400462void nfs_advise_use_readdirplus(struct inode *dir)
463{
Trond Myklebust63519fb2016-11-19 11:21:54 -0500464 struct nfs_inode *nfsi = NFS_I(dir);
465
466 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
467 !list_empty(&nfsi->open_files))
468 set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400469}
470
Trond Myklebust311324a2014-02-07 17:02:08 -0500471/*
472 * This function is mainly for use by nfs_getattr().
473 *
474 * If this is an 'ls -l', we want to force use of readdirplus.
475 * Do this by checking if there is an active file descriptor
476 * and calling nfs_advise_use_readdirplus, then forcing a
477 * cache flush.
478 */
479void nfs_force_use_readdirplus(struct inode *dir)
480{
Trond Myklebust63519fb2016-11-19 11:21:54 -0500481 struct nfs_inode *nfsi = NFS_I(dir);
482
483 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) &&
484 !list_empty(&nfsi->open_files)) {
485 set_bit(NFS_INO_ADVISE_RDPLUS, &nfsi->flags);
Trond Myklebust79f687a32016-11-19 10:54:55 -0500486 invalidate_mapping_pages(dir->i_mapping, 0, -1);
Trond Myklebust311324a2014-02-07 17:02:08 -0500487 }
488}
489
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400490static
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400491void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
492{
Linus Torvalds26fe5752012-05-10 13:14:12 -0700493 struct qstr filename = QSTR_INIT(entry->name, entry->len);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400494 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400495 struct dentry *dentry;
496 struct dentry *alias;
David Howells2b0143b2015-03-17 22:25:59 +0000497 struct inode *dir = d_inode(parent);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400498 struct inode *inode;
David Quigleyaa9c2662013-05-22 12:50:44 -0400499 int status;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400500
Trond Myklebustfa923362015-02-23 18:51:32 -0500501 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID))
502 return;
Trond Myklebust6c441c22015-02-22 16:35:36 -0500503 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID))
504 return;
Trond Myklebust78d04af2016-09-20 14:34:24 -0400505 if (filename.len == 0)
506 return;
507 /* Validate that the name doesn't contain any illegal '\0' */
508 if (strnlen(filename.name, filename.len) != filename.len)
509 return;
510 /* ...or '/' */
511 if (strnchr(filename.name, filename.len, '/'))
512 return;
Trond Myklebust4a201d62010-10-23 14:53:23 -0400513 if (filename.name[0] == '.') {
514 if (filename.len == 1)
515 return;
516 if (filename.len == 2 && filename.name[1] == '.')
517 return;
518 }
Linus Torvalds8387ff22016-06-10 07:51:30 -0700519 filename.hash = full_name_hash(parent, filename.name, filename.len);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400520
Trond Myklebust4a201d62010-10-23 14:53:23 -0400521 dentry = d_lookup(parent, &filename);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400522again:
523 if (!dentry) {
524 dentry = d_alloc_parallel(parent, &filename, &wq);
525 if (IS_ERR(dentry))
526 return;
527 }
528 if (!d_in_lookup(dentry)) {
Trond Myklebust6c441c22015-02-22 16:35:36 -0500529 /* Is there a mountpoint here? If so, just exit */
530 if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid,
531 &entry->fattr->fsid))
532 goto out;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400533 if (nfs_same_file(dentry, entry)) {
Trond Myklebust7dc72d52016-09-22 13:38:52 -0400534 if (!entry->fh->size)
535 goto out;
Jeff Laytoncda57a12013-07-04 06:35:23 -0400536 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
David Howells2b0143b2015-03-17 22:25:59 +0000537 status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
David Quigleyaa9c2662013-05-22 12:50:44 -0400538 if (!status)
David Howells2b0143b2015-03-17 22:25:59 +0000539 nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400540 goto out;
541 } else {
Eric W. Biederman5542aa22014-02-13 09:46:25 -0800542 d_invalidate(dentry);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400543 dput(dentry);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400544 dentry = NULL;
545 goto again;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400546 }
547 }
Trond Myklebust7dc72d52016-09-22 13:38:52 -0400548 if (!entry->fh->size) {
549 d_lookup_done(dentry);
550 goto out;
551 }
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400552
David Quigley1775fd32013-05-22 12:50:42 -0400553 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
Al Viro41d28bc2014-10-12 22:24:21 -0400554 alias = d_splice_alias(inode, dentry);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400555 d_lookup_done(dentry);
556 if (alias) {
557 if (IS_ERR(alias))
558 goto out;
559 dput(dentry);
560 dentry = alias;
561 }
562 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400563out:
564 dput(dentry);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400565}
566
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400567/* Perform conversion from xdr to cache array */
568static
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500569int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
Trond Myklebust66502392011-01-08 17:45:38 -0500570 struct page **xdr_pages, struct page *page, unsigned int buflen)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400571{
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400572 struct xdr_stream stream;
Benny Halevyf7da7a12011-05-19 14:16:47 -0400573 struct xdr_buf buf;
Trond Myklebust66502392011-01-08 17:45:38 -0500574 struct page *scratch;
Bryan Schumaker99424382010-10-21 16:33:16 -0400575 struct nfs_cache_array *array;
Trond Myklebust5c346852010-11-20 12:43:45 -0500576 unsigned int count = 0;
577 int status;
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400578
Trond Myklebust66502392011-01-08 17:45:38 -0500579 scratch = alloc_page(GFP_KERNEL);
580 if (scratch == NULL)
581 return -ENOMEM;
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400582
Benjamin Coddingtonce85cfb2015-04-21 14:17:35 -0400583 if (buflen == 0)
584 goto out_nopages;
585
Benny Halevyf7da7a12011-05-19 14:16:47 -0400586 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
Trond Myklebust66502392011-01-08 17:45:38 -0500587 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
Bryan Schumaker99424382010-10-21 16:33:16 -0400588
589 do {
590 status = xdr_decode(desc, entry, &stream);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500591 if (status != 0) {
592 if (status == -EAGAIN)
593 status = 0;
Bryan Schumaker99424382010-10-21 16:33:16 -0400594 break;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500595 }
Bryan Schumaker99424382010-10-21 16:33:16 -0400596
Trond Myklebust5c346852010-11-20 12:43:45 -0500597 count++;
598
Trond Myklebust47c716c2010-12-07 12:44:56 -0500599 if (desc->plus != 0)
Miklos Szeredibe62a1a2016-03-26 16:14:39 -0400600 nfs_prime_dcache(file_dentry(desc->file), entry);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500601
602 status = nfs_readdir_add_to_array(entry, page);
603 if (status != 0)
604 break;
Bryan Schumaker99424382010-10-21 16:33:16 -0400605 } while (!entry->eof);
606
Benjamin Coddingtonce85cfb2015-04-21 14:17:35 -0400607out_nopages:
Trond Myklebust47c716c2010-12-07 12:44:56 -0500608 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
Bryan Schumaker99424382010-10-21 16:33:16 -0400609 array = nfs_readdir_get_array(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500610 if (!IS_ERR(array)) {
611 array->eof_index = array->size;
612 status = 0;
613 nfs_readdir_release_array(page);
Trond Myklebust5c346852010-11-20 12:43:45 -0500614 } else
615 status = PTR_ERR(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400616 }
Trond Myklebust66502392011-01-08 17:45:38 -0500617
618 put_page(scratch);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500619 return status;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400620}
621
622static
Anna Schumakerc7e96682015-07-13 14:01:25 -0400623void nfs_readdir_free_pages(struct page **pages, unsigned int npages)
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400624{
625 unsigned int i;
626 for (i = 0; i < npages; i++)
627 put_page(pages[i]);
628}
629
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400630/*
631 * nfs_readdir_large_page will allocate pages that must be freed with a call
Anna Schumaker0b936e32015-07-13 14:01:24 -0400632 * to nfs_readdir_free_pagearray
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400633 */
634static
Anna Schumakerc7e96682015-07-13 14:01:25 -0400635int nfs_readdir_alloc_pages(struct page **pages, unsigned int npages)
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400636{
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400637 unsigned int i;
638
639 for (i = 0; i < npages; i++) {
640 struct page *page = alloc_page(GFP_KERNEL);
641 if (page == NULL)
642 goto out_freepages;
643 pages[i] = page;
644 }
Trond Myklebust66502392011-01-08 17:45:38 -0500645 return 0;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400646
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400647out_freepages:
Anna Schumakerc7e96682015-07-13 14:01:25 -0400648 nfs_readdir_free_pages(pages, i);
Trond Myklebust66502392011-01-08 17:45:38 -0500649 return -ENOMEM;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400650}
651
652static
653int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
654{
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400655 struct page *pages[NFS_MAX_READDIR_PAGES];
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400656 struct nfs_entry entry;
657 struct file *file = desc->file;
658 struct nfs_cache_array *array;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500659 int status = -ENOMEM;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400660 unsigned int array_size = ARRAY_SIZE(pages);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400661
662 entry.prev_cookie = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500663 entry.cookie = desc->last_cookie;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400664 entry.eof = 0;
665 entry.fh = nfs_alloc_fhandle();
666 entry.fattr = nfs_alloc_fattr();
Chuck Lever573c4e12010-12-14 14:58:11 +0000667 entry.server = NFS_SERVER(inode);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400668 if (entry.fh == NULL || entry.fattr == NULL)
669 goto out;
670
David Quigley14c43f72013-05-22 12:50:43 -0400671 entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
672 if (IS_ERR(entry.label)) {
673 status = PTR_ERR(entry.label);
674 goto out;
675 }
676
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400677 array = nfs_readdir_get_array(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500678 if (IS_ERR(array)) {
679 status = PTR_ERR(array);
David Quigley14c43f72013-05-22 12:50:43 -0400680 goto out_label_free;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500681 }
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400682 memset(array, 0, sizeof(struct nfs_cache_array));
Al Viro9ac3d3e2016-04-28 19:52:56 -0400683 atomic_set(&array->refcount, 1);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400684 array->eof_index = -1;
685
Anna Schumakerc7e96682015-07-13 14:01:25 -0400686 status = nfs_readdir_alloc_pages(pages, array_size);
Trond Myklebust66502392011-01-08 17:45:38 -0500687 if (status < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400688 goto out_release_array;
689 do {
Trond Myklebustac396122010-11-15 20:26:22 -0500690 unsigned int pglen;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400691 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400692
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400693 if (status < 0)
694 break;
Trond Myklebustac396122010-11-15 20:26:22 -0500695 pglen = status;
Trond Myklebust66502392011-01-08 17:45:38 -0500696 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500697 if (status < 0) {
698 if (status == -ENOSPC)
699 status = 0;
700 break;
701 }
702 } while (array->eof_index < 0);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400703
Anna Schumakerc7e96682015-07-13 14:01:25 -0400704 nfs_readdir_free_pages(pages, array_size);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400705out_release_array:
706 nfs_readdir_release_array(page);
David Quigley14c43f72013-05-22 12:50:43 -0400707out_label_free:
708 nfs4_label_free(entry.label);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400709out:
710 nfs_free_fattr(entry.fattr);
711 nfs_free_fhandle(entry.fh);
712 return status;
713}
714
715/*
716 * Now we cache directories properly, by converting xdr information
717 * to an array that can be used for lookups later. This results in
718 * fewer cache pages, since we can store more information on each page.
719 * We only need to convert from xdr once so future lookups are much simpler
720 */
721static
722int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
723{
Al Viro496ad9a2013-01-23 17:07:38 -0500724 struct inode *inode = file_inode(desc->file);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500725 int ret;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400726
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500727 ret = nfs_readdir_xdr_to_array(desc, page, inode);
728 if (ret < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400729 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 SetPageUptodate(page);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400731
Trond Myklebust2aac05a2008-07-07 13:26:10 -0400732 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700733 /* Should never happen */
734 nfs_zap_mapping(inode, inode->i_mapping);
735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 unlock_page(page);
737 return 0;
738 error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 unlock_page(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500740 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400743static
744void cache_page_release(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745{
Al Viro9ac3d3e2016-04-28 19:52:56 -0400746 nfs_readdir_clear_array(desc->page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300747 put_page(desc->page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 desc->page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749}
750
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400751static
752struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Al Viro9ac3d3e2016-04-28 19:52:56 -0400754 struct page *page;
755
756 for (;;) {
Al Viro93c76a32015-12-04 23:45:44 -0500757 page = read_cache_page(desc->file->f_mapping,
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400758 desc->page_index, (filler_t *)nfs_readdir_filler, desc);
Al Viro9ac3d3e2016-04-28 19:52:56 -0400759 if (IS_ERR(page) || grab_page(page))
760 break;
761 put_page(page);
762 }
763 return page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
765
766/*
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400767 * Returns 0 if desc->dir_cookie was found on page desc->page_index
Olivier Galibert00a92642005-06-22 17:16:29 +0000768 */
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400769static
770int find_cache_page(nfs_readdir_descriptor_t *desc)
Olivier Galibert00a92642005-06-22 17:16:29 +0000771{
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400772 int res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000773
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400774 desc->page = get_cache_page(desc);
775 if (IS_ERR(desc->page))
776 return PTR_ERR(desc->page);
Olivier Galibert00a92642005-06-22 17:16:29 +0000777
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400778 res = nfs_readdir_search_array(desc);
Trond Myklebust47c716c2010-12-07 12:44:56 -0500779 if (res != 0)
780 cache_page_release(desc);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400781 return res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000782}
783
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400784/* Search for desc->dir_cookie from the beginning of the page cache */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785static inline
786int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
787{
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500788 int res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000789
Trond Myklebust0aded702010-11-30 21:56:32 -0500790 if (desc->page_index == 0) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500791 desc->current_index = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500792 desc->last_cookie = 0;
793 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500794 do {
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400795 res = find_cache_page(desc);
Trond Myklebust47c716c2010-12-07 12:44:56 -0500796 } while (res == -EAGAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 return res;
798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800/*
801 * Once we've found the start of the dirent within a page: fill 'er up...
802 */
803static
Al Viro23db8622013-05-17 16:34:50 -0400804int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
806 struct file *file = desc->file;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400807 int i = 0;
808 int res = 0;
809 struct nfs_cache_array *array = NULL;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400810 struct nfs_open_dir_context *ctx = file->private_data;
811
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400812 array = nfs_readdir_get_array(desc->page);
Trond Myklebuste7c58e92010-11-20 13:22:24 -0500813 if (IS_ERR(array)) {
814 res = PTR_ERR(array);
815 goto out;
816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400818 for (i = desc->cache_entry_index; i < array->size; i++) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500819 struct nfs_cache_array_entry *ent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
Trond Myklebustece0b422010-11-20 13:55:33 -0500821 ent = &array->array[i];
Al Viro23db8622013-05-17 16:34:50 -0400822 if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
823 nfs_compat_user_ino64(ent->ino), ent->d_type)) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500824 desc->eof = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 break;
Trond Myklebustece0b422010-11-20 13:55:33 -0500826 }
Al Viro23db8622013-05-17 16:34:50 -0400827 desc->ctx->pos++;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400828 if (i < (array->size-1))
829 *desc->dir_cookie = array->array[i+1].cookie;
830 else
831 *desc->dir_cookie = array->last_cookie;
Trond Myklebust0c030802011-07-30 12:45:35 -0400832 if (ctx->duped != 0)
833 ctx->duped = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500835 if (array->eof_index >= 0)
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500836 desc->eof = 1;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400837
838 nfs_readdir_release_array(desc->page);
Trond Myklebuste7c58e92010-11-20 13:22:24 -0500839out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400840 cache_page_release(desc);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500841 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
842 (unsigned long long)*desc->dir_cookie, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 return res;
844}
845
846/*
847 * If we cannot find a cookie in our cache, we suspect that this is
848 * because it points to a deleted file, so we ask the server to return
849 * whatever it thinks is the next entry. We then feed this to filldir.
850 * If all goes well, we should then be able to find our way round the
851 * cache on the next call to readdir_search_pagecache();
852 *
853 * NOTE: we cannot add the anonymous page to the pagecache because
854 * the data it contains might not be page aligned. Besides,
855 * we should already have a complete representation of the
856 * directory in the page cache by the time we get here.
857 */
858static inline
Al Viro23db8622013-05-17 16:34:50 -0400859int uncached_readdir(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 struct page *page = NULL;
862 int status;
Al Viro496ad9a2013-01-23 17:07:38 -0500863 struct inode *inode = file_inode(desc->file);
Trond Myklebust0c030802011-07-30 12:45:35 -0400864 struct nfs_open_dir_context *ctx = desc->file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500866 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
867 (unsigned long long)*desc->dir_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 page = alloc_page(GFP_HIGHUSER);
870 if (!page) {
871 status = -ENOMEM;
872 goto out;
873 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500875 desc->page_index = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500876 desc->last_cookie = *desc->dir_cookie;
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500877 desc->page = page;
Trond Myklebust0c030802011-07-30 12:45:35 -0400878 ctx->duped = 0;
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500879
Trond Myklebust85f86072010-11-20 13:24:49 -0500880 status = nfs_readdir_xdr_to_array(desc, page, inode);
881 if (status < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400882 goto out_release;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400883
Al Viro23db8622013-05-17 16:34:50 -0400884 status = nfs_do_filldir(desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 out:
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500887 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700888 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 return status;
890 out_release:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400891 cache_page_release(desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 goto out;
893}
894
Olivier Galibert00a92642005-06-22 17:16:29 +0000895/* The file offset position represents the dirent entry number. A
896 last cookie cache takes care of the common case of reading the
897 whole directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 */
Al Viro23db8622013-05-17 16:34:50 -0400899static int nfs_readdir(struct file *file, struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900{
Miklos Szeredibe62a1a2016-03-26 16:14:39 -0400901 struct dentry *dentry = file_dentry(file);
David Howells2b0143b2015-03-17 22:25:59 +0000902 struct inode *inode = d_inode(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 nfs_readdir_descriptor_t my_desc,
904 *desc = &my_desc;
Al Viro23db8622013-05-17 16:34:50 -0400905 struct nfs_open_dir_context *dir_ctx = file->private_data;
Scott Mayhew07b5ce82013-07-05 17:49:31 -0400906 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
Al Viro6de14722013-09-16 10:53:17 -0400908 dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
909 file, (long long)ctx->pos);
Chuck Lever91d5b472006-03-20 13:44:14 -0500910 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 /*
Al Viro23db8622013-05-17 16:34:50 -0400913 * ctx->pos points to the dirent entry number.
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000914 * *desc->dir_cookie has the cookie for the next entry. We have
Olivier Galibert00a92642005-06-22 17:16:29 +0000915 * to either find the entry with the appropriate number or
916 * revalidate the cookie.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 */
918 memset(desc, 0, sizeof(*desc));
919
Al Viro23db8622013-05-17 16:34:50 -0400920 desc->file = file;
921 desc->ctx = ctx;
Bryan Schumaker480c2002011-03-23 14:48:29 -0400922 desc->dir_cookie = &dir_ctx->dir_cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 desc->decode = NFS_PROTO(inode)->decode_dirent;
Al Viro23db8622013-05-17 16:34:50 -0400924 desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Trond Myklebust79f687a32016-11-19 10:54:55 -0500926 if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))
Scott Mayhew07b5ce82013-07-05 17:49:31 -0400927 res = nfs_revalidate_mapping(inode, file->f_mapping);
Trond Myklebustfccca7f2008-01-26 17:37:47 -0500928 if (res < 0)
929 goto out;
930
Trond Myklebust47c716c2010-12-07 12:44:56 -0500931 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 res = readdir_search_pagecache(desc);
Olivier Galibert00a92642005-06-22 17:16:29 +0000933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (res == -EBADCOOKIE) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500935 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /* This means either end of directory */
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400937 if (*desc->dir_cookie && desc->eof == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 /* Or that the server has 'lost' a cookie */
Al Viro23db8622013-05-17 16:34:50 -0400939 res = uncached_readdir(desc);
Trond Myklebustece0b422010-11-20 13:55:33 -0500940 if (res == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 continue;
942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 break;
944 }
945 if (res == -ETOOSMALL && desc->plus) {
Benny Halevy3a10c302008-01-23 08:58:59 +0200946 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 nfs_zap_caches(inode);
Trond Myklebustbaf57a02010-09-24 18:49:43 -0400948 desc->page_index = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 desc->plus = 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400950 desc->eof = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 continue;
952 }
953 if (res < 0)
954 break;
955
Al Viro23db8622013-05-17 16:34:50 -0400956 res = nfs_do_filldir(desc);
Trond Myklebustece0b422010-11-20 13:55:33 -0500957 if (res < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 break;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500959 } while (!desc->eof);
Trond Myklebustfccca7f2008-01-26 17:37:47 -0500960out:
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500961 if (res > 0)
962 res = 0;
Al Viro6de14722013-09-16 10:53:17 -0400963 dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500964 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965}
966
Andrew Morton965c8e52012-12-17 15:59:39 -0800967static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000968{
Bryan Schumaker480c2002011-03-23 14:48:29 -0400969 struct nfs_open_dir_context *dir_ctx = filp->private_data;
Chuck Leverb84e06c2008-06-11 17:55:34 -0400970
Al Viro6de14722013-09-16 10:53:17 -0400971 dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
972 filp, offset, whence);
Chuck Leverb84e06c2008-06-11 17:55:34 -0400973
Andrew Morton965c8e52012-12-17 15:59:39 -0800974 switch (whence) {
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000975 case 1:
976 offset += filp->f_pos;
977 case 0:
978 if (offset >= 0)
979 break;
980 default:
Al Viro9ac3d3e2016-04-28 19:52:56 -0400981 return -EINVAL;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000982 }
983 if (offset != filp->f_pos) {
984 filp->f_pos = offset;
Bryan Schumaker480c2002011-03-23 14:48:29 -0400985 dir_ctx->dir_cookie = 0;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400986 dir_ctx->duped = 0;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000987 }
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000988 return offset;
989}
990
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991/*
992 * All directory operations under NFS are synchronous, so fsync()
993 * is a dummy operation.
994 */
Josef Bacik02c24a82011-07-16 20:44:56 -0400995static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
996 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997{
Al Viro6de14722013-09-16 10:53:17 -0400998 struct inode *inode = file_inode(filp);
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200999
Al Viro6de14722013-09-16 10:53:17 -04001000 dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05001001
Al Viro59551022016-01-22 15:40:57 -05001002 inode_lock(inode);
Al Viro6de14722013-09-16 10:53:17 -04001003 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
Al Viro59551022016-01-22 15:40:57 -05001004 inode_unlock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 return 0;
1006}
1007
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001008/**
1009 * nfs_force_lookup_revalidate - Mark the directory as having changed
1010 * @dir - pointer to directory inode
1011 *
1012 * This forces the revalidation code in nfs_lookup_revalidate() to do a
1013 * full lookup on all child dentries of 'dir' whenever a change occurs
1014 * on the server that might have invalidated our dcache.
1015 *
1016 * The caller should be holding dir->i_lock
1017 */
1018void nfs_force_lookup_revalidate(struct inode *dir)
1019{
Trond Myklebust011935a2008-10-14 19:24:50 -04001020 NFS_I(dir)->cache_change_attribute++;
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001021}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001022EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
Trond Myklebustbfc69a42007-10-15 18:18:29 -04001023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024/*
1025 * A check for whether or not the parent directory has changed.
1026 * In the case it has, we assume that the dentries are untrustworthy
1027 * and may need to be looked up again.
NeilBrown912a1082014-07-14 11:28:20 +10001028 * If rcu_walk prevents us from performing a full check, return 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 */
NeilBrown912a1082014-07-14 11:28:20 +10001030static int nfs_check_verifier(struct inode *dir, struct dentry *dentry,
1031 int rcu_walk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032{
1033 if (IS_ROOT(dentry))
1034 return 1;
Trond Myklebust4eec9522008-07-15 17:58:13 -04001035 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
1036 return 0;
Trond Myklebustf2c77f42007-10-02 12:54:39 -04001037 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1038 return 0;
1039 /* Revalidate nfsi->cache_change_attribute before we declare a match */
Trond Myklebust1cd9cb02016-12-04 18:34:34 -05001040 if (nfs_mapping_need_revalidate_inode(dir)) {
1041 if (rcu_walk)
1042 return 0;
1043 if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1044 return 0;
1045 }
Trond Myklebustf2c77f42007-10-02 12:54:39 -04001046 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1047 return 0;
1048 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051/*
Trond Myklebusta12802c2007-10-02 19:13:04 -04001052 * Use intent information to check whether or not we're going to do
1053 * an O_EXCL create using this path component.
1054 */
Al Virofa3c56b2012-06-10 15:36:40 -04001055static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
Trond Myklebusta12802c2007-10-02 19:13:04 -04001056{
1057 if (NFS_PROTO(dir)->version == 2)
1058 return 0;
Al Virofa3c56b2012-06-10 15:36:40 -04001059 return flags & LOOKUP_EXCL;
Trond Myklebusta12802c2007-10-02 19:13:04 -04001060}
1061
1062/*
Trond Myklebust1d6757f2005-06-07 18:37:01 -04001063 * Inode and filehandle revalidation for lookups.
1064 *
1065 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1066 * or if the intent information indicates that we're about to open this
1067 * particular file and the "nocto" mount flag is not set.
1068 *
1069 */
Trond Myklebust65a0c142012-12-14 17:51:40 -05001070static
Al Virofa3c56b2012-06-10 15:36:40 -04001071int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072{
1073 struct nfs_server *server = NFS_SERVER(inode);
Trond Myklebust65a0c142012-12-14 17:51:40 -05001074 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075
David Howells36d43a42011-01-14 18:45:42 +00001076 if (IS_AUTOMOUNT(inode))
Trond Myklebust4e99a1f2008-03-06 12:34:59 -05001077 return 0;
Al Virofacc3532012-06-10 15:33:51 -04001078 /* VFS wants an on-the-wire revalidation */
Al Virofa3c56b2012-06-10 15:36:40 -04001079 if (flags & LOOKUP_REVAL)
Al Virofacc3532012-06-10 15:33:51 -04001080 goto out_force;
1081 /* This is an open(2) */
Al Virofa3c56b2012-06-10 15:36:40 -04001082 if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
1083 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
Al Virofacc3532012-06-10 15:33:51 -04001084 goto out_force;
Trond Myklebust65a0c142012-12-14 17:51:40 -05001085out:
1086 return (inode->i_nlink == 0) ? -ENOENT : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087out_force:
NeilBrown1fa1e382014-07-14 11:28:20 +10001088 if (flags & LOOKUP_RCU)
1089 return -ECHILD;
Trond Myklebust65a0c142012-12-14 17:51:40 -05001090 ret = __nfs_revalidate_inode(server, inode);
1091 if (ret != 0)
1092 return ret;
1093 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
1095
1096/*
1097 * We judge how long we want to trust negative
1098 * dentries by looking at the parent inode mtime.
1099 *
1100 * If parent mtime has changed, we revalidate, else we wait for a
1101 * period corresponding to the parent's attribute cache timeout value.
NeilBrown912a1082014-07-14 11:28:20 +10001102 *
1103 * If LOOKUP_RCU prevents us from performing a full check, return 1
1104 * suggesting a reval is needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 */
1106static inline
1107int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
Al Virofa3c56b2012-06-10 15:36:40 -04001108 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 /* Don't revalidate a negative dentry if we're creating a new file */
Al Virofa3c56b2012-06-10 15:36:40 -04001111 if (flags & LOOKUP_CREATE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 return 0;
Trond Myklebust4eec9522008-07-15 17:58:13 -04001113 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1114 return 1;
NeilBrown912a1082014-07-14 11:28:20 +10001115 return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
1118/*
1119 * This is called every time the dcache has a lookup hit,
1120 * and we should check whether we can really trust that
1121 * lookup.
1122 *
1123 * NOTE! The hit can be a negative hit too, don't assume
1124 * we have an inode!
1125 *
1126 * If the parent directory is seen to have changed, we throw out the
1127 * cached dentry and do a new lookup.
1128 */
Al Viro0b728e12012-06-10 16:03:43 -04001129static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131 struct inode *dir;
1132 struct inode *inode;
1133 struct dentry *parent;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001134 struct nfs_fh *fhandle = NULL;
1135 struct nfs_fattr *fattr = NULL;
David Quigley1775fd32013-05-22 12:50:42 -04001136 struct nfs4_label *label = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
NeilBrownd51ac1a2014-07-14 11:28:20 +10001139 if (flags & LOOKUP_RCU) {
NeilBrown50d77732014-08-04 16:24:00 +10001140 parent = ACCESS_ONCE(dentry->d_parent);
David Howells2b0143b2015-03-17 22:25:59 +00001141 dir = d_inode_rcu(parent);
NeilBrownd51ac1a2014-07-14 11:28:20 +10001142 if (!dir)
1143 return -ECHILD;
1144 } else {
1145 parent = dget_parent(dentry);
David Howells2b0143b2015-03-17 22:25:59 +00001146 dir = d_inode(parent);
NeilBrownd51ac1a2014-07-14 11:28:20 +10001147 }
Chuck Lever91d5b472006-03-20 13:44:14 -05001148 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
David Howells2b0143b2015-03-17 22:25:59 +00001149 inode = d_inode(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 if (!inode) {
NeilBrown912a1082014-07-14 11:28:20 +10001152 if (nfs_neg_need_reval(dir, dentry, flags)) {
1153 if (flags & LOOKUP_RCU)
1154 return -ECHILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 goto out_bad;
NeilBrown912a1082014-07-14 11:28:20 +10001156 }
Trond Myklebust63519fb2016-11-19 11:21:54 -05001157 goto out_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
1159
1160 if (is_bad_inode(inode)) {
NeilBrownd51ac1a2014-07-14 11:28:20 +10001161 if (flags & LOOKUP_RCU)
1162 return -ECHILD;
Al Viro6de14722013-09-16 10:53:17 -04001163 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1164 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 goto out_bad;
1166 }
1167
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001168 if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
Trond Myklebust15860ab2008-12-23 15:21:54 -05001169 goto out_set_verifier;
1170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 /* Force a full look up iff the parent directory has changed */
NeilBrown912a1082014-07-14 11:28:20 +10001172 if (!nfs_is_exclusive_create(dir, flags) &&
1173 nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
1174
NeilBrown1fa1e382014-07-14 11:28:20 +10001175 if (nfs_lookup_verify_inode(inode, flags)) {
1176 if (flags & LOOKUP_RCU)
1177 return -ECHILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 goto out_zap_parent;
NeilBrown1fa1e382014-07-14 11:28:20 +10001179 }
Trond Myklebust63519fb2016-11-19 11:21:54 -05001180 nfs_advise_use_readdirplus(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 goto out_valid;
1182 }
1183
NeilBrown912a1082014-07-14 11:28:20 +10001184 if (flags & LOOKUP_RCU)
1185 return -ECHILD;
1186
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (NFS_STALE(inode))
1188 goto out_bad;
1189
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001190 error = -ENOMEM;
1191 fhandle = nfs_alloc_fhandle();
1192 fattr = nfs_alloc_fattr();
1193 if (fhandle == NULL || fattr == NULL)
1194 goto out_error;
1195
David Quigley14c43f72013-05-22 12:50:43 -04001196 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
1197 if (IS_ERR(label))
1198 goto out_error;
1199
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001200 trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
David Quigley1775fd32013-05-22 12:50:42 -04001201 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001202 trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 if (error)
1204 goto out_bad;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001205 if (nfs_compare_fh(NFS_FH(inode), fhandle))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 goto out_bad;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001207 if ((error = nfs_refresh_inode(inode, fattr)) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 goto out_bad;
1209
David Quigleyaa9c2662013-05-22 12:50:44 -04001210 nfs_setsecurity(inode, fattr, label);
1211
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001212 nfs_free_fattr(fattr);
1213 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001214 nfs4_label_free(label);
1215
Trond Myklebust63519fb2016-11-19 11:21:54 -05001216 /* set a readdirplus hint that we had a cache miss */
1217 nfs_force_use_readdirplus(dir);
1218
Trond Myklebust15860ab2008-12-23 15:21:54 -05001219out_set_verifier:
Trond Myklebustcf8ba452007-10-01 13:46:53 -04001220 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 out_valid:
NeilBrownd51ac1a2014-07-14 11:28:20 +10001222 if (flags & LOOKUP_RCU) {
NeilBrown50d77732014-08-04 16:24:00 +10001223 if (parent != ACCESS_ONCE(dentry->d_parent))
NeilBrownd51ac1a2014-07-14 11:28:20 +10001224 return -ECHILD;
1225 } else
1226 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001227 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
1228 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 return 1;
1230out_zap_parent:
1231 nfs_zap_caches(dir);
1232 out_bad:
NeilBrownd51ac1a2014-07-14 11:28:20 +10001233 WARN_ON(flags & LOOKUP_RCU);
Al Viroc44600c2012-11-29 22:04:36 -05001234 nfs_free_fattr(fattr);
1235 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001236 nfs4_label_free(label);
Trond Myklebusta1643a92007-09-29 17:25:43 -04001237 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 if (inode && S_ISDIR(inode->i_mode)) {
1239 /* Purge readdir caches. */
1240 nfs_zap_caches(inode);
J. Bruce Fieldsa3f432b2013-10-15 17:03:16 -04001241 /*
1242 * We can't d_drop the root of a disconnected tree:
1243 * its d_hash is on the s_anon list and d_drop() would hide
1244 * it from shrink_dcache_for_unmount(), leading to busy
1245 * inodes on unmount and further oopses.
1246 */
1247 if (IS_ROOT(dentry))
Al Virod9e80b72010-04-29 03:10:43 +01001248 goto out_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001251 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
1252 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 return 0;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001254out_error:
NeilBrownd51ac1a2014-07-14 11:28:20 +10001255 WARN_ON(flags & LOOKUP_RCU);
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001256 nfs_free_fattr(fattr);
1257 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001258 nfs4_label_free(label);
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001259 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001260 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
1261 __func__, dentry, error);
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001262 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263}
1264
1265/*
David Howells2b0143b2015-03-17 22:25:59 +00001266 * A weaker form of d_revalidate for revalidating just the d_inode(dentry)
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001267 * when we don't really care about the dentry name. This is called when a
1268 * pathwalk ends on a dentry that was not found via a normal lookup in the
1269 * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
1270 *
1271 * In this situation, we just want to verify that the inode itself is OK
1272 * since the dentry might have changed on the server.
1273 */
1274static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
1275{
David Howells2b0143b2015-03-17 22:25:59 +00001276 struct inode *inode = d_inode(dentry);
Trond Myklebust9cdd1d32016-12-16 18:04:47 -05001277 int error = 0;
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001278
1279 /*
1280 * I believe we can only get a negative dentry here in the case of a
1281 * procfs-style symlink. Just assume it's correct for now, but we may
1282 * eventually need to do something more here.
1283 */
1284 if (!inode) {
Al Viro6de14722013-09-16 10:53:17 -04001285 dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
1286 __func__, dentry);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001287 return 1;
1288 }
1289
1290 if (is_bad_inode(inode)) {
Al Viro6de14722013-09-16 10:53:17 -04001291 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1292 __func__, dentry);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001293 return 0;
1294 }
1295
Trond Myklebust9cdd1d32016-12-16 18:04:47 -05001296 if (nfs_mapping_need_revalidate_inode(inode))
1297 error = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001298 dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1299 __func__, inode->i_ino, error ? "invalid" : "valid");
1300 return !error;
1301}
1302
1303/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 * This is called from dput() when d_count is going to 0.
1305 */
Nick Pigginfe15ce42011-01-07 17:49:23 +11001306static int nfs_dentry_delete(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307{
Al Viro6de14722013-09-16 10:53:17 -04001308 dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
1309 dentry, dentry->d_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Trond Myklebust77f11192008-01-28 19:43:19 -05001311 /* Unhash any dentry with a stale inode */
David Howells2b0143b2015-03-17 22:25:59 +00001312 if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
Trond Myklebust77f11192008-01-28 19:43:19 -05001313 return 1;
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1316 /* Unhash it, so that ->d_iput() would be called */
1317 return 1;
1318 }
1319 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1320 /* Unhash it, so that ancestors of killed async unlink
1321 * files will be cleaned up during umount */
1322 return 1;
1323 }
1324 return 0;
1325
1326}
1327
Trond Myklebust1f018452012-12-14 16:38:46 -05001328/* Ensure that we revalidate inode->i_nlink */
Trond Myklebust1b83d702008-06-11 15:44:04 -04001329static void nfs_drop_nlink(struct inode *inode)
1330{
1331 spin_lock(&inode->i_lock);
Trond Myklebust1f018452012-12-14 16:38:46 -05001332 /* drop the inode if we're reasonably sure this is the last link */
1333 if (inode->i_nlink == 1)
1334 clear_nlink(inode);
1335 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebust1b83d702008-06-11 15:44:04 -04001336 spin_unlock(&inode->i_lock);
1337}
1338
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339/*
1340 * Called when the dentry loses inode.
1341 * We use it to clean up silly-renamed files.
1342 */
1343static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1344{
Neil Brown83672d32007-02-26 12:48:25 +11001345 if (S_ISDIR(inode->i_mode))
1346 /* drop any readdir cache as it could easily be old */
1347 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001350 nfs_complete_unlink(dentry, inode);
Trond Myklebust1f018452012-12-14 16:38:46 -05001351 nfs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 iput(inode);
1354}
1355
Al Virob1942c52011-03-16 05:44:14 -04001356static void nfs_d_release(struct dentry *dentry)
1357{
1358 /* free cached devname value, if it survived that far */
1359 if (unlikely(dentry->d_fsdata)) {
1360 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1361 WARN_ON(1);
1362 else
1363 kfree(dentry->d_fsdata);
1364 }
1365}
1366
Al Virof786aa92009-02-20 05:51:22 +00001367const struct dentry_operations nfs_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 .d_revalidate = nfs_lookup_revalidate,
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001369 .d_weak_revalidate = nfs_weak_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 .d_delete = nfs_dentry_delete,
1371 .d_iput = nfs_dentry_iput,
David Howells36d43a42011-01-14 18:45:42 +00001372 .d_automount = nfs_d_automount,
Al Virob1942c52011-03-16 05:44:14 -04001373 .d_release = nfs_d_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374};
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001375EXPORT_SYMBOL_GPL(nfs_dentry_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Bryan Schumaker597d9282012-07-16 16:39:10 -04001377struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378{
1379 struct dentry *res;
1380 struct inode *inode = NULL;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001381 struct nfs_fh *fhandle = NULL;
1382 struct nfs_fattr *fattr = NULL;
David Quigley1775fd32013-05-22 12:50:42 -04001383 struct nfs4_label *label = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
Al Viro6de14722013-09-16 10:53:17 -04001386 dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
Chuck Lever91d5b472006-03-20 13:44:14 -05001387 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
Al Viro130f9ab2016-03-07 22:40:43 -05001389 if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen))
1390 return ERR_PTR(-ENAMETOOLONG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Trond Myklebustfd684072006-09-05 12:27:44 -04001392 /*
1393 * If we're doing an exclusive create, optimize away the lookup
1394 * but don't hash the dentry.
1395 */
Al Viro130f9ab2016-03-07 22:40:43 -05001396 if (nfs_is_exclusive_create(dir, flags))
1397 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001399 res = ERR_PTR(-ENOMEM);
1400 fhandle = nfs_alloc_fhandle();
1401 fattr = nfs_alloc_fattr();
1402 if (fhandle == NULL || fattr == NULL)
1403 goto out;
1404
David Quigley14c43f72013-05-22 12:50:43 -04001405 label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
1406 if (IS_ERR(label))
1407 goto out;
1408
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001409 trace_nfs_lookup_enter(dir, dentry, flags);
David Quigley1775fd32013-05-22 12:50:42 -04001410 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 if (error == -ENOENT)
1412 goto no_entry;
1413 if (error < 0) {
1414 res = ERR_PTR(error);
Al Virobf130912016-05-29 15:14:14 -04001415 goto out_label;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 }
David Quigley1775fd32013-05-22 12:50:42 -04001417 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
Namhyung Kimbf0c84f2010-12-28 17:02:46 +00001418 res = ERR_CAST(inode);
Trond Myklebust03f28e32006-03-20 13:44:48 -05001419 if (IS_ERR(res))
Al Virobf130912016-05-29 15:14:14 -04001420 goto out_label;
David Howells54ceac42006-08-22 20:06:13 -04001421
Trond Myklebust63519fb2016-11-19 11:21:54 -05001422 /* Notify readdir to use READDIRPLUS */
1423 nfs_force_use_readdirplus(dir);
Trond Myklebustd69ee9b2012-05-01 17:37:59 -04001424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425no_entry:
Al Viro41d28bc2014-10-12 22:24:21 -04001426 res = d_splice_alias(inode, dentry);
Trond Myklebust9eaef272006-10-21 10:24:20 -07001427 if (res != NULL) {
1428 if (IS_ERR(res))
Al Virobf130912016-05-29 15:14:14 -04001429 goto out_label;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 dentry = res;
Trond Myklebust9eaef272006-10-21 10:24:20 -07001431 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Al Virobf130912016-05-29 15:14:14 -04001433out_label:
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001434 trace_nfs_lookup_exit(dir, dentry, flags, error);
David Quigley14c43f72013-05-22 12:50:43 -04001435 nfs4_label_free(label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436out:
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001437 nfs_free_fattr(fattr);
1438 nfs_free_fhandle(fhandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 return res;
1440}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001441EXPORT_SYMBOL_GPL(nfs_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001443#if IS_ENABLED(CONFIG_NFS_V4)
Al Viro0b728e12012-06-10 16:03:43 -04001444static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
Al Virof786aa92009-02-20 05:51:22 +00001446const struct dentry_operations nfs4_dentry_operations = {
Miklos Szeredi0ef97dc2012-05-21 17:30:20 +02001447 .d_revalidate = nfs4_lookup_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 .d_delete = nfs_dentry_delete,
1449 .d_iput = nfs_dentry_iput,
David Howells36d43a42011-01-14 18:45:42 +00001450 .d_automount = nfs_d_automount,
Al Virob1942c52011-03-16 05:44:14 -04001451 .d_release = nfs_d_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452};
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001453EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
Al Viro8a5e9292011-06-25 19:15:54 -04001455static fmode_t flags_to_mode(int flags)
1456{
1457 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1458 if ((flags & O_ACCMODE) != O_WRONLY)
1459 res |= FMODE_READ;
1460 if ((flags & O_ACCMODE) != O_RDONLY)
1461 res |= FMODE_WRITE;
1462 return res;
1463}
1464
NeilBrown532d4de2016-10-13 15:26:47 +11001465static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags, struct file *filp)
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001466{
NeilBrown532d4de2016-10-13 15:26:47 +11001467 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags), filp);
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001468}
1469
1470static int do_open(struct inode *inode, struct file *filp)
1471{
David Howellsf1fe29b2013-09-27 11:20:03 +01001472 nfs_fscache_open_file(inode, filp);
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001473 return 0;
1474}
1475
Al Virod9585272012-06-22 12:39:14 +04001476static int nfs_finish_open(struct nfs_open_context *ctx,
1477 struct dentry *dentry,
Al Viro30d90492012-06-22 12:40:19 +04001478 struct file *file, unsigned open_flags,
Al Virod9585272012-06-22 12:39:14 +04001479 int *opened)
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001480{
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001481 int err;
1482
Al Viro30d90492012-06-22 12:40:19 +04001483 err = finish_open(file, dentry, do_open, opened);
1484 if (err)
Al Virod9585272012-06-22 12:39:14 +04001485 goto out;
Al Viro30d90492012-06-22 12:40:19 +04001486 nfs_file_set_open_context(file, ctx);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001487
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001488out:
Al Virod9585272012-06-22 12:39:14 +04001489 return err;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001490}
1491
Bryan Schumaker73a79702012-07-16 16:39:12 -04001492int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1493 struct file *file, unsigned open_flags,
1494 umode_t mode, int *opened)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495{
Al Viroc94c0952016-07-05 09:49:21 -04001496 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001497 struct nfs_open_context *ctx;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001498 struct dentry *res;
1499 struct iattr attr = { .ia_valid = ATTR_OPEN };
Trond Myklebustf46e0bd2010-09-17 10:56:50 -04001500 struct inode *inode;
Trond Myklebust1472b832013-08-20 11:59:41 -04001501 unsigned int lookup_flags = 0;
Al Viroc94c0952016-07-05 09:49:21 -04001502 bool switched = false;
Trond Myklebust898f6352010-10-23 11:24:25 -04001503 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001505 /* Expect a negative dentry */
David Howells2b0143b2015-03-17 22:25:59 +00001506 BUG_ON(d_inode(dentry));
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001507
Niels de Vos1e8968c2013-12-17 18:20:16 +01001508 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001509 dir->i_sb->s_id, dir->i_ino, dentry);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05001510
Jeff Layton9597c132013-08-02 11:39:32 -04001511 err = nfs_check_flags(open_flags);
1512 if (err)
1513 return err;
1514
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001515 /* NFS only supports OPEN on regular files */
1516 if ((open_flags & O_DIRECTORY)) {
Al Viro00699ad2016-07-05 09:44:53 -04001517 if (!d_in_lookup(dentry)) {
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001518 /*
1519 * Hashed negative dentry with O_DIRECTORY: dentry was
1520 * revalidated and is fine, no need to perform lookup
1521 * again
1522 */
Al Virod9585272012-06-22 12:39:14 +04001523 return -ENOENT;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001524 }
Trond Myklebust1472b832013-08-20 11:59:41 -04001525 lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 goto no_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001529 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
Al Virod9585272012-06-22 12:39:14 +04001530 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001532 if (open_flags & O_CREAT) {
Andreas Gruenbacherdff25dd2016-12-02 22:53:30 -05001533 struct nfs_server *server = NFS_SERVER(dir);
1534
1535 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
1536 mode &= ~current_umask();
1537
Trond Myklebust536e43d2012-01-17 22:04:26 -05001538 attr.ia_valid |= ATTR_MODE;
Andreas Gruenbacherdff25dd2016-12-02 22:53:30 -05001539 attr.ia_mode = mode;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001540 }
Trond Myklebust536e43d2012-01-17 22:04:26 -05001541 if (open_flags & O_TRUNC) {
1542 attr.ia_valid |= ATTR_SIZE;
1543 attr.ia_size = 0;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001544 }
1545
Al Viroc94c0952016-07-05 09:49:21 -04001546 if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) {
1547 d_drop(dentry);
1548 switched = true;
1549 dentry = d_alloc_parallel(dentry->d_parent,
1550 &dentry->d_name, &wq);
1551 if (IS_ERR(dentry))
1552 return PTR_ERR(dentry);
1553 if (unlikely(!d_in_lookup(dentry)))
1554 return finish_no_open(file, dentry);
1555 }
1556
NeilBrown532d4de2016-10-13 15:26:47 +11001557 ctx = create_nfs_open_context(dentry, open_flags, file);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001558 err = PTR_ERR(ctx);
1559 if (IS_ERR(ctx))
Al Virod9585272012-06-22 12:39:14 +04001560 goto out;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001561
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001562 trace_nfs_atomic_open_enter(dir, ctx, open_flags);
Trond Myklebust5bc2afc2013-09-23 18:01:28 -04001563 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, opened);
Trond Myklebustf46e0bd2010-09-17 10:56:50 -04001564 if (IS_ERR(inode)) {
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001565 err = PTR_ERR(inode);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001566 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
Trond Myklebust2d9db752013-08-30 09:17:33 -04001567 put_nfs_open_context(ctx);
Al Virod20cb712016-06-20 13:14:36 -04001568 d_drop(dentry);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001569 switch (err) {
1570 case -ENOENT:
1571 d_add(dentry, NULL);
Trond Myklebust809fd142014-10-23 19:33:14 +03001572 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001573 break;
1574 case -EISDIR:
1575 case -ENOTDIR:
1576 goto no_open;
1577 case -ELOOP:
1578 if (!(open_flags & O_NOFOLLOW))
Trond Myklebust6f926b52005-10-18 14:20:18 -07001579 goto no_open;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001580 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 /* case -EINVAL: */
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001582 default:
1583 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
Al Virod9585272012-06-22 12:39:14 +04001585 goto out;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001586 }
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001587
Trond Myklebust275bb302013-05-29 13:11:28 -04001588 err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001589 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
Trond Myklebust2d9db752013-08-30 09:17:33 -04001590 put_nfs_open_context(ctx);
Al Virod9585272012-06-22 12:39:14 +04001591out:
Al Viroc94c0952016-07-05 09:49:21 -04001592 if (unlikely(switched)) {
1593 d_lookup_done(dentry);
1594 dput(dentry);
1595 }
Al Virod9585272012-06-22 12:39:14 +04001596 return err;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598no_open:
Trond Myklebust1472b832013-08-20 11:59:41 -04001599 res = nfs_lookup(dir, dentry, lookup_flags);
Al Viroc94c0952016-07-05 09:49:21 -04001600 if (switched) {
1601 d_lookup_done(dentry);
1602 if (!res)
1603 res = dentry;
1604 else
1605 dput(dentry);
1606 }
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001607 if (IS_ERR(res))
Al Viroc94c0952016-07-05 09:49:21 -04001608 return PTR_ERR(res);
Al Viroe45198a2012-06-10 06:48:09 -04001609 return finish_no_open(file, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001611EXPORT_SYMBOL_GPL(nfs_atomic_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612
Al Viro0b728e12012-06-10 16:03:43 -04001613static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
Nick Piggin657e94b2011-01-14 02:48:39 +00001615 struct inode *inode;
Miklos Szeredi50de3482012-06-05 15:10:20 +02001616 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Al Virofa3c56b2012-06-10 15:36:40 -04001618 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
Miklos Szeredieda72af2012-06-05 15:10:21 +02001619 goto no_open;
1620 if (d_mountpoint(dentry))
Trond Myklebust5584c302008-12-23 15:21:54 -05001621 goto no_open;
Trond Myklebust49f9a0f2013-03-15 16:44:28 -04001622 if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
1623 goto no_open;
Trond Myklebust2b484292010-09-17 10:56:51 -04001624
David Howells2b0143b2015-03-17 22:25:59 +00001625 inode = d_inode(dentry);
Trond Myklebust2b484292010-09-17 10:56:51 -04001626
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 /* We can't create new files in nfs_open_revalidate(), so we
1628 * optimize away revalidation of negative dentries.
1629 */
Trond Myklebust216d5d062007-10-01 20:10:12 -04001630 if (inode == NULL) {
NeilBrown49317a72014-07-14 11:28:20 +10001631 struct dentry *parent;
1632 struct inode *dir;
1633
NeilBrown912a1082014-07-14 11:28:20 +10001634 if (flags & LOOKUP_RCU) {
NeilBrown50d77732014-08-04 16:24:00 +10001635 parent = ACCESS_ONCE(dentry->d_parent);
David Howells2b0143b2015-03-17 22:25:59 +00001636 dir = d_inode_rcu(parent);
NeilBrown912a1082014-07-14 11:28:20 +10001637 if (!dir)
1638 return -ECHILD;
1639 } else {
1640 parent = dget_parent(dentry);
David Howells2b0143b2015-03-17 22:25:59 +00001641 dir = d_inode(parent);
NeilBrown912a1082014-07-14 11:28:20 +10001642 }
Al Virofa3c56b2012-06-10 15:36:40 -04001643 if (!nfs_neg_need_reval(dir, dentry, flags))
Trond Myklebust216d5d062007-10-01 20:10:12 -04001644 ret = 1;
NeilBrown912a1082014-07-14 11:28:20 +10001645 else if (flags & LOOKUP_RCU)
1646 ret = -ECHILD;
1647 if (!(flags & LOOKUP_RCU))
1648 dput(parent);
NeilBrown50d77732014-08-04 16:24:00 +10001649 else if (parent != ACCESS_ONCE(dentry->d_parent))
NeilBrown912a1082014-07-14 11:28:20 +10001650 return -ECHILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto out;
Trond Myklebust216d5d062007-10-01 20:10:12 -04001652 }
1653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 /* NFS only supports OPEN on regular files */
1655 if (!S_ISREG(inode->i_mode))
NeilBrown49317a72014-07-14 11:28:20 +10001656 goto no_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 /* We cannot do exclusive creation on a positive dentry */
Al Virofa3c56b2012-06-10 15:36:40 -04001658 if (flags & LOOKUP_EXCL)
NeilBrown49317a72014-07-14 11:28:20 +10001659 goto no_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Miklos Szeredi0ef97dc2012-05-21 17:30:20 +02001661 /* Let f_op->open() actually open (and revalidate) the file */
1662 ret = 1;
Trond Myklebust536e43d2012-01-17 22:04:26 -05001663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 return ret;
Trond Myklebust535918f2010-09-17 10:56:51 -04001666
Trond Myklebust5584c302008-12-23 15:21:54 -05001667no_open:
Al Viro0b728e12012-06-10 16:03:43 -04001668 return nfs_lookup_revalidate(dentry, flags);
Trond Myklebustc0204fd2010-09-17 10:56:51 -04001669}
1670
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671#endif /* CONFIG_NFSV4 */
1672
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673/*
1674 * Code common to create, mkdir, and mknod.
1675 */
1676int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
David Quigley1775fd32013-05-22 12:50:42 -04001677 struct nfs_fattr *fattr,
1678 struct nfs4_label *label)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679{
Trond Myklebustfab728e2007-09-29 17:41:33 -04001680 struct dentry *parent = dget_parent(dentry);
David Howells2b0143b2015-03-17 22:25:59 +00001681 struct inode *dir = d_inode(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 struct inode *inode;
1683 int error = -EACCES;
1684
Trond Myklebustfab728e2007-09-29 17:41:33 -04001685 d_drop(dentry);
1686
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 /* We may have been initialized further down */
David Howells2b0143b2015-03-17 22:25:59 +00001688 if (d_really_is_positive(dentry))
Trond Myklebustfab728e2007-09-29 17:41:33 -04001689 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 if (fhandle->size == 0) {
David Quigley1775fd32013-05-22 12:50:42 -04001691 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 if (error)
Trond Myklebustfab728e2007-09-29 17:41:33 -04001693 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
Trond Myklebust5724ab32007-10-01 21:51:38 -04001695 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1697 struct nfs_server *server = NFS_SB(dentry->d_sb);
David Quigley1775fd32013-05-22 12:50:42 -04001698 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 if (error < 0)
Trond Myklebustfab728e2007-09-29 17:41:33 -04001700 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 }
David Quigley1775fd32013-05-22 12:50:42 -04001702 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
Trond Myklebust03f28e32006-03-20 13:44:48 -05001703 error = PTR_ERR(inode);
1704 if (IS_ERR(inode))
Trond Myklebustfab728e2007-09-29 17:41:33 -04001705 goto out_error;
1706 d_add(dentry, inode);
1707out:
1708 dput(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 return 0;
Trond Myklebustfab728e2007-09-29 17:41:33 -04001710out_error:
1711 nfs_mark_for_revalidate(dir);
1712 dput(parent);
1713 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001715EXPORT_SYMBOL_GPL(nfs_instantiate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
1717/*
1718 * Following a failed create operation, we drop the dentry rather
1719 * than retain a negative dentry. This avoids a problem in the event
1720 * that the operation succeeded on the server, but an error in the
1721 * reply path made it appear to have failed.
1722 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001723int nfs_create(struct inode *dir, struct dentry *dentry,
Al Viroebfc3b42012-06-10 18:05:36 -04001724 umode_t mode, bool excl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
1726 struct iattr attr;
Al Viroebfc3b42012-06-10 18:05:36 -04001727 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Niels de Vos1e8968c2013-12-17 18:20:16 +01001730 dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001731 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733 attr.ia_mode = mode;
1734 attr.ia_valid = ATTR_MODE;
1735
Trond Myklebust8b0ad3d2013-08-21 10:53:09 -04001736 trace_nfs_create_enter(dir, dentry, open_flags);
Miklos Szeredi8867fe52012-06-05 15:10:19 +02001737 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
Trond Myklebust8b0ad3d2013-08-21 10:53:09 -04001738 trace_nfs_create_exit(dir, dentry, open_flags, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 if (error != 0)
1740 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 return 0;
1742out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 d_drop(dentry);
1744 return error;
1745}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001746EXPORT_SYMBOL_GPL(nfs_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
1748/*
1749 * See comments for nfs_proc_create regarding failed operations.
1750 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001751int
Al Viro1a67aaf2011-07-26 01:52:52 -04001752nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753{
1754 struct iattr attr;
1755 int status;
1756
Niels de Vos1e8968c2013-12-17 18:20:16 +01001757 dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001758 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 attr.ia_mode = mode;
1761 attr.ia_valid = ATTR_MODE;
1762
Trond Myklebust1ca42382013-08-21 12:36:04 -04001763 trace_nfs_mknod_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001765 trace_nfs_mknod_exit(dir, dentry, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 if (status != 0)
1767 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 return 0;
1769out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 d_drop(dentry);
1771 return status;
1772}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001773EXPORT_SYMBOL_GPL(nfs_mknod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
1775/*
1776 * See comments for nfs_proc_create regarding failed operations.
1777 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001778int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779{
1780 struct iattr attr;
1781 int error;
1782
Niels de Vos1e8968c2013-12-17 18:20:16 +01001783 dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001784 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
1786 attr.ia_valid = ATTR_MODE;
1787 attr.ia_mode = mode | S_IFDIR;
1788
Trond Myklebust1ca42382013-08-21 12:36:04 -04001789 trace_nfs_mkdir_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001791 trace_nfs_mkdir_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 if (error != 0)
1793 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 return 0;
1795out_err:
1796 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 return error;
1798}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001799EXPORT_SYMBOL_GPL(nfs_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001801static void nfs_dentry_handle_enoent(struct dentry *dentry)
1802{
Al Virodc3f4192015-05-18 10:10:34 -04001803 if (simple_positive(dentry))
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001804 d_delete(dentry);
1805}
1806
Bryan Schumaker597d9282012-07-16 16:39:10 -04001807int nfs_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808{
1809 int error;
1810
Niels de Vos1e8968c2013-12-17 18:20:16 +01001811 dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001812 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813
Trond Myklebust1ca42382013-08-21 12:36:04 -04001814 trace_nfs_rmdir_enter(dir, dentry);
David Howells2b0143b2015-03-17 22:25:59 +00001815 if (d_really_is_positive(dentry)) {
Al Viro884be172016-04-28 23:56:31 -04001816 down_write(&NFS_I(d_inode(dentry))->rmdir_sem);
Trond Myklebustba6c0592013-08-30 12:24:25 -04001817 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1818 /* Ensure the VFS deletes this inode */
1819 switch (error) {
1820 case 0:
David Howells2b0143b2015-03-17 22:25:59 +00001821 clear_nlink(d_inode(dentry));
Trond Myklebustba6c0592013-08-30 12:24:25 -04001822 break;
1823 case -ENOENT:
1824 nfs_dentry_handle_enoent(dentry);
1825 }
Al Viro884be172016-04-28 23:56:31 -04001826 up_write(&NFS_I(d_inode(dentry))->rmdir_sem);
Trond Myklebustba6c0592013-08-30 12:24:25 -04001827 } else
1828 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001829 trace_nfs_rmdir_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
1831 return error;
1832}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001833EXPORT_SYMBOL_GPL(nfs_rmdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835/*
1836 * Remove a file after making sure there are no pending writes,
1837 * and after checking that the file has only one user.
1838 *
1839 * We invalidate the attribute cache and free the inode prior to the operation
1840 * to avoid possible races if the server reuses the inode.
1841 */
1842static int nfs_safe_remove(struct dentry *dentry)
1843{
David Howells2b0143b2015-03-17 22:25:59 +00001844 struct inode *dir = d_inode(dentry->d_parent);
1845 struct inode *inode = d_inode(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 int error = -EBUSY;
1847
Al Viro6de14722013-09-16 10:53:17 -04001848 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849
1850 /* If the dentry was sillyrenamed, we simply call d_delete() */
1851 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1852 error = 0;
1853 goto out;
1854 }
1855
Trond Myklebust1ca42382013-08-21 12:36:04 -04001856 trace_nfs_remove_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 if (inode != NULL) {
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001858 NFS_PROTO(inode)->return_delegation(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 if (error == 0)
Trond Myklebust1b83d702008-06-11 15:44:04 -04001861 nfs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 } else
1863 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001864 if (error == -ENOENT)
1865 nfs_dentry_handle_enoent(dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001866 trace_nfs_remove_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867out:
1868 return error;
1869}
1870
1871/* We do silly rename. In case sillyrename() returns -EBUSY, the inode
1872 * belongs to an active ".nfs..." file and we return -EBUSY.
1873 *
1874 * If sillyrename() returns 0, we do nothing, otherwise we unlink.
1875 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001876int nfs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
1878 int error;
1879 int need_rehash = 0;
1880
Niels de Vos1e8968c2013-12-17 18:20:16 +01001881 dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
Al Viro6de14722013-09-16 10:53:17 -04001882 dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883
Trond Myklebust1ca42382013-08-21 12:36:04 -04001884 trace_nfs_unlink_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 spin_lock(&dentry->d_lock);
Al Viro84d08fa2013-07-05 18:59:33 +04001886 if (d_count(dentry) > 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 spin_unlock(&dentry->d_lock);
Trond Myklebustccfeb502007-01-13 02:28:12 -05001888 /* Start asynchronous writeout of the inode */
David Howells2b0143b2015-03-17 22:25:59 +00001889 write_inode_now(d_inode(dentry), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 error = nfs_sillyrename(dir, dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001891 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 }
1893 if (!d_unhashed(dentry)) {
1894 __d_drop(dentry);
1895 need_rehash = 1;
1896 }
1897 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 error = nfs_safe_remove(dentry);
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001899 if (!error || error == -ENOENT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1901 } else if (need_rehash)
1902 d_rehash(dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001903out:
1904 trace_nfs_unlink_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 return error;
1906}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001907EXPORT_SYMBOL_GPL(nfs_unlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
Chuck Lever873101b2006-08-22 20:06:23 -04001909/*
1910 * To create a symbolic link, most file systems instantiate a new inode,
1911 * add a page to it containing the path, then write it out to the disk
1912 * using prepare_write/commit_write.
1913 *
1914 * Unfortunately the NFS client can't create the in-core inode first
1915 * because it needs a file handle to create an in-core inode (see
1916 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the
1917 * symlink request has completed on the server.
1918 *
1919 * So instead we allocate a raw page, copy the symname into it, then do
1920 * the SYMLINK request with the page as the buffer. If it succeeds, we
1921 * now have a new file handle and can instantiate an in-core NFS inode
1922 * and move the raw page into its mapping.
1923 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001924int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925{
Chuck Lever873101b2006-08-22 20:06:23 -04001926 struct page *page;
1927 char *kaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 struct iattr attr;
Chuck Lever873101b2006-08-22 20:06:23 -04001929 unsigned int pathlen = strlen(symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 int error;
1931
Niels de Vos1e8968c2013-12-17 18:20:16 +01001932 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
Al Viro6de14722013-09-16 10:53:17 -04001933 dir->i_ino, dentry, symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
Chuck Lever873101b2006-08-22 20:06:23 -04001935 if (pathlen > PAGE_SIZE)
1936 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
Chuck Lever873101b2006-08-22 20:06:23 -04001938 attr.ia_mode = S_IFLNK | S_IRWXUGO;
1939 attr.ia_valid = ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
Al Viroe8ecde22016-01-14 17:52:59 -05001941 page = alloc_page(GFP_USER);
Trond Myklebust76566992008-06-11 15:44:22 -04001942 if (!page)
Chuck Lever873101b2006-08-22 20:06:23 -04001943 return -ENOMEM;
Chuck Lever873101b2006-08-22 20:06:23 -04001944
Al Viroe8ecde22016-01-14 17:52:59 -05001945 kaddr = page_address(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001946 memcpy(kaddr, symname, pathlen);
1947 if (pathlen < PAGE_SIZE)
1948 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
Chuck Lever873101b2006-08-22 20:06:23 -04001949
Trond Myklebust1ca42382013-08-21 12:36:04 -04001950 trace_nfs_symlink_enter(dir, dentry);
Chuck Lever94a6d752006-08-22 20:06:23 -04001951 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001952 trace_nfs_symlink_exit(dir, dentry, error);
Chuck Lever873101b2006-08-22 20:06:23 -04001953 if (error != 0) {
Niels de Vos1e8968c2013-12-17 18:20:16 +01001954 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
Chuck Lever873101b2006-08-22 20:06:23 -04001955 dir->i_sb->s_id, dir->i_ino,
Al Viro6de14722013-09-16 10:53:17 -04001956 dentry, symname, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 d_drop(dentry);
Chuck Lever873101b2006-08-22 20:06:23 -04001958 __free_page(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001959 return error;
1960 }
1961
1962 /*
1963 * No big deal if we can't add this page to the page cache here.
1964 * READLINK will get the missing page from the server if needed.
1965 */
David Howells2b0143b2015-03-17 22:25:59 +00001966 if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
Chuck Lever873101b2006-08-22 20:06:23 -04001967 GFP_KERNEL)) {
Chuck Lever873101b2006-08-22 20:06:23 -04001968 SetPageUptodate(page);
1969 unlock_page(page);
Rafael Aquinia0b54ad2014-02-10 14:25:48 -08001970 /*
1971 * add_to_page_cache_lru() grabs an extra page refcount.
1972 * Drop it here to avoid leaking this page later.
1973 */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001974 put_page(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001975 } else
1976 __free_page(page);
1977
Chuck Lever873101b2006-08-22 20:06:23 -04001978 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001980EXPORT_SYMBOL_GPL(nfs_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981
Bryan Schumaker597d9282012-07-16 16:39:10 -04001982int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1984{
David Howells2b0143b2015-03-17 22:25:59 +00001985 struct inode *inode = d_inode(old_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 int error;
1987
Al Viro6de14722013-09-16 10:53:17 -04001988 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
1989 old_dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990
Trond Myklebust1fd10852013-08-21 13:54:44 -04001991 trace_nfs_link_enter(inode, dir, dentry);
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001992 NFS_PROTO(inode)->return_delegation(inode);
Trond Myklebust9a3936a2009-10-26 08:09:46 -04001993
Trond Myklebust9697d232007-10-02 21:58:05 -04001994 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
Trond Myklebustcf809552005-10-27 22:12:42 -04001996 if (error == 0) {
Al Viro7de9c6ee2010-10-23 11:11:40 -04001997 ihold(inode);
Trond Myklebust9697d232007-10-02 21:58:05 -04001998 d_add(dentry, inode);
Trond Myklebustcf809552005-10-27 22:12:42 -04001999 }
Trond Myklebust1fd10852013-08-21 13:54:44 -04002000 trace_nfs_link_exit(inode, dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 return error;
2002}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04002003EXPORT_SYMBOL_GPL(nfs_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
Benjamin Coddington920b4532017-02-01 00:00:07 -05002005static void
2006nfs_complete_rename(struct rpc_task *task, struct nfs_renamedata *data)
2007{
2008 struct dentry *old_dentry = data->old_dentry;
2009 struct dentry *new_dentry = data->new_dentry;
2010 struct inode *old_inode = d_inode(old_dentry);
2011 struct inode *new_inode = d_inode(new_dentry);
2012
2013 nfs_mark_for_revalidate(old_inode);
2014
2015 switch (task->tk_status) {
2016 case 0:
2017 if (new_inode != NULL)
2018 nfs_drop_nlink(new_inode);
2019 d_move(old_dentry, new_dentry);
2020 nfs_set_verifier(new_dentry,
2021 nfs_save_change_attribute(data->new_dir));
2022 break;
2023 case -ENOENT:
2024 nfs_dentry_handle_enoent(old_dentry);
2025 }
2026}
2027
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028/*
2029 * RENAME
2030 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
2031 * different file handle for the same inode after a rename (e.g. when
2032 * moving to a different directory). A fail-safe method to do so would
2033 * be to look up old_dir/old_name, create a link to new_dir/new_name and
2034 * rename the old file using the sillyrename stuff. This way, the original
2035 * file in old_dir will go away when the last process iput()s the inode.
2036 *
2037 * FIXED.
2038 *
2039 * It actually works quite well. One needs to have the possibility for
2040 * at least one ".nfs..." file in each directory the file ever gets
2041 * moved or linked to which happens automagically with the new
2042 * implementation that only depends on the dcache stuff instead of
2043 * using the inode layer
2044 *
2045 * Unfortunately, things are a little more complicated than indicated
2046 * above. For a cross-directory move, we want to make sure we can get
2047 * rid of the old inode after the operation. This means there must be
2048 * no pending writes (if it's a file), and the use count must be 1.
2049 * If these conditions are met, we can drop the dentries before doing
2050 * the rename.
2051 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04002052int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
Miklos Szeredi1cd66c92016-09-27 11:03:58 +02002053 struct inode *new_dir, struct dentry *new_dentry,
2054 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055{
David Howells2b0143b2015-03-17 22:25:59 +00002056 struct inode *old_inode = d_inode(old_dentry);
2057 struct inode *new_inode = d_inode(new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 struct dentry *dentry = NULL, *rehash = NULL;
Jeff Layton80a491f2014-03-17 07:06:56 -04002059 struct rpc_task *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 int error = -EBUSY;
2061
Miklos Szeredi1cd66c92016-09-27 11:03:58 +02002062 if (flags)
2063 return -EINVAL;
2064
Al Viro6de14722013-09-16 10:53:17 -04002065 dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
2066 old_dentry, new_dentry,
Al Viro84d08fa2013-07-05 18:59:33 +04002067 d_count(new_dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
Trond Myklebust70ded202013-08-21 12:08:45 -04002069 trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 /*
Miklos Szeredi28f79a12009-12-03 15:58:56 -05002071 * For non-directories, check whether the target is busy and if so,
2072 * make a copy of the dentry and then do a silly-rename. If the
2073 * silly-rename succeeds, the copied dentry is hashed and becomes
2074 * the new target.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 */
Miklos Szeredi27226102009-12-03 15:58:56 -05002076 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
2077 /*
2078 * To prevent any new references to the target during the
2079 * rename, we unhash the dentry in advance.
2080 */
2081 if (!d_unhashed(new_dentry)) {
2082 d_drop(new_dentry);
2083 rehash = new_dentry;
2084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
Al Viro84d08fa2013-07-05 18:59:33 +04002086 if (d_count(new_dentry) > 2) {
Miklos Szeredi27226102009-12-03 15:58:56 -05002087 int err;
2088
2089 /* copy the target dentry's name */
2090 dentry = d_alloc(new_dentry->d_parent,
2091 &new_dentry->d_name);
2092 if (!dentry)
2093 goto out;
2094
2095 /* silly-rename the existing target ... */
2096 err = nfs_sillyrename(new_dir, new_dentry);
Miklos Szeredi24e93022009-12-03 15:58:56 -05002097 if (err)
Miklos Szeredi27226102009-12-03 15:58:56 -05002098 goto out;
Miklos Szeredi24e93022009-12-03 15:58:56 -05002099
2100 new_dentry = dentry;
OGAWA Hirofumi56335932010-01-06 18:48:26 -05002101 rehash = NULL;
Miklos Szeredi24e93022009-12-03 15:58:56 -05002102 new_inode = NULL;
Miklos Szeredi27226102009-12-03 15:58:56 -05002103 }
Trond Myklebustb1e4adf2009-03-19 15:35:49 -04002104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04002106 NFS_PROTO(old_inode)->return_delegation(old_inode);
Trond Myklebustb1e4adf2009-03-19 15:35:49 -04002107 if (new_inode != NULL)
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04002108 NFS_PROTO(new_inode)->return_delegation(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
Benjamin Coddington920b4532017-02-01 00:00:07 -05002110 task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry,
2111 nfs_complete_rename);
Jeff Layton80a491f2014-03-17 07:06:56 -04002112 if (IS_ERR(task)) {
2113 error = PTR_ERR(task);
2114 goto out;
2115 }
2116
2117 error = rpc_wait_for_completion_task(task);
2118 if (error == 0)
2119 error = task->tk_status;
2120 rpc_put_task(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121out:
2122 if (rehash)
2123 d_rehash(rehash);
Trond Myklebust70ded202013-08-21 12:08:45 -04002124 trace_nfs_rename_exit(old_dir, old_dentry,
2125 new_dir, new_dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 /* new dentry created? */
2127 if (dentry)
2128 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 return error;
2130}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04002131EXPORT_SYMBOL_GPL(nfs_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002133static DEFINE_SPINLOCK(nfs_access_lru_lock);
2134static LIST_HEAD(nfs_access_lru_list);
2135static atomic_long_t nfs_access_nr_entries;
2136
Trond Myklebust3a505842014-07-21 13:53:48 -04002137static unsigned long nfs_access_max_cachesize = ULONG_MAX;
2138module_param(nfs_access_max_cachesize, ulong, 0644);
2139MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length");
2140
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002141static void nfs_access_free_entry(struct nfs_access_entry *entry)
2142{
2143 put_rpccred(entry->cred);
NeilBrownf682a392014-07-14 11:28:20 +10002144 kfree_rcu(entry, rcu_head);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002145 smp_mb__before_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002146 atomic_long_dec(&nfs_access_nr_entries);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002147 smp_mb__after_atomic();
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002148}
2149
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002150static void nfs_access_free_list(struct list_head *head)
2151{
2152 struct nfs_access_entry *cache;
2153
2154 while (!list_empty(head)) {
2155 cache = list_entry(head->next, struct nfs_access_entry, lru);
2156 list_del(&cache->lru);
2157 nfs_access_free_entry(cache);
2158 }
2159}
2160
Trond Myklebust3a505842014-07-21 13:53:48 -04002161static unsigned long
2162nfs_do_access_cache_scan(unsigned int nr_to_scan)
Trond Myklebust979df722006-07-25 11:28:19 -04002163{
2164 LIST_HEAD(head);
Trond Myklebustaa510da2010-09-29 15:11:56 -04002165 struct nfs_inode *nfsi, *next;
Trond Myklebust979df722006-07-25 11:28:19 -04002166 struct nfs_access_entry *cache;
Dave Chinner1ab6c492013-08-28 10:18:09 +10002167 long freed = 0;
Trond Myklebust979df722006-07-25 11:28:19 -04002168
Trond Myklebusta50f7952007-06-05 19:23:43 -04002169 spin_lock(&nfs_access_lru_lock);
Trond Myklebustaa510da2010-09-29 15:11:56 -04002170 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
Trond Myklebust979df722006-07-25 11:28:19 -04002171 struct inode *inode;
2172
2173 if (nr_to_scan-- == 0)
2174 break;
Trond Myklebust9c7e7e22010-05-13 12:51:06 -04002175 inode = &nfsi->vfs_inode;
Trond Myklebust979df722006-07-25 11:28:19 -04002176 spin_lock(&inode->i_lock);
2177 if (list_empty(&nfsi->access_cache_entry_lru))
2178 goto remove_lru_entry;
2179 cache = list_entry(nfsi->access_cache_entry_lru.next,
2180 struct nfs_access_entry, lru);
2181 list_move(&cache->lru, &head);
2182 rb_erase(&cache->rb_node, &nfsi->access_cache);
Dave Chinner1ab6c492013-08-28 10:18:09 +10002183 freed++;
Trond Myklebust979df722006-07-25 11:28:19 -04002184 if (!list_empty(&nfsi->access_cache_entry_lru))
2185 list_move_tail(&nfsi->access_cache_inode_lru,
2186 &nfs_access_lru_list);
2187 else {
2188remove_lru_entry:
2189 list_del_init(&nfsi->access_cache_inode_lru);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002190 smp_mb__before_atomic();
Trond Myklebust979df722006-07-25 11:28:19 -04002191 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002192 smp_mb__after_atomic();
Trond Myklebust979df722006-07-25 11:28:19 -04002193 }
Trond Myklebust59844a92010-05-26 08:42:24 -04002194 spin_unlock(&inode->i_lock);
Trond Myklebust979df722006-07-25 11:28:19 -04002195 }
2196 spin_unlock(&nfs_access_lru_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002197 nfs_access_free_list(&head);
Dave Chinner1ab6c492013-08-28 10:18:09 +10002198 return freed;
2199}
2200
2201unsigned long
Trond Myklebust3a505842014-07-21 13:53:48 -04002202nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
2203{
2204 int nr_to_scan = sc->nr_to_scan;
2205 gfp_t gfp_mask = sc->gfp_mask;
2206
2207 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
2208 return SHRINK_STOP;
2209 return nfs_do_access_cache_scan(nr_to_scan);
2210}
2211
2212
2213unsigned long
Dave Chinner1ab6c492013-08-28 10:18:09 +10002214nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
2215{
Glauber Costa55f841c2013-08-28 10:17:53 +10002216 return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
Trond Myklebust979df722006-07-25 11:28:19 -04002217}
2218
Trond Myklebust3a505842014-07-21 13:53:48 -04002219static void
2220nfs_access_cache_enforce_limit(void)
2221{
2222 long nr_entries = atomic_long_read(&nfs_access_nr_entries);
2223 unsigned long diff;
2224 unsigned int nr_to_scan;
2225
2226 if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize)
2227 return;
2228 nr_to_scan = 100;
2229 diff = nr_entries - nfs_access_max_cachesize;
2230 if (diff < nr_to_scan)
2231 nr_to_scan = diff;
2232 nfs_do_access_cache_scan(nr_to_scan);
2233}
2234
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002235static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002236{
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002237 struct rb_root *root_node = &nfsi->access_cache;
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002238 struct rb_node *n;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002239 struct nfs_access_entry *entry;
2240
2241 /* Unhook entries from the cache */
2242 while ((n = rb_first(root_node)) != NULL) {
2243 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2244 rb_erase(n, root_node);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002245 list_move(&entry->lru, head);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002246 }
2247 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002248}
2249
2250void nfs_access_zap_cache(struct inode *inode)
2251{
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002252 LIST_HEAD(head);
2253
2254 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2255 return;
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002256 /* Remove from global LRU init */
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002257 spin_lock(&nfs_access_lru_lock);
2258 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002259 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002260
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002261 spin_lock(&inode->i_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002262 __nfs_access_zap_cache(NFS_I(inode), &head);
2263 spin_unlock(&inode->i_lock);
2264 spin_unlock(&nfs_access_lru_lock);
2265 nfs_access_free_list(&head);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002266}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04002267EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002268
2269static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2270{
2271 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2272 struct nfs_access_entry *entry;
2273
2274 while (n != NULL) {
2275 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2276
2277 if (cred < entry->cred)
2278 n = n->rb_left;
2279 else if (cred > entry->cred)
2280 n = n->rb_right;
2281 else
2282 return entry;
2283 }
2284 return NULL;
2285}
2286
Trond Myklebust57b69182016-06-03 17:07:19 -04002287static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res, bool may_block)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288{
Chuck Lever55296802005-08-18 11:24:09 -07002289 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002290 struct nfs_access_entry *cache;
Trond Myklebust57b69182016-06-03 17:07:19 -04002291 bool retry = true;
2292 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002294 spin_lock(&inode->i_lock);
Trond Myklebust57b69182016-06-03 17:07:19 -04002295 for(;;) {
2296 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2297 goto out_zap;
2298 cache = nfs_access_search_rbtree(inode, cred);
2299 err = -ENOENT;
2300 if (cache == NULL)
2301 goto out;
2302 /* Found an entry, is our attribute cache valid? */
Trond Myklebust21c3ba72016-12-16 18:40:03 -05002303 if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
Trond Myklebust57b69182016-06-03 17:07:19 -04002304 break;
2305 err = -ECHILD;
2306 if (!may_block)
2307 goto out;
2308 if (!retry)
2309 goto out_zap;
2310 spin_unlock(&inode->i_lock);
2311 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
2312 if (err)
2313 return err;
2314 spin_lock(&inode->i_lock);
2315 retry = false;
2316 }
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002317 res->jiffies = cache->jiffies;
2318 res->cred = cache->cred;
2319 res->mask = cache->mask;
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002320 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002321 err = 0;
2322out:
2323 spin_unlock(&inode->i_lock);
2324 return err;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002325out_zap:
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002326 spin_unlock(&inode->i_lock);
2327 nfs_access_zap_cache(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002328 return -ENOENT;
2329}
2330
NeilBrownf682a392014-07-14 11:28:20 +10002331static int nfs_access_get_cached_rcu(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
2332{
2333 /* Only check the most recently returned cache entry,
2334 * but do it without locking.
2335 */
2336 struct nfs_inode *nfsi = NFS_I(inode);
2337 struct nfs_access_entry *cache;
2338 int err = -ECHILD;
2339 struct list_head *lh;
2340
2341 rcu_read_lock();
2342 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2343 goto out;
2344 lh = rcu_dereference(nfsi->access_cache_entry_lru.prev);
2345 cache = list_entry(lh, struct nfs_access_entry, lru);
2346 if (lh == &nfsi->access_cache_entry_lru ||
2347 cred != cache->cred)
2348 cache = NULL;
2349 if (cache == NULL)
2350 goto out;
Trond Myklebust21c3ba72016-12-16 18:40:03 -05002351 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))
NeilBrownf682a392014-07-14 11:28:20 +10002352 goto out;
2353 res->jiffies = cache->jiffies;
2354 res->cred = cache->cred;
2355 res->mask = cache->mask;
Trond Myklebust21c3ba72016-12-16 18:40:03 -05002356 err = 0;
NeilBrownf682a392014-07-14 11:28:20 +10002357out:
2358 rcu_read_unlock();
2359 return err;
2360}
2361
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002362static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2363{
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002364 struct nfs_inode *nfsi = NFS_I(inode);
2365 struct rb_root *root_node = &nfsi->access_cache;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002366 struct rb_node **p = &root_node->rb_node;
2367 struct rb_node *parent = NULL;
2368 struct nfs_access_entry *entry;
2369
2370 spin_lock(&inode->i_lock);
2371 while (*p != NULL) {
2372 parent = *p;
2373 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2374
2375 if (set->cred < entry->cred)
2376 p = &parent->rb_left;
2377 else if (set->cred > entry->cred)
2378 p = &parent->rb_right;
2379 else
2380 goto found;
2381 }
2382 rb_link_node(&set->rb_node, parent, p);
2383 rb_insert_color(&set->rb_node, root_node);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002384 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002385 spin_unlock(&inode->i_lock);
2386 return;
2387found:
2388 rb_replace_node(parent, &set->rb_node, root_node);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002389 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2390 list_del(&entry->lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002391 spin_unlock(&inode->i_lock);
2392 nfs_access_free_entry(entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393}
2394
Weston Andros Adamson6168f622012-09-10 14:00:46 -04002395void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396{
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002397 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2398 if (cache == NULL)
2399 return;
2400 RB_CLEAR_NODE(&cache->rb_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 cache->jiffies = set->jiffies;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002402 cache->cred = get_rpccred(set->cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 cache->mask = set->mask;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002404
NeilBrownf682a392014-07-14 11:28:20 +10002405 /* The above field assignments must be visible
2406 * before this item appears on the lru. We cannot easily
2407 * use rcu_assign_pointer, so just force the memory barrier.
2408 */
2409 smp_wmb();
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002410 nfs_access_add_rbtree(inode, cache);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002411
2412 /* Update accounting */
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002413 smp_mb__before_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002414 atomic_long_inc(&nfs_access_nr_entries);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002415 smp_mb__after_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002416
2417 /* Add inode to global LRU list */
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002418 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002419 spin_lock(&nfs_access_lru_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002420 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2421 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2422 &nfs_access_lru_list);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002423 spin_unlock(&nfs_access_lru_lock);
2424 }
Trond Myklebust3a505842014-07-21 13:53:48 -04002425 nfs_access_cache_enforce_limit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426}
Weston Andros Adamson6168f622012-09-10 14:00:46 -04002427EXPORT_SYMBOL_GPL(nfs_access_add_cache);
2428
2429void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
2430{
2431 entry->mask = 0;
2432 if (access_result & NFS4_ACCESS_READ)
2433 entry->mask |= MAY_READ;
2434 if (access_result &
2435 (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
2436 entry->mask |= MAY_WRITE;
2437 if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
2438 entry->mask |= MAY_EXEC;
2439}
2440EXPORT_SYMBOL_GPL(nfs_access_set_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441
2442static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2443{
2444 struct nfs_access_entry cache;
Trond Myklebust57b69182016-06-03 17:07:19 -04002445 bool may_block = (mask & MAY_NOT_BLOCK) == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 int status;
2447
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002448 trace_nfs_access_enter(inode);
2449
NeilBrownf682a392014-07-14 11:28:20 +10002450 status = nfs_access_get_cached_rcu(inode, cred, &cache);
2451 if (status != 0)
Trond Myklebust57b69182016-06-03 17:07:19 -04002452 status = nfs_access_get_cached(inode, cred, &cache, may_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 if (status == 0)
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002454 goto out_cached;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455
NeilBrownf3324a22014-07-14 11:28:20 +10002456 status = -ECHILD;
Trond Myklebust57b69182016-06-03 17:07:19 -04002457 if (!may_block)
NeilBrownf3324a22014-07-14 11:28:20 +10002458 goto out;
2459
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 /* Be clever: ask server to check for all possible rights */
2461 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2462 cache.cred = cred;
2463 cache.jiffies = jiffies;
2464 status = NFS_PROTO(inode)->access(inode, &cache);
Suresh Jayaramana71ee332009-03-10 20:33:21 -04002465 if (status != 0) {
2466 if (status == -ESTALE) {
2467 nfs_zap_caches(inode);
2468 if (!S_ISDIR(inode->i_mode))
2469 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2470 }
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002471 goto out;
Suresh Jayaramana71ee332009-03-10 20:33:21 -04002472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 nfs_access_add_cache(inode, &cache);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002474out_cached:
2475 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
2476 status = -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477out:
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002478 trace_nfs_access_exit(inode, status);
2479 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480}
2481
Trond Myklebustaf22f942007-08-10 17:45:10 -04002482static int nfs_open_permission_mask(int openflags)
2483{
2484 int mask = 0;
2485
Weston Andros Adamsonf8d9a892013-01-03 16:42:29 -05002486 if (openflags & __FMODE_EXEC) {
2487 /* ONLY check exec rights */
2488 mask = MAY_EXEC;
2489 } else {
2490 if ((openflags & O_ACCMODE) != O_WRONLY)
2491 mask |= MAY_READ;
2492 if ((openflags & O_ACCMODE) != O_RDONLY)
2493 mask |= MAY_WRITE;
2494 }
2495
Trond Myklebustaf22f942007-08-10 17:45:10 -04002496 return mask;
2497}
2498
2499int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2500{
2501 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2502}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002503EXPORT_SYMBOL_GPL(nfs_may_open);
Trond Myklebustaf22f942007-08-10 17:45:10 -04002504
Trond Myklebust5c5fc092015-12-28 19:30:05 -05002505static int nfs_execute_ok(struct inode *inode, int mask)
2506{
2507 struct nfs_server *server = NFS_SERVER(inode);
Trond Myklebust21c3ba72016-12-16 18:40:03 -05002508 int ret = 0;
Trond Myklebust5c5fc092015-12-28 19:30:05 -05002509
Trond Myklebust21c3ba72016-12-16 18:40:03 -05002510 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS)) {
2511 if (mask & MAY_NOT_BLOCK)
2512 return -ECHILD;
2513 ret = __nfs_revalidate_inode(server, inode);
2514 }
Trond Myklebust5c5fc092015-12-28 19:30:05 -05002515 if (ret == 0 && !execute_ok(inode))
2516 ret = -EACCES;
2517 return ret;
2518}
2519
Al Viro10556cb2011-06-20 19:28:19 -04002520int nfs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521{
2522 struct rpc_cred *cred;
2523 int res = 0;
2524
Chuck Lever91d5b472006-03-20 13:44:14 -05002525 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2526
Al Viroe6305c42008-07-15 21:03:57 -04002527 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 goto out;
2529 /* Is this sys_access() ? */
Eric Paris9cfcac82010-07-23 11:43:51 -04002530 if (mask & (MAY_ACCESS | MAY_CHDIR))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 goto force_lookup;
2532
2533 switch (inode->i_mode & S_IFMT) {
2534 case S_IFLNK:
2535 goto out;
2536 case S_IFREG:
Trond Myklebust762674f2015-12-26 21:54:58 -05002537 if ((mask & MAY_OPEN) &&
2538 nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN))
2539 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 break;
2541 case S_IFDIR:
2542 /*
2543 * Optimize away all write operations, since the server
2544 * will check permissions when we perform the op.
2545 */
2546 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2547 goto out;
2548 }
2549
2550force_lookup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 if (!NFS_PROTO(inode)->access)
2552 goto out_notsup;
2553
NeilBrownf3324a22014-07-14 11:28:20 +10002554 /* Always try fast lookups first */
2555 rcu_read_lock();
2556 cred = rpc_lookup_cred_nonblock();
2557 if (!IS_ERR(cred))
2558 res = nfs_do_access(inode, cred, mask|MAY_NOT_BLOCK);
2559 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 res = PTR_ERR(cred);
NeilBrownf3324a22014-07-14 11:28:20 +10002561 rcu_read_unlock();
2562 if (res == -ECHILD && !(mask & MAY_NOT_BLOCK)) {
2563 /* Fast lookup failed, try the slow way */
2564 cred = rpc_lookup_cred();
2565 if (!IS_ERR(cred)) {
2566 res = nfs_do_access(inode, cred, mask);
2567 put_rpccred(cred);
2568 } else
2569 res = PTR_ERR(cred);
2570 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571out:
Trond Myklebust5c5fc092015-12-28 19:30:05 -05002572 if (!res && (mask & MAY_EXEC))
2573 res = nfs_execute_ok(inode, mask);
Miklos Szeredif696a362008-07-31 13:41:58 +02002574
Niels de Vos1e8968c2013-12-17 18:20:16 +01002575 dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05002576 inode->i_sb->s_id, inode->i_ino, mask, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 return res;
2578out_notsup:
NeilBrownd51ac1a2014-07-14 11:28:20 +10002579 if (mask & MAY_NOT_BLOCK)
2580 return -ECHILD;
2581
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2583 if (res == 0)
Al Viro2830ba72011-06-20 19:16:29 -04002584 res = generic_permission(inode, mask);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05002585 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04002587EXPORT_SYMBOL_GPL(nfs_permission);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588
2589/*
2590 * Local variables:
2591 * version-control: t
2592 * kept-new-versions: 5
2593 * End:
2594 */