11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/nfs/dir.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1992 Rick Sladkey 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * nfs directory handling functions 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * 10 Apr 1996 Added silly rename for unlink --okir 91da177e4SLinus Torvalds * 28 Sep 1996 Improved directory cache --okir 101da177e4SLinus Torvalds * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de 111da177e4SLinus Torvalds * Re-implemented silly rename for unlink, newly implemented 121da177e4SLinus Torvalds * silly rename for nfs_rename() following the suggestions 131da177e4SLinus Torvalds * of Olaf Kirch (okir) found in this file. 141da177e4SLinus Torvalds * Following Linus comments on my original hack, this version 151da177e4SLinus Torvalds * depends only on the dcache stuff and doesn't touch the inode 161da177e4SLinus Torvalds * layer (iput() and friends). 171da177e4SLinus Torvalds * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds 20ddda8e0aSBryan Schumaker #include <linux/module.h> 211da177e4SLinus Torvalds #include <linux/time.h> 221da177e4SLinus Torvalds #include <linux/errno.h> 231da177e4SLinus Torvalds #include <linux/stat.h> 241da177e4SLinus Torvalds #include <linux/fcntl.h> 251da177e4SLinus Torvalds #include <linux/string.h> 261da177e4SLinus Torvalds #include <linux/kernel.h> 271da177e4SLinus Torvalds #include <linux/slab.h> 281da177e4SLinus Torvalds #include <linux/mm.h> 291da177e4SLinus Torvalds #include <linux/sunrpc/clnt.h> 301da177e4SLinus Torvalds #include <linux/nfs_fs.h> 311da177e4SLinus Torvalds #include <linux/nfs_mount.h> 321da177e4SLinus Torvalds #include <linux/pagemap.h> 33873101b3SChuck Lever #include <linux/pagevec.h> 341da177e4SLinus Torvalds #include <linux/namei.h> 3554ceac45SDavid Howells #include <linux/mount.h> 36a0b8cab3SMel Gorman #include <linux/swap.h> 37e8edc6e0SAlexey Dobriyan #include <linux/sched.h> 3804e4bd1cSCatalin Marinas #include <linux/kmemleak.h> 3964c2ce8bSAneesh Kumar K.V #include <linux/xattr.h> 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds #include "delegation.h" 4291d5b470SChuck Lever #include "iostat.h" 434c30d56eSAdrian Bunk #include "internal.h" 44cd9a1c0eSTrond Myklebust #include "fscache.h" 451da177e4SLinus Torvalds 46f4ce1299STrond Myklebust #include "nfstrace.h" 47f4ce1299STrond Myklebust 481da177e4SLinus Torvalds /* #define NFS_DEBUG_VERBOSE 1 */ 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds static int nfs_opendir(struct inode *, struct file *); 51480c2006SBryan Schumaker static int nfs_closedir(struct inode *, struct file *); 5223db8620SAl Viro static int nfs_readdir(struct file *, struct dir_context *); 5302c24a82SJosef Bacik static int nfs_fsync_dir(struct file *, loff_t, loff_t, int); 54f0dd2136STrond Myklebust static loff_t nfs_llseek_dir(struct file *, loff_t, int); 5511de3b11STrond Myklebust static void nfs_readdir_clear_array(struct page*); 561da177e4SLinus Torvalds 574b6f5d20SArjan van de Ven const struct file_operations nfs_dir_operations = { 58f0dd2136STrond Myklebust .llseek = nfs_llseek_dir, 591da177e4SLinus Torvalds .read = generic_read_dir, 609ac3d3e8SAl Viro .iterate_shared = nfs_readdir, 611da177e4SLinus Torvalds .open = nfs_opendir, 62480c2006SBryan Schumaker .release = nfs_closedir, 631da177e4SLinus Torvalds .fsync = nfs_fsync_dir, 641da177e4SLinus Torvalds }; 651da177e4SLinus Torvalds 6611de3b11STrond Myklebust const struct address_space_operations nfs_dir_aops = { 6711de3b11STrond Myklebust .freepage = nfs_readdir_clear_array, 68d1bacf9eSBryan Schumaker }; 69d1bacf9eSBryan Schumaker 700c030806STrond Myklebust static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred) 71480c2006SBryan Schumaker { 72311324adSTrond Myklebust struct nfs_inode *nfsi = NFS_I(dir); 73480c2006SBryan Schumaker struct nfs_open_dir_context *ctx; 74480c2006SBryan Schumaker ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 75480c2006SBryan Schumaker if (ctx != NULL) { 768ef2ce3eSBryan Schumaker ctx->duped = 0; 77311324adSTrond Myklebust ctx->attr_gencount = nfsi->attr_gencount; 78480c2006SBryan Schumaker ctx->dir_cookie = 0; 798ef2ce3eSBryan Schumaker ctx->dup_cookie = 0; 80480c2006SBryan Schumaker ctx->cred = get_rpccred(cred); 81311324adSTrond Myklebust spin_lock(&dir->i_lock); 82311324adSTrond Myklebust list_add(&ctx->list, &nfsi->open_files); 83311324adSTrond Myklebust spin_unlock(&dir->i_lock); 84480c2006SBryan Schumaker return ctx; 85480c2006SBryan Schumaker } 860c030806STrond Myklebust return ERR_PTR(-ENOMEM); 870c030806STrond Myklebust } 88480c2006SBryan Schumaker 89311324adSTrond Myklebust static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx) 90480c2006SBryan Schumaker { 91311324adSTrond Myklebust spin_lock(&dir->i_lock); 92311324adSTrond Myklebust list_del(&ctx->list); 93311324adSTrond Myklebust spin_unlock(&dir->i_lock); 94480c2006SBryan Schumaker put_rpccred(ctx->cred); 95480c2006SBryan Schumaker kfree(ctx); 96480c2006SBryan Schumaker } 97480c2006SBryan Schumaker 981da177e4SLinus Torvalds /* 991da177e4SLinus Torvalds * Open file 1001da177e4SLinus Torvalds */ 1011da177e4SLinus Torvalds static int 1021da177e4SLinus Torvalds nfs_opendir(struct inode *inode, struct file *filp) 1031da177e4SLinus Torvalds { 104480c2006SBryan Schumaker int res = 0; 105480c2006SBryan Schumaker struct nfs_open_dir_context *ctx; 106480c2006SBryan Schumaker struct rpc_cred *cred; 1071da177e4SLinus Torvalds 1086de1472fSAl Viro dfprintk(FILE, "NFS: open dir(%pD2)\n", filp); 109cc0dd2d1SChuck Lever 110cc0dd2d1SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 1111e7cb3dcSChuck Lever 112480c2006SBryan Schumaker cred = rpc_lookup_cred(); 113480c2006SBryan Schumaker if (IS_ERR(cred)) 114480c2006SBryan Schumaker return PTR_ERR(cred); 1150c030806STrond Myklebust ctx = alloc_nfs_open_dir_context(inode, cred); 116480c2006SBryan Schumaker if (IS_ERR(ctx)) { 117480c2006SBryan Schumaker res = PTR_ERR(ctx); 118480c2006SBryan Schumaker goto out; 119480c2006SBryan Schumaker } 120480c2006SBryan Schumaker filp->private_data = ctx; 121f5a73672SNeil Brown if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 122f5a73672SNeil Brown /* This is a mountpoint, so d_revalidate will never 123f5a73672SNeil Brown * have been called, so we need to refresh the 124f5a73672SNeil Brown * inode (for close-open consistency) ourselves. 125f5a73672SNeil Brown */ 126f5a73672SNeil Brown __nfs_revalidate_inode(NFS_SERVER(inode), inode); 127f5a73672SNeil Brown } 128480c2006SBryan Schumaker out: 129480c2006SBryan Schumaker put_rpccred(cred); 1301da177e4SLinus Torvalds return res; 1311da177e4SLinus Torvalds } 1321da177e4SLinus Torvalds 133480c2006SBryan Schumaker static int 134480c2006SBryan Schumaker nfs_closedir(struct inode *inode, struct file *filp) 135480c2006SBryan Schumaker { 136a455589fSAl Viro put_nfs_open_dir_context(file_inode(filp), filp->private_data); 137480c2006SBryan Schumaker return 0; 138480c2006SBryan Schumaker } 139480c2006SBryan Schumaker 140d1bacf9eSBryan Schumaker struct nfs_cache_array_entry { 141d1bacf9eSBryan Schumaker u64 cookie; 142d1bacf9eSBryan Schumaker u64 ino; 143d1bacf9eSBryan Schumaker struct qstr string; 1440b26a0bfSTrond Myklebust unsigned char d_type; 145d1bacf9eSBryan Schumaker }; 146d1bacf9eSBryan Schumaker 147d1bacf9eSBryan Schumaker struct nfs_cache_array { 1489ac3d3e8SAl Viro atomic_t refcount; 14988b8e133SChuck Lever int size; 150d1bacf9eSBryan Schumaker int eof_index; 151d1bacf9eSBryan Schumaker u64 last_cookie; 152d1bacf9eSBryan Schumaker struct nfs_cache_array_entry array[0]; 153d1bacf9eSBryan Schumaker }; 154d1bacf9eSBryan Schumaker 155573c4e1eSChuck Lever typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int); 1561da177e4SLinus Torvalds typedef struct { 1571da177e4SLinus Torvalds struct file *file; 1581da177e4SLinus Torvalds struct page *page; 15923db8620SAl Viro struct dir_context *ctx; 1601da177e4SLinus Torvalds unsigned long page_index; 161f0dd2136STrond Myklebust u64 *dir_cookie; 1620aded708STrond Myklebust u64 last_cookie; 163f0dd2136STrond Myklebust loff_t current_index; 1641da177e4SLinus Torvalds decode_dirent_t decode; 165d1bacf9eSBryan Schumaker 1661f4eab7eSNeil Brown unsigned long timestamp; 1674704f0e2STrond Myklebust unsigned long gencount; 168d1bacf9eSBryan Schumaker unsigned int cache_entry_index; 169d1bacf9eSBryan Schumaker unsigned int plus:1; 170d1bacf9eSBryan Schumaker unsigned int eof:1; 1711da177e4SLinus Torvalds } nfs_readdir_descriptor_t; 1721da177e4SLinus Torvalds 173d1bacf9eSBryan Schumaker /* 174d1bacf9eSBryan Schumaker * The caller is responsible for calling nfs_readdir_release_array(page) 1751da177e4SLinus Torvalds */ 1761da177e4SLinus Torvalds static 177d1bacf9eSBryan Schumaker struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 1781da177e4SLinus Torvalds { 1798cd51a0cSTrond Myklebust void *ptr; 180d1bacf9eSBryan Schumaker if (page == NULL) 181d1bacf9eSBryan Schumaker return ERR_PTR(-EIO); 1828cd51a0cSTrond Myklebust ptr = kmap(page); 1838cd51a0cSTrond Myklebust if (ptr == NULL) 1848cd51a0cSTrond Myklebust return ERR_PTR(-ENOMEM); 1858cd51a0cSTrond Myklebust return ptr; 186d1bacf9eSBryan Schumaker } 187d1bacf9eSBryan Schumaker 188d1bacf9eSBryan Schumaker static 189d1bacf9eSBryan Schumaker void nfs_readdir_release_array(struct page *page) 190d1bacf9eSBryan Schumaker { 191d1bacf9eSBryan Schumaker kunmap(page); 192d1bacf9eSBryan Schumaker } 193d1bacf9eSBryan Schumaker 194d1bacf9eSBryan Schumaker /* 195d1bacf9eSBryan Schumaker * we are freeing strings created by nfs_add_to_readdir_array() 196d1bacf9eSBryan Schumaker */ 197d1bacf9eSBryan Schumaker static 19811de3b11STrond Myklebust void nfs_readdir_clear_array(struct page *page) 199d1bacf9eSBryan Schumaker { 20011de3b11STrond Myklebust struct nfs_cache_array *array; 201d1bacf9eSBryan Schumaker int i; 2028cd51a0cSTrond Myklebust 2032b86ce2dSCong Wang array = kmap_atomic(page); 2049ac3d3e8SAl Viro if (atomic_dec_and_test(&array->refcount)) 205d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) 206d1bacf9eSBryan Schumaker kfree(array->array[i].string.name); 2072b86ce2dSCong Wang kunmap_atomic(array); 208d1bacf9eSBryan Schumaker } 209d1bacf9eSBryan Schumaker 2109ac3d3e8SAl Viro static bool grab_page(struct page *page) 2119ac3d3e8SAl Viro { 2129ac3d3e8SAl Viro struct nfs_cache_array *array = kmap_atomic(page); 2139ac3d3e8SAl Viro bool res = atomic_inc_not_zero(&array->refcount); 2149ac3d3e8SAl Viro kunmap_atomic(array); 2159ac3d3e8SAl Viro return res; 2169ac3d3e8SAl Viro } 2179ac3d3e8SAl Viro 218d1bacf9eSBryan Schumaker /* 219d1bacf9eSBryan Schumaker * the caller is responsible for freeing qstr.name 220d1bacf9eSBryan Schumaker * when called by nfs_readdir_add_to_array, the strings will be freed in 221d1bacf9eSBryan Schumaker * nfs_clear_readdir_array() 222d1bacf9eSBryan Schumaker */ 223d1bacf9eSBryan Schumaker static 2244a201d6eSTrond Myklebust int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 225d1bacf9eSBryan Schumaker { 226d1bacf9eSBryan Schumaker string->len = len; 227d1bacf9eSBryan Schumaker string->name = kmemdup(name, len, GFP_KERNEL); 2284a201d6eSTrond Myklebust if (string->name == NULL) 2294a201d6eSTrond Myklebust return -ENOMEM; 23004e4bd1cSCatalin Marinas /* 23104e4bd1cSCatalin Marinas * Avoid a kmemleak false positive. The pointer to the name is stored 23204e4bd1cSCatalin Marinas * in a page cache page which kmemleak does not scan. 23304e4bd1cSCatalin Marinas */ 23404e4bd1cSCatalin Marinas kmemleak_not_leak(string->name); 2358387ff25SLinus Torvalds string->hash = full_name_hash(NULL, name, len); 2364a201d6eSTrond Myklebust return 0; 237d1bacf9eSBryan Schumaker } 238d1bacf9eSBryan Schumaker 239d1bacf9eSBryan Schumaker static 240d1bacf9eSBryan Schumaker int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 241d1bacf9eSBryan Schumaker { 242d1bacf9eSBryan Schumaker struct nfs_cache_array *array = nfs_readdir_get_array(page); 2434a201d6eSTrond Myklebust struct nfs_cache_array_entry *cache_entry; 2444a201d6eSTrond Myklebust int ret; 2454a201d6eSTrond Myklebust 246d1bacf9eSBryan Schumaker if (IS_ERR(array)) 247d1bacf9eSBryan Schumaker return PTR_ERR(array); 248d1bacf9eSBryan Schumaker 2494a201d6eSTrond Myklebust cache_entry = &array->array[array->size]; 2503020093fSTrond Myklebust 2513020093fSTrond Myklebust /* Check that this entry lies within the page bounds */ 2523020093fSTrond Myklebust ret = -ENOSPC; 2533020093fSTrond Myklebust if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE) 2543020093fSTrond Myklebust goto out; 2553020093fSTrond Myklebust 2564a201d6eSTrond Myklebust cache_entry->cookie = entry->prev_cookie; 2574a201d6eSTrond Myklebust cache_entry->ino = entry->ino; 2580b26a0bfSTrond Myklebust cache_entry->d_type = entry->d_type; 2594a201d6eSTrond Myklebust ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 2604a201d6eSTrond Myklebust if (ret) 2614a201d6eSTrond Myklebust goto out; 262d1bacf9eSBryan Schumaker array->last_cookie = entry->cookie; 2638cd51a0cSTrond Myklebust array->size++; 26447c716cbSTrond Myklebust if (entry->eof != 0) 265d1bacf9eSBryan Schumaker array->eof_index = array->size; 2664a201d6eSTrond Myklebust out: 267d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 2684a201d6eSTrond Myklebust return ret; 269d1bacf9eSBryan Schumaker } 270d1bacf9eSBryan Schumaker 271d1bacf9eSBryan Schumaker static 272d1bacf9eSBryan Schumaker int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 273d1bacf9eSBryan Schumaker { 27423db8620SAl Viro loff_t diff = desc->ctx->pos - desc->current_index; 275d1bacf9eSBryan Schumaker unsigned int index; 276d1bacf9eSBryan Schumaker 277d1bacf9eSBryan Schumaker if (diff < 0) 278d1bacf9eSBryan Schumaker goto out_eof; 279d1bacf9eSBryan Schumaker if (diff >= array->size) { 2808cd51a0cSTrond Myklebust if (array->eof_index >= 0) 281d1bacf9eSBryan Schumaker goto out_eof; 282d1bacf9eSBryan Schumaker return -EAGAIN; 283d1bacf9eSBryan Schumaker } 284d1bacf9eSBryan Schumaker 285d1bacf9eSBryan Schumaker index = (unsigned int)diff; 286d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[index].cookie; 287d1bacf9eSBryan Schumaker desc->cache_entry_index = index; 288d1bacf9eSBryan Schumaker return 0; 289d1bacf9eSBryan Schumaker out_eof: 290d1bacf9eSBryan Schumaker desc->eof = 1; 291d1bacf9eSBryan Schumaker return -EBADCOOKIE; 292d1bacf9eSBryan Schumaker } 293d1bacf9eSBryan Schumaker 2944db72b40SJeff Layton static bool 2954db72b40SJeff Layton nfs_readdir_inode_mapping_valid(struct nfs_inode *nfsi) 2964db72b40SJeff Layton { 2974db72b40SJeff Layton if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA)) 2984db72b40SJeff Layton return false; 2994db72b40SJeff Layton smp_rmb(); 3004db72b40SJeff Layton return !test_bit(NFS_INO_INVALIDATING, &nfsi->flags); 3014db72b40SJeff Layton } 3024db72b40SJeff Layton 303d1bacf9eSBryan Schumaker static 304d1bacf9eSBryan Schumaker int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 305d1bacf9eSBryan Schumaker { 306d1bacf9eSBryan Schumaker int i; 3078ef2ce3eSBryan Schumaker loff_t new_pos; 308d1bacf9eSBryan Schumaker int status = -EAGAIN; 309d1bacf9eSBryan Schumaker 310d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) { 3118cd51a0cSTrond Myklebust if (array->array[i].cookie == *desc->dir_cookie) { 312496ad9aaSAl Viro struct nfs_inode *nfsi = NFS_I(file_inode(desc->file)); 3130c030806STrond Myklebust struct nfs_open_dir_context *ctx = desc->file->private_data; 3140c030806STrond Myklebust 3158ef2ce3eSBryan Schumaker new_pos = desc->current_index + i; 3164db72b40SJeff Layton if (ctx->attr_gencount != nfsi->attr_gencount || 3174db72b40SJeff Layton !nfs_readdir_inode_mapping_valid(nfsi)) { 3180c030806STrond Myklebust ctx->duped = 0; 3190c030806STrond Myklebust ctx->attr_gencount = nfsi->attr_gencount; 32023db8620SAl Viro } else if (new_pos < desc->ctx->pos) { 3210c030806STrond Myklebust if (ctx->duped > 0 3220c030806STrond Myklebust && ctx->dup_cookie == *desc->dir_cookie) { 3230c030806STrond Myklebust if (printk_ratelimit()) { 3246de1472fSAl Viro pr_notice("NFS: directory %pD2 contains a readdir loop." 3250c030806STrond Myklebust "Please contact your server vendor. " 3269581a4aeSJeff Layton "The file: %.*s has duplicate cookie %llu\n", 3279581a4aeSJeff Layton desc->file, array->array[i].string.len, 3289581a4aeSJeff Layton array->array[i].string.name, *desc->dir_cookie); 3290c030806STrond Myklebust } 3300c030806STrond Myklebust status = -ELOOP; 3310c030806STrond Myklebust goto out; 3320c030806STrond Myklebust } 3338ef2ce3eSBryan Schumaker ctx->dup_cookie = *desc->dir_cookie; 3340c030806STrond Myklebust ctx->duped = -1; 3358ef2ce3eSBryan Schumaker } 33623db8620SAl Viro desc->ctx->pos = new_pos; 3378cd51a0cSTrond Myklebust desc->cache_entry_index = i; 33847c716cbSTrond Myklebust return 0; 3398cd51a0cSTrond Myklebust } 3408cd51a0cSTrond Myklebust } 34147c716cbSTrond Myklebust if (array->eof_index >= 0) { 342d1bacf9eSBryan Schumaker status = -EBADCOOKIE; 34318fb5fe4STrond Myklebust if (*desc->dir_cookie == array->last_cookie) 34418fb5fe4STrond Myklebust desc->eof = 1; 345d1bacf9eSBryan Schumaker } 3460c030806STrond Myklebust out: 347d1bacf9eSBryan Schumaker return status; 348d1bacf9eSBryan Schumaker } 349d1bacf9eSBryan Schumaker 350d1bacf9eSBryan Schumaker static 351d1bacf9eSBryan Schumaker int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 352d1bacf9eSBryan Schumaker { 353d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 35447c716cbSTrond Myklebust int status; 355d1bacf9eSBryan Schumaker 356d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 357d1bacf9eSBryan Schumaker if (IS_ERR(array)) { 358d1bacf9eSBryan Schumaker status = PTR_ERR(array); 359d1bacf9eSBryan Schumaker goto out; 360d1bacf9eSBryan Schumaker } 361d1bacf9eSBryan Schumaker 362d1bacf9eSBryan Schumaker if (*desc->dir_cookie == 0) 363d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_pos(array, desc); 364d1bacf9eSBryan Schumaker else 365d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_cookie(array, desc); 366d1bacf9eSBryan Schumaker 36747c716cbSTrond Myklebust if (status == -EAGAIN) { 3680aded708STrond Myklebust desc->last_cookie = array->last_cookie; 369e47c085aSTrond Myklebust desc->current_index += array->size; 37047c716cbSTrond Myklebust desc->page_index++; 37147c716cbSTrond Myklebust } 372d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 373d1bacf9eSBryan Schumaker out: 374d1bacf9eSBryan Schumaker return status; 375d1bacf9eSBryan Schumaker } 376d1bacf9eSBryan Schumaker 377d1bacf9eSBryan Schumaker /* Fill a page with xdr information before transferring to the cache page */ 378d1bacf9eSBryan Schumaker static 37956e4ebf8SBryan Schumaker int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 380d1bacf9eSBryan Schumaker struct nfs_entry *entry, struct file *file, struct inode *inode) 381d1bacf9eSBryan Schumaker { 382480c2006SBryan Schumaker struct nfs_open_dir_context *ctx = file->private_data; 383480c2006SBryan Schumaker struct rpc_cred *cred = ctx->cred; 3844704f0e2STrond Myklebust unsigned long timestamp, gencount; 3851da177e4SLinus Torvalds int error; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds again: 3881da177e4SLinus Torvalds timestamp = jiffies; 3894704f0e2STrond Myklebust gencount = nfs_inc_attr_generation_counter(); 390be62a1a8SMiklos Szeredi error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages, 3911da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, desc->plus); 3921da177e4SLinus Torvalds if (error < 0) { 3931da177e4SLinus Torvalds /* We requested READDIRPLUS, but the server doesn't grok it */ 3941da177e4SLinus Torvalds if (error == -ENOTSUPP && desc->plus) { 3951da177e4SLinus Torvalds NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 3963a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 3971da177e4SLinus Torvalds desc->plus = 0; 3981da177e4SLinus Torvalds goto again; 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds goto error; 4011da177e4SLinus Torvalds } 4021f4eab7eSNeil Brown desc->timestamp = timestamp; 4034704f0e2STrond Myklebust desc->gencount = gencount; 404d1bacf9eSBryan Schumaker error: 405d1bacf9eSBryan Schumaker return error; 406d1bacf9eSBryan Schumaker } 407d1bacf9eSBryan Schumaker 408573c4e1eSChuck Lever static int xdr_decode(nfs_readdir_descriptor_t *desc, 409573c4e1eSChuck Lever struct nfs_entry *entry, struct xdr_stream *xdr) 410d1bacf9eSBryan Schumaker { 411573c4e1eSChuck Lever int error; 412d1bacf9eSBryan Schumaker 413573c4e1eSChuck Lever error = desc->decode(xdr, entry, desc->plus); 414573c4e1eSChuck Lever if (error) 415573c4e1eSChuck Lever return error; 416d1bacf9eSBryan Schumaker entry->fattr->time_start = desc->timestamp; 417d1bacf9eSBryan Schumaker entry->fattr->gencount = desc->gencount; 418d1bacf9eSBryan Schumaker return 0; 419d1bacf9eSBryan Schumaker } 420d1bacf9eSBryan Schumaker 421fa923369STrond Myklebust /* Match file and dirent using either filehandle or fileid 422fa923369STrond Myklebust * Note: caller is responsible for checking the fsid 423fa923369STrond Myklebust */ 424d39ab9deSBryan Schumaker static 425d39ab9deSBryan Schumaker int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 426d39ab9deSBryan Schumaker { 427d8fdb47fSTrond Myklebust struct inode *inode; 428fa923369STrond Myklebust struct nfs_inode *nfsi; 429fa923369STrond Myklebust 4302b0143b5SDavid Howells if (d_really_is_negative(dentry)) 4312b0143b5SDavid Howells return 0; 432fa923369STrond Myklebust 433d8fdb47fSTrond Myklebust inode = d_inode(dentry); 434d8fdb47fSTrond Myklebust if (is_bad_inode(inode) || NFS_STALE(inode)) 435d8fdb47fSTrond Myklebust return 0; 436d8fdb47fSTrond Myklebust 437d8fdb47fSTrond Myklebust nfsi = NFS_I(inode); 438fa923369STrond Myklebust if (entry->fattr->fileid == nfsi->fileid) 439fa923369STrond Myklebust return 1; 440fa923369STrond Myklebust if (nfs_compare_fh(entry->fh, &nfsi->fh) == 0) 441d39ab9deSBryan Schumaker return 1; 442d39ab9deSBryan Schumaker return 0; 443d39ab9deSBryan Schumaker } 444d39ab9deSBryan Schumaker 445d39ab9deSBryan Schumaker static 44623db8620SAl Viro bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx) 447d69ee9b8STrond Myklebust { 448d69ee9b8STrond Myklebust if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS)) 449d69ee9b8STrond Myklebust return false; 450d69ee9b8STrond Myklebust if (test_and_clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags)) 451d69ee9b8STrond Myklebust return true; 45223db8620SAl Viro if (ctx->pos == 0) 453d69ee9b8STrond Myklebust return true; 454d69ee9b8STrond Myklebust return false; 455d69ee9b8STrond Myklebust } 456d69ee9b8STrond Myklebust 457d69ee9b8STrond Myklebust /* 458d69ee9b8STrond Myklebust * This function is called by the lookup code to request the use of 459d69ee9b8STrond Myklebust * readdirplus to accelerate any future lookups in the same 460d69ee9b8STrond Myklebust * directory. 461d69ee9b8STrond Myklebust */ 462d69ee9b8STrond Myklebust static 463d69ee9b8STrond Myklebust void nfs_advise_use_readdirplus(struct inode *dir) 464d69ee9b8STrond Myklebust { 465d69ee9b8STrond Myklebust set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags); 466d69ee9b8STrond Myklebust } 467d69ee9b8STrond Myklebust 468311324adSTrond Myklebust /* 469311324adSTrond Myklebust * This function is mainly for use by nfs_getattr(). 470311324adSTrond Myklebust * 471311324adSTrond Myklebust * If this is an 'ls -l', we want to force use of readdirplus. 472311324adSTrond Myklebust * Do this by checking if there is an active file descriptor 473311324adSTrond Myklebust * and calling nfs_advise_use_readdirplus, then forcing a 474311324adSTrond Myklebust * cache flush. 475311324adSTrond Myklebust */ 476311324adSTrond Myklebust void nfs_force_use_readdirplus(struct inode *dir) 477311324adSTrond Myklebust { 478311324adSTrond Myklebust if (!list_empty(&NFS_I(dir)->open_files)) { 479311324adSTrond Myklebust nfs_advise_use_readdirplus(dir); 480311324adSTrond Myklebust nfs_zap_mapping(dir, dir->i_mapping); 481311324adSTrond Myklebust } 482311324adSTrond Myklebust } 483311324adSTrond Myklebust 484d69ee9b8STrond Myklebust static 485d39ab9deSBryan Schumaker void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry) 486d39ab9deSBryan Schumaker { 48726fe5750SLinus Torvalds struct qstr filename = QSTR_INIT(entry->name, entry->len); 4889ac3d3e8SAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 4894a201d6eSTrond Myklebust struct dentry *dentry; 4904a201d6eSTrond Myklebust struct dentry *alias; 4912b0143b5SDavid Howells struct inode *dir = d_inode(parent); 492d39ab9deSBryan Schumaker struct inode *inode; 493aa9c2669SDavid Quigley int status; 494d39ab9deSBryan Schumaker 495fa923369STrond Myklebust if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID)) 496fa923369STrond Myklebust return; 4976c441c25STrond Myklebust if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID)) 4986c441c25STrond Myklebust return; 49978d04af4STrond Myklebust if (filename.len == 0) 50078d04af4STrond Myklebust return; 50178d04af4STrond Myklebust /* Validate that the name doesn't contain any illegal '\0' */ 50278d04af4STrond Myklebust if (strnlen(filename.name, filename.len) != filename.len) 50378d04af4STrond Myklebust return; 50478d04af4STrond Myklebust /* ...or '/' */ 50578d04af4STrond Myklebust if (strnchr(filename.name, filename.len, '/')) 50678d04af4STrond Myklebust return; 5074a201d6eSTrond Myklebust if (filename.name[0] == '.') { 5084a201d6eSTrond Myklebust if (filename.len == 1) 5094a201d6eSTrond Myklebust return; 5104a201d6eSTrond Myklebust if (filename.len == 2 && filename.name[1] == '.') 5114a201d6eSTrond Myklebust return; 5124a201d6eSTrond Myklebust } 5138387ff25SLinus Torvalds filename.hash = full_name_hash(parent, filename.name, filename.len); 514d39ab9deSBryan Schumaker 5154a201d6eSTrond Myklebust dentry = d_lookup(parent, &filename); 5169ac3d3e8SAl Viro again: 5179ac3d3e8SAl Viro if (!dentry) { 5189ac3d3e8SAl Viro dentry = d_alloc_parallel(parent, &filename, &wq); 5199ac3d3e8SAl Viro if (IS_ERR(dentry)) 5209ac3d3e8SAl Viro return; 5219ac3d3e8SAl Viro } 5229ac3d3e8SAl Viro if (!d_in_lookup(dentry)) { 5236c441c25STrond Myklebust /* Is there a mountpoint here? If so, just exit */ 5246c441c25STrond Myklebust if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid, 5256c441c25STrond Myklebust &entry->fattr->fsid)) 5266c441c25STrond Myklebust goto out; 527d39ab9deSBryan Schumaker if (nfs_same_file(dentry, entry)) { 528cda57a1eSJeff Layton nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 5292b0143b5SDavid Howells status = nfs_refresh_inode(d_inode(dentry), entry->fattr); 530aa9c2669SDavid Quigley if (!status) 5312b0143b5SDavid Howells nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label); 532d39ab9deSBryan Schumaker goto out; 533d39ab9deSBryan Schumaker } else { 5345542aa2fSEric W. Biederman d_invalidate(dentry); 535d39ab9deSBryan Schumaker dput(dentry); 5369ac3d3e8SAl Viro dentry = NULL; 5379ac3d3e8SAl Viro goto again; 538d39ab9deSBryan Schumaker } 539d39ab9deSBryan Schumaker } 540d39ab9deSBryan Schumaker 5411775fd3eSDavid Quigley inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label); 54241d28bcaSAl Viro alias = d_splice_alias(inode, dentry); 5439ac3d3e8SAl Viro d_lookup_done(dentry); 5449ac3d3e8SAl Viro if (alias) { 545d39ab9deSBryan Schumaker if (IS_ERR(alias)) 546d39ab9deSBryan Schumaker goto out; 5479ac3d3e8SAl Viro dput(dentry); 5489ac3d3e8SAl Viro dentry = alias; 5499ac3d3e8SAl Viro } 550d39ab9deSBryan Schumaker nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 551d39ab9deSBryan Schumaker out: 552d39ab9deSBryan Schumaker dput(dentry); 553d39ab9deSBryan Schumaker } 554d39ab9deSBryan Schumaker 555d1bacf9eSBryan Schumaker /* Perform conversion from xdr to cache array */ 556d1bacf9eSBryan Schumaker static 5578cd51a0cSTrond Myklebust int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, 5586650239aSTrond Myklebust struct page **xdr_pages, struct page *page, unsigned int buflen) 559d1bacf9eSBryan Schumaker { 560babddc72SBryan Schumaker struct xdr_stream stream; 561f7da7a12SBenny Halevy struct xdr_buf buf; 5626650239aSTrond Myklebust struct page *scratch; 56399424380SBryan Schumaker struct nfs_cache_array *array; 5645c346854STrond Myklebust unsigned int count = 0; 5655c346854STrond Myklebust int status; 566babddc72SBryan Schumaker 5676650239aSTrond Myklebust scratch = alloc_page(GFP_KERNEL); 5686650239aSTrond Myklebust if (scratch == NULL) 5696650239aSTrond Myklebust return -ENOMEM; 570babddc72SBryan Schumaker 571ce85cfbeSBenjamin Coddington if (buflen == 0) 572ce85cfbeSBenjamin Coddington goto out_nopages; 573ce85cfbeSBenjamin Coddington 574f7da7a12SBenny Halevy xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen); 5756650239aSTrond Myklebust xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 57699424380SBryan Schumaker 57799424380SBryan Schumaker do { 57899424380SBryan Schumaker status = xdr_decode(desc, entry, &stream); 5798cd51a0cSTrond Myklebust if (status != 0) { 5808cd51a0cSTrond Myklebust if (status == -EAGAIN) 5818cd51a0cSTrond Myklebust status = 0; 58299424380SBryan Schumaker break; 5838cd51a0cSTrond Myklebust } 58499424380SBryan Schumaker 5855c346854STrond Myklebust count++; 5865c346854STrond Myklebust 58747c716cbSTrond Myklebust if (desc->plus != 0) 588be62a1a8SMiklos Szeredi nfs_prime_dcache(file_dentry(desc->file), entry); 5898cd51a0cSTrond Myklebust 5908cd51a0cSTrond Myklebust status = nfs_readdir_add_to_array(entry, page); 5918cd51a0cSTrond Myklebust if (status != 0) 5928cd51a0cSTrond Myklebust break; 59399424380SBryan Schumaker } while (!entry->eof); 59499424380SBryan Schumaker 595ce85cfbeSBenjamin Coddington out_nopages: 59647c716cbSTrond Myklebust if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) { 59799424380SBryan Schumaker array = nfs_readdir_get_array(page); 5988cd51a0cSTrond Myklebust if (!IS_ERR(array)) { 5998cd51a0cSTrond Myklebust array->eof_index = array->size; 60099424380SBryan Schumaker status = 0; 60199424380SBryan Schumaker nfs_readdir_release_array(page); 6025c346854STrond Myklebust } else 6035c346854STrond Myklebust status = PTR_ERR(array); 60456e4ebf8SBryan Schumaker } 6056650239aSTrond Myklebust 6066650239aSTrond Myklebust put_page(scratch); 6078cd51a0cSTrond Myklebust return status; 6088cd51a0cSTrond Myklebust } 60956e4ebf8SBryan Schumaker 61056e4ebf8SBryan Schumaker static 611c7e9668eSAnna Schumaker void nfs_readdir_free_pages(struct page **pages, unsigned int npages) 61256e4ebf8SBryan Schumaker { 61356e4ebf8SBryan Schumaker unsigned int i; 61456e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) 61556e4ebf8SBryan Schumaker put_page(pages[i]); 61656e4ebf8SBryan Schumaker } 61756e4ebf8SBryan Schumaker 61856e4ebf8SBryan Schumaker /* 61956e4ebf8SBryan Schumaker * nfs_readdir_large_page will allocate pages that must be freed with a call 6200b936e37SAnna Schumaker * to nfs_readdir_free_pagearray 62156e4ebf8SBryan Schumaker */ 62256e4ebf8SBryan Schumaker static 623c7e9668eSAnna Schumaker int nfs_readdir_alloc_pages(struct page **pages, unsigned int npages) 62456e4ebf8SBryan Schumaker { 62556e4ebf8SBryan Schumaker unsigned int i; 62656e4ebf8SBryan Schumaker 62756e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) { 62856e4ebf8SBryan Schumaker struct page *page = alloc_page(GFP_KERNEL); 62956e4ebf8SBryan Schumaker if (page == NULL) 63056e4ebf8SBryan Schumaker goto out_freepages; 63156e4ebf8SBryan Schumaker pages[i] = page; 63256e4ebf8SBryan Schumaker } 6336650239aSTrond Myklebust return 0; 63456e4ebf8SBryan Schumaker 63556e4ebf8SBryan Schumaker out_freepages: 636c7e9668eSAnna Schumaker nfs_readdir_free_pages(pages, i); 6376650239aSTrond Myklebust return -ENOMEM; 638d1bacf9eSBryan Schumaker } 639d1bacf9eSBryan Schumaker 640d1bacf9eSBryan Schumaker static 641d1bacf9eSBryan Schumaker int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 642d1bacf9eSBryan Schumaker { 64356e4ebf8SBryan Schumaker struct page *pages[NFS_MAX_READDIR_PAGES]; 644d1bacf9eSBryan Schumaker struct nfs_entry entry; 645d1bacf9eSBryan Schumaker struct file *file = desc->file; 646d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 6478cd51a0cSTrond Myklebust int status = -ENOMEM; 64856e4ebf8SBryan Schumaker unsigned int array_size = ARRAY_SIZE(pages); 649d1bacf9eSBryan Schumaker 650d1bacf9eSBryan Schumaker entry.prev_cookie = 0; 6510aded708STrond Myklebust entry.cookie = desc->last_cookie; 652d1bacf9eSBryan Schumaker entry.eof = 0; 653d1bacf9eSBryan Schumaker entry.fh = nfs_alloc_fhandle(); 654d1bacf9eSBryan Schumaker entry.fattr = nfs_alloc_fattr(); 655573c4e1eSChuck Lever entry.server = NFS_SERVER(inode); 656d1bacf9eSBryan Schumaker if (entry.fh == NULL || entry.fattr == NULL) 657d1bacf9eSBryan Schumaker goto out; 658d1bacf9eSBryan Schumaker 65914c43f76SDavid Quigley entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT); 66014c43f76SDavid Quigley if (IS_ERR(entry.label)) { 66114c43f76SDavid Quigley status = PTR_ERR(entry.label); 66214c43f76SDavid Quigley goto out; 66314c43f76SDavid Quigley } 66414c43f76SDavid Quigley 665d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(page); 6668cd51a0cSTrond Myklebust if (IS_ERR(array)) { 6678cd51a0cSTrond Myklebust status = PTR_ERR(array); 66814c43f76SDavid Quigley goto out_label_free; 6698cd51a0cSTrond Myklebust } 670d1bacf9eSBryan Schumaker memset(array, 0, sizeof(struct nfs_cache_array)); 6719ac3d3e8SAl Viro atomic_set(&array->refcount, 1); 672d1bacf9eSBryan Schumaker array->eof_index = -1; 673d1bacf9eSBryan Schumaker 674c7e9668eSAnna Schumaker status = nfs_readdir_alloc_pages(pages, array_size); 6756650239aSTrond Myklebust if (status < 0) 676d1bacf9eSBryan Schumaker goto out_release_array; 677d1bacf9eSBryan Schumaker do { 678ac396128STrond Myklebust unsigned int pglen; 67956e4ebf8SBryan Schumaker status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode); 680babddc72SBryan Schumaker 681d1bacf9eSBryan Schumaker if (status < 0) 682d1bacf9eSBryan Schumaker break; 683ac396128STrond Myklebust pglen = status; 6846650239aSTrond Myklebust status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen); 6858cd51a0cSTrond Myklebust if (status < 0) { 6868cd51a0cSTrond Myklebust if (status == -ENOSPC) 6878cd51a0cSTrond Myklebust status = 0; 6888cd51a0cSTrond Myklebust break; 6898cd51a0cSTrond Myklebust } 6908cd51a0cSTrond Myklebust } while (array->eof_index < 0); 691d1bacf9eSBryan Schumaker 692c7e9668eSAnna Schumaker nfs_readdir_free_pages(pages, array_size); 693d1bacf9eSBryan Schumaker out_release_array: 694d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 69514c43f76SDavid Quigley out_label_free: 69614c43f76SDavid Quigley nfs4_label_free(entry.label); 697d1bacf9eSBryan Schumaker out: 698d1bacf9eSBryan Schumaker nfs_free_fattr(entry.fattr); 699d1bacf9eSBryan Schumaker nfs_free_fhandle(entry.fh); 700d1bacf9eSBryan Schumaker return status; 701d1bacf9eSBryan Schumaker } 702d1bacf9eSBryan Schumaker 703d1bacf9eSBryan Schumaker /* 704d1bacf9eSBryan Schumaker * Now we cache directories properly, by converting xdr information 705d1bacf9eSBryan Schumaker * to an array that can be used for lookups later. This results in 706d1bacf9eSBryan Schumaker * fewer cache pages, since we can store more information on each page. 707d1bacf9eSBryan Schumaker * We only need to convert from xdr once so future lookups are much simpler 7081da177e4SLinus Torvalds */ 709d1bacf9eSBryan Schumaker static 710d1bacf9eSBryan Schumaker int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 711d1bacf9eSBryan Schumaker { 712496ad9aaSAl Viro struct inode *inode = file_inode(desc->file); 7138cd51a0cSTrond Myklebust int ret; 714d1bacf9eSBryan Schumaker 7158cd51a0cSTrond Myklebust ret = nfs_readdir_xdr_to_array(desc, page, inode); 7168cd51a0cSTrond Myklebust if (ret < 0) 717d1bacf9eSBryan Schumaker goto error; 718d1bacf9eSBryan Schumaker SetPageUptodate(page); 719d1bacf9eSBryan Schumaker 7202aac05a9STrond Myklebust if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 721cd9ae2b6STrond Myklebust /* Should never happen */ 722cd9ae2b6STrond Myklebust nfs_zap_mapping(inode, inode->i_mapping); 723cd9ae2b6STrond Myklebust } 7241da177e4SLinus Torvalds unlock_page(page); 7251da177e4SLinus Torvalds return 0; 7261da177e4SLinus Torvalds error: 7271da177e4SLinus Torvalds unlock_page(page); 7288cd51a0cSTrond Myklebust return ret; 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds 731d1bacf9eSBryan Schumaker static 732d1bacf9eSBryan Schumaker void cache_page_release(nfs_readdir_descriptor_t *desc) 7331da177e4SLinus Torvalds { 73411de3b11STrond Myklebust nfs_readdir_clear_array(desc->page); 73509cbfeafSKirill A. Shutemov put_page(desc->page); 7361da177e4SLinus Torvalds desc->page = NULL; 7371da177e4SLinus Torvalds } 7381da177e4SLinus Torvalds 739d1bacf9eSBryan Schumaker static 740d1bacf9eSBryan Schumaker struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 7411da177e4SLinus Torvalds { 7429ac3d3e8SAl Viro struct page *page; 7439ac3d3e8SAl Viro 7449ac3d3e8SAl Viro for (;;) { 74593c76a3dSAl Viro page = read_cache_page(desc->file->f_mapping, 746d1bacf9eSBryan Schumaker desc->page_index, (filler_t *)nfs_readdir_filler, desc); 7479ac3d3e8SAl Viro if (IS_ERR(page) || grab_page(page)) 7489ac3d3e8SAl Viro break; 7499ac3d3e8SAl Viro put_page(page); 7509ac3d3e8SAl Viro } 7519ac3d3e8SAl Viro return page; 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds /* 755d1bacf9eSBryan Schumaker * Returns 0 if desc->dir_cookie was found on page desc->page_index 7561da177e4SLinus Torvalds */ 757d1bacf9eSBryan Schumaker static 758d1bacf9eSBryan Schumaker int find_cache_page(nfs_readdir_descriptor_t *desc) 759d1bacf9eSBryan Schumaker { 760d1bacf9eSBryan Schumaker int res; 761d1bacf9eSBryan Schumaker 762d1bacf9eSBryan Schumaker desc->page = get_cache_page(desc); 763d1bacf9eSBryan Schumaker if (IS_ERR(desc->page)) 764d1bacf9eSBryan Schumaker return PTR_ERR(desc->page); 765d1bacf9eSBryan Schumaker 766d1bacf9eSBryan Schumaker res = nfs_readdir_search_array(desc); 76747c716cbSTrond Myklebust if (res != 0) 768d1bacf9eSBryan Schumaker cache_page_release(desc); 769d1bacf9eSBryan Schumaker return res; 770d1bacf9eSBryan Schumaker } 771d1bacf9eSBryan Schumaker 772d1bacf9eSBryan Schumaker /* Search for desc->dir_cookie from the beginning of the page cache */ 7731da177e4SLinus Torvalds static inline 7741da177e4SLinus Torvalds int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 7751da177e4SLinus Torvalds { 7768cd51a0cSTrond Myklebust int res; 777d1bacf9eSBryan Schumaker 7780aded708STrond Myklebust if (desc->page_index == 0) { 7798cd51a0cSTrond Myklebust desc->current_index = 0; 7800aded708STrond Myklebust desc->last_cookie = 0; 7810aded708STrond Myklebust } 78247c716cbSTrond Myklebust do { 783d1bacf9eSBryan Schumaker res = find_cache_page(desc); 78447c716cbSTrond Myklebust } while (res == -EAGAIN); 7851da177e4SLinus Torvalds return res; 7861da177e4SLinus Torvalds } 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds /* 7891da177e4SLinus Torvalds * Once we've found the start of the dirent within a page: fill 'er up... 7901da177e4SLinus Torvalds */ 7911da177e4SLinus Torvalds static 79223db8620SAl Viro int nfs_do_filldir(nfs_readdir_descriptor_t *desc) 7931da177e4SLinus Torvalds { 7941da177e4SLinus Torvalds struct file *file = desc->file; 795d1bacf9eSBryan Schumaker int i = 0; 796d1bacf9eSBryan Schumaker int res = 0; 797d1bacf9eSBryan Schumaker struct nfs_cache_array *array = NULL; 7988ef2ce3eSBryan Schumaker struct nfs_open_dir_context *ctx = file->private_data; 7998ef2ce3eSBryan Schumaker 800d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 801e7c58e97STrond Myklebust if (IS_ERR(array)) { 802e7c58e97STrond Myklebust res = PTR_ERR(array); 803e7c58e97STrond Myklebust goto out; 804e7c58e97STrond Myklebust } 8051da177e4SLinus Torvalds 806d1bacf9eSBryan Schumaker for (i = desc->cache_entry_index; i < array->size; i++) { 807ece0b423STrond Myklebust struct nfs_cache_array_entry *ent; 8081da177e4SLinus Torvalds 809ece0b423STrond Myklebust ent = &array->array[i]; 81023db8620SAl Viro if (!dir_emit(desc->ctx, ent->string.name, ent->string.len, 81123db8620SAl Viro nfs_compat_user_ino64(ent->ino), ent->d_type)) { 812ece0b423STrond Myklebust desc->eof = 1; 8131da177e4SLinus Torvalds break; 814ece0b423STrond Myklebust } 81523db8620SAl Viro desc->ctx->pos++; 816d1bacf9eSBryan Schumaker if (i < (array->size-1)) 817d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[i+1].cookie; 818d1bacf9eSBryan Schumaker else 819d1bacf9eSBryan Schumaker *desc->dir_cookie = array->last_cookie; 8200c030806STrond Myklebust if (ctx->duped != 0) 8210c030806STrond Myklebust ctx->duped = 1; 8228cd51a0cSTrond Myklebust } 82347c716cbSTrond Myklebust if (array->eof_index >= 0) 824d1bacf9eSBryan Schumaker desc->eof = 1; 825d1bacf9eSBryan Schumaker 826d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 827e7c58e97STrond Myklebust out: 828d1bacf9eSBryan Schumaker cache_page_release(desc); 8291e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 8301e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie, res); 8311da177e4SLinus Torvalds return res; 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds /* 8351da177e4SLinus Torvalds * If we cannot find a cookie in our cache, we suspect that this is 8361da177e4SLinus Torvalds * because it points to a deleted file, so we ask the server to return 8371da177e4SLinus Torvalds * whatever it thinks is the next entry. We then feed this to filldir. 8381da177e4SLinus Torvalds * If all goes well, we should then be able to find our way round the 8391da177e4SLinus Torvalds * cache on the next call to readdir_search_pagecache(); 8401da177e4SLinus Torvalds * 8411da177e4SLinus Torvalds * NOTE: we cannot add the anonymous page to the pagecache because 8421da177e4SLinus Torvalds * the data it contains might not be page aligned. Besides, 8431da177e4SLinus Torvalds * we should already have a complete representation of the 8441da177e4SLinus Torvalds * directory in the page cache by the time we get here. 8451da177e4SLinus Torvalds */ 8461da177e4SLinus Torvalds static inline 84723db8620SAl Viro int uncached_readdir(nfs_readdir_descriptor_t *desc) 8481da177e4SLinus Torvalds { 8491da177e4SLinus Torvalds struct page *page = NULL; 8501da177e4SLinus Torvalds int status; 851496ad9aaSAl Viro struct inode *inode = file_inode(desc->file); 8520c030806STrond Myklebust struct nfs_open_dir_context *ctx = desc->file->private_data; 8531da177e4SLinus Torvalds 8541e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 8551e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie); 8561da177e4SLinus Torvalds 8571da177e4SLinus Torvalds page = alloc_page(GFP_HIGHUSER); 8581da177e4SLinus Torvalds if (!page) { 8591da177e4SLinus Torvalds status = -ENOMEM; 8601da177e4SLinus Torvalds goto out; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 8637a8e1dc3STrond Myklebust desc->page_index = 0; 8640aded708STrond Myklebust desc->last_cookie = *desc->dir_cookie; 8657a8e1dc3STrond Myklebust desc->page = page; 8660c030806STrond Myklebust ctx->duped = 0; 8677a8e1dc3STrond Myklebust 86885f8607eSTrond Myklebust status = nfs_readdir_xdr_to_array(desc, page, inode); 86985f8607eSTrond Myklebust if (status < 0) 870d1bacf9eSBryan Schumaker goto out_release; 871d1bacf9eSBryan Schumaker 87223db8620SAl Viro status = nfs_do_filldir(desc); 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds out: 8751e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 8763110ff80SHarvey Harrison __func__, status); 8771da177e4SLinus Torvalds return status; 8781da177e4SLinus Torvalds out_release: 879d1bacf9eSBryan Schumaker cache_page_release(desc); 8801da177e4SLinus Torvalds goto out; 8811da177e4SLinus Torvalds } 8821da177e4SLinus Torvalds 883311324adSTrond Myklebust static bool nfs_dir_mapping_need_revalidate(struct inode *dir) 884311324adSTrond Myklebust { 885311324adSTrond Myklebust struct nfs_inode *nfsi = NFS_I(dir); 886311324adSTrond Myklebust 887311324adSTrond Myklebust if (nfs_attribute_cache_expired(dir)) 888311324adSTrond Myklebust return true; 889311324adSTrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_DATA) 890311324adSTrond Myklebust return true; 891311324adSTrond Myklebust return false; 892311324adSTrond Myklebust } 893311324adSTrond Myklebust 89400a92642SOlivier Galibert /* The file offset position represents the dirent entry number. A 89500a92642SOlivier Galibert last cookie cache takes care of the common case of reading the 89600a92642SOlivier Galibert whole directory. 8971da177e4SLinus Torvalds */ 89823db8620SAl Viro static int nfs_readdir(struct file *file, struct dir_context *ctx) 8991da177e4SLinus Torvalds { 900be62a1a8SMiklos Szeredi struct dentry *dentry = file_dentry(file); 9012b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 9021da177e4SLinus Torvalds nfs_readdir_descriptor_t my_desc, 9031da177e4SLinus Torvalds *desc = &my_desc; 90423db8620SAl Viro struct nfs_open_dir_context *dir_ctx = file->private_data; 90507b5ce8eSScott Mayhew int res = 0; 9061da177e4SLinus Torvalds 9076de1472fSAl Viro dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n", 9086de1472fSAl Viro file, (long long)ctx->pos); 90991d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 91091d5b470SChuck Lever 9111da177e4SLinus Torvalds /* 91223db8620SAl Viro * ctx->pos points to the dirent entry number. 913f0dd2136STrond Myklebust * *desc->dir_cookie has the cookie for the next entry. We have 91400a92642SOlivier Galibert * to either find the entry with the appropriate number or 91500a92642SOlivier Galibert * revalidate the cookie. 9161da177e4SLinus Torvalds */ 9171da177e4SLinus Torvalds memset(desc, 0, sizeof(*desc)); 9181da177e4SLinus Torvalds 91923db8620SAl Viro desc->file = file; 92023db8620SAl Viro desc->ctx = ctx; 921480c2006SBryan Schumaker desc->dir_cookie = &dir_ctx->dir_cookie; 9221da177e4SLinus Torvalds desc->decode = NFS_PROTO(inode)->decode_dirent; 92323db8620SAl Viro desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0; 9241da177e4SLinus Torvalds 925311324adSTrond Myklebust if (ctx->pos == 0 || nfs_dir_mapping_need_revalidate(inode)) 92623db8620SAl Viro res = nfs_revalidate_mapping(inode, file->f_mapping); 927fccca7fcSTrond Myklebust if (res < 0) 928fccca7fcSTrond Myklebust goto out; 929fccca7fcSTrond Myklebust 93047c716cbSTrond Myklebust do { 9311da177e4SLinus Torvalds res = readdir_search_pagecache(desc); 93200a92642SOlivier Galibert 9331da177e4SLinus Torvalds if (res == -EBADCOOKIE) { 934ece0b423STrond Myklebust res = 0; 9351da177e4SLinus Torvalds /* This means either end of directory */ 936d1bacf9eSBryan Schumaker if (*desc->dir_cookie && desc->eof == 0) { 9371da177e4SLinus Torvalds /* Or that the server has 'lost' a cookie */ 93823db8620SAl Viro res = uncached_readdir(desc); 939ece0b423STrond Myklebust if (res == 0) 9401da177e4SLinus Torvalds continue; 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds break; 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds if (res == -ETOOSMALL && desc->plus) { 9453a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 9461da177e4SLinus Torvalds nfs_zap_caches(inode); 947baf57a09STrond Myklebust desc->page_index = 0; 9481da177e4SLinus Torvalds desc->plus = 0; 949d1bacf9eSBryan Schumaker desc->eof = 0; 9501da177e4SLinus Torvalds continue; 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds if (res < 0) 9531da177e4SLinus Torvalds break; 9541da177e4SLinus Torvalds 95523db8620SAl Viro res = nfs_do_filldir(desc); 956ece0b423STrond Myklebust if (res < 0) 9571da177e4SLinus Torvalds break; 95847c716cbSTrond Myklebust } while (!desc->eof); 959fccca7fcSTrond Myklebust out: 9601e7cb3dcSChuck Lever if (res > 0) 9611e7cb3dcSChuck Lever res = 0; 9626de1472fSAl Viro dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res); 9631da177e4SLinus Torvalds return res; 9641da177e4SLinus Torvalds } 9651da177e4SLinus Torvalds 966965c8e59SAndrew Morton static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence) 967f0dd2136STrond Myklebust { 968480c2006SBryan Schumaker struct nfs_open_dir_context *dir_ctx = filp->private_data; 969b84e06c5SChuck Lever 9706de1472fSAl Viro dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n", 9716de1472fSAl Viro filp, offset, whence); 972b84e06c5SChuck Lever 973965c8e59SAndrew Morton switch (whence) { 974f0dd2136STrond Myklebust case 1: 975f0dd2136STrond Myklebust offset += filp->f_pos; 976f0dd2136STrond Myklebust case 0: 977f0dd2136STrond Myklebust if (offset >= 0) 978f0dd2136STrond Myklebust break; 979f0dd2136STrond Myklebust default: 9809ac3d3e8SAl Viro return -EINVAL; 981f0dd2136STrond Myklebust } 982f0dd2136STrond Myklebust if (offset != filp->f_pos) { 983f0dd2136STrond Myklebust filp->f_pos = offset; 984480c2006SBryan Schumaker dir_ctx->dir_cookie = 0; 9858ef2ce3eSBryan Schumaker dir_ctx->duped = 0; 986f0dd2136STrond Myklebust } 987f0dd2136STrond Myklebust return offset; 988f0dd2136STrond Myklebust } 989f0dd2136STrond Myklebust 9901da177e4SLinus Torvalds /* 9911da177e4SLinus Torvalds * All directory operations under NFS are synchronous, so fsync() 9921da177e4SLinus Torvalds * is a dummy operation. 9931da177e4SLinus Torvalds */ 99402c24a82SJosef Bacik static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end, 99502c24a82SJosef Bacik int datasync) 9961da177e4SLinus Torvalds { 9976de1472fSAl Viro struct inode *inode = file_inode(filp); 9987ea80859SChristoph Hellwig 9996de1472fSAl Viro dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync); 10001e7cb3dcSChuck Lever 10015955102cSAl Viro inode_lock(inode); 10026de1472fSAl Viro nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 10035955102cSAl Viro inode_unlock(inode); 10041da177e4SLinus Torvalds return 0; 10051da177e4SLinus Torvalds } 10061da177e4SLinus Torvalds 1007bfc69a45STrond Myklebust /** 1008bfc69a45STrond Myklebust * nfs_force_lookup_revalidate - Mark the directory as having changed 1009bfc69a45STrond Myklebust * @dir - pointer to directory inode 1010bfc69a45STrond Myklebust * 1011bfc69a45STrond Myklebust * This forces the revalidation code in nfs_lookup_revalidate() to do a 1012bfc69a45STrond Myklebust * full lookup on all child dentries of 'dir' whenever a change occurs 1013bfc69a45STrond Myklebust * on the server that might have invalidated our dcache. 1014bfc69a45STrond Myklebust * 1015bfc69a45STrond Myklebust * The caller should be holding dir->i_lock 1016bfc69a45STrond Myklebust */ 1017bfc69a45STrond Myklebust void nfs_force_lookup_revalidate(struct inode *dir) 1018bfc69a45STrond Myklebust { 1019011935a0STrond Myklebust NFS_I(dir)->cache_change_attribute++; 1020bfc69a45STrond Myklebust } 102189d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate); 1022bfc69a45STrond Myklebust 10231da177e4SLinus Torvalds /* 10241da177e4SLinus Torvalds * A check for whether or not the parent directory has changed. 10251da177e4SLinus Torvalds * In the case it has, we assume that the dentries are untrustworthy 10261da177e4SLinus Torvalds * and may need to be looked up again. 1027912a108dSNeilBrown * If rcu_walk prevents us from performing a full check, return 0. 10281da177e4SLinus Torvalds */ 1029912a108dSNeilBrown static int nfs_check_verifier(struct inode *dir, struct dentry *dentry, 1030912a108dSNeilBrown int rcu_walk) 10311da177e4SLinus Torvalds { 1032912a108dSNeilBrown int ret; 1033912a108dSNeilBrown 10341da177e4SLinus Torvalds if (IS_ROOT(dentry)) 10351da177e4SLinus Torvalds return 1; 10364eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 10374eec952eSTrond Myklebust return 0; 1038f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 10396ecc5e8fSTrond Myklebust return 0; 1040f2c77f4eSTrond Myklebust /* Revalidate nfsi->cache_change_attribute before we declare a match */ 1041912a108dSNeilBrown if (rcu_walk) 1042912a108dSNeilBrown ret = nfs_revalidate_inode_rcu(NFS_SERVER(dir), dir); 1043912a108dSNeilBrown else 1044912a108dSNeilBrown ret = nfs_revalidate_inode(NFS_SERVER(dir), dir); 1045912a108dSNeilBrown if (ret < 0) 1046f2c77f4eSTrond Myklebust return 0; 1047f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 1048f2c77f4eSTrond Myklebust return 0; 1049f2c77f4eSTrond Myklebust return 1; 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds /* 1053a12802caSTrond Myklebust * Use intent information to check whether or not we're going to do 1054a12802caSTrond Myklebust * an O_EXCL create using this path component. 1055a12802caSTrond Myklebust */ 1056fa3c56bbSAl Viro static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags) 1057a12802caSTrond Myklebust { 1058a12802caSTrond Myklebust if (NFS_PROTO(dir)->version == 2) 1059a12802caSTrond Myklebust return 0; 1060fa3c56bbSAl Viro return flags & LOOKUP_EXCL; 1061a12802caSTrond Myklebust } 1062a12802caSTrond Myklebust 1063a12802caSTrond Myklebust /* 10641d6757fbSTrond Myklebust * Inode and filehandle revalidation for lookups. 10651d6757fbSTrond Myklebust * 10661d6757fbSTrond Myklebust * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 10671d6757fbSTrond Myklebust * or if the intent information indicates that we're about to open this 10681d6757fbSTrond Myklebust * particular file and the "nocto" mount flag is not set. 10691d6757fbSTrond Myklebust * 10701d6757fbSTrond Myklebust */ 107165a0c149STrond Myklebust static 1072fa3c56bbSAl Viro int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds struct nfs_server *server = NFS_SERVER(inode); 107565a0c149STrond Myklebust int ret; 10761da177e4SLinus Torvalds 107736d43a43SDavid Howells if (IS_AUTOMOUNT(inode)) 10784e99a1ffSTrond Myklebust return 0; 10791da177e4SLinus Torvalds /* VFS wants an on-the-wire revalidation */ 1080fa3c56bbSAl Viro if (flags & LOOKUP_REVAL) 10811da177e4SLinus Torvalds goto out_force; 10821da177e4SLinus Torvalds /* This is an open(2) */ 1083fa3c56bbSAl Viro if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) && 1084fa3c56bbSAl Viro (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) 10851da177e4SLinus Torvalds goto out_force; 108665a0c149STrond Myklebust out: 108765a0c149STrond Myklebust return (inode->i_nlink == 0) ? -ENOENT : 0; 10881da177e4SLinus Torvalds out_force: 10891fa1e384SNeilBrown if (flags & LOOKUP_RCU) 10901fa1e384SNeilBrown return -ECHILD; 109165a0c149STrond Myklebust ret = __nfs_revalidate_inode(server, inode); 109265a0c149STrond Myklebust if (ret != 0) 109365a0c149STrond Myklebust return ret; 109465a0c149STrond Myklebust goto out; 10951da177e4SLinus Torvalds } 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds /* 10981da177e4SLinus Torvalds * We judge how long we want to trust negative 10991da177e4SLinus Torvalds * dentries by looking at the parent inode mtime. 11001da177e4SLinus Torvalds * 11011da177e4SLinus Torvalds * If parent mtime has changed, we revalidate, else we wait for a 11021da177e4SLinus Torvalds * period corresponding to the parent's attribute cache timeout value. 1103912a108dSNeilBrown * 1104912a108dSNeilBrown * If LOOKUP_RCU prevents us from performing a full check, return 1 1105912a108dSNeilBrown * suggesting a reval is needed. 11061da177e4SLinus Torvalds */ 11071da177e4SLinus Torvalds static inline 11081da177e4SLinus Torvalds int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 1109fa3c56bbSAl Viro unsigned int flags) 11101da177e4SLinus Torvalds { 11111da177e4SLinus Torvalds /* Don't revalidate a negative dentry if we're creating a new file */ 1112fa3c56bbSAl Viro if (flags & LOOKUP_CREATE) 11131da177e4SLinus Torvalds return 0; 11144eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 11154eec952eSTrond Myklebust return 1; 1116912a108dSNeilBrown return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU); 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds /* 11201da177e4SLinus Torvalds * This is called every time the dcache has a lookup hit, 11211da177e4SLinus Torvalds * and we should check whether we can really trust that 11221da177e4SLinus Torvalds * lookup. 11231da177e4SLinus Torvalds * 11241da177e4SLinus Torvalds * NOTE! The hit can be a negative hit too, don't assume 11251da177e4SLinus Torvalds * we have an inode! 11261da177e4SLinus Torvalds * 11271da177e4SLinus Torvalds * If the parent directory is seen to have changed, we throw out the 11281da177e4SLinus Torvalds * cached dentry and do a new lookup. 11291da177e4SLinus Torvalds */ 11300b728e19SAl Viro static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) 11311da177e4SLinus Torvalds { 11321da177e4SLinus Torvalds struct inode *dir; 11331da177e4SLinus Torvalds struct inode *inode; 11341da177e4SLinus Torvalds struct dentry *parent; 1135e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1136e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 11371775fd3eSDavid Quigley struct nfs4_label *label = NULL; 11381da177e4SLinus Torvalds int error; 11391da177e4SLinus Torvalds 1140d51ac1a8SNeilBrown if (flags & LOOKUP_RCU) { 114150d77739SNeilBrown parent = ACCESS_ONCE(dentry->d_parent); 11422b0143b5SDavid Howells dir = d_inode_rcu(parent); 1143d51ac1a8SNeilBrown if (!dir) 114434286d66SNick Piggin return -ECHILD; 1145d51ac1a8SNeilBrown } else { 11461da177e4SLinus Torvalds parent = dget_parent(dentry); 11472b0143b5SDavid Howells dir = d_inode(parent); 1148d51ac1a8SNeilBrown } 114991d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 11502b0143b5SDavid Howells inode = d_inode(dentry); 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds if (!inode) { 1153912a108dSNeilBrown if (nfs_neg_need_reval(dir, dentry, flags)) { 1154d51ac1a8SNeilBrown if (flags & LOOKUP_RCU) 1155d51ac1a8SNeilBrown return -ECHILD; 11561da177e4SLinus Torvalds goto out_bad; 1157912a108dSNeilBrown } 1158d69ee9b8STrond Myklebust goto out_valid_noent; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds if (is_bad_inode(inode)) { 1162d51ac1a8SNeilBrown if (flags & LOOKUP_RCU) 1163d51ac1a8SNeilBrown return -ECHILD; 11646de1472fSAl Viro dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n", 11656de1472fSAl Viro __func__, dentry); 11661da177e4SLinus Torvalds goto out_bad; 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds 1169011e2a7fSBryan Schumaker if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ)) 117015860ab1STrond Myklebust goto out_set_verifier; 117115860ab1STrond Myklebust 1172912a108dSNeilBrown /* Force a full look up iff the parent directory has changed */ 1173912a108dSNeilBrown if (!nfs_is_exclusive_create(dir, flags) && 1174912a108dSNeilBrown nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) { 1175912a108dSNeilBrown 11761fa1e384SNeilBrown if (nfs_lookup_verify_inode(inode, flags)) { 1177d51ac1a8SNeilBrown if (flags & LOOKUP_RCU) 1178d51ac1a8SNeilBrown return -ECHILD; 11791da177e4SLinus Torvalds goto out_zap_parent; 11801fa1e384SNeilBrown } 11811da177e4SLinus Torvalds goto out_valid; 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 1184912a108dSNeilBrown if (flags & LOOKUP_RCU) 1185912a108dSNeilBrown return -ECHILD; 1186912a108dSNeilBrown 11871da177e4SLinus Torvalds if (NFS_STALE(inode)) 11881da177e4SLinus Torvalds goto out_bad; 11891da177e4SLinus Torvalds 1190e1fb4d05STrond Myklebust error = -ENOMEM; 1191e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1192e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1193e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1194e1fb4d05STrond Myklebust goto out_error; 1195e1fb4d05STrond Myklebust 119614c43f76SDavid Quigley label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT); 119714c43f76SDavid Quigley if (IS_ERR(label)) 119814c43f76SDavid Quigley goto out_error; 119914c43f76SDavid Quigley 12006e0d0be7STrond Myklebust trace_nfs_lookup_revalidate_enter(dir, dentry, flags); 12011775fd3eSDavid Quigley error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label); 12026e0d0be7STrond Myklebust trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error); 12031da177e4SLinus Torvalds if (error) 12041da177e4SLinus Torvalds goto out_bad; 1205e1fb4d05STrond Myklebust if (nfs_compare_fh(NFS_FH(inode), fhandle)) 12061da177e4SLinus Torvalds goto out_bad; 1207e1fb4d05STrond Myklebust if ((error = nfs_refresh_inode(inode, fattr)) != 0) 12081da177e4SLinus Torvalds goto out_bad; 12091da177e4SLinus Torvalds 1210aa9c2669SDavid Quigley nfs_setsecurity(inode, fattr, label); 1211aa9c2669SDavid Quigley 1212e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1213e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 121414c43f76SDavid Quigley nfs4_label_free(label); 121514c43f76SDavid Quigley 121615860ab1STrond Myklebust out_set_verifier: 1217cf8ba45eSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 12181da177e4SLinus Torvalds out_valid: 1219d69ee9b8STrond Myklebust /* Success: notify readdir to use READDIRPLUS */ 1220d69ee9b8STrond Myklebust nfs_advise_use_readdirplus(dir); 1221d69ee9b8STrond Myklebust out_valid_noent: 1222d51ac1a8SNeilBrown if (flags & LOOKUP_RCU) { 122350d77739SNeilBrown if (parent != ACCESS_ONCE(dentry->d_parent)) 1224d51ac1a8SNeilBrown return -ECHILD; 1225d51ac1a8SNeilBrown } else 12261da177e4SLinus Torvalds dput(parent); 12276de1472fSAl Viro dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n", 12286de1472fSAl Viro __func__, dentry); 12291da177e4SLinus Torvalds return 1; 12301da177e4SLinus Torvalds out_zap_parent: 12311da177e4SLinus Torvalds nfs_zap_caches(dir); 12321da177e4SLinus Torvalds out_bad: 1233d51ac1a8SNeilBrown WARN_ON(flags & LOOKUP_RCU); 1234c44600c9SAl Viro nfs_free_fattr(fattr); 1235c44600c9SAl Viro nfs_free_fhandle(fhandle); 123614c43f76SDavid Quigley nfs4_label_free(label); 1237a1643a92STrond Myklebust nfs_mark_for_revalidate(dir); 12381da177e4SLinus Torvalds if (inode && S_ISDIR(inode->i_mode)) { 12391da177e4SLinus Torvalds /* Purge readdir caches. */ 12401da177e4SLinus Torvalds nfs_zap_caches(inode); 1241a3f432bfSJ. Bruce Fields /* 1242a3f432bfSJ. Bruce Fields * We can't d_drop the root of a disconnected tree: 1243a3f432bfSJ. Bruce Fields * its d_hash is on the s_anon list and d_drop() would hide 1244a3f432bfSJ. Bruce Fields * it from shrink_dcache_for_unmount(), leading to busy 1245a3f432bfSJ. Bruce Fields * inodes on unmount and further oopses. 1246a3f432bfSJ. Bruce Fields */ 1247a3f432bfSJ. Bruce Fields if (IS_ROOT(dentry)) 1248d9e80b7dSAl Viro goto out_valid; 12491da177e4SLinus Torvalds } 12501da177e4SLinus Torvalds dput(parent); 12516de1472fSAl Viro dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n", 12526de1472fSAl Viro __func__, dentry); 12531da177e4SLinus Torvalds return 0; 1254e1fb4d05STrond Myklebust out_error: 1255d51ac1a8SNeilBrown WARN_ON(flags & LOOKUP_RCU); 1256e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1257e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 125814c43f76SDavid Quigley nfs4_label_free(label); 1259e1fb4d05STrond Myklebust dput(parent); 12606de1472fSAl Viro dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n", 12616de1472fSAl Viro __func__, dentry, error); 1262e1fb4d05STrond Myklebust return error; 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds /* 12662b0143b5SDavid Howells * A weaker form of d_revalidate for revalidating just the d_inode(dentry) 1267ecf3d1f1SJeff Layton * when we don't really care about the dentry name. This is called when a 1268ecf3d1f1SJeff Layton * pathwalk ends on a dentry that was not found via a normal lookup in the 1269ecf3d1f1SJeff Layton * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals). 1270ecf3d1f1SJeff Layton * 1271ecf3d1f1SJeff Layton * In this situation, we just want to verify that the inode itself is OK 1272ecf3d1f1SJeff Layton * since the dentry might have changed on the server. 1273ecf3d1f1SJeff Layton */ 1274ecf3d1f1SJeff Layton static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags) 1275ecf3d1f1SJeff Layton { 1276ecf3d1f1SJeff Layton int error; 12772b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 1278ecf3d1f1SJeff Layton 1279ecf3d1f1SJeff Layton /* 1280ecf3d1f1SJeff Layton * I believe we can only get a negative dentry here in the case of a 1281ecf3d1f1SJeff Layton * procfs-style symlink. Just assume it's correct for now, but we may 1282ecf3d1f1SJeff Layton * eventually need to do something more here. 1283ecf3d1f1SJeff Layton */ 1284ecf3d1f1SJeff Layton if (!inode) { 12856de1472fSAl Viro dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n", 12866de1472fSAl Viro __func__, dentry); 1287ecf3d1f1SJeff Layton return 1; 1288ecf3d1f1SJeff Layton } 1289ecf3d1f1SJeff Layton 1290ecf3d1f1SJeff Layton if (is_bad_inode(inode)) { 12916de1472fSAl Viro dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n", 12926de1472fSAl Viro __func__, dentry); 1293ecf3d1f1SJeff Layton return 0; 1294ecf3d1f1SJeff Layton } 1295ecf3d1f1SJeff Layton 1296ecf3d1f1SJeff Layton error = nfs_revalidate_inode(NFS_SERVER(inode), inode); 1297ecf3d1f1SJeff Layton dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n", 1298ecf3d1f1SJeff Layton __func__, inode->i_ino, error ? "invalid" : "valid"); 1299ecf3d1f1SJeff Layton return !error; 1300ecf3d1f1SJeff Layton } 1301ecf3d1f1SJeff Layton 1302ecf3d1f1SJeff Layton /* 13031da177e4SLinus Torvalds * This is called from dput() when d_count is going to 0. 13041da177e4SLinus Torvalds */ 1305fe15ce44SNick Piggin static int nfs_dentry_delete(const struct dentry *dentry) 13061da177e4SLinus Torvalds { 13076de1472fSAl Viro dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n", 13086de1472fSAl Viro dentry, dentry->d_flags); 13091da177e4SLinus Torvalds 131077f11192STrond Myklebust /* Unhash any dentry with a stale inode */ 13112b0143b5SDavid Howells if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry))) 131277f11192STrond Myklebust return 1; 131377f11192STrond Myklebust 13141da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 13151da177e4SLinus Torvalds /* Unhash it, so that ->d_iput() would be called */ 13161da177e4SLinus Torvalds return 1; 13171da177e4SLinus Torvalds } 13181da177e4SLinus Torvalds if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 13191da177e4SLinus Torvalds /* Unhash it, so that ancestors of killed async unlink 13201da177e4SLinus Torvalds * files will be cleaned up during umount */ 13211da177e4SLinus Torvalds return 1; 13221da177e4SLinus Torvalds } 13231da177e4SLinus Torvalds return 0; 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds } 13261da177e4SLinus Torvalds 13271f018458STrond Myklebust /* Ensure that we revalidate inode->i_nlink */ 13281b83d707STrond Myklebust static void nfs_drop_nlink(struct inode *inode) 13291b83d707STrond Myklebust { 13301b83d707STrond Myklebust spin_lock(&inode->i_lock); 13311f018458STrond Myklebust /* drop the inode if we're reasonably sure this is the last link */ 13321f018458STrond Myklebust if (inode->i_nlink == 1) 13331f018458STrond Myklebust clear_nlink(inode); 13341f018458STrond Myklebust NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR; 13351b83d707STrond Myklebust spin_unlock(&inode->i_lock); 13361b83d707STrond Myklebust } 13371b83d707STrond Myklebust 13381da177e4SLinus Torvalds /* 13391da177e4SLinus Torvalds * Called when the dentry loses inode. 13401da177e4SLinus Torvalds * We use it to clean up silly-renamed files. 13411da177e4SLinus Torvalds */ 13421da177e4SLinus Torvalds static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 13431da177e4SLinus Torvalds { 134483672d39SNeil Brown if (S_ISDIR(inode->i_mode)) 134583672d39SNeil Brown /* drop any readdir cache as it could easily be old */ 134683672d39SNeil Brown NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 134783672d39SNeil Brown 13481da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1349e4eff1a6STrond Myklebust nfs_complete_unlink(dentry, inode); 13501f018458STrond Myklebust nfs_drop_nlink(inode); 13511da177e4SLinus Torvalds } 13521da177e4SLinus Torvalds iput(inode); 13531da177e4SLinus Torvalds } 13541da177e4SLinus Torvalds 1355b1942c5fSAl Viro static void nfs_d_release(struct dentry *dentry) 1356b1942c5fSAl Viro { 1357b1942c5fSAl Viro /* free cached devname value, if it survived that far */ 1358b1942c5fSAl Viro if (unlikely(dentry->d_fsdata)) { 1359b1942c5fSAl Viro if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1360b1942c5fSAl Viro WARN_ON(1); 1361b1942c5fSAl Viro else 1362b1942c5fSAl Viro kfree(dentry->d_fsdata); 1363b1942c5fSAl Viro } 1364b1942c5fSAl Viro } 1365b1942c5fSAl Viro 1366f786aa90SAl Viro const struct dentry_operations nfs_dentry_operations = { 13671da177e4SLinus Torvalds .d_revalidate = nfs_lookup_revalidate, 1368ecf3d1f1SJeff Layton .d_weak_revalidate = nfs_weak_revalidate, 13691da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 13701da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 137136d43a43SDavid Howells .d_automount = nfs_d_automount, 1372b1942c5fSAl Viro .d_release = nfs_d_release, 13731da177e4SLinus Torvalds }; 1374ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_dentry_operations); 13751da177e4SLinus Torvalds 1376597d9289SBryan Schumaker struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 13771da177e4SLinus Torvalds { 13781da177e4SLinus Torvalds struct dentry *res; 13791da177e4SLinus Torvalds struct inode *inode = NULL; 1380e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1381e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 13821775fd3eSDavid Quigley struct nfs4_label *label = NULL; 13831da177e4SLinus Torvalds int error; 13841da177e4SLinus Torvalds 13856de1472fSAl Viro dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry); 138691d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 13871da177e4SLinus Torvalds 1388130f9ab7SAl Viro if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen)) 1389130f9ab7SAl Viro return ERR_PTR(-ENAMETOOLONG); 13901da177e4SLinus Torvalds 1391fd684071STrond Myklebust /* 1392fd684071STrond Myklebust * If we're doing an exclusive create, optimize away the lookup 1393fd684071STrond Myklebust * but don't hash the dentry. 1394fd684071STrond Myklebust */ 1395130f9ab7SAl Viro if (nfs_is_exclusive_create(dir, flags)) 1396130f9ab7SAl Viro return NULL; 13971da177e4SLinus Torvalds 1398e1fb4d05STrond Myklebust res = ERR_PTR(-ENOMEM); 1399e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1400e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1401e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1402e1fb4d05STrond Myklebust goto out; 1403e1fb4d05STrond Myklebust 140414c43f76SDavid Quigley label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT); 140514c43f76SDavid Quigley if (IS_ERR(label)) 140614c43f76SDavid Quigley goto out; 140714c43f76SDavid Quigley 14086e0d0be7STrond Myklebust trace_nfs_lookup_enter(dir, dentry, flags); 14091775fd3eSDavid Quigley error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label); 14101da177e4SLinus Torvalds if (error == -ENOENT) 14111da177e4SLinus Torvalds goto no_entry; 14121da177e4SLinus Torvalds if (error < 0) { 14131da177e4SLinus Torvalds res = ERR_PTR(error); 1414bf130914SAl Viro goto out_label; 14151da177e4SLinus Torvalds } 14161775fd3eSDavid Quigley inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label); 1417bf0c84f1SNamhyung Kim res = ERR_CAST(inode); 141803f28e3aSTrond Myklebust if (IS_ERR(res)) 1419bf130914SAl Viro goto out_label; 142054ceac45SDavid Howells 1421d69ee9b8STrond Myklebust /* Success: notify readdir to use READDIRPLUS */ 1422d69ee9b8STrond Myklebust nfs_advise_use_readdirplus(dir); 1423d69ee9b8STrond Myklebust 14241da177e4SLinus Torvalds no_entry: 142541d28bcaSAl Viro res = d_splice_alias(inode, dentry); 14269eaef27bSTrond Myklebust if (res != NULL) { 14279eaef27bSTrond Myklebust if (IS_ERR(res)) 1428bf130914SAl Viro goto out_label; 14291da177e4SLinus Torvalds dentry = res; 14309eaef27bSTrond Myklebust } 14311da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1432bf130914SAl Viro out_label: 14336e0d0be7STrond Myklebust trace_nfs_lookup_exit(dir, dentry, flags, error); 143414c43f76SDavid Quigley nfs4_label_free(label); 14351da177e4SLinus Torvalds out: 1436e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1437e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 14381da177e4SLinus Torvalds return res; 14391da177e4SLinus Torvalds } 1440ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_lookup); 14411da177e4SLinus Torvalds 144289d77c8fSBryan Schumaker #if IS_ENABLED(CONFIG_NFS_V4) 14430b728e19SAl Viro static int nfs4_lookup_revalidate(struct dentry *, unsigned int); 14441da177e4SLinus Torvalds 1445f786aa90SAl Viro const struct dentry_operations nfs4_dentry_operations = { 14460ef97dcfSMiklos Szeredi .d_revalidate = nfs4_lookup_revalidate, 14471da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 14481da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 144936d43a43SDavid Howells .d_automount = nfs_d_automount, 1450b1942c5fSAl Viro .d_release = nfs_d_release, 14511da177e4SLinus Torvalds }; 145289d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs4_dentry_operations); 14531da177e4SLinus Torvalds 14548a5e929dSAl Viro static fmode_t flags_to_mode(int flags) 14558a5e929dSAl Viro { 14568a5e929dSAl Viro fmode_t res = (__force fmode_t)flags & FMODE_EXEC; 14578a5e929dSAl Viro if ((flags & O_ACCMODE) != O_WRONLY) 14588a5e929dSAl Viro res |= FMODE_READ; 14598a5e929dSAl Viro if ((flags & O_ACCMODE) != O_RDONLY) 14608a5e929dSAl Viro res |= FMODE_WRITE; 14618a5e929dSAl Viro return res; 14628a5e929dSAl Viro } 14638a5e929dSAl Viro 146451141598SAl Viro static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags) 1465cd9a1c0eSTrond Myklebust { 14665ede7b1cSAl Viro return alloc_nfs_open_context(dentry, flags_to_mode(open_flags)); 1467cd9a1c0eSTrond Myklebust } 1468cd9a1c0eSTrond Myklebust 1469cd9a1c0eSTrond Myklebust static int do_open(struct inode *inode, struct file *filp) 1470cd9a1c0eSTrond Myklebust { 1471f1fe29b4SDavid Howells nfs_fscache_open_file(inode, filp); 1472cd9a1c0eSTrond Myklebust return 0; 1473cd9a1c0eSTrond Myklebust } 1474cd9a1c0eSTrond Myklebust 1475d9585277SAl Viro static int nfs_finish_open(struct nfs_open_context *ctx, 14760dd2b474SMiklos Szeredi struct dentry *dentry, 147730d90494SAl Viro struct file *file, unsigned open_flags, 147847237687SAl Viro int *opened) 1479cd9a1c0eSTrond Myklebust { 14800dd2b474SMiklos Szeredi int err; 14810dd2b474SMiklos Szeredi 148230d90494SAl Viro err = finish_open(file, dentry, do_open, opened); 148330d90494SAl Viro if (err) 1484d9585277SAl Viro goto out; 148530d90494SAl Viro nfs_file_set_open_context(file, ctx); 14860dd2b474SMiklos Szeredi 1487cd9a1c0eSTrond Myklebust out: 1488d9585277SAl Viro return err; 1489cd9a1c0eSTrond Myklebust } 1490cd9a1c0eSTrond Myklebust 149173a79706SBryan Schumaker int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 149230d90494SAl Viro struct file *file, unsigned open_flags, 149347237687SAl Viro umode_t mode, int *opened) 14941da177e4SLinus Torvalds { 1495c94c0953SAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 1496cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 14970dd2b474SMiklos Szeredi struct dentry *res; 14980dd2b474SMiklos Szeredi struct iattr attr = { .ia_valid = ATTR_OPEN }; 1499f46e0bd3STrond Myklebust struct inode *inode; 15001472b83eSTrond Myklebust unsigned int lookup_flags = 0; 1501c94c0953SAl Viro bool switched = false; 1502898f635cSTrond Myklebust int err; 15031da177e4SLinus Torvalds 15040dd2b474SMiklos Szeredi /* Expect a negative dentry */ 15052b0143b5SDavid Howells BUG_ON(d_inode(dentry)); 15060dd2b474SMiklos Szeredi 15071e8968c5SNiels de Vos dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n", 15086de1472fSAl Viro dir->i_sb->s_id, dir->i_ino, dentry); 15091e7cb3dcSChuck Lever 15109597c13bSJeff Layton err = nfs_check_flags(open_flags); 15119597c13bSJeff Layton if (err) 15129597c13bSJeff Layton return err; 15139597c13bSJeff Layton 15140dd2b474SMiklos Szeredi /* NFS only supports OPEN on regular files */ 15150dd2b474SMiklos Szeredi if ((open_flags & O_DIRECTORY)) { 151600699ad8SAl Viro if (!d_in_lookup(dentry)) { 15170dd2b474SMiklos Szeredi /* 15180dd2b474SMiklos Szeredi * Hashed negative dentry with O_DIRECTORY: dentry was 15190dd2b474SMiklos Szeredi * revalidated and is fine, no need to perform lookup 15200dd2b474SMiklos Szeredi * again 15210dd2b474SMiklos Szeredi */ 1522d9585277SAl Viro return -ENOENT; 15230dd2b474SMiklos Szeredi } 15241472b83eSTrond Myklebust lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY; 15251da177e4SLinus Torvalds goto no_open; 15261da177e4SLinus Torvalds } 15271da177e4SLinus Torvalds 15280dd2b474SMiklos Szeredi if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 1529d9585277SAl Viro return -ENAMETOOLONG; 15301da177e4SLinus Torvalds 15310dd2b474SMiklos Szeredi if (open_flags & O_CREAT) { 1532536e43d1STrond Myklebust attr.ia_valid |= ATTR_MODE; 15330dd2b474SMiklos Szeredi attr.ia_mode = mode & ~current_umask(); 15340dd2b474SMiklos Szeredi } 1535536e43d1STrond Myklebust if (open_flags & O_TRUNC) { 1536536e43d1STrond Myklebust attr.ia_valid |= ATTR_SIZE; 1537536e43d1STrond Myklebust attr.ia_size = 0; 1538cd9a1c0eSTrond Myklebust } 1539cd9a1c0eSTrond Myklebust 1540c94c0953SAl Viro if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) { 1541c94c0953SAl Viro d_drop(dentry); 1542c94c0953SAl Viro switched = true; 1543c94c0953SAl Viro dentry = d_alloc_parallel(dentry->d_parent, 1544c94c0953SAl Viro &dentry->d_name, &wq); 1545c94c0953SAl Viro if (IS_ERR(dentry)) 1546c94c0953SAl Viro return PTR_ERR(dentry); 1547c94c0953SAl Viro if (unlikely(!d_in_lookup(dentry))) 1548c94c0953SAl Viro return finish_no_open(file, dentry); 1549c94c0953SAl Viro } 1550c94c0953SAl Viro 15510dd2b474SMiklos Szeredi ctx = create_nfs_open_context(dentry, open_flags); 15520dd2b474SMiklos Szeredi err = PTR_ERR(ctx); 15530dd2b474SMiklos Szeredi if (IS_ERR(ctx)) 1554d9585277SAl Viro goto out; 15550dd2b474SMiklos Szeredi 15566e0d0be7STrond Myklebust trace_nfs_atomic_open_enter(dir, ctx, open_flags); 15575bc2afc2STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, opened); 1558275bb307STrond Myklebust if (IS_ERR(inode)) { 15590dd2b474SMiklos Szeredi err = PTR_ERR(inode); 15606e0d0be7STrond Myklebust trace_nfs_atomic_open_exit(dir, ctx, open_flags, err); 15612d9db750STrond Myklebust put_nfs_open_context(ctx); 1562d20cb71dSAl Viro d_drop(dentry); 15630dd2b474SMiklos Szeredi switch (err) { 15641da177e4SLinus Torvalds case -ENOENT: 1565f46e0bd3STrond Myklebust d_add(dentry, NULL); 1566809fd143STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 15670dd2b474SMiklos Szeredi break; 15681788ea6eSJeff Layton case -EISDIR: 15696f926b5bSTrond Myklebust case -ENOTDIR: 15706f926b5bSTrond Myklebust goto no_open; 15711da177e4SLinus Torvalds case -ELOOP: 15720dd2b474SMiklos Szeredi if (!(open_flags & O_NOFOLLOW)) 15731da177e4SLinus Torvalds goto no_open; 15740dd2b474SMiklos Szeredi break; 15751da177e4SLinus Torvalds /* case -EINVAL: */ 15761da177e4SLinus Torvalds default: 15770dd2b474SMiklos Szeredi break; 15781da177e4SLinus Torvalds } 15791da177e4SLinus Torvalds goto out; 15801da177e4SLinus Torvalds } 15810dd2b474SMiklos Szeredi 1582275bb307STrond Myklebust err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened); 15836e0d0be7STrond Myklebust trace_nfs_atomic_open_exit(dir, ctx, open_flags, err); 15842d9db750STrond Myklebust put_nfs_open_context(ctx); 1585d9585277SAl Viro out: 1586c94c0953SAl Viro if (unlikely(switched)) { 1587c94c0953SAl Viro d_lookup_done(dentry); 1588c94c0953SAl Viro dput(dentry); 1589c94c0953SAl Viro } 1590d9585277SAl Viro return err; 15910dd2b474SMiklos Szeredi 15921da177e4SLinus Torvalds no_open: 15931472b83eSTrond Myklebust res = nfs_lookup(dir, dentry, lookup_flags); 1594c94c0953SAl Viro if (switched) { 1595c94c0953SAl Viro d_lookup_done(dentry); 1596c94c0953SAl Viro if (!res) 1597c94c0953SAl Viro res = dentry; 1598c94c0953SAl Viro else 1599c94c0953SAl Viro dput(dentry); 1600c94c0953SAl Viro } 16010dd2b474SMiklos Szeredi if (IS_ERR(res)) 1602c94c0953SAl Viro return PTR_ERR(res); 1603e45198a6SAl Viro return finish_no_open(file, res); 16041da177e4SLinus Torvalds } 160589d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_atomic_open); 16061da177e4SLinus Torvalds 16070b728e19SAl Viro static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags) 16081da177e4SLinus Torvalds { 1609657e94b6SNick Piggin struct inode *inode; 161050de348cSMiklos Szeredi int ret = 0; 16111da177e4SLinus Torvalds 1612fa3c56bbSAl Viro if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY)) 1613eda72afbSMiklos Szeredi goto no_open; 1614eda72afbSMiklos Szeredi if (d_mountpoint(dentry)) 16155584c306STrond Myklebust goto no_open; 161649f9a0faSTrond Myklebust if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1) 161749f9a0faSTrond Myklebust goto no_open; 16182b484297STrond Myklebust 16192b0143b5SDavid Howells inode = d_inode(dentry); 16202b484297STrond Myklebust 16211da177e4SLinus Torvalds /* We can't create new files in nfs_open_revalidate(), so we 16221da177e4SLinus Torvalds * optimize away revalidation of negative dentries. 16231da177e4SLinus Torvalds */ 1624216d5d06STrond Myklebust if (inode == NULL) { 162549317a7fSNeilBrown struct dentry *parent; 162649317a7fSNeilBrown struct inode *dir; 162749317a7fSNeilBrown 1628912a108dSNeilBrown if (flags & LOOKUP_RCU) { 162950d77739SNeilBrown parent = ACCESS_ONCE(dentry->d_parent); 16302b0143b5SDavid Howells dir = d_inode_rcu(parent); 1631912a108dSNeilBrown if (!dir) 1632d51ac1a8SNeilBrown return -ECHILD; 1633912a108dSNeilBrown } else { 163449317a7fSNeilBrown parent = dget_parent(dentry); 16352b0143b5SDavid Howells dir = d_inode(parent); 1636912a108dSNeilBrown } 1637fa3c56bbSAl Viro if (!nfs_neg_need_reval(dir, dentry, flags)) 1638216d5d06STrond Myklebust ret = 1; 1639912a108dSNeilBrown else if (flags & LOOKUP_RCU) 1640912a108dSNeilBrown ret = -ECHILD; 1641912a108dSNeilBrown if (!(flags & LOOKUP_RCU)) 164249317a7fSNeilBrown dput(parent); 164350d77739SNeilBrown else if (parent != ACCESS_ONCE(dentry->d_parent)) 1644912a108dSNeilBrown return -ECHILD; 16451da177e4SLinus Torvalds goto out; 1646216d5d06STrond Myklebust } 1647216d5d06STrond Myklebust 16481da177e4SLinus Torvalds /* NFS only supports OPEN on regular files */ 16491da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 165049317a7fSNeilBrown goto no_open; 16511da177e4SLinus Torvalds /* We cannot do exclusive creation on a positive dentry */ 1652fa3c56bbSAl Viro if (flags & LOOKUP_EXCL) 165349317a7fSNeilBrown goto no_open; 16541da177e4SLinus Torvalds 16550ef97dcfSMiklos Szeredi /* Let f_op->open() actually open (and revalidate) the file */ 1656898f635cSTrond Myklebust ret = 1; 16570ef97dcfSMiklos Szeredi 16581da177e4SLinus Torvalds out: 16591da177e4SLinus Torvalds return ret; 1660535918f1STrond Myklebust 16615584c306STrond Myklebust no_open: 16620b728e19SAl Viro return nfs_lookup_revalidate(dentry, flags); 1663c0204fd2STrond Myklebust } 1664c0204fd2STrond Myklebust 16651da177e4SLinus Torvalds #endif /* CONFIG_NFSV4 */ 16661da177e4SLinus Torvalds 16671da177e4SLinus Torvalds /* 16681da177e4SLinus Torvalds * Code common to create, mkdir, and mknod. 16691da177e4SLinus Torvalds */ 16701da177e4SLinus Torvalds int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 16711775fd3eSDavid Quigley struct nfs_fattr *fattr, 16721775fd3eSDavid Quigley struct nfs4_label *label) 16731da177e4SLinus Torvalds { 1674fab728e1STrond Myklebust struct dentry *parent = dget_parent(dentry); 16752b0143b5SDavid Howells struct inode *dir = d_inode(parent); 16761da177e4SLinus Torvalds struct inode *inode; 16771da177e4SLinus Torvalds int error = -EACCES; 16781da177e4SLinus Torvalds 1679fab728e1STrond Myklebust d_drop(dentry); 1680fab728e1STrond Myklebust 16811da177e4SLinus Torvalds /* We may have been initialized further down */ 16822b0143b5SDavid Howells if (d_really_is_positive(dentry)) 1683fab728e1STrond Myklebust goto out; 16841da177e4SLinus Torvalds if (fhandle->size == 0) { 16851775fd3eSDavid Quigley error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL); 16861da177e4SLinus Torvalds if (error) 1687fab728e1STrond Myklebust goto out_error; 16881da177e4SLinus Torvalds } 16895724ab37STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 16901da177e4SLinus Torvalds if (!(fattr->valid & NFS_ATTR_FATTR)) { 16911da177e4SLinus Torvalds struct nfs_server *server = NFS_SB(dentry->d_sb); 16921775fd3eSDavid Quigley error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL); 16931da177e4SLinus Torvalds if (error < 0) 1694fab728e1STrond Myklebust goto out_error; 16951da177e4SLinus Torvalds } 16961775fd3eSDavid Quigley inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label); 169703f28e3aSTrond Myklebust error = PTR_ERR(inode); 169803f28e3aSTrond Myklebust if (IS_ERR(inode)) 1699fab728e1STrond Myklebust goto out_error; 1700fab728e1STrond Myklebust d_add(dentry, inode); 1701fab728e1STrond Myklebust out: 1702fab728e1STrond Myklebust dput(parent); 17031da177e4SLinus Torvalds return 0; 1704fab728e1STrond Myklebust out_error: 1705fab728e1STrond Myklebust nfs_mark_for_revalidate(dir); 1706fab728e1STrond Myklebust dput(parent); 1707fab728e1STrond Myklebust return error; 17081da177e4SLinus Torvalds } 1709ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_instantiate); 17101da177e4SLinus Torvalds 17111da177e4SLinus Torvalds /* 17121da177e4SLinus Torvalds * Following a failed create operation, we drop the dentry rather 17131da177e4SLinus Torvalds * than retain a negative dentry. This avoids a problem in the event 17141da177e4SLinus Torvalds * that the operation succeeded on the server, but an error in the 17151da177e4SLinus Torvalds * reply path made it appear to have failed. 17161da177e4SLinus Torvalds */ 1717597d9289SBryan Schumaker int nfs_create(struct inode *dir, struct dentry *dentry, 1718ebfc3b49SAl Viro umode_t mode, bool excl) 17191da177e4SLinus Torvalds { 17201da177e4SLinus Torvalds struct iattr attr; 1721ebfc3b49SAl Viro int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT; 17221da177e4SLinus Torvalds int error; 17231da177e4SLinus Torvalds 17241e8968c5SNiels de Vos dfprintk(VFS, "NFS: create(%s/%lu), %pd\n", 17256de1472fSAl Viro dir->i_sb->s_id, dir->i_ino, dentry); 17261da177e4SLinus Torvalds 17271da177e4SLinus Torvalds attr.ia_mode = mode; 17281da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 17291da177e4SLinus Torvalds 17308b0ad3d4STrond Myklebust trace_nfs_create_enter(dir, dentry, open_flags); 17318867fe58SMiklos Szeredi error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags); 17328b0ad3d4STrond Myklebust trace_nfs_create_exit(dir, dentry, open_flags, error); 17331da177e4SLinus Torvalds if (error != 0) 17341da177e4SLinus Torvalds goto out_err; 17351da177e4SLinus Torvalds return 0; 17361da177e4SLinus Torvalds out_err: 17371da177e4SLinus Torvalds d_drop(dentry); 17381da177e4SLinus Torvalds return error; 17391da177e4SLinus Torvalds } 1740ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_create); 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds /* 17431da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 17441da177e4SLinus Torvalds */ 1745597d9289SBryan Schumaker int 17461a67aafbSAl Viro nfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev) 17471da177e4SLinus Torvalds { 17481da177e4SLinus Torvalds struct iattr attr; 17491da177e4SLinus Torvalds int status; 17501da177e4SLinus Torvalds 17511e8968c5SNiels de Vos dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n", 17526de1472fSAl Viro dir->i_sb->s_id, dir->i_ino, dentry); 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds attr.ia_mode = mode; 17551da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 17561da177e4SLinus Torvalds 17571ca42382STrond Myklebust trace_nfs_mknod_enter(dir, dentry); 17581da177e4SLinus Torvalds status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 17591ca42382STrond Myklebust trace_nfs_mknod_exit(dir, dentry, status); 17601da177e4SLinus Torvalds if (status != 0) 17611da177e4SLinus Torvalds goto out_err; 17621da177e4SLinus Torvalds return 0; 17631da177e4SLinus Torvalds out_err: 17641da177e4SLinus Torvalds d_drop(dentry); 17651da177e4SLinus Torvalds return status; 17661da177e4SLinus Torvalds } 1767ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_mknod); 17681da177e4SLinus Torvalds 17691da177e4SLinus Torvalds /* 17701da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 17711da177e4SLinus Torvalds */ 1772597d9289SBryan Schumaker int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 17731da177e4SLinus Torvalds { 17741da177e4SLinus Torvalds struct iattr attr; 17751da177e4SLinus Torvalds int error; 17761da177e4SLinus Torvalds 17771e8968c5SNiels de Vos dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n", 17786de1472fSAl Viro dir->i_sb->s_id, dir->i_ino, dentry); 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 17811da177e4SLinus Torvalds attr.ia_mode = mode | S_IFDIR; 17821da177e4SLinus Torvalds 17831ca42382STrond Myklebust trace_nfs_mkdir_enter(dir, dentry); 17841da177e4SLinus Torvalds error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 17851ca42382STrond Myklebust trace_nfs_mkdir_exit(dir, dentry, error); 17861da177e4SLinus Torvalds if (error != 0) 17871da177e4SLinus Torvalds goto out_err; 17881da177e4SLinus Torvalds return 0; 17891da177e4SLinus Torvalds out_err: 17901da177e4SLinus Torvalds d_drop(dentry); 17911da177e4SLinus Torvalds return error; 17921da177e4SLinus Torvalds } 1793ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_mkdir); 17941da177e4SLinus Torvalds 1795d45b9d8bSTrond Myklebust static void nfs_dentry_handle_enoent(struct dentry *dentry) 1796d45b9d8bSTrond Myklebust { 1797dc3f4198SAl Viro if (simple_positive(dentry)) 1798d45b9d8bSTrond Myklebust d_delete(dentry); 1799d45b9d8bSTrond Myklebust } 1800d45b9d8bSTrond Myklebust 1801597d9289SBryan Schumaker int nfs_rmdir(struct inode *dir, struct dentry *dentry) 18021da177e4SLinus Torvalds { 18031da177e4SLinus Torvalds int error; 18041da177e4SLinus Torvalds 18051e8968c5SNiels de Vos dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n", 18066de1472fSAl Viro dir->i_sb->s_id, dir->i_ino, dentry); 18071da177e4SLinus Torvalds 18081ca42382STrond Myklebust trace_nfs_rmdir_enter(dir, dentry); 18092b0143b5SDavid Howells if (d_really_is_positive(dentry)) { 1810884be175SAl Viro down_write(&NFS_I(d_inode(dentry))->rmdir_sem); 18111da177e4SLinus Torvalds error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 18121da177e4SLinus Torvalds /* Ensure the VFS deletes this inode */ 1813ba6c0592STrond Myklebust switch (error) { 1814ba6c0592STrond Myklebust case 0: 18152b0143b5SDavid Howells clear_nlink(d_inode(dentry)); 1816ba6c0592STrond Myklebust break; 1817ba6c0592STrond Myklebust case -ENOENT: 1818d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 1819ba6c0592STrond Myklebust } 1820884be175SAl Viro up_write(&NFS_I(d_inode(dentry))->rmdir_sem); 1821ba6c0592STrond Myklebust } else 1822ba6c0592STrond Myklebust error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 18231ca42382STrond Myklebust trace_nfs_rmdir_exit(dir, dentry, error); 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds return error; 18261da177e4SLinus Torvalds } 1827ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_rmdir); 18281da177e4SLinus Torvalds 18291da177e4SLinus Torvalds /* 18301da177e4SLinus Torvalds * Remove a file after making sure there are no pending writes, 18311da177e4SLinus Torvalds * and after checking that the file has only one user. 18321da177e4SLinus Torvalds * 18331da177e4SLinus Torvalds * We invalidate the attribute cache and free the inode prior to the operation 18341da177e4SLinus Torvalds * to avoid possible races if the server reuses the inode. 18351da177e4SLinus Torvalds */ 18361da177e4SLinus Torvalds static int nfs_safe_remove(struct dentry *dentry) 18371da177e4SLinus Torvalds { 18382b0143b5SDavid Howells struct inode *dir = d_inode(dentry->d_parent); 18392b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 18401da177e4SLinus Torvalds int error = -EBUSY; 18411da177e4SLinus Torvalds 18426de1472fSAl Viro dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry); 18431da177e4SLinus Torvalds 18441da177e4SLinus Torvalds /* If the dentry was sillyrenamed, we simply call d_delete() */ 18451da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 18461da177e4SLinus Torvalds error = 0; 18471da177e4SLinus Torvalds goto out; 18481da177e4SLinus Torvalds } 18491da177e4SLinus Torvalds 18501ca42382STrond Myklebust trace_nfs_remove_enter(dir, dentry); 18511da177e4SLinus Torvalds if (inode != NULL) { 185257ec14c5SBryan Schumaker NFS_PROTO(inode)->return_delegation(inode); 18531da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 18541da177e4SLinus Torvalds if (error == 0) 18551b83d707STrond Myklebust nfs_drop_nlink(inode); 18561da177e4SLinus Torvalds } else 18571da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1858d45b9d8bSTrond Myklebust if (error == -ENOENT) 1859d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 18601ca42382STrond Myklebust trace_nfs_remove_exit(dir, dentry, error); 18611da177e4SLinus Torvalds out: 18621da177e4SLinus Torvalds return error; 18631da177e4SLinus Torvalds } 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 18661da177e4SLinus Torvalds * belongs to an active ".nfs..." file and we return -EBUSY. 18671da177e4SLinus Torvalds * 18681da177e4SLinus Torvalds * If sillyrename() returns 0, we do nothing, otherwise we unlink. 18691da177e4SLinus Torvalds */ 1870597d9289SBryan Schumaker int nfs_unlink(struct inode *dir, struct dentry *dentry) 18711da177e4SLinus Torvalds { 18721da177e4SLinus Torvalds int error; 18731da177e4SLinus Torvalds int need_rehash = 0; 18741da177e4SLinus Torvalds 18751e8968c5SNiels de Vos dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id, 18766de1472fSAl Viro dir->i_ino, dentry); 18771da177e4SLinus Torvalds 18781ca42382STrond Myklebust trace_nfs_unlink_enter(dir, dentry); 18791da177e4SLinus Torvalds spin_lock(&dentry->d_lock); 188084d08fa8SAl Viro if (d_count(dentry) > 1) { 18811da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 1882ccfeb506STrond Myklebust /* Start asynchronous writeout of the inode */ 18832b0143b5SDavid Howells write_inode_now(d_inode(dentry), 0); 18841da177e4SLinus Torvalds error = nfs_sillyrename(dir, dentry); 18851ca42382STrond Myklebust goto out; 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds if (!d_unhashed(dentry)) { 18881da177e4SLinus Torvalds __d_drop(dentry); 18891da177e4SLinus Torvalds need_rehash = 1; 18901da177e4SLinus Torvalds } 18911da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 18921da177e4SLinus Torvalds error = nfs_safe_remove(dentry); 1893d45b9d8bSTrond Myklebust if (!error || error == -ENOENT) { 18941da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 18951da177e4SLinus Torvalds } else if (need_rehash) 18961da177e4SLinus Torvalds d_rehash(dentry); 18971ca42382STrond Myklebust out: 18981ca42382STrond Myklebust trace_nfs_unlink_exit(dir, dentry, error); 18991da177e4SLinus Torvalds return error; 19001da177e4SLinus Torvalds } 1901ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_unlink); 19021da177e4SLinus Torvalds 1903873101b3SChuck Lever /* 1904873101b3SChuck Lever * To create a symbolic link, most file systems instantiate a new inode, 1905873101b3SChuck Lever * add a page to it containing the path, then write it out to the disk 1906873101b3SChuck Lever * using prepare_write/commit_write. 1907873101b3SChuck Lever * 1908873101b3SChuck Lever * Unfortunately the NFS client can't create the in-core inode first 1909873101b3SChuck Lever * because it needs a file handle to create an in-core inode (see 1910873101b3SChuck Lever * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1911873101b3SChuck Lever * symlink request has completed on the server. 1912873101b3SChuck Lever * 1913873101b3SChuck Lever * So instead we allocate a raw page, copy the symname into it, then do 1914873101b3SChuck Lever * the SYMLINK request with the page as the buffer. If it succeeds, we 1915873101b3SChuck Lever * now have a new file handle and can instantiate an in-core NFS inode 1916873101b3SChuck Lever * and move the raw page into its mapping. 1917873101b3SChuck Lever */ 1918597d9289SBryan Schumaker int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 19191da177e4SLinus Torvalds { 1920873101b3SChuck Lever struct page *page; 1921873101b3SChuck Lever char *kaddr; 19221da177e4SLinus Torvalds struct iattr attr; 1923873101b3SChuck Lever unsigned int pathlen = strlen(symname); 19241da177e4SLinus Torvalds int error; 19251da177e4SLinus Torvalds 19261e8968c5SNiels de Vos dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id, 19276de1472fSAl Viro dir->i_ino, dentry, symname); 19281da177e4SLinus Torvalds 1929873101b3SChuck Lever if (pathlen > PAGE_SIZE) 1930873101b3SChuck Lever return -ENAMETOOLONG; 19311da177e4SLinus Torvalds 1932873101b3SChuck Lever attr.ia_mode = S_IFLNK | S_IRWXUGO; 1933873101b3SChuck Lever attr.ia_valid = ATTR_MODE; 19341da177e4SLinus Torvalds 1935e8ecde25SAl Viro page = alloc_page(GFP_USER); 193676566991STrond Myklebust if (!page) 1937873101b3SChuck Lever return -ENOMEM; 1938873101b3SChuck Lever 1939e8ecde25SAl Viro kaddr = page_address(page); 1940873101b3SChuck Lever memcpy(kaddr, symname, pathlen); 1941873101b3SChuck Lever if (pathlen < PAGE_SIZE) 1942873101b3SChuck Lever memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1943873101b3SChuck Lever 19441ca42382STrond Myklebust trace_nfs_symlink_enter(dir, dentry); 194594a6d753SChuck Lever error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 19461ca42382STrond Myklebust trace_nfs_symlink_exit(dir, dentry, error); 1947873101b3SChuck Lever if (error != 0) { 19481e8968c5SNiels de Vos dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n", 1949873101b3SChuck Lever dir->i_sb->s_id, dir->i_ino, 19506de1472fSAl Viro dentry, symname, error); 19511da177e4SLinus Torvalds d_drop(dentry); 1952873101b3SChuck Lever __free_page(page); 19531da177e4SLinus Torvalds return error; 19541da177e4SLinus Torvalds } 19551da177e4SLinus Torvalds 1956873101b3SChuck Lever /* 1957873101b3SChuck Lever * No big deal if we can't add this page to the page cache here. 1958873101b3SChuck Lever * READLINK will get the missing page from the server if needed. 1959873101b3SChuck Lever */ 19602b0143b5SDavid Howells if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0, 1961873101b3SChuck Lever GFP_KERNEL)) { 1962873101b3SChuck Lever SetPageUptodate(page); 1963873101b3SChuck Lever unlock_page(page); 1964a0b54addSRafael Aquini /* 1965a0b54addSRafael Aquini * add_to_page_cache_lru() grabs an extra page refcount. 1966a0b54addSRafael Aquini * Drop it here to avoid leaking this page later. 1967a0b54addSRafael Aquini */ 196809cbfeafSKirill A. Shutemov put_page(page); 1969873101b3SChuck Lever } else 1970873101b3SChuck Lever __free_page(page); 1971873101b3SChuck Lever 1972873101b3SChuck Lever return 0; 1973873101b3SChuck Lever } 1974ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_symlink); 1975873101b3SChuck Lever 1976597d9289SBryan Schumaker int 19771da177e4SLinus Torvalds nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 19781da177e4SLinus Torvalds { 19792b0143b5SDavid Howells struct inode *inode = d_inode(old_dentry); 19801da177e4SLinus Torvalds int error; 19811da177e4SLinus Torvalds 19826de1472fSAl Viro dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n", 19836de1472fSAl Viro old_dentry, dentry); 19841da177e4SLinus Torvalds 19851fd1085bSTrond Myklebust trace_nfs_link_enter(inode, dir, dentry); 198657ec14c5SBryan Schumaker NFS_PROTO(inode)->return_delegation(inode); 19879a3936aaSTrond Myklebust 19889697d234STrond Myklebust d_drop(dentry); 19891da177e4SLinus Torvalds error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1990cf809556STrond Myklebust if (error == 0) { 19917de9c6eeSAl Viro ihold(inode); 19929697d234STrond Myklebust d_add(dentry, inode); 1993cf809556STrond Myklebust } 19941fd1085bSTrond Myklebust trace_nfs_link_exit(inode, dir, dentry, error); 19951da177e4SLinus Torvalds return error; 19961da177e4SLinus Torvalds } 1997ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_link); 19981da177e4SLinus Torvalds 19991da177e4SLinus Torvalds /* 20001da177e4SLinus Torvalds * RENAME 20011da177e4SLinus Torvalds * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 20021da177e4SLinus Torvalds * different file handle for the same inode after a rename (e.g. when 20031da177e4SLinus Torvalds * moving to a different directory). A fail-safe method to do so would 20041da177e4SLinus Torvalds * be to look up old_dir/old_name, create a link to new_dir/new_name and 20051da177e4SLinus Torvalds * rename the old file using the sillyrename stuff. This way, the original 20061da177e4SLinus Torvalds * file in old_dir will go away when the last process iput()s the inode. 20071da177e4SLinus Torvalds * 20081da177e4SLinus Torvalds * FIXED. 20091da177e4SLinus Torvalds * 20101da177e4SLinus Torvalds * It actually works quite well. One needs to have the possibility for 20111da177e4SLinus Torvalds * at least one ".nfs..." file in each directory the file ever gets 20121da177e4SLinus Torvalds * moved or linked to which happens automagically with the new 20131da177e4SLinus Torvalds * implementation that only depends on the dcache stuff instead of 20141da177e4SLinus Torvalds * using the inode layer 20151da177e4SLinus Torvalds * 20161da177e4SLinus Torvalds * Unfortunately, things are a little more complicated than indicated 20171da177e4SLinus Torvalds * above. For a cross-directory move, we want to make sure we can get 20181da177e4SLinus Torvalds * rid of the old inode after the operation. This means there must be 20191da177e4SLinus Torvalds * no pending writes (if it's a file), and the use count must be 1. 20201da177e4SLinus Torvalds * If these conditions are met, we can drop the dentries before doing 20211da177e4SLinus Torvalds * the rename. 20221da177e4SLinus Torvalds */ 2023597d9289SBryan Schumaker int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 20241da177e4SLinus Torvalds struct inode *new_dir, struct dentry *new_dentry) 20251da177e4SLinus Torvalds { 20262b0143b5SDavid Howells struct inode *old_inode = d_inode(old_dentry); 20272b0143b5SDavid Howells struct inode *new_inode = d_inode(new_dentry); 20281da177e4SLinus Torvalds struct dentry *dentry = NULL, *rehash = NULL; 202980a491fdSJeff Layton struct rpc_task *task; 20301da177e4SLinus Torvalds int error = -EBUSY; 20311da177e4SLinus Torvalds 20326de1472fSAl Viro dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n", 20336de1472fSAl Viro old_dentry, new_dentry, 203484d08fa8SAl Viro d_count(new_dentry)); 20351da177e4SLinus Torvalds 203670ded201STrond Myklebust trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry); 20371da177e4SLinus Torvalds /* 203828f79a1aSMiklos Szeredi * For non-directories, check whether the target is busy and if so, 203928f79a1aSMiklos Szeredi * make a copy of the dentry and then do a silly-rename. If the 204028f79a1aSMiklos Szeredi * silly-rename succeeds, the copied dentry is hashed and becomes 204128f79a1aSMiklos Szeredi * the new target. 20421da177e4SLinus Torvalds */ 204327226104SMiklos Szeredi if (new_inode && !S_ISDIR(new_inode->i_mode)) { 204427226104SMiklos Szeredi /* 204527226104SMiklos Szeredi * To prevent any new references to the target during the 204627226104SMiklos Szeredi * rename, we unhash the dentry in advance. 204727226104SMiklos Szeredi */ 204827226104SMiklos Szeredi if (!d_unhashed(new_dentry)) { 204927226104SMiklos Szeredi d_drop(new_dentry); 205027226104SMiklos Szeredi rehash = new_dentry; 205127226104SMiklos Szeredi } 205227226104SMiklos Szeredi 205384d08fa8SAl Viro if (d_count(new_dentry) > 2) { 20541da177e4SLinus Torvalds int err; 205527226104SMiklos Szeredi 20561da177e4SLinus Torvalds /* copy the target dentry's name */ 20571da177e4SLinus Torvalds dentry = d_alloc(new_dentry->d_parent, 20581da177e4SLinus Torvalds &new_dentry->d_name); 20591da177e4SLinus Torvalds if (!dentry) 20601da177e4SLinus Torvalds goto out; 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds /* silly-rename the existing target ... */ 20631da177e4SLinus Torvalds err = nfs_sillyrename(new_dir, new_dentry); 206424e93025SMiklos Szeredi if (err) 20651da177e4SLinus Torvalds goto out; 206624e93025SMiklos Szeredi 206724e93025SMiklos Szeredi new_dentry = dentry; 206856335936SOGAWA Hirofumi rehash = NULL; 206924e93025SMiklos Szeredi new_inode = NULL; 2070b1e4adf4STrond Myklebust } 207127226104SMiklos Szeredi } 20721da177e4SLinus Torvalds 207357ec14c5SBryan Schumaker NFS_PROTO(old_inode)->return_delegation(old_inode); 2074b1e4adf4STrond Myklebust if (new_inode != NULL) 207557ec14c5SBryan Schumaker NFS_PROTO(new_inode)->return_delegation(new_inode); 20761da177e4SLinus Torvalds 207780a491fdSJeff Layton task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL); 207880a491fdSJeff Layton if (IS_ERR(task)) { 207980a491fdSJeff Layton error = PTR_ERR(task); 208080a491fdSJeff Layton goto out; 208180a491fdSJeff Layton } 208280a491fdSJeff Layton 208380a491fdSJeff Layton error = rpc_wait_for_completion_task(task); 208480a491fdSJeff Layton if (error == 0) 208580a491fdSJeff Layton error = task->tk_status; 208680a491fdSJeff Layton rpc_put_task(task); 20875ba7cc48STrond Myklebust nfs_mark_for_revalidate(old_inode); 20881da177e4SLinus Torvalds out: 20891da177e4SLinus Torvalds if (rehash) 20901da177e4SLinus Torvalds d_rehash(rehash); 209170ded201STrond Myklebust trace_nfs_rename_exit(old_dir, old_dentry, 209270ded201STrond Myklebust new_dir, new_dentry, error); 20931da177e4SLinus Torvalds if (!error) { 2094b1e4adf4STrond Myklebust if (new_inode != NULL) 2095b1e4adf4STrond Myklebust nfs_drop_nlink(new_inode); 20961da177e4SLinus Torvalds d_move(old_dentry, new_dentry); 20978fb559f8SChuck Lever nfs_set_verifier(new_dentry, 20988fb559f8SChuck Lever nfs_save_change_attribute(new_dir)); 2099d45b9d8bSTrond Myklebust } else if (error == -ENOENT) 2100d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(old_dentry); 21011da177e4SLinus Torvalds 21021da177e4SLinus Torvalds /* new dentry created? */ 21031da177e4SLinus Torvalds if (dentry) 21041da177e4SLinus Torvalds dput(dentry); 21051da177e4SLinus Torvalds return error; 21061da177e4SLinus Torvalds } 2107ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_rename); 21081da177e4SLinus Torvalds 2109cfcea3e8STrond Myklebust static DEFINE_SPINLOCK(nfs_access_lru_lock); 2110cfcea3e8STrond Myklebust static LIST_HEAD(nfs_access_lru_list); 2111cfcea3e8STrond Myklebust static atomic_long_t nfs_access_nr_entries; 2112cfcea3e8STrond Myklebust 21133a505845STrond Myklebust static unsigned long nfs_access_max_cachesize = ULONG_MAX; 21143a505845STrond Myklebust module_param(nfs_access_max_cachesize, ulong, 0644); 21153a505845STrond Myklebust MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length"); 21163a505845STrond Myklebust 21171c3c07e9STrond Myklebust static void nfs_access_free_entry(struct nfs_access_entry *entry) 21181c3c07e9STrond Myklebust { 21191c3c07e9STrond Myklebust put_rpccred(entry->cred); 2120f682a398SNeilBrown kfree_rcu(entry, rcu_head); 21214e857c58SPeter Zijlstra smp_mb__before_atomic(); 2122cfcea3e8STrond Myklebust atomic_long_dec(&nfs_access_nr_entries); 21234e857c58SPeter Zijlstra smp_mb__after_atomic(); 21241c3c07e9STrond Myklebust } 21251c3c07e9STrond Myklebust 21261a81bb8aSTrond Myklebust static void nfs_access_free_list(struct list_head *head) 21271a81bb8aSTrond Myklebust { 21281a81bb8aSTrond Myklebust struct nfs_access_entry *cache; 21291a81bb8aSTrond Myklebust 21301a81bb8aSTrond Myklebust while (!list_empty(head)) { 21311a81bb8aSTrond Myklebust cache = list_entry(head->next, struct nfs_access_entry, lru); 21321a81bb8aSTrond Myklebust list_del(&cache->lru); 21331a81bb8aSTrond Myklebust nfs_access_free_entry(cache); 21341a81bb8aSTrond Myklebust } 21351a81bb8aSTrond Myklebust } 21361a81bb8aSTrond Myklebust 21373a505845STrond Myklebust static unsigned long 21383a505845STrond Myklebust nfs_do_access_cache_scan(unsigned int nr_to_scan) 2139979df72eSTrond Myklebust { 2140979df72eSTrond Myklebust LIST_HEAD(head); 2141aa510da5STrond Myklebust struct nfs_inode *nfsi, *next; 2142979df72eSTrond Myklebust struct nfs_access_entry *cache; 21431ab6c499SDave Chinner long freed = 0; 2144979df72eSTrond Myklebust 2145a50f7951STrond Myklebust spin_lock(&nfs_access_lru_lock); 2146aa510da5STrond Myklebust list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 2147979df72eSTrond Myklebust struct inode *inode; 2148979df72eSTrond Myklebust 2149979df72eSTrond Myklebust if (nr_to_scan-- == 0) 2150979df72eSTrond Myklebust break; 21519c7e7e23STrond Myklebust inode = &nfsi->vfs_inode; 2152979df72eSTrond Myklebust spin_lock(&inode->i_lock); 2153979df72eSTrond Myklebust if (list_empty(&nfsi->access_cache_entry_lru)) 2154979df72eSTrond Myklebust goto remove_lru_entry; 2155979df72eSTrond Myklebust cache = list_entry(nfsi->access_cache_entry_lru.next, 2156979df72eSTrond Myklebust struct nfs_access_entry, lru); 2157979df72eSTrond Myklebust list_move(&cache->lru, &head); 2158979df72eSTrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 21591ab6c499SDave Chinner freed++; 2160979df72eSTrond Myklebust if (!list_empty(&nfsi->access_cache_entry_lru)) 2161979df72eSTrond Myklebust list_move_tail(&nfsi->access_cache_inode_lru, 2162979df72eSTrond Myklebust &nfs_access_lru_list); 2163979df72eSTrond Myklebust else { 2164979df72eSTrond Myklebust remove_lru_entry: 2165979df72eSTrond Myklebust list_del_init(&nfsi->access_cache_inode_lru); 21664e857c58SPeter Zijlstra smp_mb__before_atomic(); 2167979df72eSTrond Myklebust clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 21684e857c58SPeter Zijlstra smp_mb__after_atomic(); 2169979df72eSTrond Myklebust } 217059844a9bSTrond Myklebust spin_unlock(&inode->i_lock); 2171979df72eSTrond Myklebust } 2172979df72eSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 21731a81bb8aSTrond Myklebust nfs_access_free_list(&head); 21741ab6c499SDave Chinner return freed; 21751ab6c499SDave Chinner } 21761ab6c499SDave Chinner 21771ab6c499SDave Chinner unsigned long 21783a505845STrond Myklebust nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc) 21793a505845STrond Myklebust { 21803a505845STrond Myklebust int nr_to_scan = sc->nr_to_scan; 21813a505845STrond Myklebust gfp_t gfp_mask = sc->gfp_mask; 21823a505845STrond Myklebust 21833a505845STrond Myklebust if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 21843a505845STrond Myklebust return SHRINK_STOP; 21853a505845STrond Myklebust return nfs_do_access_cache_scan(nr_to_scan); 21863a505845STrond Myklebust } 21873a505845STrond Myklebust 21883a505845STrond Myklebust 21893a505845STrond Myklebust unsigned long 21901ab6c499SDave Chinner nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc) 21911ab6c499SDave Chinner { 219255f841ceSGlauber Costa return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries)); 2193979df72eSTrond Myklebust } 2194979df72eSTrond Myklebust 21953a505845STrond Myklebust static void 21963a505845STrond Myklebust nfs_access_cache_enforce_limit(void) 21973a505845STrond Myklebust { 21983a505845STrond Myklebust long nr_entries = atomic_long_read(&nfs_access_nr_entries); 21993a505845STrond Myklebust unsigned long diff; 22003a505845STrond Myklebust unsigned int nr_to_scan; 22013a505845STrond Myklebust 22023a505845STrond Myklebust if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize) 22033a505845STrond Myklebust return; 22043a505845STrond Myklebust nr_to_scan = 100; 22053a505845STrond Myklebust diff = nr_entries - nfs_access_max_cachesize; 22063a505845STrond Myklebust if (diff < nr_to_scan) 22073a505845STrond Myklebust nr_to_scan = diff; 22083a505845STrond Myklebust nfs_do_access_cache_scan(nr_to_scan); 22093a505845STrond Myklebust } 22103a505845STrond Myklebust 22111a81bb8aSTrond Myklebust static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 22121c3c07e9STrond Myklebust { 22131c3c07e9STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 22141a81bb8aSTrond Myklebust struct rb_node *n; 22151c3c07e9STrond Myklebust struct nfs_access_entry *entry; 22161c3c07e9STrond Myklebust 22171c3c07e9STrond Myklebust /* Unhook entries from the cache */ 22181c3c07e9STrond Myklebust while ((n = rb_first(root_node)) != NULL) { 22191c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 22201c3c07e9STrond Myklebust rb_erase(n, root_node); 22211a81bb8aSTrond Myklebust list_move(&entry->lru, head); 22221c3c07e9STrond Myklebust } 22231c3c07e9STrond Myklebust nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 22241c3c07e9STrond Myklebust } 22251c3c07e9STrond Myklebust 22261c3c07e9STrond Myklebust void nfs_access_zap_cache(struct inode *inode) 22271c3c07e9STrond Myklebust { 22281a81bb8aSTrond Myklebust LIST_HEAD(head); 22291a81bb8aSTrond Myklebust 22301a81bb8aSTrond Myklebust if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 22311a81bb8aSTrond Myklebust return; 2232cfcea3e8STrond Myklebust /* Remove from global LRU init */ 2233cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 22341a81bb8aSTrond Myklebust if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2235cfcea3e8STrond Myklebust list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2236cfcea3e8STrond Myklebust 22371c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 22381a81bb8aSTrond Myklebust __nfs_access_zap_cache(NFS_I(inode), &head); 22391a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 22401a81bb8aSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 22411a81bb8aSTrond Myklebust nfs_access_free_list(&head); 22421c3c07e9STrond Myklebust } 22431c606fb7SBryan Schumaker EXPORT_SYMBOL_GPL(nfs_access_zap_cache); 22441c3c07e9STrond Myklebust 22451c3c07e9STrond Myklebust static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 22461c3c07e9STrond Myklebust { 22471c3c07e9STrond Myklebust struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 22481c3c07e9STrond Myklebust struct nfs_access_entry *entry; 22491c3c07e9STrond Myklebust 22501c3c07e9STrond Myklebust while (n != NULL) { 22511c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 22521c3c07e9STrond Myklebust 22531c3c07e9STrond Myklebust if (cred < entry->cred) 22541c3c07e9STrond Myklebust n = n->rb_left; 22551c3c07e9STrond Myklebust else if (cred > entry->cred) 22561c3c07e9STrond Myklebust n = n->rb_right; 22571c3c07e9STrond Myklebust else 22581c3c07e9STrond Myklebust return entry; 22591c3c07e9STrond Myklebust } 22601c3c07e9STrond Myklebust return NULL; 22611c3c07e9STrond Myklebust } 22621c3c07e9STrond Myklebust 226357b69181STrond Myklebust static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res, bool may_block) 22641da177e4SLinus Torvalds { 226555296809SChuck Lever struct nfs_inode *nfsi = NFS_I(inode); 22661c3c07e9STrond Myklebust struct nfs_access_entry *cache; 226757b69181STrond Myklebust bool retry = true; 226857b69181STrond Myklebust int err; 22691da177e4SLinus Torvalds 22701c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 227157b69181STrond Myklebust for(;;) { 22721c3c07e9STrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 22731c3c07e9STrond Myklebust goto out_zap; 22741c3c07e9STrond Myklebust cache = nfs_access_search_rbtree(inode, cred); 227557b69181STrond Myklebust err = -ENOENT; 22761c3c07e9STrond Myklebust if (cache == NULL) 22771c3c07e9STrond Myklebust goto out; 227857b69181STrond Myklebust /* Found an entry, is our attribute cache valid? */ 227957b69181STrond Myklebust if (!nfs_attribute_cache_expired(inode) && 228057b69181STrond Myklebust !(nfsi->cache_validity & NFS_INO_INVALID_ATTR)) 228157b69181STrond Myklebust break; 228257b69181STrond Myklebust err = -ECHILD; 228357b69181STrond Myklebust if (!may_block) 228457b69181STrond Myklebust goto out; 228557b69181STrond Myklebust if (!retry) 228657b69181STrond Myklebust goto out_zap; 228757b69181STrond Myklebust spin_unlock(&inode->i_lock); 228857b69181STrond Myklebust err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 228957b69181STrond Myklebust if (err) 229057b69181STrond Myklebust return err; 229157b69181STrond Myklebust spin_lock(&inode->i_lock); 229257b69181STrond Myklebust retry = false; 229357b69181STrond Myklebust } 22941c3c07e9STrond Myklebust res->jiffies = cache->jiffies; 22951c3c07e9STrond Myklebust res->cred = cache->cred; 22961c3c07e9STrond Myklebust res->mask = cache->mask; 2297cfcea3e8STrond Myklebust list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 22981c3c07e9STrond Myklebust err = 0; 22991c3c07e9STrond Myklebust out: 23001c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 23011c3c07e9STrond Myklebust return err; 23021c3c07e9STrond Myklebust out_zap: 23031a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 23041a81bb8aSTrond Myklebust nfs_access_zap_cache(inode); 23051c3c07e9STrond Myklebust return -ENOENT; 23061c3c07e9STrond Myklebust } 23071c3c07e9STrond Myklebust 2308f682a398SNeilBrown static int nfs_access_get_cached_rcu(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 2309f682a398SNeilBrown { 2310f682a398SNeilBrown /* Only check the most recently returned cache entry, 2311f682a398SNeilBrown * but do it without locking. 2312f682a398SNeilBrown */ 2313f682a398SNeilBrown struct nfs_inode *nfsi = NFS_I(inode); 2314f682a398SNeilBrown struct nfs_access_entry *cache; 2315f682a398SNeilBrown int err = -ECHILD; 2316f682a398SNeilBrown struct list_head *lh; 2317f682a398SNeilBrown 2318f682a398SNeilBrown rcu_read_lock(); 2319f682a398SNeilBrown if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2320f682a398SNeilBrown goto out; 2321f682a398SNeilBrown lh = rcu_dereference(nfsi->access_cache_entry_lru.prev); 2322f682a398SNeilBrown cache = list_entry(lh, struct nfs_access_entry, lru); 2323f682a398SNeilBrown if (lh == &nfsi->access_cache_entry_lru || 2324f682a398SNeilBrown cred != cache->cred) 2325f682a398SNeilBrown cache = NULL; 2326f682a398SNeilBrown if (cache == NULL) 2327f682a398SNeilBrown goto out; 232857b69181STrond Myklebust err = nfs_revalidate_inode_rcu(NFS_SERVER(inode), inode); 232957b69181STrond Myklebust if (err) 2330f682a398SNeilBrown goto out; 2331f682a398SNeilBrown res->jiffies = cache->jiffies; 2332f682a398SNeilBrown res->cred = cache->cred; 2333f682a398SNeilBrown res->mask = cache->mask; 2334f682a398SNeilBrown out: 2335f682a398SNeilBrown rcu_read_unlock(); 2336f682a398SNeilBrown return err; 2337f682a398SNeilBrown } 2338f682a398SNeilBrown 23391c3c07e9STrond Myklebust static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 23401c3c07e9STrond Myklebust { 2341cfcea3e8STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 2342cfcea3e8STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 23431c3c07e9STrond Myklebust struct rb_node **p = &root_node->rb_node; 23441c3c07e9STrond Myklebust struct rb_node *parent = NULL; 23451c3c07e9STrond Myklebust struct nfs_access_entry *entry; 23461c3c07e9STrond Myklebust 23471c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 23481c3c07e9STrond Myklebust while (*p != NULL) { 23491c3c07e9STrond Myklebust parent = *p; 23501c3c07e9STrond Myklebust entry = rb_entry(parent, struct nfs_access_entry, rb_node); 23511c3c07e9STrond Myklebust 23521c3c07e9STrond Myklebust if (set->cred < entry->cred) 23531c3c07e9STrond Myklebust p = &parent->rb_left; 23541c3c07e9STrond Myklebust else if (set->cred > entry->cred) 23551c3c07e9STrond Myklebust p = &parent->rb_right; 23561c3c07e9STrond Myklebust else 23571c3c07e9STrond Myklebust goto found; 23581c3c07e9STrond Myklebust } 23591c3c07e9STrond Myklebust rb_link_node(&set->rb_node, parent, p); 23601c3c07e9STrond Myklebust rb_insert_color(&set->rb_node, root_node); 2361cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 23621c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 23631c3c07e9STrond Myklebust return; 23641c3c07e9STrond Myklebust found: 23651c3c07e9STrond Myklebust rb_replace_node(parent, &set->rb_node, root_node); 2366cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2367cfcea3e8STrond Myklebust list_del(&entry->lru); 23681c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 23691c3c07e9STrond Myklebust nfs_access_free_entry(entry); 23701da177e4SLinus Torvalds } 23711da177e4SLinus Torvalds 23726168f62cSWeston Andros Adamson void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 23731da177e4SLinus Torvalds { 23741c3c07e9STrond Myklebust struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 23751c3c07e9STrond Myklebust if (cache == NULL) 23761c3c07e9STrond Myklebust return; 23771c3c07e9STrond Myklebust RB_CLEAR_NODE(&cache->rb_node); 23781da177e4SLinus Torvalds cache->jiffies = set->jiffies; 23791c3c07e9STrond Myklebust cache->cred = get_rpccred(set->cred); 23801da177e4SLinus Torvalds cache->mask = set->mask; 23811c3c07e9STrond Myklebust 2382f682a398SNeilBrown /* The above field assignments must be visible 2383f682a398SNeilBrown * before this item appears on the lru. We cannot easily 2384f682a398SNeilBrown * use rcu_assign_pointer, so just force the memory barrier. 2385f682a398SNeilBrown */ 2386f682a398SNeilBrown smp_wmb(); 23871c3c07e9STrond Myklebust nfs_access_add_rbtree(inode, cache); 2388cfcea3e8STrond Myklebust 2389cfcea3e8STrond Myklebust /* Update accounting */ 23904e857c58SPeter Zijlstra smp_mb__before_atomic(); 2391cfcea3e8STrond Myklebust atomic_long_inc(&nfs_access_nr_entries); 23924e857c58SPeter Zijlstra smp_mb__after_atomic(); 2393cfcea3e8STrond Myklebust 2394cfcea3e8STrond Myklebust /* Add inode to global LRU list */ 23951a81bb8aSTrond Myklebust if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2396cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 23971a81bb8aSTrond Myklebust if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 23981a81bb8aSTrond Myklebust list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 23991a81bb8aSTrond Myklebust &nfs_access_lru_list); 2400cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 2401cfcea3e8STrond Myklebust } 24023a505845STrond Myklebust nfs_access_cache_enforce_limit(); 24031da177e4SLinus Torvalds } 24046168f62cSWeston Andros Adamson EXPORT_SYMBOL_GPL(nfs_access_add_cache); 24056168f62cSWeston Andros Adamson 24066168f62cSWeston Andros Adamson void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result) 24076168f62cSWeston Andros Adamson { 24086168f62cSWeston Andros Adamson entry->mask = 0; 24096168f62cSWeston Andros Adamson if (access_result & NFS4_ACCESS_READ) 24106168f62cSWeston Andros Adamson entry->mask |= MAY_READ; 24116168f62cSWeston Andros Adamson if (access_result & 24126168f62cSWeston Andros Adamson (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE)) 24136168f62cSWeston Andros Adamson entry->mask |= MAY_WRITE; 24146168f62cSWeston Andros Adamson if (access_result & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE)) 24156168f62cSWeston Andros Adamson entry->mask |= MAY_EXEC; 24166168f62cSWeston Andros Adamson } 24176168f62cSWeston Andros Adamson EXPORT_SYMBOL_GPL(nfs_access_set_mask); 24181da177e4SLinus Torvalds 24191da177e4SLinus Torvalds static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 24201da177e4SLinus Torvalds { 24211da177e4SLinus Torvalds struct nfs_access_entry cache; 242257b69181STrond Myklebust bool may_block = (mask & MAY_NOT_BLOCK) == 0; 24231da177e4SLinus Torvalds int status; 24241da177e4SLinus Torvalds 2425f4ce1299STrond Myklebust trace_nfs_access_enter(inode); 2426f4ce1299STrond Myklebust 2427f682a398SNeilBrown status = nfs_access_get_cached_rcu(inode, cred, &cache); 2428f682a398SNeilBrown if (status != 0) 242957b69181STrond Myklebust status = nfs_access_get_cached(inode, cred, &cache, may_block); 24301da177e4SLinus Torvalds if (status == 0) 2431f4ce1299STrond Myklebust goto out_cached; 24321da177e4SLinus Torvalds 2433f3324a2aSNeilBrown status = -ECHILD; 243457b69181STrond Myklebust if (!may_block) 2435f3324a2aSNeilBrown goto out; 2436f3324a2aSNeilBrown 24371da177e4SLinus Torvalds /* Be clever: ask server to check for all possible rights */ 24381da177e4SLinus Torvalds cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 24391da177e4SLinus Torvalds cache.cred = cred; 24401da177e4SLinus Torvalds cache.jiffies = jiffies; 24411da177e4SLinus Torvalds status = NFS_PROTO(inode)->access(inode, &cache); 2442a71ee337SSuresh Jayaraman if (status != 0) { 2443a71ee337SSuresh Jayaraman if (status == -ESTALE) { 2444a71ee337SSuresh Jayaraman nfs_zap_caches(inode); 2445a71ee337SSuresh Jayaraman if (!S_ISDIR(inode->i_mode)) 2446a71ee337SSuresh Jayaraman set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2447a71ee337SSuresh Jayaraman } 2448f4ce1299STrond Myklebust goto out; 2449a71ee337SSuresh Jayaraman } 24501da177e4SLinus Torvalds nfs_access_add_cache(inode, &cache); 2451f4ce1299STrond Myklebust out_cached: 2452f4ce1299STrond Myklebust if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0) 2453f4ce1299STrond Myklebust status = -EACCES; 24541da177e4SLinus Torvalds out: 2455f4ce1299STrond Myklebust trace_nfs_access_exit(inode, status); 2456f4ce1299STrond Myklebust return status; 24571da177e4SLinus Torvalds } 24581da177e4SLinus Torvalds 2459af22f94aSTrond Myklebust static int nfs_open_permission_mask(int openflags) 2460af22f94aSTrond Myklebust { 2461af22f94aSTrond Myklebust int mask = 0; 2462af22f94aSTrond Myklebust 2463f8d9a897SWeston Andros Adamson if (openflags & __FMODE_EXEC) { 2464f8d9a897SWeston Andros Adamson /* ONLY check exec rights */ 2465f8d9a897SWeston Andros Adamson mask = MAY_EXEC; 2466f8d9a897SWeston Andros Adamson } else { 24678a5e929dSAl Viro if ((openflags & O_ACCMODE) != O_WRONLY) 2468af22f94aSTrond Myklebust mask |= MAY_READ; 24698a5e929dSAl Viro if ((openflags & O_ACCMODE) != O_RDONLY) 2470af22f94aSTrond Myklebust mask |= MAY_WRITE; 2471f8d9a897SWeston Andros Adamson } 2472f8d9a897SWeston Andros Adamson 2473af22f94aSTrond Myklebust return mask; 2474af22f94aSTrond Myklebust } 2475af22f94aSTrond Myklebust 2476af22f94aSTrond Myklebust int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2477af22f94aSTrond Myklebust { 2478af22f94aSTrond Myklebust return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2479af22f94aSTrond Myklebust } 248089d77c8fSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_may_open); 2481af22f94aSTrond Myklebust 24825c5fc09aSTrond Myklebust static int nfs_execute_ok(struct inode *inode, int mask) 24835c5fc09aSTrond Myklebust { 24845c5fc09aSTrond Myklebust struct nfs_server *server = NFS_SERVER(inode); 24855c5fc09aSTrond Myklebust int ret; 24865c5fc09aSTrond Myklebust 24875c5fc09aSTrond Myklebust if (mask & MAY_NOT_BLOCK) 24885c5fc09aSTrond Myklebust ret = nfs_revalidate_inode_rcu(server, inode); 24895c5fc09aSTrond Myklebust else 24905c5fc09aSTrond Myklebust ret = nfs_revalidate_inode(server, inode); 24915c5fc09aSTrond Myklebust if (ret == 0 && !execute_ok(inode)) 24925c5fc09aSTrond Myklebust ret = -EACCES; 24935c5fc09aSTrond Myklebust return ret; 24945c5fc09aSTrond Myklebust } 24955c5fc09aSTrond Myklebust 249610556cb2SAl Viro int nfs_permission(struct inode *inode, int mask) 24971da177e4SLinus Torvalds { 24981da177e4SLinus Torvalds struct rpc_cred *cred; 24991da177e4SLinus Torvalds int res = 0; 25001da177e4SLinus Torvalds 250191d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSACCESS); 250291d5b470SChuck Lever 2503e6305c43SAl Viro if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 25041da177e4SLinus Torvalds goto out; 25051da177e4SLinus Torvalds /* Is this sys_access() ? */ 25069cfcac81SEric Paris if (mask & (MAY_ACCESS | MAY_CHDIR)) 25071da177e4SLinus Torvalds goto force_lookup; 25081da177e4SLinus Torvalds 25091da177e4SLinus Torvalds switch (inode->i_mode & S_IFMT) { 25101da177e4SLinus Torvalds case S_IFLNK: 25111da177e4SLinus Torvalds goto out; 25121da177e4SLinus Torvalds case S_IFREG: 2513762674f8STrond Myklebust if ((mask & MAY_OPEN) && 2514762674f8STrond Myklebust nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)) 2515762674f8STrond Myklebust return 0; 25161da177e4SLinus Torvalds break; 25171da177e4SLinus Torvalds case S_IFDIR: 25181da177e4SLinus Torvalds /* 25191da177e4SLinus Torvalds * Optimize away all write operations, since the server 25201da177e4SLinus Torvalds * will check permissions when we perform the op. 25211da177e4SLinus Torvalds */ 25221da177e4SLinus Torvalds if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 25231da177e4SLinus Torvalds goto out; 25241da177e4SLinus Torvalds } 25251da177e4SLinus Torvalds 25261da177e4SLinus Torvalds force_lookup: 25271da177e4SLinus Torvalds if (!NFS_PROTO(inode)->access) 25281da177e4SLinus Torvalds goto out_notsup; 25291da177e4SLinus Torvalds 2530f3324a2aSNeilBrown /* Always try fast lookups first */ 2531f3324a2aSNeilBrown rcu_read_lock(); 2532f3324a2aSNeilBrown cred = rpc_lookup_cred_nonblock(); 2533f3324a2aSNeilBrown if (!IS_ERR(cred)) 2534f3324a2aSNeilBrown res = nfs_do_access(inode, cred, mask|MAY_NOT_BLOCK); 2535f3324a2aSNeilBrown else 2536f3324a2aSNeilBrown res = PTR_ERR(cred); 2537f3324a2aSNeilBrown rcu_read_unlock(); 2538f3324a2aSNeilBrown if (res == -ECHILD && !(mask & MAY_NOT_BLOCK)) { 2539f3324a2aSNeilBrown /* Fast lookup failed, try the slow way */ 254098a8e323STrond Myklebust cred = rpc_lookup_cred(); 25411da177e4SLinus Torvalds if (!IS_ERR(cred)) { 25421da177e4SLinus Torvalds res = nfs_do_access(inode, cred, mask); 25431da177e4SLinus Torvalds put_rpccred(cred); 25441da177e4SLinus Torvalds } else 25451da177e4SLinus Torvalds res = PTR_ERR(cred); 2546f3324a2aSNeilBrown } 25471da177e4SLinus Torvalds out: 25485c5fc09aSTrond Myklebust if (!res && (mask & MAY_EXEC)) 25495c5fc09aSTrond Myklebust res = nfs_execute_ok(inode, mask); 2550f696a365SMiklos Szeredi 25511e8968c5SNiels de Vos dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n", 25521e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino, mask, res); 25531da177e4SLinus Torvalds return res; 25541da177e4SLinus Torvalds out_notsup: 2555d51ac1a8SNeilBrown if (mask & MAY_NOT_BLOCK) 2556d51ac1a8SNeilBrown return -ECHILD; 2557d51ac1a8SNeilBrown 25581da177e4SLinus Torvalds res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 25591da177e4SLinus Torvalds if (res == 0) 25602830ba7fSAl Viro res = generic_permission(inode, mask); 25611e7cb3dcSChuck Lever goto out; 25621da177e4SLinus Torvalds } 2563ddda8e0aSBryan Schumaker EXPORT_SYMBOL_GPL(nfs_permission); 25641da177e4SLinus Torvalds 25651da177e4SLinus Torvalds /* 25661da177e4SLinus Torvalds * Local variables: 25671da177e4SLinus Torvalds * version-control: t 25681da177e4SLinus Torvalds * kept-new-versions: 5 25691da177e4SLinus Torvalds * End: 25701da177e4SLinus Torvalds */ 2571