blob: 4a3d4ef76127bc716028d3d9df25791d91ff76ce [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 Viro23db8622013-05-17 16:34:50 -040060 .iterate = 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{
Trond Myklebust311324a2014-02-07 17:02:08 -0500136 put_nfs_open_dir_context(filp->f_path.dentry->d_inode, 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 {
Chuck Lever88b8e132012-03-01 17:00:23 -0500148 int size;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400149 int eof_index;
150 u64 last_cookie;
151 struct nfs_cache_array_entry array[0];
152};
153
Chuck Lever573c4e12010-12-14 14:58:11 +0000154typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155typedef struct {
156 struct file *file;
157 struct page *page;
Al Viro23db8622013-05-17 16:34:50 -0400158 struct dir_context *ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 unsigned long page_index;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000160 u64 *dir_cookie;
Trond Myklebust0aded702010-11-30 21:56:32 -0500161 u64 last_cookie;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000162 loff_t current_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 decode_dirent_t decode;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400164
Neil Brown1f4eab72007-04-16 09:35:27 +1000165 unsigned long timestamp;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400166 unsigned long gencount;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400167 unsigned int cache_entry_index;
168 unsigned int plus:1;
169 unsigned int eof:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170} nfs_readdir_descriptor_t;
171
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400172/*
173 * The caller is responsible for calling nfs_readdir_release_array(page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 */
175static
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400176struct nfs_cache_array *nfs_readdir_get_array(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500178 void *ptr;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400179 if (page == NULL)
180 return ERR_PTR(-EIO);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500181 ptr = kmap(page);
182 if (ptr == NULL)
183 return ERR_PTR(-ENOMEM);
184 return ptr;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400185}
186
187static
188void nfs_readdir_release_array(struct page *page)
189{
190 kunmap(page);
191}
192
193/*
194 * we are freeing strings created by nfs_add_to_readdir_array()
195 */
196static
Trond Myklebust11de3b12010-12-01 14:17:06 -0500197void nfs_readdir_clear_array(struct page *page)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400198{
Trond Myklebust11de3b12010-12-01 14:17:06 -0500199 struct nfs_cache_array *array;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400200 int i;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500201
Cong Wang2b86ce22011-11-25 23:14:33 +0800202 array = kmap_atomic(page);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400203 for (i = 0; i < array->size; i++)
204 kfree(array->array[i].string.name);
Cong Wang2b86ce22011-11-25 23:14:33 +0800205 kunmap_atomic(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400206}
207
208/*
209 * the caller is responsible for freeing qstr.name
210 * when called by nfs_readdir_add_to_array, the strings will be freed in
211 * nfs_clear_readdir_array()
212 */
213static
Trond Myklebust4a201d62010-10-23 14:53:23 -0400214int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400215{
216 string->len = len;
217 string->name = kmemdup(name, len, GFP_KERNEL);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400218 if (string->name == NULL)
219 return -ENOMEM;
Catalin Marinas04e4bd12010-11-11 12:53:47 +0000220 /*
221 * Avoid a kmemleak false positive. The pointer to the name is stored
222 * in a page cache page which kmemleak does not scan.
223 */
224 kmemleak_not_leak(string->name);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400225 string->hash = full_name_hash(name, len);
226 return 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400227}
228
229static
230int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page)
231{
232 struct nfs_cache_array *array = nfs_readdir_get_array(page);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400233 struct nfs_cache_array_entry *cache_entry;
234 int ret;
235
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400236 if (IS_ERR(array))
237 return PTR_ERR(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400238
Trond Myklebust4a201d62010-10-23 14:53:23 -0400239 cache_entry = &array->array[array->size];
Trond Myklebust3020093f2010-11-20 15:18:22 -0500240
241 /* Check that this entry lies within the page bounds */
242 ret = -ENOSPC;
243 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE)
244 goto out;
245
Trond Myklebust4a201d62010-10-23 14:53:23 -0400246 cache_entry->cookie = entry->prev_cookie;
247 cache_entry->ino = entry->ino;
Trond Myklebust0b26a0b2010-11-20 14:26:44 -0500248 cache_entry->d_type = entry->d_type;
Trond Myklebust4a201d62010-10-23 14:53:23 -0400249 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len);
250 if (ret)
251 goto out;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400252 array->last_cookie = entry->cookie;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500253 array->size++;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500254 if (entry->eof != 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400255 array->eof_index = array->size;
Trond Myklebust4a201d62010-10-23 14:53:23 -0400256out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400257 nfs_readdir_release_array(page);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400258 return ret;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400259}
260
261static
262int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
263{
Al Viro23db8622013-05-17 16:34:50 -0400264 loff_t diff = desc->ctx->pos - desc->current_index;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400265 unsigned int index;
266
267 if (diff < 0)
268 goto out_eof;
269 if (diff >= array->size) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500270 if (array->eof_index >= 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400271 goto out_eof;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400272 return -EAGAIN;
273 }
274
275 index = (unsigned int)diff;
276 *desc->dir_cookie = array->array[index].cookie;
277 desc->cache_entry_index = index;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400278 return 0;
279out_eof:
280 desc->eof = 1;
281 return -EBADCOOKIE;
282}
283
Jeff Layton4db72b42014-01-28 13:47:46 -0500284static bool
285nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi)
286{
287 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
288 return false;
289 smp_rmb();
290 return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags);
291}
292
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400293static
294int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc)
295{
296 int i;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400297 loff_t new_pos;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400298 int status = -EAGAIN;
299
300 for (i = 0; i < array->size; i++) {
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400301 if (array->array[i].cookie == *desc->dir_cookie) {
Al Viro496ad9a2013-01-23 17:07:38 -0500302 struct nfs_inode *nfsi = NFS_I(file_inode(desc->file));
Trond Myklebust0c030802011-07-30 12:45:35 -0400303 struct nfs_open_dir_context *ctx = desc->file->private_data;
304
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400305 new_pos = desc->current_index + i;
Jeff Layton4db72b42014-01-28 13:47:46 -0500306 if (ctx->attr_gencount != nfsi->attr_gencount ||
307 !nfs_readdir_inode_mapping_valid(nfsi)) {
Trond Myklebust0c030802011-07-30 12:45:35 -0400308 ctx->duped = 0;
309 ctx->attr_gencount = nfsi->attr_gencount;
Al Viro23db8622013-05-17 16:34:50 -0400310 } else if (new_pos < desc->ctx->pos) {
Trond Myklebust0c030802011-07-30 12:45:35 -0400311 if (ctx->duped > 0
312 && ctx->dup_cookie == *desc->dir_cookie) {
313 if (printk_ratelimit()) {
Al Viro6de14722013-09-16 10:53:17 -0400314 pr_notice("NFS: directory %pD2 contains a readdir loop."
Trond Myklebust0c030802011-07-30 12:45:35 -0400315 "Please contact your server vendor. "
Jeff Layton9581a4a2014-04-05 08:45:57 -0400316 "The file: %.*s has duplicate cookie %llu\n",
317 desc->file, array->array[i].string.len,
318 array->array[i].string.name, *desc->dir_cookie);
Trond Myklebust0c030802011-07-30 12:45:35 -0400319 }
320 status = -ELOOP;
321 goto out;
322 }
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400323 ctx->dup_cookie = *desc->dir_cookie;
Trond Myklebust0c030802011-07-30 12:45:35 -0400324 ctx->duped = -1;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400325 }
Al Viro23db8622013-05-17 16:34:50 -0400326 desc->ctx->pos = new_pos;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400327 desc->cache_entry_index = i;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500328 return 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400329 }
330 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500331 if (array->eof_index >= 0) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500332 status = -EBADCOOKIE;
Trond Myklebust18fb5fe2010-12-07 12:41:58 -0500333 if (*desc->dir_cookie == array->last_cookie)
334 desc->eof = 1;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500335 }
Trond Myklebust0c030802011-07-30 12:45:35 -0400336out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400337 return status;
338}
339
340static
341int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc)
342{
343 struct nfs_cache_array *array;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500344 int status;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400345
346 array = nfs_readdir_get_array(desc->page);
347 if (IS_ERR(array)) {
348 status = PTR_ERR(array);
349 goto out;
350 }
351
352 if (*desc->dir_cookie == 0)
353 status = nfs_readdir_search_for_pos(array, desc);
354 else
355 status = nfs_readdir_search_for_cookie(array, desc);
356
Trond Myklebust47c716c2010-12-07 12:44:56 -0500357 if (status == -EAGAIN) {
Trond Myklebust0aded702010-11-30 21:56:32 -0500358 desc->last_cookie = array->last_cookie;
Trond Myklebuste47c0852011-03-23 08:43:09 -0400359 desc->current_index += array->size;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500360 desc->page_index++;
361 }
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400362 nfs_readdir_release_array(desc->page);
363out:
364 return status;
365}
366
367/* Fill a page with xdr information before transferring to the cache page */
368static
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400369int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc,
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400370 struct nfs_entry *entry, struct file *file, struct inode *inode)
371{
Bryan Schumaker480c2002011-03-23 14:48:29 -0400372 struct nfs_open_dir_context *ctx = file->private_data;
373 struct rpc_cred *cred = ctx->cred;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400374 unsigned long timestamp, gencount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 int error;
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 again:
378 timestamp = jiffies;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400379 gencount = nfs_inc_attr_generation_counter();
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400380 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 NFS_SERVER(inode)->dtsize, desc->plus);
382 if (error < 0) {
383 /* We requested READDIRPLUS, but the server doesn't grok it */
384 if (error == -ENOTSUPP && desc->plus) {
385 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
Benny Halevy3a10c302008-01-23 08:58:59 +0200386 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 desc->plus = 0;
388 goto again;
389 }
390 goto error;
391 }
Neil Brown1f4eab72007-04-16 09:35:27 +1000392 desc->timestamp = timestamp;
Trond Myklebust4704f0e2008-10-14 19:16:07 -0400393 desc->gencount = gencount;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400394error:
395 return error;
396}
397
Chuck Lever573c4e12010-12-14 14:58:11 +0000398static int xdr_decode(nfs_readdir_descriptor_t *desc,
399 struct nfs_entry *entry, struct xdr_stream *xdr)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400400{
Chuck Lever573c4e12010-12-14 14:58:11 +0000401 int error;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400402
Chuck Lever573c4e12010-12-14 14:58:11 +0000403 error = desc->decode(xdr, entry, desc->plus);
404 if (error)
405 return error;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400406 entry->fattr->time_start = desc->timestamp;
407 entry->fattr->gencount = desc->gencount;
408 return 0;
409}
410
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400411static
412int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
413{
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400414 if (dentry->d_inode == NULL)
415 goto different;
Trond Myklebust37a09f02010-11-30 12:42:34 -0500416 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0)
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400417 goto different;
418 return 1;
419different:
420 return 0;
421}
422
423static
Al Viro23db8622013-05-17 16:34:50 -0400424bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx)
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400425{
426 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS))
427 return false;
428 if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags))
429 return true;
Al Viro23db8622013-05-17 16:34:50 -0400430 if (ctx->pos == 0)
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400431 return true;
432 return false;
433}
434
435/*
436 * This function is called by the lookup code to request the use of
437 * readdirplus to accelerate any future lookups in the same
438 * directory.
439 */
440static
441void nfs_advise_use_readdirplus(struct inode *dir)
442{
443 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);
444}
445
Trond Myklebust311324a2014-02-07 17:02:08 -0500446/*
447 * This function is mainly for use by nfs_getattr().
448 *
449 * If this is an 'ls -l', we want to force use of readdirplus.
450 * Do this by checking if there is an active file descriptor
451 * and calling nfs_advise_use_readdirplus, then forcing a
452 * cache flush.
453 */
454void nfs_force_use_readdirplus(struct inode *dir)
455{
456 if (!list_empty(&NFS_I(dir)->open_files)) {
457 nfs_advise_use_readdirplus(dir);
458 nfs_zap_mapping(dir, dir->i_mapping);
459 }
460}
461
Trond Myklebustd69ee9b2012-05-01 17:37:59 -0400462static
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400463void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
464{
Linus Torvalds26fe5752012-05-10 13:14:12 -0700465 struct qstr filename = QSTR_INIT(entry->name, entry->len);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400466 struct dentry *dentry;
467 struct dentry *alias;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400468 struct inode *dir = parent->d_inode;
469 struct inode *inode;
David Quigleyaa9c2662013-05-22 12:50:44 -0400470 int status;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400471
Trond Myklebust4a201d62010-10-23 14:53:23 -0400472 if (filename.name[0] == '.') {
473 if (filename.len == 1)
474 return;
475 if (filename.len == 2 && filename.name[1] == '.')
476 return;
477 }
478 filename.hash = full_name_hash(filename.name, filename.len);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400479
Trond Myklebust4a201d62010-10-23 14:53:23 -0400480 dentry = d_lookup(parent, &filename);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400481 if (dentry != NULL) {
482 if (nfs_same_file(dentry, entry)) {
Jeff Laytoncda57a12013-07-04 06:35:23 -0400483 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
David Quigleyaa9c2662013-05-22 12:50:44 -0400484 status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
485 if (!status)
486 nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400487 goto out;
488 } else {
Al Viro696199f2012-11-29 22:00:51 -0500489 if (d_invalidate(dentry) != 0)
490 goto out;
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400491 dput(dentry);
492 }
493 }
494
495 dentry = d_alloc(parent, &filename);
Trond Myklebust4a201d62010-10-23 14:53:23 -0400496 if (dentry == NULL)
497 return;
498
David Quigley1775fd32013-05-22 12:50:42 -0400499 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400500 if (IS_ERR(inode))
501 goto out;
502
503 alias = d_materialise_unique(dentry, inode);
504 if (IS_ERR(alias))
505 goto out;
506 else if (alias) {
507 nfs_set_verifier(alias, nfs_save_change_attribute(dir));
508 dput(alias);
509 } else
510 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
511
512out:
513 dput(dentry);
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400514}
515
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400516/* Perform conversion from xdr to cache array */
517static
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500518int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry,
Trond Myklebust66502392011-01-08 17:45:38 -0500519 struct page **xdr_pages, struct page *page, unsigned int buflen)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400520{
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400521 struct xdr_stream stream;
Benny Halevyf7da7a12011-05-19 14:16:47 -0400522 struct xdr_buf buf;
Trond Myklebust66502392011-01-08 17:45:38 -0500523 struct page *scratch;
Bryan Schumaker99424382010-10-21 16:33:16 -0400524 struct nfs_cache_array *array;
Trond Myklebust5c346852010-11-20 12:43:45 -0500525 unsigned int count = 0;
526 int status;
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400527
Trond Myklebust66502392011-01-08 17:45:38 -0500528 scratch = alloc_page(GFP_KERNEL);
529 if (scratch == NULL)
530 return -ENOMEM;
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400531
Benny Halevyf7da7a12011-05-19 14:16:47 -0400532 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
Trond Myklebust66502392011-01-08 17:45:38 -0500533 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
Bryan Schumaker99424382010-10-21 16:33:16 -0400534
535 do {
536 status = xdr_decode(desc, entry, &stream);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500537 if (status != 0) {
538 if (status == -EAGAIN)
539 status = 0;
Bryan Schumaker99424382010-10-21 16:33:16 -0400540 break;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500541 }
Bryan Schumaker99424382010-10-21 16:33:16 -0400542
Trond Myklebust5c346852010-11-20 12:43:45 -0500543 count++;
544
Trond Myklebust47c716c2010-12-07 12:44:56 -0500545 if (desc->plus != 0)
Bryan Schumakerd39ab9d2010-09-24 18:50:01 -0400546 nfs_prime_dcache(desc->file->f_path.dentry, entry);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500547
548 status = nfs_readdir_add_to_array(entry, page);
549 if (status != 0)
550 break;
Bryan Schumaker99424382010-10-21 16:33:16 -0400551 } while (!entry->eof);
552
Trond Myklebust47c716c2010-12-07 12:44:56 -0500553 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
Bryan Schumaker99424382010-10-21 16:33:16 -0400554 array = nfs_readdir_get_array(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500555 if (!IS_ERR(array)) {
556 array->eof_index = array->size;
557 status = 0;
558 nfs_readdir_release_array(page);
Trond Myklebust5c346852010-11-20 12:43:45 -0500559 } else
560 status = PTR_ERR(array);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400561 }
Trond Myklebust66502392011-01-08 17:45:38 -0500562
563 put_page(scratch);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500564 return status;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400565}
566
567static
568void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages)
569{
570 unsigned int i;
571 for (i = 0; i < npages; i++)
572 put_page(pages[i]);
573}
574
575static
576void nfs_readdir_free_large_page(void *ptr, struct page **pages,
577 unsigned int npages)
578{
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400579 nfs_readdir_free_pagearray(pages, npages);
580}
581
582/*
583 * nfs_readdir_large_page will allocate pages that must be freed with a call
584 * to nfs_readdir_free_large_page
585 */
586static
Trond Myklebust66502392011-01-08 17:45:38 -0500587int nfs_readdir_large_page(struct page **pages, unsigned int npages)
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400588{
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400589 unsigned int i;
590
591 for (i = 0; i < npages; i++) {
592 struct page *page = alloc_page(GFP_KERNEL);
593 if (page == NULL)
594 goto out_freepages;
595 pages[i] = page;
596 }
Trond Myklebust66502392011-01-08 17:45:38 -0500597 return 0;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400598
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400599out_freepages:
600 nfs_readdir_free_pagearray(pages, i);
Trond Myklebust66502392011-01-08 17:45:38 -0500601 return -ENOMEM;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400602}
603
604static
605int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode)
606{
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400607 struct page *pages[NFS_MAX_READDIR_PAGES];
608 void *pages_ptr = NULL;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400609 struct nfs_entry entry;
610 struct file *file = desc->file;
611 struct nfs_cache_array *array;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500612 int status = -ENOMEM;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400613 unsigned int array_size = ARRAY_SIZE(pages);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400614
615 entry.prev_cookie = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500616 entry.cookie = desc->last_cookie;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400617 entry.eof = 0;
618 entry.fh = nfs_alloc_fhandle();
619 entry.fattr = nfs_alloc_fattr();
Chuck Lever573c4e12010-12-14 14:58:11 +0000620 entry.server = NFS_SERVER(inode);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400621 if (entry.fh == NULL || entry.fattr == NULL)
622 goto out;
623
David Quigley14c43f72013-05-22 12:50:43 -0400624 entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
625 if (IS_ERR(entry.label)) {
626 status = PTR_ERR(entry.label);
627 goto out;
628 }
629
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400630 array = nfs_readdir_get_array(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500631 if (IS_ERR(array)) {
632 status = PTR_ERR(array);
David Quigley14c43f72013-05-22 12:50:43 -0400633 goto out_label_free;
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500634 }
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400635 memset(array, 0, sizeof(struct nfs_cache_array));
636 array->eof_index = -1;
637
Trond Myklebust66502392011-01-08 17:45:38 -0500638 status = nfs_readdir_large_page(pages, array_size);
639 if (status < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400640 goto out_release_array;
641 do {
Trond Myklebustac396122010-11-15 20:26:22 -0500642 unsigned int pglen;
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400643 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode);
Bryan Schumakerbabddc72010-10-20 15:44:29 -0400644
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400645 if (status < 0)
646 break;
Trond Myklebustac396122010-11-15 20:26:22 -0500647 pglen = status;
Trond Myklebust66502392011-01-08 17:45:38 -0500648 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500649 if (status < 0) {
650 if (status == -ENOSPC)
651 status = 0;
652 break;
653 }
654 } while (array->eof_index < 0);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400655
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400656 nfs_readdir_free_large_page(pages_ptr, pages, array_size);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400657out_release_array:
658 nfs_readdir_release_array(page);
David Quigley14c43f72013-05-22 12:50:43 -0400659out_label_free:
660 nfs4_label_free(entry.label);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400661out:
662 nfs_free_fattr(entry.fattr);
663 nfs_free_fhandle(entry.fh);
664 return status;
665}
666
667/*
668 * Now we cache directories properly, by converting xdr information
669 * to an array that can be used for lookups later. This results in
670 * fewer cache pages, since we can store more information on each page.
671 * We only need to convert from xdr once so future lookups are much simpler
672 */
673static
674int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page)
675{
Al Viro496ad9a2013-01-23 17:07:38 -0500676 struct inode *inode = file_inode(desc->file);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500677 int ret;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400678
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500679 ret = nfs_readdir_xdr_to_array(desc, page, inode);
680 if (ret < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400681 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 SetPageUptodate(page);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400683
Trond Myklebust2aac05a2008-07-07 13:26:10 -0400684 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) {
Trond Myklebustcd9ae2b2006-10-19 23:28:40 -0700685 /* Should never happen */
686 nfs_zap_mapping(inode, inode->i_mapping);
687 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 unlock_page(page);
689 return 0;
690 error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 unlock_page(page);
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500692 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693}
694
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400695static
696void cache_page_release(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
Trond Myklebust11de3b12010-12-01 14:17:06 -0500698 if (!desc->page->mapping)
699 nfs_readdir_clear_array(desc->page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 page_cache_release(desc->page);
701 desc->page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400704static
705struct page *get_cache_page(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Al Viro496ad9a2013-01-23 17:07:38 -0500707 return read_cache_page(file_inode(desc->file)->i_mapping,
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400708 desc->page_index, (filler_t *)nfs_readdir_filler, desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
711/*
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400712 * Returns 0 if desc->dir_cookie was found on page desc->page_index
Olivier Galibert00a92642005-06-22 17:16:29 +0000713 */
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400714static
715int find_cache_page(nfs_readdir_descriptor_t *desc)
Olivier Galibert00a92642005-06-22 17:16:29 +0000716{
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400717 int res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000718
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400719 desc->page = get_cache_page(desc);
720 if (IS_ERR(desc->page))
721 return PTR_ERR(desc->page);
Olivier Galibert00a92642005-06-22 17:16:29 +0000722
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400723 res = nfs_readdir_search_array(desc);
Trond Myklebust47c716c2010-12-07 12:44:56 -0500724 if (res != 0)
725 cache_page_release(desc);
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400726 return res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000727}
728
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400729/* Search for desc->dir_cookie from the beginning of the page cache */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730static inline
731int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
732{
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500733 int res;
Olivier Galibert00a92642005-06-22 17:16:29 +0000734
Trond Myklebust0aded702010-11-30 21:56:32 -0500735 if (desc->page_index == 0) {
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500736 desc->current_index = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500737 desc->last_cookie = 0;
738 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500739 do {
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400740 res = find_cache_page(desc);
Trond Myklebust47c716c2010-12-07 12:44:56 -0500741 } while (res == -EAGAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return res;
743}
744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745/*
746 * Once we've found the start of the dirent within a page: fill 'er up...
747 */
748static
Al Viro23db8622013-05-17 16:34:50 -0400749int nfs_do_filldir(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
751 struct file *file = desc->file;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400752 int i = 0;
753 int res = 0;
754 struct nfs_cache_array *array = NULL;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400755 struct nfs_open_dir_context *ctx = file->private_data;
756
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400757 array = nfs_readdir_get_array(desc->page);
Trond Myklebuste7c58e92010-11-20 13:22:24 -0500758 if (IS_ERR(array)) {
759 res = PTR_ERR(array);
760 goto out;
761 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400763 for (i = desc->cache_entry_index; i < array->size; i++) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500764 struct nfs_cache_array_entry *ent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Trond Myklebustece0b422010-11-20 13:55:33 -0500766 ent = &array->array[i];
Al Viro23db8622013-05-17 16:34:50 -0400767 if (!dir_emit(desc->ctx, ent->string.name, ent->string.len,
768 nfs_compat_user_ino64(ent->ino), ent->d_type)) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500769 desc->eof = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 break;
Trond Myklebustece0b422010-11-20 13:55:33 -0500771 }
Al Viro23db8622013-05-17 16:34:50 -0400772 desc->ctx->pos++;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400773 if (i < (array->size-1))
774 *desc->dir_cookie = array->array[i+1].cookie;
775 else
776 *desc->dir_cookie = array->last_cookie;
Trond Myklebust0c030802011-07-30 12:45:35 -0400777 if (ctx->duped != 0)
778 ctx->duped = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 }
Trond Myklebust47c716c2010-12-07 12:44:56 -0500780 if (array->eof_index >= 0)
Trond Myklebust8cd51a02010-11-15 20:26:22 -0500781 desc->eof = 1;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400782
783 nfs_readdir_release_array(desc->page);
Trond Myklebuste7c58e92010-11-20 13:22:24 -0500784out:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400785 cache_page_release(desc);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500786 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n",
787 (unsigned long long)*desc->dir_cookie, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 return res;
789}
790
791/*
792 * If we cannot find a cookie in our cache, we suspect that this is
793 * because it points to a deleted file, so we ask the server to return
794 * whatever it thinks is the next entry. We then feed this to filldir.
795 * If all goes well, we should then be able to find our way round the
796 * cache on the next call to readdir_search_pagecache();
797 *
798 * NOTE: we cannot add the anonymous page to the pagecache because
799 * the data it contains might not be page aligned. Besides,
800 * we should already have a complete representation of the
801 * directory in the page cache by the time we get here.
802 */
803static inline
Al Viro23db8622013-05-17 16:34:50 -0400804int uncached_readdir(nfs_readdir_descriptor_t *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 struct page *page = NULL;
807 int status;
Al Viro496ad9a2013-01-23 17:07:38 -0500808 struct inode *inode = file_inode(desc->file);
Trond Myklebust0c030802011-07-30 12:45:35 -0400809 struct nfs_open_dir_context *ctx = desc->file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500811 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
812 (unsigned long long)*desc->dir_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814 page = alloc_page(GFP_HIGHUSER);
815 if (!page) {
816 status = -ENOMEM;
817 goto out;
818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500820 desc->page_index = 0;
Trond Myklebust0aded702010-11-30 21:56:32 -0500821 desc->last_cookie = *desc->dir_cookie;
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500822 desc->page = page;
Trond Myklebust0c030802011-07-30 12:45:35 -0400823 ctx->duped = 0;
Trond Myklebust7a8e1dc2010-11-20 13:24:46 -0500824
Trond Myklebust85f86072010-11-20 13:24:49 -0500825 status = nfs_readdir_xdr_to_array(desc, page, inode);
826 if (status < 0)
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400827 goto out_release;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400828
Al Viro23db8622013-05-17 16:34:50 -0400829 status = nfs_do_filldir(desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 out:
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500832 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700833 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 return status;
835 out_release:
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400836 cache_page_release(desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 goto out;
838}
839
Trond Myklebust311324a2014-02-07 17:02:08 -0500840static bool nfs_dir_mapping_need_revalidate(struct inode *dir)
841{
842 struct nfs_inode *nfsi = NFS_I(dir);
843
844 if (nfs_attribute_cache_expired(dir))
845 return true;
846 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
847 return true;
848 return false;
849}
850
Olivier Galibert00a92642005-06-22 17:16:29 +0000851/* The file offset position represents the dirent entry number. A
852 last cookie cache takes care of the common case of reading the
853 whole directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 */
Al Viro23db8622013-05-17 16:34:50 -0400855static int nfs_readdir(struct file *file, struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
Al Viro23db8622013-05-17 16:34:50 -0400857 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 struct inode *inode = dentry->d_inode;
859 nfs_readdir_descriptor_t my_desc,
860 *desc = &my_desc;
Al Viro23db8622013-05-17 16:34:50 -0400861 struct nfs_open_dir_context *dir_ctx = file->private_data;
Scott Mayhew07b5ce82013-07-05 17:49:31 -0400862 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Al Viro6de14722013-09-16 10:53:17 -0400864 dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
865 file, (long long)ctx->pos);
Chuck Lever91d5b472006-03-20 13:44:14 -0500866 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 /*
Al Viro23db8622013-05-17 16:34:50 -0400869 * ctx->pos points to the dirent entry number.
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000870 * *desc->dir_cookie has the cookie for the next entry. We have
Olivier Galibert00a92642005-06-22 17:16:29 +0000871 * to either find the entry with the appropriate number or
872 * revalidate the cookie.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 */
874 memset(desc, 0, sizeof(*desc));
875
Al Viro23db8622013-05-17 16:34:50 -0400876 desc->file = file;
877 desc->ctx = ctx;
Bryan Schumaker480c2002011-03-23 14:48:29 -0400878 desc->dir_cookie = &dir_ctx->dir_cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 desc->decode = NFS_PROTO(inode)->decode_dirent;
Al Viro23db8622013-05-17 16:34:50 -0400880 desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Trond Myklebust565277f2007-10-15 18:17:53 -0400882 nfs_block_sillyrename(dentry);
Trond Myklebust311324a2014-02-07 17:02:08 -0500883 if (ctx->pos == 0 || nfs_dir_mapping_need_revalidate(inode))
Scott Mayhew07b5ce82013-07-05 17:49:31 -0400884 res = nfs_revalidate_mapping(inode, file->f_mapping);
Trond Myklebustfccca7f2008-01-26 17:37:47 -0500885 if (res < 0)
886 goto out;
887
Trond Myklebust47c716c2010-12-07 12:44:56 -0500888 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 res = readdir_search_pagecache(desc);
Olivier Galibert00a92642005-06-22 17:16:29 +0000890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 if (res == -EBADCOOKIE) {
Trond Myklebustece0b422010-11-20 13:55:33 -0500892 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 /* This means either end of directory */
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400894 if (*desc->dir_cookie && desc->eof == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 /* Or that the server has 'lost' a cookie */
Al Viro23db8622013-05-17 16:34:50 -0400896 res = uncached_readdir(desc);
Trond Myklebustece0b422010-11-20 13:55:33 -0500897 if (res == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 continue;
899 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 break;
901 }
902 if (res == -ETOOSMALL && desc->plus) {
Benny Halevy3a10c302008-01-23 08:58:59 +0200903 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 nfs_zap_caches(inode);
Trond Myklebustbaf57a02010-09-24 18:49:43 -0400905 desc->page_index = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 desc->plus = 0;
Bryan Schumakerd1bacf92010-09-24 14:48:42 -0400907 desc->eof = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 continue;
909 }
910 if (res < 0)
911 break;
912
Al Viro23db8622013-05-17 16:34:50 -0400913 res = nfs_do_filldir(desc);
Trond Myklebustece0b422010-11-20 13:55:33 -0500914 if (res < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 break;
Trond Myklebust47c716c2010-12-07 12:44:56 -0500916 } while (!desc->eof);
Trond Myklebustfccca7f2008-01-26 17:37:47 -0500917out:
Trond Myklebust565277f2007-10-15 18:17:53 -0400918 nfs_unblock_sillyrename(dentry);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500919 if (res > 0)
920 res = 0;
Al Viro6de14722013-09-16 10:53:17 -0400921 dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500922 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
924
Andrew Morton965c8e52012-12-17 15:59:39 -0800925static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000926{
Al Viro6de14722013-09-16 10:53:17 -0400927 struct inode *inode = file_inode(filp);
Bryan Schumaker480c2002011-03-23 14:48:29 -0400928 struct nfs_open_dir_context *dir_ctx = filp->private_data;
Chuck Leverb84e06c2008-06-11 17:55:34 -0400929
Al Viro6de14722013-09-16 10:53:17 -0400930 dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
931 filp, offset, whence);
Chuck Leverb84e06c2008-06-11 17:55:34 -0400932
933 mutex_lock(&inode->i_mutex);
Andrew Morton965c8e52012-12-17 15:59:39 -0800934 switch (whence) {
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000935 case 1:
936 offset += filp->f_pos;
937 case 0:
938 if (offset >= 0)
939 break;
940 default:
941 offset = -EINVAL;
942 goto out;
943 }
944 if (offset != filp->f_pos) {
945 filp->f_pos = offset;
Bryan Schumaker480c2002011-03-23 14:48:29 -0400946 dir_ctx->dir_cookie = 0;
Bryan Schumaker8ef2ce32011-03-23 15:04:31 -0400947 dir_ctx->duped = 0;
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000948 }
949out:
Chuck Leverb84e06c2008-06-11 17:55:34 -0400950 mutex_unlock(&inode->i_mutex);
Trond Myklebustf0dd2132005-06-22 17:16:29 +0000951 return offset;
952}
953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954/*
955 * All directory operations under NFS are synchronous, so fsync()
956 * is a dummy operation.
957 */
Josef Bacik02c24a82011-07-16 20:44:56 -0400958static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
959 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
Al Viro6de14722013-09-16 10:53:17 -0400961 struct inode *inode = file_inode(filp);
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200962
Al Viro6de14722013-09-16 10:53:17 -0400963 dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -0500964
Josef Bacik02c24a82011-07-16 20:44:56 -0400965 mutex_lock(&inode->i_mutex);
Al Viro6de14722013-09-16 10:53:17 -0400966 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
Josef Bacik02c24a82011-07-16 20:44:56 -0400967 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 return 0;
969}
970
Trond Myklebustbfc69a42007-10-15 18:18:29 -0400971/**
972 * nfs_force_lookup_revalidate - Mark the directory as having changed
973 * @dir - pointer to directory inode
974 *
975 * This forces the revalidation code in nfs_lookup_revalidate() to do a
976 * full lookup on all child dentries of 'dir' whenever a change occurs
977 * on the server that might have invalidated our dcache.
978 *
979 * The caller should be holding dir->i_lock
980 */
981void nfs_force_lookup_revalidate(struct inode *dir)
982{
Trond Myklebust011935a2008-10-14 19:24:50 -0400983 NFS_I(dir)->cache_change_attribute++;
Trond Myklebustbfc69a42007-10-15 18:18:29 -0400984}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400985EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);
Trond Myklebustbfc69a42007-10-15 18:18:29 -0400986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987/*
988 * A check for whether or not the parent directory has changed.
989 * In the case it has, we assume that the dentries are untrustworthy
990 * and may need to be looked up again.
991 */
Trond Myklebustc79ba782007-01-31 08:16:24 -0500992static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993{
994 if (IS_ROOT(dentry))
995 return 1;
Trond Myklebust4eec9522008-07-15 17:58:13 -0400996 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
997 return 0;
Trond Myklebustf2c77f42007-10-02 12:54:39 -0400998 if (!nfs_verify_change_attribute(dir, dentry->d_time))
999 return 0;
1000 /* Revalidate nfsi->cache_change_attribute before we declare a match */
1001 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)
1002 return 0;
1003 if (!nfs_verify_change_attribute(dir, dentry->d_time))
1004 return 0;
1005 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006}
1007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008/*
Trond Myklebusta12802c2007-10-02 19:13:04 -04001009 * Use intent information to check whether or not we're going to do
1010 * an O_EXCL create using this path component.
1011 */
Al Virofa3c56b2012-06-10 15:36:40 -04001012static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
Trond Myklebusta12802c2007-10-02 19:13:04 -04001013{
1014 if (NFS_PROTO(dir)->version == 2)
1015 return 0;
Al Virofa3c56b2012-06-10 15:36:40 -04001016 return flags & LOOKUP_EXCL;
Trond Myklebusta12802c2007-10-02 19:13:04 -04001017}
1018
1019/*
Trond Myklebust1d6757f2005-06-07 18:37:01 -04001020 * Inode and filehandle revalidation for lookups.
1021 *
1022 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL,
1023 * or if the intent information indicates that we're about to open this
1024 * particular file and the "nocto" mount flag is not set.
1025 *
1026 */
Trond Myklebust65a0c142012-12-14 17:51:40 -05001027static
Al Virofa3c56b2012-06-10 15:36:40 -04001028int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
1030 struct nfs_server *server = NFS_SERVER(inode);
Trond Myklebust65a0c142012-12-14 17:51:40 -05001031 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
David Howells36d43a42011-01-14 18:45:42 +00001033 if (IS_AUTOMOUNT(inode))
Trond Myklebust4e99a1f2008-03-06 12:34:59 -05001034 return 0;
Al Virofacc3532012-06-10 15:33:51 -04001035 /* VFS wants an on-the-wire revalidation */
Al Virofa3c56b2012-06-10 15:36:40 -04001036 if (flags & LOOKUP_REVAL)
Al Virofacc3532012-06-10 15:33:51 -04001037 goto out_force;
1038 /* This is an open(2) */
Al Virofa3c56b2012-06-10 15:36:40 -04001039 if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
1040 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
Al Virofacc3532012-06-10 15:33:51 -04001041 goto out_force;
Trond Myklebust65a0c142012-12-14 17:51:40 -05001042out:
1043 return (inode->i_nlink == 0) ? -ENOENT : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044out_force:
Trond Myklebust65a0c142012-12-14 17:51:40 -05001045 ret = __nfs_revalidate_inode(server, inode);
1046 if (ret != 0)
1047 return ret;
1048 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
1051/*
1052 * We judge how long we want to trust negative
1053 * dentries by looking at the parent inode mtime.
1054 *
1055 * If parent mtime has changed, we revalidate, else we wait for a
1056 * period corresponding to the parent's attribute cache timeout value.
1057 */
1058static inline
1059int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
Al Virofa3c56b2012-06-10 15:36:40 -04001060 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 /* Don't revalidate a negative dentry if we're creating a new file */
Al Virofa3c56b2012-06-10 15:36:40 -04001063 if (flags & LOOKUP_CREATE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 return 0;
Trond Myklebust4eec9522008-07-15 17:58:13 -04001065 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
1066 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return !nfs_check_verifier(dir, dentry);
1068}
1069
1070/*
1071 * This is called every time the dcache has a lookup hit,
1072 * and we should check whether we can really trust that
1073 * lookup.
1074 *
1075 * NOTE! The hit can be a negative hit too, don't assume
1076 * we have an inode!
1077 *
1078 * If the parent directory is seen to have changed, we throw out the
1079 * cached dentry and do a new lookup.
1080 */
Al Viro0b728e12012-06-10 16:03:43 -04001081static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082{
1083 struct inode *dir;
1084 struct inode *inode;
1085 struct dentry *parent;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001086 struct nfs_fh *fhandle = NULL;
1087 struct nfs_fattr *fattr = NULL;
David Quigley1775fd32013-05-22 12:50:42 -04001088 struct nfs4_label *label = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
Al Virofa3c56b2012-06-10 15:36:40 -04001091 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +11001092 return -ECHILD;
1093
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 parent = dget_parent(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 dir = parent->d_inode;
Chuck Lever91d5b472006-03-20 13:44:14 -05001096 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 inode = dentry->d_inode;
1098
1099 if (!inode) {
Al Virofa3c56b2012-06-10 15:36:40 -04001100 if (nfs_neg_need_reval(dir, dentry, flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 goto out_bad;
Trond Myklebustd69ee9b2012-05-01 17:37:59 -04001102 goto out_valid_noent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
1104
1105 if (is_bad_inode(inode)) {
Al Viro6de14722013-09-16 10:53:17 -04001106 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1107 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 goto out_bad;
1109 }
1110
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001111 if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
Trond Myklebust15860ab2008-12-23 15:21:54 -05001112 goto out_set_verifier;
1113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 /* Force a full look up iff the parent directory has changed */
Al Virofa3c56b2012-06-10 15:36:40 -04001115 if (!nfs_is_exclusive_create(dir, flags) && nfs_check_verifier(dir, dentry)) {
1116 if (nfs_lookup_verify_inode(inode, flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 goto out_zap_parent;
1118 goto out_valid;
1119 }
1120
1121 if (NFS_STALE(inode))
1122 goto out_bad;
1123
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001124 error = -ENOMEM;
1125 fhandle = nfs_alloc_fhandle();
1126 fattr = nfs_alloc_fattr();
1127 if (fhandle == NULL || fattr == NULL)
1128 goto out_error;
1129
David Quigley14c43f72013-05-22 12:50:43 -04001130 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
1131 if (IS_ERR(label))
1132 goto out_error;
1133
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001134 trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
David Quigley1775fd32013-05-22 12:50:42 -04001135 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001136 trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 if (error)
1138 goto out_bad;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001139 if (nfs_compare_fh(NFS_FH(inode), fhandle))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 goto out_bad;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001141 if ((error = nfs_refresh_inode(inode, fattr)) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 goto out_bad;
1143
David Quigleyaa9c2662013-05-22 12:50:44 -04001144 nfs_setsecurity(inode, fattr, label);
1145
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001146 nfs_free_fattr(fattr);
1147 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001148 nfs4_label_free(label);
1149
Trond Myklebust15860ab2008-12-23 15:21:54 -05001150out_set_verifier:
Trond Myklebustcf8ba452007-10-01 13:46:53 -04001151 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 out_valid:
Trond Myklebustd69ee9b2012-05-01 17:37:59 -04001153 /* Success: notify readdir to use READDIRPLUS */
1154 nfs_advise_use_readdirplus(dir);
1155 out_valid_noent:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001157 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
1158 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 return 1;
1160out_zap_parent:
1161 nfs_zap_caches(dir);
1162 out_bad:
Al Viroc44600c2012-11-29 22:04:36 -05001163 nfs_free_fattr(fattr);
1164 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001165 nfs4_label_free(label);
Trond Myklebusta1643a92007-09-29 17:25:43 -04001166 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (inode && S_ISDIR(inode->i_mode)) {
1168 /* Purge readdir caches. */
1169 nfs_zap_caches(inode);
J. Bruce Fieldsa3f432b2013-10-15 17:03:16 -04001170 /*
1171 * We can't d_drop the root of a disconnected tree:
1172 * its d_hash is on the s_anon list and d_drop() would hide
1173 * it from shrink_dcache_for_unmount(), leading to busy
1174 * inodes on unmount and further oopses.
1175 */
1176 if (IS_ROOT(dentry))
Al Virod9e80b72010-04-29 03:10:43 +01001177 goto out_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
Miklos Szeredi13caa9f2013-09-05 11:44:40 +02001179 /* If we have submounts, don't unhash ! */
1180 if (check_submounts_and_drop(dentry) != 0)
1181 goto out_valid;
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001184 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
1185 __func__, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 return 0;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001187out_error:
1188 nfs_free_fattr(fattr);
1189 nfs_free_fhandle(fhandle);
David Quigley14c43f72013-05-22 12:50:43 -04001190 nfs4_label_free(label);
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001191 dput(parent);
Al Viro6de14722013-09-16 10:53:17 -04001192 dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
1193 __func__, dentry, error);
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001194 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195}
1196
1197/*
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001198 * A weaker form of d_revalidate for revalidating just the dentry->d_inode
1199 * when we don't really care about the dentry name. This is called when a
1200 * pathwalk ends on a dentry that was not found via a normal lookup in the
1201 * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
1202 *
1203 * In this situation, we just want to verify that the inode itself is OK
1204 * since the dentry might have changed on the server.
1205 */
1206static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
1207{
1208 int error;
1209 struct inode *inode = dentry->d_inode;
1210
1211 /*
1212 * I believe we can only get a negative dentry here in the case of a
1213 * procfs-style symlink. Just assume it's correct for now, but we may
1214 * eventually need to do something more here.
1215 */
1216 if (!inode) {
Al Viro6de14722013-09-16 10:53:17 -04001217 dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
1218 __func__, dentry);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001219 return 1;
1220 }
1221
1222 if (is_bad_inode(inode)) {
Al Viro6de14722013-09-16 10:53:17 -04001223 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
1224 __func__, dentry);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001225 return 0;
1226 }
1227
1228 error = nfs_revalidate_inode(NFS_SERVER(inode), inode);
1229 dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1230 __func__, inode->i_ino, error ? "invalid" : "valid");
1231 return !error;
1232}
1233
1234/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 * This is called from dput() when d_count is going to 0.
1236 */
Nick Pigginfe15ce42011-01-07 17:49:23 +11001237static int nfs_dentry_delete(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238{
Al Viro6de14722013-09-16 10:53:17 -04001239 dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
1240 dentry, dentry->d_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Trond Myklebust77f11192008-01-28 19:43:19 -05001242 /* Unhash any dentry with a stale inode */
1243 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
1244 return 1;
1245
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1247 /* Unhash it, so that ->d_iput() would be called */
1248 return 1;
1249 }
1250 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) {
1251 /* Unhash it, so that ancestors of killed async unlink
1252 * files will be cleaned up during umount */
1253 return 1;
1254 }
1255 return 0;
1256
1257}
1258
Trond Myklebust1f018452012-12-14 16:38:46 -05001259/* Ensure that we revalidate inode->i_nlink */
Trond Myklebust1b83d702008-06-11 15:44:04 -04001260static void nfs_drop_nlink(struct inode *inode)
1261{
1262 spin_lock(&inode->i_lock);
Trond Myklebust1f018452012-12-14 16:38:46 -05001263 /* drop the inode if we're reasonably sure this is the last link */
1264 if (inode->i_nlink == 1)
1265 clear_nlink(inode);
1266 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebust1b83d702008-06-11 15:44:04 -04001267 spin_unlock(&inode->i_lock);
1268}
1269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270/*
1271 * Called when the dentry loses inode.
1272 * We use it to clean up silly-renamed files.
1273 */
1274static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
1275{
Neil Brown83672d32007-02-26 12:48:25 +11001276 if (S_ISDIR(inode->i_mode))
1277 /* drop any readdir cache as it could easily be old */
1278 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
1279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001281 nfs_complete_unlink(dentry, inode);
Trond Myklebust1f018452012-12-14 16:38:46 -05001282 nfs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 iput(inode);
1285}
1286
Al Virob1942c52011-03-16 05:44:14 -04001287static void nfs_d_release(struct dentry *dentry)
1288{
1289 /* free cached devname value, if it survived that far */
1290 if (unlikely(dentry->d_fsdata)) {
1291 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1292 WARN_ON(1);
1293 else
1294 kfree(dentry->d_fsdata);
1295 }
1296}
1297
Al Virof786aa92009-02-20 05:51:22 +00001298const struct dentry_operations nfs_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 .d_revalidate = nfs_lookup_revalidate,
Jeff Laytonecf3d1f2013-02-20 11:19:05 -05001300 .d_weak_revalidate = nfs_weak_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 .d_delete = nfs_dentry_delete,
1302 .d_iput = nfs_dentry_iput,
David Howells36d43a42011-01-14 18:45:42 +00001303 .d_automount = nfs_d_automount,
Al Virob1942c52011-03-16 05:44:14 -04001304 .d_release = nfs_d_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305};
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001306EXPORT_SYMBOL_GPL(nfs_dentry_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
Bryan Schumaker597d9282012-07-16 16:39:10 -04001308struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309{
1310 struct dentry *res;
Trond Myklebust565277f2007-10-15 18:17:53 -04001311 struct dentry *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 struct inode *inode = NULL;
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001313 struct nfs_fh *fhandle = NULL;
1314 struct nfs_fattr *fattr = NULL;
David Quigley1775fd32013-05-22 12:50:42 -04001315 struct nfs4_label *label = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Al Viro6de14722013-09-16 10:53:17 -04001318 dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
Chuck Lever91d5b472006-03-20 13:44:14 -05001319 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
1321 res = ERR_PTR(-ENAMETOOLONG);
1322 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
1323 goto out;
1324
Trond Myklebustfd684072006-09-05 12:27:44 -04001325 /*
1326 * If we're doing an exclusive create, optimize away the lookup
1327 * but don't hash the dentry.
1328 */
Al Viro00cd8dd2012-06-10 17:13:09 -04001329 if (nfs_is_exclusive_create(dir, flags)) {
Trond Myklebustfd684072006-09-05 12:27:44 -04001330 d_instantiate(dentry, NULL);
1331 res = NULL;
Trond Myklebustfc0f6842008-06-11 15:44:20 -04001332 goto out;
Trond Myklebustfd684072006-09-05 12:27:44 -04001333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001335 res = ERR_PTR(-ENOMEM);
1336 fhandle = nfs_alloc_fhandle();
1337 fattr = nfs_alloc_fattr();
1338 if (fhandle == NULL || fattr == NULL)
1339 goto out;
1340
David Quigley14c43f72013-05-22 12:50:43 -04001341 label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
1342 if (IS_ERR(label))
1343 goto out;
1344
Trond Myklebust565277f2007-10-15 18:17:53 -04001345 parent = dentry->d_parent;
1346 /* Protect against concurrent sillydeletes */
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001347 trace_nfs_lookup_enter(dir, dentry, flags);
Trond Myklebust565277f2007-10-15 18:17:53 -04001348 nfs_block_sillyrename(parent);
David Quigley1775fd32013-05-22 12:50:42 -04001349 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 if (error == -ENOENT)
1351 goto no_entry;
1352 if (error < 0) {
1353 res = ERR_PTR(error);
Trond Myklebust565277f2007-10-15 18:17:53 -04001354 goto out_unblock_sillyrename;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 }
David Quigley1775fd32013-05-22 12:50:42 -04001356 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
Namhyung Kimbf0c84f2010-12-28 17:02:46 +00001357 res = ERR_CAST(inode);
Trond Myklebust03f28e32006-03-20 13:44:48 -05001358 if (IS_ERR(res))
Trond Myklebust565277f2007-10-15 18:17:53 -04001359 goto out_unblock_sillyrename;
David Howells54ceac42006-08-22 20:06:13 -04001360
Trond Myklebustd69ee9b2012-05-01 17:37:59 -04001361 /* Success: notify readdir to use READDIRPLUS */
1362 nfs_advise_use_readdirplus(dir);
1363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364no_entry:
David Howells54ceac42006-08-22 20:06:13 -04001365 res = d_materialise_unique(dentry, inode);
Trond Myklebust9eaef272006-10-21 10:24:20 -07001366 if (res != NULL) {
1367 if (IS_ERR(res))
Trond Myklebust565277f2007-10-15 18:17:53 -04001368 goto out_unblock_sillyrename;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 dentry = res;
Trond Myklebust9eaef272006-10-21 10:24:20 -07001370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Trond Myklebust565277f2007-10-15 18:17:53 -04001372out_unblock_sillyrename:
1373 nfs_unblock_sillyrename(parent);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001374 trace_nfs_lookup_exit(dir, dentry, flags, error);
David Quigley14c43f72013-05-22 12:50:43 -04001375 nfs4_label_free(label);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376out:
Trond Myklebuste1fb4d02010-04-16 16:22:47 -04001377 nfs_free_fattr(fattr);
1378 nfs_free_fhandle(fhandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 return res;
1380}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001381EXPORT_SYMBOL_GPL(nfs_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001383#if IS_ENABLED(CONFIG_NFS_V4)
Al Viro0b728e12012-06-10 16:03:43 -04001384static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
Al Virof786aa92009-02-20 05:51:22 +00001386const struct dentry_operations nfs4_dentry_operations = {
Miklos Szeredi0ef97dc2012-05-21 17:30:20 +02001387 .d_revalidate = nfs4_lookup_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 .d_delete = nfs_dentry_delete,
1389 .d_iput = nfs_dentry_iput,
David Howells36d43a42011-01-14 18:45:42 +00001390 .d_automount = nfs_d_automount,
Al Virob1942c52011-03-16 05:44:14 -04001391 .d_release = nfs_d_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392};
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001393EXPORT_SYMBOL_GPL(nfs4_dentry_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
Al Viro8a5e9292011-06-25 19:15:54 -04001395static fmode_t flags_to_mode(int flags)
1396{
1397 fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
1398 if ((flags & O_ACCMODE) != O_WRONLY)
1399 res |= FMODE_READ;
1400 if ((flags & O_ACCMODE) != O_RDONLY)
1401 res |= FMODE_WRITE;
1402 return res;
1403}
1404
Al Viro51141592011-06-22 18:47:28 -04001405static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags)
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001406{
Al Viro5ede7b12011-10-23 18:49:54 -04001407 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags));
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001408}
1409
1410static int do_open(struct inode *inode, struct file *filp)
1411{
David Howellsf1fe29b2013-09-27 11:20:03 +01001412 nfs_fscache_open_file(inode, filp);
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001413 return 0;
1414}
1415
Al Virod9585272012-06-22 12:39:14 +04001416static int nfs_finish_open(struct nfs_open_context *ctx,
1417 struct dentry *dentry,
Al Viro30d90492012-06-22 12:40:19 +04001418 struct file *file, unsigned open_flags,
Al Virod9585272012-06-22 12:39:14 +04001419 int *opened)
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001420{
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001421 int err;
1422
Miklos Szeredi01c919a2013-09-16 14:52:04 +02001423 if ((open_flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
1424 *opened |= FILE_CREATED;
1425
Al Viro30d90492012-06-22 12:40:19 +04001426 err = finish_open(file, dentry, do_open, opened);
1427 if (err)
Al Virod9585272012-06-22 12:39:14 +04001428 goto out;
Al Viro30d90492012-06-22 12:40:19 +04001429 nfs_file_set_open_context(file, ctx);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001430
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001431out:
Al Virod9585272012-06-22 12:39:14 +04001432 return err;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001433}
1434
Bryan Schumaker73a79702012-07-16 16:39:12 -04001435int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
1436 struct file *file, unsigned open_flags,
1437 umode_t mode, int *opened)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438{
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001439 struct nfs_open_context *ctx;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001440 struct dentry *res;
1441 struct iattr attr = { .ia_valid = ATTR_OPEN };
Trond Myklebustf46e0bd2010-09-17 10:56:50 -04001442 struct inode *inode;
Trond Myklebust1472b832013-08-20 11:59:41 -04001443 unsigned int lookup_flags = 0;
Trond Myklebust898f6352010-10-23 11:24:25 -04001444 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001446 /* Expect a negative dentry */
1447 BUG_ON(dentry->d_inode);
1448
Niels de Vos1e8968c2013-12-17 18:20:16 +01001449 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001450 dir->i_sb->s_id, dir->i_ino, dentry);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05001451
Jeff Layton9597c132013-08-02 11:39:32 -04001452 err = nfs_check_flags(open_flags);
1453 if (err)
1454 return err;
1455
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001456 /* NFS only supports OPEN on regular files */
1457 if ((open_flags & O_DIRECTORY)) {
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001458 if (!d_unhashed(dentry)) {
1459 /*
1460 * Hashed negative dentry with O_DIRECTORY: dentry was
1461 * revalidated and is fine, no need to perform lookup
1462 * again
1463 */
Al Virod9585272012-06-22 12:39:14 +04001464 return -ENOENT;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001465 }
Trond Myklebust1472b832013-08-20 11:59:41 -04001466 lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 goto no_open;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001470 if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
Al Virod9585272012-06-22 12:39:14 +04001471 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001473 if (open_flags & O_CREAT) {
Trond Myklebust536e43d2012-01-17 22:04:26 -05001474 attr.ia_valid |= ATTR_MODE;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001475 attr.ia_mode = mode & ~current_umask();
1476 }
Trond Myklebust536e43d2012-01-17 22:04:26 -05001477 if (open_flags & O_TRUNC) {
1478 attr.ia_valid |= ATTR_SIZE;
1479 attr.ia_size = 0;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001480 }
1481
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001482 ctx = create_nfs_open_context(dentry, open_flags);
1483 err = PTR_ERR(ctx);
1484 if (IS_ERR(ctx))
Al Virod9585272012-06-22 12:39:14 +04001485 goto out;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001486
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001487 trace_nfs_atomic_open_enter(dir, ctx, open_flags);
Trond Myklebustf46e0bd2010-09-17 10:56:50 -04001488 nfs_block_sillyrename(dentry->d_parent);
Trond Myklebust5bc2afc2013-09-23 18:01:28 -04001489 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, opened);
Trond Myklebust275bb302013-05-29 13:11:28 -04001490 nfs_unblock_sillyrename(dentry->d_parent);
Trond Myklebustf46e0bd2010-09-17 10:56:50 -04001491 if (IS_ERR(inode)) {
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001492 err = PTR_ERR(inode);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001493 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
Trond Myklebust2d9db752013-08-30 09:17:33 -04001494 put_nfs_open_context(ctx);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001495 switch (err) {
1496 case -ENOENT:
Trond Myklebust275bb302013-05-29 13:11:28 -04001497 d_drop(dentry);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001498 d_add(dentry, NULL);
1499 break;
1500 case -EISDIR:
1501 case -ENOTDIR:
1502 goto no_open;
1503 case -ELOOP:
1504 if (!(open_flags & O_NOFOLLOW))
Trond Myklebust6f926b52005-10-18 14:20:18 -07001505 goto no_open;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001506 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 /* case -EINVAL: */
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001508 default:
1509 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 }
Al Virod9585272012-06-22 12:39:14 +04001511 goto out;
Trond Myklebustcd9a1c02010-09-17 10:56:50 -04001512 }
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001513
Trond Myklebust275bb302013-05-29 13:11:28 -04001514 err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
Trond Myklebust6e0d0be2013-08-20 11:26:17 -04001515 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
Trond Myklebust2d9db752013-08-30 09:17:33 -04001516 put_nfs_open_context(ctx);
Al Virod9585272012-06-22 12:39:14 +04001517out:
1518 return err;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001519
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520no_open:
Trond Myklebust1472b832013-08-20 11:59:41 -04001521 res = nfs_lookup(dir, dentry, lookup_flags);
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001522 err = PTR_ERR(res);
1523 if (IS_ERR(res))
Al Virod9585272012-06-22 12:39:14 +04001524 goto out;
Miklos Szeredi0dd2b472012-06-05 15:10:18 +02001525
Al Viroe45198a2012-06-10 06:48:09 -04001526 return finish_no_open(file, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04001528EXPORT_SYMBOL_GPL(nfs_atomic_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529
Al Viro0b728e12012-06-10 16:03:43 -04001530static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
1532 struct dentry *parent = NULL;
Nick Piggin657e94b2011-01-14 02:48:39 +00001533 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 struct inode *dir;
Miklos Szeredi50de3482012-06-05 15:10:20 +02001535 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
Al Virofa3c56b2012-06-10 15:36:40 -04001537 if (flags & LOOKUP_RCU)
Nick Piggin657e94b2011-01-14 02:48:39 +00001538 return -ECHILD;
1539
Al Virofa3c56b2012-06-10 15:36:40 -04001540 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
Miklos Szeredieda72af2012-06-05 15:10:21 +02001541 goto no_open;
1542 if (d_mountpoint(dentry))
Trond Myklebust5584c302008-12-23 15:21:54 -05001543 goto no_open;
Trond Myklebust49f9a0f2013-03-15 16:44:28 -04001544 if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
1545 goto no_open;
Trond Myklebust2b484292010-09-17 10:56:51 -04001546
Miklos Szeredieda72af2012-06-05 15:10:21 +02001547 inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 parent = dget_parent(dentry);
1549 dir = parent->d_inode;
Trond Myklebust2b484292010-09-17 10:56:51 -04001550
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 /* We can't create new files in nfs_open_revalidate(), so we
1552 * optimize away revalidation of negative dentries.
1553 */
Trond Myklebust216d5d02007-10-01 20:10:12 -04001554 if (inode == NULL) {
Al Virofa3c56b2012-06-10 15:36:40 -04001555 if (!nfs_neg_need_reval(dir, dentry, flags))
Trond Myklebust216d5d02007-10-01 20:10:12 -04001556 ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 goto out;
Trond Myklebust216d5d02007-10-01 20:10:12 -04001558 }
1559
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 /* NFS only supports OPEN on regular files */
1561 if (!S_ISREG(inode->i_mode))
Trond Myklebust5584c302008-12-23 15:21:54 -05001562 goto no_open_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 /* We cannot do exclusive creation on a positive dentry */
Al Virofa3c56b2012-06-10 15:36:40 -04001564 if (flags & LOOKUP_EXCL)
Trond Myklebust5584c302008-12-23 15:21:54 -05001565 goto no_open_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
Miklos Szeredi0ef97dc2012-05-21 17:30:20 +02001567 /* Let f_op->open() actually open (and revalidate) the file */
1568 ret = 1;
Trond Myklebust536e43d2012-01-17 22:04:26 -05001569
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570out:
1571 dput(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 return ret;
Trond Myklebust535918f2010-09-17 10:56:51 -04001573
Trond Myklebust5584c302008-12-23 15:21:54 -05001574no_open_dput:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 dput(parent);
Trond Myklebust5584c302008-12-23 15:21:54 -05001576no_open:
Al Viro0b728e12012-06-10 16:03:43 -04001577 return nfs_lookup_revalidate(dentry, flags);
Trond Myklebustc0204fd2010-09-17 10:56:51 -04001578}
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580#endif /* CONFIG_NFSV4 */
1581
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582/*
1583 * Code common to create, mkdir, and mknod.
1584 */
1585int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
David Quigley1775fd32013-05-22 12:50:42 -04001586 struct nfs_fattr *fattr,
1587 struct nfs4_label *label)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588{
Trond Myklebustfab728e2007-09-29 17:41:33 -04001589 struct dentry *parent = dget_parent(dentry);
1590 struct inode *dir = parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 struct inode *inode;
1592 int error = -EACCES;
1593
Trond Myklebustfab728e2007-09-29 17:41:33 -04001594 d_drop(dentry);
1595
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 /* We may have been initialized further down */
1597 if (dentry->d_inode)
Trond Myklebustfab728e2007-09-29 17:41:33 -04001598 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 if (fhandle->size == 0) {
David Quigley1775fd32013-05-22 12:50:42 -04001600 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 if (error)
Trond Myklebustfab728e2007-09-29 17:41:33 -04001602 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 }
Trond Myklebust5724ab32007-10-01 21:51:38 -04001604 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 if (!(fattr->valid & NFS_ATTR_FATTR)) {
1606 struct nfs_server *server = NFS_SB(dentry->d_sb);
David Quigley1775fd32013-05-22 12:50:42 -04001607 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 if (error < 0)
Trond Myklebustfab728e2007-09-29 17:41:33 -04001609 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
David Quigley1775fd32013-05-22 12:50:42 -04001611 inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
Trond Myklebust03f28e32006-03-20 13:44:48 -05001612 error = PTR_ERR(inode);
1613 if (IS_ERR(inode))
Trond Myklebustfab728e2007-09-29 17:41:33 -04001614 goto out_error;
1615 d_add(dentry, inode);
1616out:
1617 dput(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 return 0;
Trond Myklebustfab728e2007-09-29 17:41:33 -04001619out_error:
1620 nfs_mark_for_revalidate(dir);
1621 dput(parent);
1622 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001624EXPORT_SYMBOL_GPL(nfs_instantiate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
1626/*
1627 * Following a failed create operation, we drop the dentry rather
1628 * than retain a negative dentry. This avoids a problem in the event
1629 * that the operation succeeded on the server, but an error in the
1630 * reply path made it appear to have failed.
1631 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001632int nfs_create(struct inode *dir, struct dentry *dentry,
Al Viroebfc3b42012-06-10 18:05:36 -04001633 umode_t mode, bool excl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634{
1635 struct iattr attr;
Al Viroebfc3b42012-06-10 18:05:36 -04001636 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Niels de Vos1e8968c2013-12-17 18:20:16 +01001639 dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001640 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642 attr.ia_mode = mode;
1643 attr.ia_valid = ATTR_MODE;
1644
Trond Myklebust8b0ad3d2013-08-21 10:53:09 -04001645 trace_nfs_create_enter(dir, dentry, open_flags);
Miklos Szeredi8867fe52012-06-05 15:10:19 +02001646 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
Trond Myklebust8b0ad3d2013-08-21 10:53:09 -04001647 trace_nfs_create_exit(dir, dentry, open_flags, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 if (error != 0)
1649 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 return 0;
1651out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 d_drop(dentry);
1653 return error;
1654}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001655EXPORT_SYMBOL_GPL(nfs_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656
1657/*
1658 * See comments for nfs_proc_create regarding failed operations.
1659 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001660int
Al Viro1a67aaf2011-07-26 01:52:52 -04001661nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662{
1663 struct iattr attr;
1664 int status;
1665
Niels de Vos1e8968c2013-12-17 18:20:16 +01001666 dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001667 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 if (!new_valid_dev(rdev))
1670 return -EINVAL;
1671
1672 attr.ia_mode = mode;
1673 attr.ia_valid = ATTR_MODE;
1674
Trond Myklebust1ca42382013-08-21 12:36:04 -04001675 trace_nfs_mknod_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001677 trace_nfs_mknod_exit(dir, dentry, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 if (status != 0)
1679 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 return 0;
1681out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 d_drop(dentry);
1683 return status;
1684}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001685EXPORT_SYMBOL_GPL(nfs_mknod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
1687/*
1688 * See comments for nfs_proc_create regarding failed operations.
1689 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001690int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691{
1692 struct iattr attr;
1693 int error;
1694
Niels de Vos1e8968c2013-12-17 18:20:16 +01001695 dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001696 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
1698 attr.ia_valid = ATTR_MODE;
1699 attr.ia_mode = mode | S_IFDIR;
1700
Trond Myklebust1ca42382013-08-21 12:36:04 -04001701 trace_nfs_mkdir_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001703 trace_nfs_mkdir_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 if (error != 0)
1705 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 return 0;
1707out_err:
1708 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 return error;
1710}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001711EXPORT_SYMBOL_GPL(nfs_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001713static void nfs_dentry_handle_enoent(struct dentry *dentry)
1714{
1715 if (dentry->d_inode != NULL && !d_unhashed(dentry))
1716 d_delete(dentry);
1717}
1718
Bryan Schumaker597d9282012-07-16 16:39:10 -04001719int nfs_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720{
1721 int error;
1722
Niels de Vos1e8968c2013-12-17 18:20:16 +01001723 dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
Al Viro6de14722013-09-16 10:53:17 -04001724 dir->i_sb->s_id, dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Trond Myklebust1ca42382013-08-21 12:36:04 -04001726 trace_nfs_rmdir_enter(dir, dentry);
Trond Myklebustba6c0592013-08-30 12:24:25 -04001727 if (dentry->d_inode) {
1728 nfs_wait_on_sillyrename(dentry);
1729 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
1730 /* Ensure the VFS deletes this inode */
1731 switch (error) {
1732 case 0:
1733 clear_nlink(dentry->d_inode);
1734 break;
1735 case -ENOENT:
1736 nfs_dentry_handle_enoent(dentry);
1737 }
1738 } else
1739 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001740 trace_nfs_rmdir_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741
1742 return error;
1743}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001744EXPORT_SYMBOL_GPL(nfs_rmdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746/*
1747 * Remove a file after making sure there are no pending writes,
1748 * and after checking that the file has only one user.
1749 *
1750 * We invalidate the attribute cache and free the inode prior to the operation
1751 * to avoid possible races if the server reuses the inode.
1752 */
1753static int nfs_safe_remove(struct dentry *dentry)
1754{
1755 struct inode *dir = dentry->d_parent->d_inode;
1756 struct inode *inode = dentry->d_inode;
1757 int error = -EBUSY;
1758
Al Viro6de14722013-09-16 10:53:17 -04001759 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
1761 /* If the dentry was sillyrenamed, we simply call d_delete() */
1762 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
1763 error = 0;
1764 goto out;
1765 }
1766
Trond Myklebust1ca42382013-08-21 12:36:04 -04001767 trace_nfs_remove_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 if (inode != NULL) {
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001769 NFS_PROTO(inode)->return_delegation(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 if (error == 0)
Trond Myklebust1b83d702008-06-11 15:44:04 -04001772 nfs_drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 } else
1774 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001775 if (error == -ENOENT)
1776 nfs_dentry_handle_enoent(dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001777 trace_nfs_remove_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778out:
1779 return error;
1780}
1781
1782/* We do silly rename. In case sillyrename() returns -EBUSY, the inode
1783 * belongs to an active ".nfs..." file and we return -EBUSY.
1784 *
1785 * If sillyrename() returns 0, we do nothing, otherwise we unlink.
1786 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001787int nfs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788{
1789 int error;
1790 int need_rehash = 0;
1791
Niels de Vos1e8968c2013-12-17 18:20:16 +01001792 dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
Al Viro6de14722013-09-16 10:53:17 -04001793 dir->i_ino, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Trond Myklebust1ca42382013-08-21 12:36:04 -04001795 trace_nfs_unlink_enter(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 spin_lock(&dentry->d_lock);
Al Viro84d08fa2013-07-05 18:59:33 +04001797 if (d_count(dentry) > 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 spin_unlock(&dentry->d_lock);
Trond Myklebustccfeb502007-01-13 02:28:12 -05001799 /* Start asynchronous writeout of the inode */
1800 write_inode_now(dentry->d_inode, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 error = nfs_sillyrename(dir, dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001802 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 }
1804 if (!d_unhashed(dentry)) {
1805 __d_drop(dentry);
1806 need_rehash = 1;
1807 }
1808 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 error = nfs_safe_remove(dentry);
Trond Myklebustd45b9d82008-01-28 19:43:18 -05001810 if (!error || error == -ENOENT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1812 } else if (need_rehash)
1813 d_rehash(dentry);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001814out:
1815 trace_nfs_unlink_exit(dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 return error;
1817}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001818EXPORT_SYMBOL_GPL(nfs_unlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
Chuck Lever873101b2006-08-22 20:06:23 -04001820/*
1821 * To create a symbolic link, most file systems instantiate a new inode,
1822 * add a page to it containing the path, then write it out to the disk
1823 * using prepare_write/commit_write.
1824 *
1825 * Unfortunately the NFS client can't create the in-core inode first
1826 * because it needs a file handle to create an in-core inode (see
1827 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the
1828 * symlink request has completed on the server.
1829 *
1830 * So instead we allocate a raw page, copy the symname into it, then do
1831 * the SYMLINK request with the page as the buffer. If it succeeds, we
1832 * now have a new file handle and can instantiate an in-core NFS inode
1833 * and move the raw page into its mapping.
1834 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001835int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836{
Chuck Lever873101b2006-08-22 20:06:23 -04001837 struct page *page;
1838 char *kaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 struct iattr attr;
Chuck Lever873101b2006-08-22 20:06:23 -04001840 unsigned int pathlen = strlen(symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 int error;
1842
Niels de Vos1e8968c2013-12-17 18:20:16 +01001843 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
Al Viro6de14722013-09-16 10:53:17 -04001844 dir->i_ino, dentry, symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845
Chuck Lever873101b2006-08-22 20:06:23 -04001846 if (pathlen > PAGE_SIZE)
1847 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848
Chuck Lever873101b2006-08-22 20:06:23 -04001849 attr.ia_mode = S_IFLNK | S_IRWXUGO;
1850 attr.ia_valid = ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
Jeff Layton83d93f22007-06-07 09:58:08 -04001852 page = alloc_page(GFP_HIGHUSER);
Trond Myklebust76566992008-06-11 15:44:22 -04001853 if (!page)
Chuck Lever873101b2006-08-22 20:06:23 -04001854 return -ENOMEM;
Chuck Lever873101b2006-08-22 20:06:23 -04001855
Cong Wang2b86ce22011-11-25 23:14:33 +08001856 kaddr = kmap_atomic(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001857 memcpy(kaddr, symname, pathlen);
1858 if (pathlen < PAGE_SIZE)
1859 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
Cong Wang2b86ce22011-11-25 23:14:33 +08001860 kunmap_atomic(kaddr);
Chuck Lever873101b2006-08-22 20:06:23 -04001861
Trond Myklebust1ca42382013-08-21 12:36:04 -04001862 trace_nfs_symlink_enter(dir, dentry);
Chuck Lever94a6d752006-08-22 20:06:23 -04001863 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
Trond Myklebust1ca42382013-08-21 12:36:04 -04001864 trace_nfs_symlink_exit(dir, dentry, error);
Chuck Lever873101b2006-08-22 20:06:23 -04001865 if (error != 0) {
Niels de Vos1e8968c2013-12-17 18:20:16 +01001866 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
Chuck Lever873101b2006-08-22 20:06:23 -04001867 dir->i_sb->s_id, dir->i_ino,
Al Viro6de14722013-09-16 10:53:17 -04001868 dentry, symname, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 d_drop(dentry);
Chuck Lever873101b2006-08-22 20:06:23 -04001870 __free_page(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001871 return error;
1872 }
1873
1874 /*
1875 * No big deal if we can't add this page to the page cache here.
1876 * READLINK will get the missing page from the server if needed.
1877 */
Mel Gormana0b8cab32013-07-03 15:02:32 -07001878 if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0,
Chuck Lever873101b2006-08-22 20:06:23 -04001879 GFP_KERNEL)) {
Chuck Lever873101b2006-08-22 20:06:23 -04001880 SetPageUptodate(page);
1881 unlock_page(page);
Rafael Aquinia0b54ad2014-02-10 14:25:48 -08001882 /*
1883 * add_to_page_cache_lru() grabs an extra page refcount.
1884 * Drop it here to avoid leaking this page later.
1885 */
1886 page_cache_release(page);
Chuck Lever873101b2006-08-22 20:06:23 -04001887 } else
1888 __free_page(page);
1889
Chuck Lever873101b2006-08-22 20:06:23 -04001890 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001892EXPORT_SYMBOL_GPL(nfs_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Bryan Schumaker597d9282012-07-16 16:39:10 -04001894int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
1896{
1897 struct inode *inode = old_dentry->d_inode;
1898 int error;
1899
Al Viro6de14722013-09-16 10:53:17 -04001900 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
1901 old_dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
Trond Myklebust1fd10852013-08-21 13:54:44 -04001903 trace_nfs_link_enter(inode, dir, dentry);
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001904 NFS_PROTO(inode)->return_delegation(inode);
Trond Myklebust9a3936a2009-10-26 08:09:46 -04001905
Trond Myklebust9697d232007-10-02 21:58:05 -04001906 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);
Trond Myklebustcf809552005-10-27 22:12:42 -04001908 if (error == 0) {
Al Viro7de9c6ee2010-10-23 11:11:40 -04001909 ihold(inode);
Trond Myklebust9697d232007-10-02 21:58:05 -04001910 d_add(dentry, inode);
Trond Myklebustcf809552005-10-27 22:12:42 -04001911 }
Trond Myklebust1fd10852013-08-21 13:54:44 -04001912 trace_nfs_link_exit(inode, dir, dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 return error;
1914}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04001915EXPORT_SYMBOL_GPL(nfs_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916
1917/*
1918 * RENAME
1919 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a
1920 * different file handle for the same inode after a rename (e.g. when
1921 * moving to a different directory). A fail-safe method to do so would
1922 * be to look up old_dir/old_name, create a link to new_dir/new_name and
1923 * rename the old file using the sillyrename stuff. This way, the original
1924 * file in old_dir will go away when the last process iput()s the inode.
1925 *
1926 * FIXED.
1927 *
1928 * It actually works quite well. One needs to have the possibility for
1929 * at least one ".nfs..." file in each directory the file ever gets
1930 * moved or linked to which happens automagically with the new
1931 * implementation that only depends on the dcache stuff instead of
1932 * using the inode layer
1933 *
1934 * Unfortunately, things are a little more complicated than indicated
1935 * above. For a cross-directory move, we want to make sure we can get
1936 * rid of the old inode after the operation. This means there must be
1937 * no pending writes (if it's a file), and the use count must be 1.
1938 * If these conditions are met, we can drop the dentries before doing
1939 * the rename.
1940 */
Bryan Schumaker597d9282012-07-16 16:39:10 -04001941int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 struct inode *new_dir, struct dentry *new_dentry)
1943{
1944 struct inode *old_inode = old_dentry->d_inode;
1945 struct inode *new_inode = new_dentry->d_inode;
1946 struct dentry *dentry = NULL, *rehash = NULL;
Jeff Layton80a491f2014-03-17 07:06:56 -04001947 struct rpc_task *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 int error = -EBUSY;
1949
Al Viro6de14722013-09-16 10:53:17 -04001950 dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
1951 old_dentry, new_dentry,
Al Viro84d08fa2013-07-05 18:59:33 +04001952 d_count(new_dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
Trond Myklebust70ded202013-08-21 12:08:45 -04001954 trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 /*
Miklos Szeredi28f79a12009-12-03 15:58:56 -05001956 * For non-directories, check whether the target is busy and if so,
1957 * make a copy of the dentry and then do a silly-rename. If the
1958 * silly-rename succeeds, the copied dentry is hashed and becomes
1959 * the new target.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 */
Miklos Szeredi27226102009-12-03 15:58:56 -05001961 if (new_inode && !S_ISDIR(new_inode->i_mode)) {
1962 /*
1963 * To prevent any new references to the target during the
1964 * rename, we unhash the dentry in advance.
1965 */
1966 if (!d_unhashed(new_dentry)) {
1967 d_drop(new_dentry);
1968 rehash = new_dentry;
1969 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970
Al Viro84d08fa2013-07-05 18:59:33 +04001971 if (d_count(new_dentry) > 2) {
Miklos Szeredi27226102009-12-03 15:58:56 -05001972 int err;
1973
1974 /* copy the target dentry's name */
1975 dentry = d_alloc(new_dentry->d_parent,
1976 &new_dentry->d_name);
1977 if (!dentry)
1978 goto out;
1979
1980 /* silly-rename the existing target ... */
1981 err = nfs_sillyrename(new_dir, new_dentry);
Miklos Szeredi24e93022009-12-03 15:58:56 -05001982 if (err)
Miklos Szeredi27226102009-12-03 15:58:56 -05001983 goto out;
Miklos Szeredi24e93022009-12-03 15:58:56 -05001984
1985 new_dentry = dentry;
OGAWA Hirofumi56335932010-01-06 18:48:26 -05001986 rehash = NULL;
Miklos Szeredi24e93022009-12-03 15:58:56 -05001987 new_inode = NULL;
Miklos Szeredi27226102009-12-03 15:58:56 -05001988 }
Trond Myklebustb1e4adf2009-03-19 15:35:49 -04001989 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001991 NFS_PROTO(old_inode)->return_delegation(old_inode);
Trond Myklebustb1e4adf2009-03-19 15:35:49 -04001992 if (new_inode != NULL)
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001993 NFS_PROTO(new_inode)->return_delegation(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994
Jeff Layton80a491f2014-03-17 07:06:56 -04001995 task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL);
1996 if (IS_ERR(task)) {
1997 error = PTR_ERR(task);
1998 goto out;
1999 }
2000
2001 error = rpc_wait_for_completion_task(task);
2002 if (error == 0)
2003 error = task->tk_status;
2004 rpc_put_task(task);
Trond Myklebust5ba7cc42005-12-03 15:20:17 -05002005 nfs_mark_for_revalidate(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006out:
2007 if (rehash)
2008 d_rehash(rehash);
Trond Myklebust70ded202013-08-21 12:08:45 -04002009 trace_nfs_rename_exit(old_dir, old_dentry,
2010 new_dir, new_dentry, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 if (!error) {
Trond Myklebustb1e4adf2009-03-19 15:35:49 -04002012 if (new_inode != NULL)
2013 nfs_drop_nlink(new_inode);
Mark Fasheh349457c2006-09-08 14:22:21 -07002014 d_move(old_dentry, new_dentry);
Chuck Lever8fb559f2007-09-24 15:40:16 -04002015 nfs_set_verifier(new_dentry,
2016 nfs_save_change_attribute(new_dir));
Trond Myklebustd45b9d82008-01-28 19:43:18 -05002017 } else if (error == -ENOENT)
2018 nfs_dentry_handle_enoent(old_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
2020 /* new dentry created? */
2021 if (dentry)
2022 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 return error;
2024}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04002025EXPORT_SYMBOL_GPL(nfs_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002027static DEFINE_SPINLOCK(nfs_access_lru_lock);
2028static LIST_HEAD(nfs_access_lru_list);
2029static atomic_long_t nfs_access_nr_entries;
2030
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002031static void nfs_access_free_entry(struct nfs_access_entry *entry)
2032{
2033 put_rpccred(entry->cred);
2034 kfree(entry);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002035 smp_mb__before_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002036 atomic_long_dec(&nfs_access_nr_entries);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002037 smp_mb__after_atomic();
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002038}
2039
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002040static void nfs_access_free_list(struct list_head *head)
2041{
2042 struct nfs_access_entry *cache;
2043
2044 while (!list_empty(head)) {
2045 cache = list_entry(head->next, struct nfs_access_entry, lru);
2046 list_del(&cache->lru);
2047 nfs_access_free_entry(cache);
2048 }
2049}
2050
Dave Chinner1ab6c492013-08-28 10:18:09 +10002051unsigned long
2052nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
Trond Myklebust979df722006-07-25 11:28:19 -04002053{
2054 LIST_HEAD(head);
Trond Myklebustaa510da2010-09-29 15:11:56 -04002055 struct nfs_inode *nfsi, *next;
Trond Myklebust979df722006-07-25 11:28:19 -04002056 struct nfs_access_entry *cache;
Ying Han1495f232011-05-24 17:12:27 -07002057 int nr_to_scan = sc->nr_to_scan;
2058 gfp_t gfp_mask = sc->gfp_mask;
Dave Chinner1ab6c492013-08-28 10:18:09 +10002059 long freed = 0;
Trond Myklebust979df722006-07-25 11:28:19 -04002060
Trond Myklebust61d5eb22010-05-13 12:51:06 -04002061 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)
Dave Chinner1ab6c492013-08-28 10:18:09 +10002062 return SHRINK_STOP;
Trond Myklebust9c7e7e22010-05-13 12:51:06 -04002063
Trond Myklebusta50f7952007-06-05 19:23:43 -04002064 spin_lock(&nfs_access_lru_lock);
Trond Myklebustaa510da2010-09-29 15:11:56 -04002065 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) {
Trond Myklebust979df722006-07-25 11:28:19 -04002066 struct inode *inode;
2067
2068 if (nr_to_scan-- == 0)
2069 break;
Trond Myklebust9c7e7e22010-05-13 12:51:06 -04002070 inode = &nfsi->vfs_inode;
Trond Myklebust979df722006-07-25 11:28:19 -04002071 spin_lock(&inode->i_lock);
2072 if (list_empty(&nfsi->access_cache_entry_lru))
2073 goto remove_lru_entry;
2074 cache = list_entry(nfsi->access_cache_entry_lru.next,
2075 struct nfs_access_entry, lru);
2076 list_move(&cache->lru, &head);
2077 rb_erase(&cache->rb_node, &nfsi->access_cache);
Dave Chinner1ab6c492013-08-28 10:18:09 +10002078 freed++;
Trond Myklebust979df722006-07-25 11:28:19 -04002079 if (!list_empty(&nfsi->access_cache_entry_lru))
2080 list_move_tail(&nfsi->access_cache_inode_lru,
2081 &nfs_access_lru_list);
2082 else {
2083remove_lru_entry:
2084 list_del_init(&nfsi->access_cache_inode_lru);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002085 smp_mb__before_atomic();
Trond Myklebust979df722006-07-25 11:28:19 -04002086 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002087 smp_mb__after_atomic();
Trond Myklebust979df722006-07-25 11:28:19 -04002088 }
Trond Myklebust59844a92010-05-26 08:42:24 -04002089 spin_unlock(&inode->i_lock);
Trond Myklebust979df722006-07-25 11:28:19 -04002090 }
2091 spin_unlock(&nfs_access_lru_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002092 nfs_access_free_list(&head);
Dave Chinner1ab6c492013-08-28 10:18:09 +10002093 return freed;
2094}
2095
2096unsigned long
2097nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc)
2098{
Glauber Costa55f841c2013-08-28 10:17:53 +10002099 return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries));
Trond Myklebust979df722006-07-25 11:28:19 -04002100}
2101
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002102static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head)
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002103{
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002104 struct rb_root *root_node = &nfsi->access_cache;
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002105 struct rb_node *n;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002106 struct nfs_access_entry *entry;
2107
2108 /* Unhook entries from the cache */
2109 while ((n = rb_first(root_node)) != NULL) {
2110 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2111 rb_erase(n, root_node);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002112 list_move(&entry->lru, head);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002113 }
2114 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002115}
2116
2117void nfs_access_zap_cache(struct inode *inode)
2118{
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002119 LIST_HEAD(head);
2120
2121 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0)
2122 return;
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002123 /* Remove from global LRU init */
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002124 spin_lock(&nfs_access_lru_lock);
2125 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002126 list_del_init(&NFS_I(inode)->access_cache_inode_lru);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002127
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002128 spin_lock(&inode->i_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002129 __nfs_access_zap_cache(NFS_I(inode), &head);
2130 spin_unlock(&inode->i_lock);
2131 spin_unlock(&nfs_access_lru_lock);
2132 nfs_access_free_list(&head);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002133}
Bryan Schumaker1c606fb2012-07-30 16:05:24 -04002134EXPORT_SYMBOL_GPL(nfs_access_zap_cache);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002135
2136static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred)
2137{
2138 struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
2139 struct nfs_access_entry *entry;
2140
2141 while (n != NULL) {
2142 entry = rb_entry(n, struct nfs_access_entry, rb_node);
2143
2144 if (cred < entry->cred)
2145 n = n->rb_left;
2146 else if (cred > entry->cred)
2147 n = n->rb_right;
2148 else
2149 return entry;
2150 }
2151 return NULL;
2152}
2153
Trond Myklebustaf22f942007-08-10 17:45:10 -04002154static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155{
Chuck Lever55296802005-08-18 11:24:09 -07002156 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002157 struct nfs_access_entry *cache;
2158 int err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002160 spin_lock(&inode->i_lock);
2161 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)
2162 goto out_zap;
2163 cache = nfs_access_search_rbtree(inode, cred);
2164 if (cache == NULL)
2165 goto out;
Trond Myklebustb4d23142010-03-10 15:21:44 -05002166 if (!nfs_have_delegated_attributes(inode) &&
Peter Staubach64672d52008-12-23 15:21:56 -05002167 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo))
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002168 goto out_stale;
2169 res->jiffies = cache->jiffies;
2170 res->cred = cache->cred;
2171 res->mask = cache->mask;
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002172 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002173 err = 0;
2174out:
2175 spin_unlock(&inode->i_lock);
2176 return err;
2177out_stale:
2178 rb_erase(&cache->rb_node, &nfsi->access_cache);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002179 list_del(&cache->lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002180 spin_unlock(&inode->i_lock);
2181 nfs_access_free_entry(cache);
2182 return -ENOENT;
2183out_zap:
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002184 spin_unlock(&inode->i_lock);
2185 nfs_access_zap_cache(inode);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002186 return -ENOENT;
2187}
2188
2189static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
2190{
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002191 struct nfs_inode *nfsi = NFS_I(inode);
2192 struct rb_root *root_node = &nfsi->access_cache;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002193 struct rb_node **p = &root_node->rb_node;
2194 struct rb_node *parent = NULL;
2195 struct nfs_access_entry *entry;
2196
2197 spin_lock(&inode->i_lock);
2198 while (*p != NULL) {
2199 parent = *p;
2200 entry = rb_entry(parent, struct nfs_access_entry, rb_node);
2201
2202 if (set->cred < entry->cred)
2203 p = &parent->rb_left;
2204 else if (set->cred > entry->cred)
2205 p = &parent->rb_right;
2206 else
2207 goto found;
2208 }
2209 rb_link_node(&set->rb_node, parent, p);
2210 rb_insert_color(&set->rb_node, root_node);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002211 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002212 spin_unlock(&inode->i_lock);
2213 return;
2214found:
2215 rb_replace_node(parent, &set->rb_node, root_node);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002216 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);
2217 list_del(&entry->lru);
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002218 spin_unlock(&inode->i_lock);
2219 nfs_access_free_entry(entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220}
2221
Weston Andros Adamson6168f622012-09-10 14:00:46 -04002222void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223{
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002224 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);
2225 if (cache == NULL)
2226 return;
2227 RB_CLEAR_NODE(&cache->rb_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 cache->jiffies = set->jiffies;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002229 cache->cred = get_rpccred(set->cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 cache->mask = set->mask;
Trond Myklebust1c3c07e2006-07-25 11:28:18 -04002231
2232 nfs_access_add_rbtree(inode, cache);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002233
2234 /* Update accounting */
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002235 smp_mb__before_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002236 atomic_long_inc(&nfs_access_nr_entries);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01002237 smp_mb__after_atomic();
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002238
2239 /* Add inode to global LRU list */
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002240 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002241 spin_lock(&nfs_access_lru_lock);
Trond Myklebust1a81bb82010-05-13 12:51:06 -04002242 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags))
2243 list_add_tail(&NFS_I(inode)->access_cache_inode_lru,
2244 &nfs_access_lru_list);
Trond Myklebustcfcea3e2006-07-25 11:28:18 -04002245 spin_unlock(&nfs_access_lru_lock);
2246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247}
Weston Andros Adamson6168f622012-09-10 14:00:46 -04002248EXPORT_SYMBOL_GPL(nfs_access_add_cache);
2249
2250void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result)
2251{
2252 entry->mask = 0;
2253 if (access_result & NFS4_ACCESS_READ)
2254 entry->mask |= MAY_READ;
2255 if (access_result &
2256 (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
2257 entry->mask |= MAY_WRITE;
2258 if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
2259 entry->mask |= MAY_EXEC;
2260}
2261EXPORT_SYMBOL_GPL(nfs_access_set_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262
2263static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask)
2264{
2265 struct nfs_access_entry cache;
2266 int status;
2267
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002268 trace_nfs_access_enter(inode);
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 status = nfs_access_get_cached(inode, cred, &cache);
2271 if (status == 0)
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002272 goto out_cached;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
2274 /* Be clever: ask server to check for all possible rights */
2275 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
2276 cache.cred = cred;
2277 cache.jiffies = jiffies;
2278 status = NFS_PROTO(inode)->access(inode, &cache);
Suresh Jayaramana71ee332009-03-10 20:33:21 -04002279 if (status != 0) {
2280 if (status == -ESTALE) {
2281 nfs_zap_caches(inode);
2282 if (!S_ISDIR(inode->i_mode))
2283 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
2284 }
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002285 goto out;
Suresh Jayaramana71ee332009-03-10 20:33:21 -04002286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 nfs_access_add_cache(inode, &cache);
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002288out_cached:
2289 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)
2290 status = -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291out:
Trond Myklebustf4ce1292013-08-19 18:59:33 -04002292 trace_nfs_access_exit(inode, status);
2293 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294}
2295
Trond Myklebustaf22f942007-08-10 17:45:10 -04002296static int nfs_open_permission_mask(int openflags)
2297{
2298 int mask = 0;
2299
Weston Andros Adamsonf8d9a892013-01-03 16:42:29 -05002300 if (openflags & __FMODE_EXEC) {
2301 /* ONLY check exec rights */
2302 mask = MAY_EXEC;
2303 } else {
2304 if ((openflags & O_ACCMODE) != O_WRONLY)
2305 mask |= MAY_READ;
2306 if ((openflags & O_ACCMODE) != O_RDONLY)
2307 mask |= MAY_WRITE;
2308 }
2309
Trond Myklebustaf22f942007-08-10 17:45:10 -04002310 return mask;
2311}
2312
2313int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
2314{
2315 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
2316}
Bryan Schumaker89d77c82012-07-30 16:05:25 -04002317EXPORT_SYMBOL_GPL(nfs_may_open);
Trond Myklebustaf22f942007-08-10 17:45:10 -04002318
Al Viro10556cb2011-06-20 19:28:19 -04002319int nfs_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320{
2321 struct rpc_cred *cred;
2322 int res = 0;
2323
Al Viro10556cb2011-06-20 19:28:19 -04002324 if (mask & MAY_NOT_BLOCK)
Nick Pigginb74c79e2011-01-07 17:49:58 +11002325 return -ECHILD;
2326
Chuck Lever91d5b472006-03-20 13:44:14 -05002327 nfs_inc_stats(inode, NFSIOS_VFSACCESS);
2328
Al Viroe6305c42008-07-15 21:03:57 -04002329 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 goto out;
2331 /* Is this sys_access() ? */
Eric Paris9cfcac82010-07-23 11:43:51 -04002332 if (mask & (MAY_ACCESS | MAY_CHDIR))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 goto force_lookup;
2334
2335 switch (inode->i_mode & S_IFMT) {
2336 case S_IFLNK:
2337 goto out;
2338 case S_IFREG:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 break;
2340 case S_IFDIR:
2341 /*
2342 * Optimize away all write operations, since the server
2343 * will check permissions when we perform the op.
2344 */
2345 if ((mask & MAY_WRITE) && !(mask & MAY_READ))
2346 goto out;
2347 }
2348
2349force_lookup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 if (!NFS_PROTO(inode)->access)
2351 goto out_notsup;
2352
Trond Myklebust98a8e322008-03-12 12:25:28 -04002353 cred = rpc_lookup_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 if (!IS_ERR(cred)) {
2355 res = nfs_do_access(inode, cred, mask);
2356 put_rpccred(cred);
2357 } else
2358 res = PTR_ERR(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359out:
Miklos Szeredif696a362008-07-31 13:41:58 +02002360 if (!res && (mask & MAY_EXEC) && !execute_ok(inode))
2361 res = -EACCES;
2362
Niels de Vos1e8968c2013-12-17 18:20:16 +01002363 dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05002364 inode->i_sb->s_id, inode->i_ino, mask, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 return res;
2366out_notsup:
2367 res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
2368 if (res == 0)
Al Viro2830ba72011-06-20 19:16:29 -04002369 res = generic_permission(inode, mask);
Chuck Lever1e7cb3d2006-03-20 13:44:24 -05002370 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371}
Bryan Schumakerddda8e02012-07-30 16:05:23 -04002372EXPORT_SYMBOL_GPL(nfs_permission);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
2374/*
2375 * Local variables:
2376 * version-control: t
2377 * kept-new-versions: 5
2378 * End:
2379 */