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 201da177e4SLinus Torvalds #include <linux/time.h> 211da177e4SLinus Torvalds #include <linux/errno.h> 221da177e4SLinus Torvalds #include <linux/stat.h> 231da177e4SLinus Torvalds #include <linux/fcntl.h> 241da177e4SLinus Torvalds #include <linux/string.h> 251da177e4SLinus Torvalds #include <linux/kernel.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/mm.h> 281da177e4SLinus Torvalds #include <linux/sunrpc/clnt.h> 291da177e4SLinus Torvalds #include <linux/nfs_fs.h> 301da177e4SLinus Torvalds #include <linux/nfs_mount.h> 311da177e4SLinus Torvalds #include <linux/pagemap.h> 32873101b3SChuck Lever #include <linux/pagevec.h> 331da177e4SLinus Torvalds #include <linux/namei.h> 3454ceac45SDavid Howells #include <linux/mount.h> 35e8edc6e0SAlexey Dobriyan #include <linux/sched.h> 3656e4ebf8SBryan Schumaker #include <linux/vmalloc.h> 3704e4bd1cSCatalin Marinas #include <linux/kmemleak.h> 38*64c2ce8bSAneesh Kumar K.V #include <linux/xattr.h> 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds #include "delegation.h" 4191d5b470SChuck Lever #include "iostat.h" 424c30d56eSAdrian Bunk #include "internal.h" 43cd9a1c0eSTrond Myklebust #include "fscache.h" 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds /* #define NFS_DEBUG_VERBOSE 1 */ 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds static int nfs_opendir(struct inode *, struct file *); 481da177e4SLinus Torvalds static int nfs_readdir(struct file *, void *, filldir_t); 491da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 501da177e4SLinus Torvalds static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *); 511da177e4SLinus Torvalds static int nfs_mkdir(struct inode *, struct dentry *, int); 521da177e4SLinus Torvalds static int nfs_rmdir(struct inode *, struct dentry *); 531da177e4SLinus Torvalds static int nfs_unlink(struct inode *, struct dentry *); 541da177e4SLinus Torvalds static int nfs_symlink(struct inode *, struct dentry *, const char *); 551da177e4SLinus Torvalds static int nfs_link(struct dentry *, struct inode *, struct dentry *); 561da177e4SLinus Torvalds static int nfs_mknod(struct inode *, struct dentry *, int, dev_t); 571da177e4SLinus Torvalds static int nfs_rename(struct inode *, struct dentry *, 581da177e4SLinus Torvalds struct inode *, struct dentry *); 597ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *, int); 60f0dd2136STrond Myklebust static loff_t nfs_llseek_dir(struct file *, loff_t, int); 6111de3b11STrond Myklebust static void nfs_readdir_clear_array(struct page*); 621da177e4SLinus Torvalds 634b6f5d20SArjan van de Ven const struct file_operations nfs_dir_operations = { 64f0dd2136STrond Myklebust .llseek = nfs_llseek_dir, 651da177e4SLinus Torvalds .read = generic_read_dir, 661da177e4SLinus Torvalds .readdir = nfs_readdir, 671da177e4SLinus Torvalds .open = nfs_opendir, 681da177e4SLinus Torvalds .release = nfs_release, 691da177e4SLinus Torvalds .fsync = nfs_fsync_dir, 701da177e4SLinus Torvalds }; 711da177e4SLinus Torvalds 7292e1d5beSArjan van de Ven const struct inode_operations nfs_dir_inode_operations = { 731da177e4SLinus Torvalds .create = nfs_create, 741da177e4SLinus Torvalds .lookup = nfs_lookup, 751da177e4SLinus Torvalds .link = nfs_link, 761da177e4SLinus Torvalds .unlink = nfs_unlink, 771da177e4SLinus Torvalds .symlink = nfs_symlink, 781da177e4SLinus Torvalds .mkdir = nfs_mkdir, 791da177e4SLinus Torvalds .rmdir = nfs_rmdir, 801da177e4SLinus Torvalds .mknod = nfs_mknod, 811da177e4SLinus Torvalds .rename = nfs_rename, 821da177e4SLinus Torvalds .permission = nfs_permission, 831da177e4SLinus Torvalds .getattr = nfs_getattr, 841da177e4SLinus Torvalds .setattr = nfs_setattr, 851da177e4SLinus Torvalds }; 861da177e4SLinus Torvalds 8711de3b11STrond Myklebust const struct address_space_operations nfs_dir_aops = { 8811de3b11STrond Myklebust .freepage = nfs_readdir_clear_array, 89d1bacf9eSBryan Schumaker }; 90d1bacf9eSBryan Schumaker 91b7fa0554SAndreas Gruenbacher #ifdef CONFIG_NFS_V3 9292e1d5beSArjan van de Ven const struct inode_operations nfs3_dir_inode_operations = { 93b7fa0554SAndreas Gruenbacher .create = nfs_create, 94b7fa0554SAndreas Gruenbacher .lookup = nfs_lookup, 95b7fa0554SAndreas Gruenbacher .link = nfs_link, 96b7fa0554SAndreas Gruenbacher .unlink = nfs_unlink, 97b7fa0554SAndreas Gruenbacher .symlink = nfs_symlink, 98b7fa0554SAndreas Gruenbacher .mkdir = nfs_mkdir, 99b7fa0554SAndreas Gruenbacher .rmdir = nfs_rmdir, 100b7fa0554SAndreas Gruenbacher .mknod = nfs_mknod, 101b7fa0554SAndreas Gruenbacher .rename = nfs_rename, 102b7fa0554SAndreas Gruenbacher .permission = nfs_permission, 103b7fa0554SAndreas Gruenbacher .getattr = nfs_getattr, 104b7fa0554SAndreas Gruenbacher .setattr = nfs_setattr, 105b7fa0554SAndreas Gruenbacher .listxattr = nfs3_listxattr, 106b7fa0554SAndreas Gruenbacher .getxattr = nfs3_getxattr, 107b7fa0554SAndreas Gruenbacher .setxattr = nfs3_setxattr, 108b7fa0554SAndreas Gruenbacher .removexattr = nfs3_removexattr, 109b7fa0554SAndreas Gruenbacher }; 110b7fa0554SAndreas Gruenbacher #endif /* CONFIG_NFS_V3 */ 111b7fa0554SAndreas Gruenbacher 1121da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *); 115c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd); 11692e1d5beSArjan van de Ven const struct inode_operations nfs4_dir_inode_operations = { 117c0204fd2STrond Myklebust .create = nfs_open_create, 1181da177e4SLinus Torvalds .lookup = nfs_atomic_lookup, 1191da177e4SLinus Torvalds .link = nfs_link, 1201da177e4SLinus Torvalds .unlink = nfs_unlink, 1211da177e4SLinus Torvalds .symlink = nfs_symlink, 1221da177e4SLinus Torvalds .mkdir = nfs_mkdir, 1231da177e4SLinus Torvalds .rmdir = nfs_rmdir, 1241da177e4SLinus Torvalds .mknod = nfs_mknod, 1251da177e4SLinus Torvalds .rename = nfs_rename, 1261da177e4SLinus Torvalds .permission = nfs_permission, 1271da177e4SLinus Torvalds .getattr = nfs_getattr, 1281da177e4SLinus Torvalds .setattr = nfs_setattr, 129*64c2ce8bSAneesh Kumar K.V .getxattr = generic_getxattr, 130*64c2ce8bSAneesh Kumar K.V .setxattr = generic_setxattr, 131*64c2ce8bSAneesh Kumar K.V .listxattr = generic_listxattr, 132*64c2ce8bSAneesh Kumar K.V .removexattr = generic_removexattr, 1331da177e4SLinus Torvalds }; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds #endif /* CONFIG_NFS_V4 */ 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds /* 1381da177e4SLinus Torvalds * Open file 1391da177e4SLinus Torvalds */ 1401da177e4SLinus Torvalds static int 1411da177e4SLinus Torvalds nfs_opendir(struct inode *inode, struct file *filp) 1421da177e4SLinus Torvalds { 1437451c4f0SCarsten Otte int res; 1441da177e4SLinus Torvalds 1456da24bc9SChuck Lever dfprintk(FILE, "NFS: open dir(%s/%s)\n", 146cc0dd2d1SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 147cc0dd2d1SChuck Lever filp->f_path.dentry->d_name.name); 148cc0dd2d1SChuck Lever 149cc0dd2d1SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 1501e7cb3dcSChuck Lever 1511da177e4SLinus Torvalds /* Call generic open code in order to cache credentials */ 1521da177e4SLinus Torvalds res = nfs_open(inode, filp); 153f5a73672SNeil Brown if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 154f5a73672SNeil Brown /* This is a mountpoint, so d_revalidate will never 155f5a73672SNeil Brown * have been called, so we need to refresh the 156f5a73672SNeil Brown * inode (for close-open consistency) ourselves. 157f5a73672SNeil Brown */ 158f5a73672SNeil Brown __nfs_revalidate_inode(NFS_SERVER(inode), inode); 159f5a73672SNeil Brown } 1601da177e4SLinus Torvalds return res; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds 163d1bacf9eSBryan Schumaker struct nfs_cache_array_entry { 164d1bacf9eSBryan Schumaker u64 cookie; 165d1bacf9eSBryan Schumaker u64 ino; 166d1bacf9eSBryan Schumaker struct qstr string; 1670b26a0bfSTrond Myklebust unsigned char d_type; 168d1bacf9eSBryan Schumaker }; 169d1bacf9eSBryan Schumaker 170d1bacf9eSBryan Schumaker struct nfs_cache_array { 171d1bacf9eSBryan Schumaker unsigned int size; 172d1bacf9eSBryan Schumaker int eof_index; 173d1bacf9eSBryan Schumaker u64 last_cookie; 174d1bacf9eSBryan Schumaker struct nfs_cache_array_entry array[0]; 175d1bacf9eSBryan Schumaker }; 176d1bacf9eSBryan Schumaker 177573c4e1eSChuck Lever typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int); 1781da177e4SLinus Torvalds typedef struct { 1791da177e4SLinus Torvalds struct file *file; 1801da177e4SLinus Torvalds struct page *page; 1811da177e4SLinus Torvalds unsigned long page_index; 182f0dd2136STrond Myklebust u64 *dir_cookie; 1830aded708STrond Myklebust u64 last_cookie; 184f0dd2136STrond Myklebust loff_t current_index; 1851da177e4SLinus Torvalds decode_dirent_t decode; 186d1bacf9eSBryan Schumaker 1871f4eab7eSNeil Brown unsigned long timestamp; 1884704f0e2STrond Myklebust unsigned long gencount; 189d1bacf9eSBryan Schumaker unsigned int cache_entry_index; 190d1bacf9eSBryan Schumaker unsigned int plus:1; 191d1bacf9eSBryan Schumaker unsigned int eof:1; 1921da177e4SLinus Torvalds } nfs_readdir_descriptor_t; 1931da177e4SLinus Torvalds 194d1bacf9eSBryan Schumaker /* 195d1bacf9eSBryan Schumaker * The caller is responsible for calling nfs_readdir_release_array(page) 1961da177e4SLinus Torvalds */ 1971da177e4SLinus Torvalds static 198d1bacf9eSBryan Schumaker struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 1991da177e4SLinus Torvalds { 2008cd51a0cSTrond Myklebust void *ptr; 201d1bacf9eSBryan Schumaker if (page == NULL) 202d1bacf9eSBryan Schumaker return ERR_PTR(-EIO); 2038cd51a0cSTrond Myklebust ptr = kmap(page); 2048cd51a0cSTrond Myklebust if (ptr == NULL) 2058cd51a0cSTrond Myklebust return ERR_PTR(-ENOMEM); 2068cd51a0cSTrond Myklebust return ptr; 207d1bacf9eSBryan Schumaker } 208d1bacf9eSBryan Schumaker 209d1bacf9eSBryan Schumaker static 210d1bacf9eSBryan Schumaker void nfs_readdir_release_array(struct page *page) 211d1bacf9eSBryan Schumaker { 212d1bacf9eSBryan Schumaker kunmap(page); 213d1bacf9eSBryan Schumaker } 214d1bacf9eSBryan Schumaker 215d1bacf9eSBryan Schumaker /* 216d1bacf9eSBryan Schumaker * we are freeing strings created by nfs_add_to_readdir_array() 217d1bacf9eSBryan Schumaker */ 218d1bacf9eSBryan Schumaker static 21911de3b11STrond Myklebust void nfs_readdir_clear_array(struct page *page) 220d1bacf9eSBryan Schumaker { 22111de3b11STrond Myklebust struct nfs_cache_array *array; 222d1bacf9eSBryan Schumaker int i; 2238cd51a0cSTrond Myklebust 22411de3b11STrond Myklebust array = kmap_atomic(page, KM_USER0); 225d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) 226d1bacf9eSBryan Schumaker kfree(array->array[i].string.name); 22711de3b11STrond Myklebust kunmap_atomic(array, KM_USER0); 228d1bacf9eSBryan Schumaker } 229d1bacf9eSBryan Schumaker 230d1bacf9eSBryan Schumaker /* 231d1bacf9eSBryan Schumaker * the caller is responsible for freeing qstr.name 232d1bacf9eSBryan Schumaker * when called by nfs_readdir_add_to_array, the strings will be freed in 233d1bacf9eSBryan Schumaker * nfs_clear_readdir_array() 234d1bacf9eSBryan Schumaker */ 235d1bacf9eSBryan Schumaker static 2364a201d6eSTrond Myklebust int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 237d1bacf9eSBryan Schumaker { 238d1bacf9eSBryan Schumaker string->len = len; 239d1bacf9eSBryan Schumaker string->name = kmemdup(name, len, GFP_KERNEL); 2404a201d6eSTrond Myklebust if (string->name == NULL) 2414a201d6eSTrond Myklebust return -ENOMEM; 24204e4bd1cSCatalin Marinas /* 24304e4bd1cSCatalin Marinas * Avoid a kmemleak false positive. The pointer to the name is stored 24404e4bd1cSCatalin Marinas * in a page cache page which kmemleak does not scan. 24504e4bd1cSCatalin Marinas */ 24604e4bd1cSCatalin Marinas kmemleak_not_leak(string->name); 2474a201d6eSTrond Myklebust string->hash = full_name_hash(name, len); 2484a201d6eSTrond Myklebust return 0; 249d1bacf9eSBryan Schumaker } 250d1bacf9eSBryan Schumaker 251d1bacf9eSBryan Schumaker static 252d1bacf9eSBryan Schumaker int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 253d1bacf9eSBryan Schumaker { 254d1bacf9eSBryan Schumaker struct nfs_cache_array *array = nfs_readdir_get_array(page); 2554a201d6eSTrond Myklebust struct nfs_cache_array_entry *cache_entry; 2564a201d6eSTrond Myklebust int ret; 2574a201d6eSTrond Myklebust 258d1bacf9eSBryan Schumaker if (IS_ERR(array)) 259d1bacf9eSBryan Schumaker return PTR_ERR(array); 260d1bacf9eSBryan Schumaker 2614a201d6eSTrond Myklebust cache_entry = &array->array[array->size]; 2623020093fSTrond Myklebust 2633020093fSTrond Myklebust /* Check that this entry lies within the page bounds */ 2643020093fSTrond Myklebust ret = -ENOSPC; 2653020093fSTrond Myklebust if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE) 2663020093fSTrond Myklebust goto out; 2673020093fSTrond Myklebust 2684a201d6eSTrond Myklebust cache_entry->cookie = entry->prev_cookie; 2694a201d6eSTrond Myklebust cache_entry->ino = entry->ino; 2700b26a0bfSTrond Myklebust cache_entry->d_type = entry->d_type; 2714a201d6eSTrond Myklebust ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 2724a201d6eSTrond Myklebust if (ret) 2734a201d6eSTrond Myklebust goto out; 274d1bacf9eSBryan Schumaker array->last_cookie = entry->cookie; 2758cd51a0cSTrond Myklebust array->size++; 27647c716cbSTrond Myklebust if (entry->eof != 0) 277d1bacf9eSBryan Schumaker array->eof_index = array->size; 2784a201d6eSTrond Myklebust out: 279d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 2804a201d6eSTrond Myklebust return ret; 281d1bacf9eSBryan Schumaker } 282d1bacf9eSBryan Schumaker 283d1bacf9eSBryan Schumaker static 284d1bacf9eSBryan Schumaker int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 285d1bacf9eSBryan Schumaker { 286d1bacf9eSBryan Schumaker loff_t diff = desc->file->f_pos - desc->current_index; 287d1bacf9eSBryan Schumaker unsigned int index; 288d1bacf9eSBryan Schumaker 289d1bacf9eSBryan Schumaker if (diff < 0) 290d1bacf9eSBryan Schumaker goto out_eof; 291d1bacf9eSBryan Schumaker if (diff >= array->size) { 2928cd51a0cSTrond Myklebust if (array->eof_index >= 0) 293d1bacf9eSBryan Schumaker goto out_eof; 294d1bacf9eSBryan Schumaker desc->current_index += array->size; 295d1bacf9eSBryan Schumaker return -EAGAIN; 296d1bacf9eSBryan Schumaker } 297d1bacf9eSBryan Schumaker 298d1bacf9eSBryan Schumaker index = (unsigned int)diff; 299d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[index].cookie; 300d1bacf9eSBryan Schumaker desc->cache_entry_index = index; 301d1bacf9eSBryan Schumaker return 0; 302d1bacf9eSBryan Schumaker out_eof: 303d1bacf9eSBryan Schumaker desc->eof = 1; 304d1bacf9eSBryan Schumaker return -EBADCOOKIE; 305d1bacf9eSBryan Schumaker } 306d1bacf9eSBryan Schumaker 307d1bacf9eSBryan Schumaker static 308d1bacf9eSBryan Schumaker int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 309d1bacf9eSBryan Schumaker { 310d1bacf9eSBryan Schumaker int i; 311d1bacf9eSBryan Schumaker int status = -EAGAIN; 312d1bacf9eSBryan Schumaker 313d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) { 3148cd51a0cSTrond Myklebust if (array->array[i].cookie == *desc->dir_cookie) { 3158cd51a0cSTrond Myklebust desc->cache_entry_index = i; 31647c716cbSTrond Myklebust return 0; 3178cd51a0cSTrond Myklebust } 3188cd51a0cSTrond Myklebust } 31947c716cbSTrond Myklebust if (array->eof_index >= 0) { 320d1bacf9eSBryan Schumaker status = -EBADCOOKIE; 32118fb5fe4STrond Myklebust if (*desc->dir_cookie == array->last_cookie) 32218fb5fe4STrond Myklebust desc->eof = 1; 323d1bacf9eSBryan Schumaker } 324d1bacf9eSBryan Schumaker return status; 325d1bacf9eSBryan Schumaker } 326d1bacf9eSBryan Schumaker 327d1bacf9eSBryan Schumaker static 328d1bacf9eSBryan Schumaker int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 329d1bacf9eSBryan Schumaker { 330d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 33147c716cbSTrond Myklebust int status; 332d1bacf9eSBryan Schumaker 333d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 334d1bacf9eSBryan Schumaker if (IS_ERR(array)) { 335d1bacf9eSBryan Schumaker status = PTR_ERR(array); 336d1bacf9eSBryan Schumaker goto out; 337d1bacf9eSBryan Schumaker } 338d1bacf9eSBryan Schumaker 339d1bacf9eSBryan Schumaker if (*desc->dir_cookie == 0) 340d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_pos(array, desc); 341d1bacf9eSBryan Schumaker else 342d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_cookie(array, desc); 343d1bacf9eSBryan Schumaker 34447c716cbSTrond Myklebust if (status == -EAGAIN) { 3450aded708STrond Myklebust desc->last_cookie = array->last_cookie; 34647c716cbSTrond Myklebust desc->page_index++; 34747c716cbSTrond Myklebust } 348d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 349d1bacf9eSBryan Schumaker out: 350d1bacf9eSBryan Schumaker return status; 351d1bacf9eSBryan Schumaker } 352d1bacf9eSBryan Schumaker 353d1bacf9eSBryan Schumaker /* Fill a page with xdr information before transferring to the cache page */ 354d1bacf9eSBryan Schumaker static 35556e4ebf8SBryan Schumaker int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 356d1bacf9eSBryan Schumaker struct nfs_entry *entry, struct file *file, struct inode *inode) 357d1bacf9eSBryan Schumaker { 3581da177e4SLinus Torvalds struct rpc_cred *cred = nfs_file_cred(file); 3594704f0e2STrond Myklebust unsigned long timestamp, gencount; 3601da177e4SLinus Torvalds int error; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds again: 3631da177e4SLinus Torvalds timestamp = jiffies; 3644704f0e2STrond Myklebust gencount = nfs_inc_attr_generation_counter(); 36556e4ebf8SBryan Schumaker error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages, 3661da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, desc->plus); 3671da177e4SLinus Torvalds if (error < 0) { 3681da177e4SLinus Torvalds /* We requested READDIRPLUS, but the server doesn't grok it */ 3691da177e4SLinus Torvalds if (error == -ENOTSUPP && desc->plus) { 3701da177e4SLinus Torvalds NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 3713a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 3721da177e4SLinus Torvalds desc->plus = 0; 3731da177e4SLinus Torvalds goto again; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds goto error; 3761da177e4SLinus Torvalds } 3771f4eab7eSNeil Brown desc->timestamp = timestamp; 3784704f0e2STrond Myklebust desc->gencount = gencount; 379d1bacf9eSBryan Schumaker error: 380d1bacf9eSBryan Schumaker return error; 381d1bacf9eSBryan Schumaker } 382d1bacf9eSBryan Schumaker 383573c4e1eSChuck Lever static int xdr_decode(nfs_readdir_descriptor_t *desc, 384573c4e1eSChuck Lever struct nfs_entry *entry, struct xdr_stream *xdr) 385d1bacf9eSBryan Schumaker { 386573c4e1eSChuck Lever int error; 387d1bacf9eSBryan Schumaker 388573c4e1eSChuck Lever error = desc->decode(xdr, entry, desc->plus); 389573c4e1eSChuck Lever if (error) 390573c4e1eSChuck Lever return error; 391d1bacf9eSBryan Schumaker entry->fattr->time_start = desc->timestamp; 392d1bacf9eSBryan Schumaker entry->fattr->gencount = desc->gencount; 393d1bacf9eSBryan Schumaker return 0; 394d1bacf9eSBryan Schumaker } 395d1bacf9eSBryan Schumaker 396d39ab9deSBryan Schumaker static 397d39ab9deSBryan Schumaker int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 398d39ab9deSBryan Schumaker { 399d39ab9deSBryan Schumaker if (dentry->d_inode == NULL) 400d39ab9deSBryan Schumaker goto different; 40137a09f07STrond Myklebust if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0) 402d39ab9deSBryan Schumaker goto different; 403d39ab9deSBryan Schumaker return 1; 404d39ab9deSBryan Schumaker different: 405d39ab9deSBryan Schumaker return 0; 406d39ab9deSBryan Schumaker } 407d39ab9deSBryan Schumaker 408d39ab9deSBryan Schumaker static 409d39ab9deSBryan Schumaker void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry) 410d39ab9deSBryan Schumaker { 4114a201d6eSTrond Myklebust struct qstr filename = { 4124a201d6eSTrond Myklebust .len = entry->len, 4134a201d6eSTrond Myklebust .name = entry->name, 4144a201d6eSTrond Myklebust }; 4154a201d6eSTrond Myklebust struct dentry *dentry; 4164a201d6eSTrond Myklebust struct dentry *alias; 417d39ab9deSBryan Schumaker struct inode *dir = parent->d_inode; 418d39ab9deSBryan Schumaker struct inode *inode; 419d39ab9deSBryan Schumaker 4204a201d6eSTrond Myklebust if (filename.name[0] == '.') { 4214a201d6eSTrond Myklebust if (filename.len == 1) 4224a201d6eSTrond Myklebust return; 4234a201d6eSTrond Myklebust if (filename.len == 2 && filename.name[1] == '.') 4244a201d6eSTrond Myklebust return; 4254a201d6eSTrond Myklebust } 4264a201d6eSTrond Myklebust filename.hash = full_name_hash(filename.name, filename.len); 427d39ab9deSBryan Schumaker 4284a201d6eSTrond Myklebust dentry = d_lookup(parent, &filename); 429d39ab9deSBryan Schumaker if (dentry != NULL) { 430d39ab9deSBryan Schumaker if (nfs_same_file(dentry, entry)) { 431d39ab9deSBryan Schumaker nfs_refresh_inode(dentry->d_inode, entry->fattr); 432d39ab9deSBryan Schumaker goto out; 433d39ab9deSBryan Schumaker } else { 434d39ab9deSBryan Schumaker d_drop(dentry); 435d39ab9deSBryan Schumaker dput(dentry); 436d39ab9deSBryan Schumaker } 437d39ab9deSBryan Schumaker } 438d39ab9deSBryan Schumaker 439d39ab9deSBryan Schumaker dentry = d_alloc(parent, &filename); 4404a201d6eSTrond Myklebust if (dentry == NULL) 4414a201d6eSTrond Myklebust return; 4424a201d6eSTrond Myklebust 443d39ab9deSBryan Schumaker dentry->d_op = NFS_PROTO(dir)->dentry_ops; 444d39ab9deSBryan Schumaker inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 445d39ab9deSBryan Schumaker if (IS_ERR(inode)) 446d39ab9deSBryan Schumaker goto out; 447d39ab9deSBryan Schumaker 448d39ab9deSBryan Schumaker alias = d_materialise_unique(dentry, inode); 449d39ab9deSBryan Schumaker if (IS_ERR(alias)) 450d39ab9deSBryan Schumaker goto out; 451d39ab9deSBryan Schumaker else if (alias) { 452d39ab9deSBryan Schumaker nfs_set_verifier(alias, nfs_save_change_attribute(dir)); 453d39ab9deSBryan Schumaker dput(alias); 454d39ab9deSBryan Schumaker } else 455d39ab9deSBryan Schumaker nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 456d39ab9deSBryan Schumaker 457d39ab9deSBryan Schumaker out: 458d39ab9deSBryan Schumaker dput(dentry); 459d39ab9deSBryan Schumaker } 460d39ab9deSBryan Schumaker 461d1bacf9eSBryan Schumaker /* Perform conversion from xdr to cache array */ 462d1bacf9eSBryan Schumaker static 4638cd51a0cSTrond Myklebust int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, 46456e4ebf8SBryan Schumaker void *xdr_page, struct page *page, unsigned int buflen) 465d1bacf9eSBryan Schumaker { 466babddc72SBryan Schumaker struct xdr_stream stream; 467babddc72SBryan Schumaker struct xdr_buf buf; 46856e4ebf8SBryan Schumaker __be32 *ptr = xdr_page; 46999424380SBryan Schumaker struct nfs_cache_array *array; 4705c346854STrond Myklebust unsigned int count = 0; 4715c346854STrond Myklebust int status; 472babddc72SBryan Schumaker 473babddc72SBryan Schumaker buf.head->iov_base = xdr_page; 474babddc72SBryan Schumaker buf.head->iov_len = buflen; 475babddc72SBryan Schumaker buf.tail->iov_len = 0; 476babddc72SBryan Schumaker buf.page_base = 0; 477babddc72SBryan Schumaker buf.page_len = 0; 478babddc72SBryan Schumaker buf.buflen = buf.head->iov_len; 479babddc72SBryan Schumaker buf.len = buf.head->iov_len; 480babddc72SBryan Schumaker 481babddc72SBryan Schumaker xdr_init_decode(&stream, &buf, ptr); 482babddc72SBryan Schumaker 48399424380SBryan Schumaker 48499424380SBryan Schumaker do { 48599424380SBryan Schumaker status = xdr_decode(desc, entry, &stream); 4868cd51a0cSTrond Myklebust if (status != 0) { 4878cd51a0cSTrond Myklebust if (status == -EAGAIN) 4888cd51a0cSTrond Myklebust status = 0; 48999424380SBryan Schumaker break; 4908cd51a0cSTrond Myklebust } 49199424380SBryan Schumaker 4925c346854STrond Myklebust count++; 4935c346854STrond Myklebust 49447c716cbSTrond Myklebust if (desc->plus != 0) 495d39ab9deSBryan Schumaker nfs_prime_dcache(desc->file->f_path.dentry, entry); 4968cd51a0cSTrond Myklebust 4978cd51a0cSTrond Myklebust status = nfs_readdir_add_to_array(entry, page); 4988cd51a0cSTrond Myklebust if (status != 0) 4998cd51a0cSTrond Myklebust break; 50099424380SBryan Schumaker } while (!entry->eof); 50199424380SBryan Schumaker 50247c716cbSTrond Myklebust if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) { 50399424380SBryan Schumaker array = nfs_readdir_get_array(page); 5048cd51a0cSTrond Myklebust if (!IS_ERR(array)) { 5058cd51a0cSTrond Myklebust array->eof_index = array->size; 50699424380SBryan Schumaker status = 0; 50799424380SBryan Schumaker nfs_readdir_release_array(page); 5085c346854STrond Myklebust } else 5095c346854STrond Myklebust status = PTR_ERR(array); 51056e4ebf8SBryan Schumaker } 5118cd51a0cSTrond Myklebust return status; 5128cd51a0cSTrond Myklebust } 51356e4ebf8SBryan Schumaker 51456e4ebf8SBryan Schumaker static 51556e4ebf8SBryan Schumaker void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages) 51656e4ebf8SBryan Schumaker { 51756e4ebf8SBryan Schumaker unsigned int i; 51856e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) 51956e4ebf8SBryan Schumaker put_page(pages[i]); 52056e4ebf8SBryan Schumaker } 52156e4ebf8SBryan Schumaker 52256e4ebf8SBryan Schumaker static 52356e4ebf8SBryan Schumaker void nfs_readdir_free_large_page(void *ptr, struct page **pages, 52456e4ebf8SBryan Schumaker unsigned int npages) 52556e4ebf8SBryan Schumaker { 52656e4ebf8SBryan Schumaker vm_unmap_ram(ptr, npages); 52756e4ebf8SBryan Schumaker nfs_readdir_free_pagearray(pages, npages); 52856e4ebf8SBryan Schumaker } 52956e4ebf8SBryan Schumaker 53056e4ebf8SBryan Schumaker /* 53156e4ebf8SBryan Schumaker * nfs_readdir_large_page will allocate pages that must be freed with a call 53256e4ebf8SBryan Schumaker * to nfs_readdir_free_large_page 53356e4ebf8SBryan Schumaker */ 53456e4ebf8SBryan Schumaker static 53556e4ebf8SBryan Schumaker void *nfs_readdir_large_page(struct page **pages, unsigned int npages) 53656e4ebf8SBryan Schumaker { 53756e4ebf8SBryan Schumaker void *ptr; 53856e4ebf8SBryan Schumaker unsigned int i; 53956e4ebf8SBryan Schumaker 54056e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) { 54156e4ebf8SBryan Schumaker struct page *page = alloc_page(GFP_KERNEL); 54256e4ebf8SBryan Schumaker if (page == NULL) 54356e4ebf8SBryan Schumaker goto out_freepages; 54456e4ebf8SBryan Schumaker pages[i] = page; 54556e4ebf8SBryan Schumaker } 54656e4ebf8SBryan Schumaker 5474a201d6eSTrond Myklebust ptr = vm_map_ram(pages, npages, 0, PAGE_KERNEL); 54856e4ebf8SBryan Schumaker if (!IS_ERR_OR_NULL(ptr)) 54956e4ebf8SBryan Schumaker return ptr; 55056e4ebf8SBryan Schumaker out_freepages: 55156e4ebf8SBryan Schumaker nfs_readdir_free_pagearray(pages, i); 55256e4ebf8SBryan Schumaker return NULL; 553d1bacf9eSBryan Schumaker } 554d1bacf9eSBryan Schumaker 555d1bacf9eSBryan Schumaker static 556d1bacf9eSBryan Schumaker int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 557d1bacf9eSBryan Schumaker { 55856e4ebf8SBryan Schumaker struct page *pages[NFS_MAX_READDIR_PAGES]; 55956e4ebf8SBryan Schumaker void *pages_ptr = NULL; 560d1bacf9eSBryan Schumaker struct nfs_entry entry; 561d1bacf9eSBryan Schumaker struct file *file = desc->file; 562d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 5638cd51a0cSTrond Myklebust int status = -ENOMEM; 56456e4ebf8SBryan Schumaker unsigned int array_size = ARRAY_SIZE(pages); 565d1bacf9eSBryan Schumaker 566d1bacf9eSBryan Schumaker entry.prev_cookie = 0; 5670aded708STrond Myklebust entry.cookie = desc->last_cookie; 568d1bacf9eSBryan Schumaker entry.eof = 0; 569d1bacf9eSBryan Schumaker entry.fh = nfs_alloc_fhandle(); 570d1bacf9eSBryan Schumaker entry.fattr = nfs_alloc_fattr(); 571573c4e1eSChuck Lever entry.server = NFS_SERVER(inode); 572d1bacf9eSBryan Schumaker if (entry.fh == NULL || entry.fattr == NULL) 573d1bacf9eSBryan Schumaker goto out; 574d1bacf9eSBryan Schumaker 575d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(page); 5768cd51a0cSTrond Myklebust if (IS_ERR(array)) { 5778cd51a0cSTrond Myklebust status = PTR_ERR(array); 5788cd51a0cSTrond Myklebust goto out; 5798cd51a0cSTrond Myklebust } 580d1bacf9eSBryan Schumaker memset(array, 0, sizeof(struct nfs_cache_array)); 581d1bacf9eSBryan Schumaker array->eof_index = -1; 582d1bacf9eSBryan Schumaker 58356e4ebf8SBryan Schumaker pages_ptr = nfs_readdir_large_page(pages, array_size); 58456e4ebf8SBryan Schumaker if (!pages_ptr) 585d1bacf9eSBryan Schumaker goto out_release_array; 586d1bacf9eSBryan Schumaker do { 587ac396128STrond Myklebust unsigned int pglen; 58856e4ebf8SBryan Schumaker status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode); 589babddc72SBryan Schumaker 590d1bacf9eSBryan Schumaker if (status < 0) 591d1bacf9eSBryan Schumaker break; 592ac396128STrond Myklebust pglen = status; 593ac396128STrond Myklebust status = nfs_readdir_page_filler(desc, &entry, pages_ptr, page, pglen); 5948cd51a0cSTrond Myklebust if (status < 0) { 5958cd51a0cSTrond Myklebust if (status == -ENOSPC) 5968cd51a0cSTrond Myklebust status = 0; 5978cd51a0cSTrond Myklebust break; 5988cd51a0cSTrond Myklebust } 5998cd51a0cSTrond Myklebust } while (array->eof_index < 0); 600d1bacf9eSBryan Schumaker 60156e4ebf8SBryan Schumaker nfs_readdir_free_large_page(pages_ptr, pages, array_size); 602d1bacf9eSBryan Schumaker out_release_array: 603d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 604d1bacf9eSBryan Schumaker out: 605d1bacf9eSBryan Schumaker nfs_free_fattr(entry.fattr); 606d1bacf9eSBryan Schumaker nfs_free_fhandle(entry.fh); 607d1bacf9eSBryan Schumaker return status; 608d1bacf9eSBryan Schumaker } 609d1bacf9eSBryan Schumaker 610d1bacf9eSBryan Schumaker /* 611d1bacf9eSBryan Schumaker * Now we cache directories properly, by converting xdr information 612d1bacf9eSBryan Schumaker * to an array that can be used for lookups later. This results in 613d1bacf9eSBryan Schumaker * fewer cache pages, since we can store more information on each page. 614d1bacf9eSBryan Schumaker * We only need to convert from xdr once so future lookups are much simpler 6151da177e4SLinus Torvalds */ 616d1bacf9eSBryan Schumaker static 617d1bacf9eSBryan Schumaker int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 618d1bacf9eSBryan Schumaker { 619d1bacf9eSBryan Schumaker struct inode *inode = desc->file->f_path.dentry->d_inode; 6208cd51a0cSTrond Myklebust int ret; 621d1bacf9eSBryan Schumaker 6228cd51a0cSTrond Myklebust ret = nfs_readdir_xdr_to_array(desc, page, inode); 6238cd51a0cSTrond Myklebust if (ret < 0) 624d1bacf9eSBryan Schumaker goto error; 625d1bacf9eSBryan Schumaker SetPageUptodate(page); 626d1bacf9eSBryan Schumaker 6272aac05a9STrond Myklebust if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 628cd9ae2b6STrond Myklebust /* Should never happen */ 629cd9ae2b6STrond Myklebust nfs_zap_mapping(inode, inode->i_mapping); 630cd9ae2b6STrond Myklebust } 6311da177e4SLinus Torvalds unlock_page(page); 6321da177e4SLinus Torvalds return 0; 6331da177e4SLinus Torvalds error: 6341da177e4SLinus Torvalds unlock_page(page); 6358cd51a0cSTrond Myklebust return ret; 6361da177e4SLinus Torvalds } 6371da177e4SLinus Torvalds 638d1bacf9eSBryan Schumaker static 639d1bacf9eSBryan Schumaker void cache_page_release(nfs_readdir_descriptor_t *desc) 6401da177e4SLinus Torvalds { 64111de3b11STrond Myklebust if (!desc->page->mapping) 64211de3b11STrond Myklebust nfs_readdir_clear_array(desc->page); 6431da177e4SLinus Torvalds page_cache_release(desc->page); 6441da177e4SLinus Torvalds desc->page = NULL; 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds 647d1bacf9eSBryan Schumaker static 648d1bacf9eSBryan Schumaker struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 6491da177e4SLinus Torvalds { 6508cd51a0cSTrond Myklebust return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping, 651d1bacf9eSBryan Schumaker desc->page_index, (filler_t *)nfs_readdir_filler, desc); 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds /* 655d1bacf9eSBryan Schumaker * Returns 0 if desc->dir_cookie was found on page desc->page_index 6561da177e4SLinus Torvalds */ 657d1bacf9eSBryan Schumaker static 658d1bacf9eSBryan Schumaker int find_cache_page(nfs_readdir_descriptor_t *desc) 659d1bacf9eSBryan Schumaker { 660d1bacf9eSBryan Schumaker int res; 661d1bacf9eSBryan Schumaker 662d1bacf9eSBryan Schumaker desc->page = get_cache_page(desc); 663d1bacf9eSBryan Schumaker if (IS_ERR(desc->page)) 664d1bacf9eSBryan Schumaker return PTR_ERR(desc->page); 665d1bacf9eSBryan Schumaker 666d1bacf9eSBryan Schumaker res = nfs_readdir_search_array(desc); 66747c716cbSTrond Myklebust if (res != 0) 668d1bacf9eSBryan Schumaker cache_page_release(desc); 669d1bacf9eSBryan Schumaker return res; 670d1bacf9eSBryan Schumaker } 671d1bacf9eSBryan Schumaker 672d1bacf9eSBryan Schumaker /* Search for desc->dir_cookie from the beginning of the page cache */ 6731da177e4SLinus Torvalds static inline 6741da177e4SLinus Torvalds int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 6751da177e4SLinus Torvalds { 6768cd51a0cSTrond Myklebust int res; 677d1bacf9eSBryan Schumaker 6780aded708STrond Myklebust if (desc->page_index == 0) { 6798cd51a0cSTrond Myklebust desc->current_index = 0; 6800aded708STrond Myklebust desc->last_cookie = 0; 6810aded708STrond Myklebust } 68247c716cbSTrond Myklebust do { 683d1bacf9eSBryan Schumaker res = find_cache_page(desc); 68447c716cbSTrond Myklebust } while (res == -EAGAIN); 6851da177e4SLinus Torvalds return res; 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds /* 6891da177e4SLinus Torvalds * Once we've found the start of the dirent within a page: fill 'er up... 6901da177e4SLinus Torvalds */ 6911da177e4SLinus Torvalds static 6921da177e4SLinus Torvalds int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent, 6931da177e4SLinus Torvalds filldir_t filldir) 6941da177e4SLinus Torvalds { 6951da177e4SLinus Torvalds struct file *file = desc->file; 696d1bacf9eSBryan Schumaker int i = 0; 697d1bacf9eSBryan Schumaker int res = 0; 698d1bacf9eSBryan Schumaker struct nfs_cache_array *array = NULL; 6991da177e4SLinus Torvalds 700d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 701e7c58e97STrond Myklebust if (IS_ERR(array)) { 702e7c58e97STrond Myklebust res = PTR_ERR(array); 703e7c58e97STrond Myklebust goto out; 704e7c58e97STrond Myklebust } 7051da177e4SLinus Torvalds 706d1bacf9eSBryan Schumaker for (i = desc->cache_entry_index; i < array->size; i++) { 707ece0b423STrond Myklebust struct nfs_cache_array_entry *ent; 7081da177e4SLinus Torvalds 709ece0b423STrond Myklebust ent = &array->array[i]; 710ece0b423STrond Myklebust if (filldir(dirent, ent->string.name, ent->string.len, 7110b26a0bfSTrond Myklebust file->f_pos, nfs_compat_user_ino64(ent->ino), 7120b26a0bfSTrond Myklebust ent->d_type) < 0) { 713ece0b423STrond Myklebust desc->eof = 1; 7141da177e4SLinus Torvalds break; 715ece0b423STrond Myklebust } 71600a92642SOlivier Galibert file->f_pos++; 717d1bacf9eSBryan Schumaker if (i < (array->size-1)) 718d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[i+1].cookie; 719d1bacf9eSBryan Schumaker else 720d1bacf9eSBryan Schumaker *desc->dir_cookie = array->last_cookie; 7218cd51a0cSTrond Myklebust } 72247c716cbSTrond Myklebust if (array->eof_index >= 0) 723d1bacf9eSBryan Schumaker desc->eof = 1; 724d1bacf9eSBryan Schumaker 725d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 726e7c58e97STrond Myklebust out: 727d1bacf9eSBryan Schumaker cache_page_release(desc); 7281e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 7291e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie, res); 7301da177e4SLinus Torvalds return res; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds /* 7341da177e4SLinus Torvalds * If we cannot find a cookie in our cache, we suspect that this is 7351da177e4SLinus Torvalds * because it points to a deleted file, so we ask the server to return 7361da177e4SLinus Torvalds * whatever it thinks is the next entry. We then feed this to filldir. 7371da177e4SLinus Torvalds * If all goes well, we should then be able to find our way round the 7381da177e4SLinus Torvalds * cache on the next call to readdir_search_pagecache(); 7391da177e4SLinus Torvalds * 7401da177e4SLinus Torvalds * NOTE: we cannot add the anonymous page to the pagecache because 7411da177e4SLinus Torvalds * the data it contains might not be page aligned. Besides, 7421da177e4SLinus Torvalds * we should already have a complete representation of the 7431da177e4SLinus Torvalds * directory in the page cache by the time we get here. 7441da177e4SLinus Torvalds */ 7451da177e4SLinus Torvalds static inline 7461da177e4SLinus Torvalds int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent, 7471da177e4SLinus Torvalds filldir_t filldir) 7481da177e4SLinus Torvalds { 7491da177e4SLinus Torvalds struct page *page = NULL; 7501da177e4SLinus Torvalds int status; 751d1bacf9eSBryan Schumaker struct inode *inode = desc->file->f_path.dentry->d_inode; 7521da177e4SLinus Torvalds 7531e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 7541e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie); 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds page = alloc_page(GFP_HIGHUSER); 7571da177e4SLinus Torvalds if (!page) { 7581da177e4SLinus Torvalds status = -ENOMEM; 7591da177e4SLinus Torvalds goto out; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7627a8e1dc3STrond Myklebust desc->page_index = 0; 7630aded708STrond Myklebust desc->last_cookie = *desc->dir_cookie; 7647a8e1dc3STrond Myklebust desc->page = page; 7657a8e1dc3STrond Myklebust 76685f8607eSTrond Myklebust status = nfs_readdir_xdr_to_array(desc, page, inode); 76785f8607eSTrond Myklebust if (status < 0) 768d1bacf9eSBryan Schumaker goto out_release; 769d1bacf9eSBryan Schumaker 7701da177e4SLinus Torvalds status = nfs_do_filldir(desc, dirent, filldir); 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds out: 7731e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 7743110ff80SHarvey Harrison __func__, status); 7751da177e4SLinus Torvalds return status; 7761da177e4SLinus Torvalds out_release: 777d1bacf9eSBryan Schumaker cache_page_release(desc); 7781da177e4SLinus Torvalds goto out; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 78100a92642SOlivier Galibert /* The file offset position represents the dirent entry number. A 78200a92642SOlivier Galibert last cookie cache takes care of the common case of reading the 78300a92642SOlivier Galibert whole directory. 7841da177e4SLinus Torvalds */ 7851da177e4SLinus Torvalds static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 7861da177e4SLinus Torvalds { 78701cce933SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 7881da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 7891da177e4SLinus Torvalds nfs_readdir_descriptor_t my_desc, 7901da177e4SLinus Torvalds *desc = &my_desc; 79147c716cbSTrond Myklebust int res; 7921da177e4SLinus Torvalds 7936da24bc9SChuck Lever dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n", 7941e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 7951e7cb3dcSChuck Lever (long long)filp->f_pos); 79691d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 79791d5b470SChuck Lever 7981da177e4SLinus Torvalds /* 79900a92642SOlivier Galibert * filp->f_pos points to the dirent entry number. 800f0dd2136STrond Myklebust * *desc->dir_cookie has the cookie for the next entry. We have 80100a92642SOlivier Galibert * to either find the entry with the appropriate number or 80200a92642SOlivier Galibert * revalidate the cookie. 8031da177e4SLinus Torvalds */ 8041da177e4SLinus Torvalds memset(desc, 0, sizeof(*desc)); 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds desc->file = filp; 807cd3758e3STrond Myklebust desc->dir_cookie = &nfs_file_open_context(filp)->dir_cookie; 8081da177e4SLinus Torvalds desc->decode = NFS_PROTO(inode)->decode_dirent; 8091da177e4SLinus Torvalds desc->plus = NFS_USE_READDIRPLUS(inode); 8101da177e4SLinus Torvalds 811565277f6STrond Myklebust nfs_block_sillyrename(dentry); 8121cda707dSTrond Myklebust res = nfs_revalidate_mapping(inode, filp->f_mapping); 813fccca7fcSTrond Myklebust if (res < 0) 814fccca7fcSTrond Myklebust goto out; 815fccca7fcSTrond Myklebust 81647c716cbSTrond Myklebust do { 8171da177e4SLinus Torvalds res = readdir_search_pagecache(desc); 81800a92642SOlivier Galibert 8191da177e4SLinus Torvalds if (res == -EBADCOOKIE) { 820ece0b423STrond Myklebust res = 0; 8211da177e4SLinus Torvalds /* This means either end of directory */ 822d1bacf9eSBryan Schumaker if (*desc->dir_cookie && desc->eof == 0) { 8231da177e4SLinus Torvalds /* Or that the server has 'lost' a cookie */ 8241da177e4SLinus Torvalds res = uncached_readdir(desc, dirent, filldir); 825ece0b423STrond Myklebust if (res == 0) 8261da177e4SLinus Torvalds continue; 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds break; 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds if (res == -ETOOSMALL && desc->plus) { 8313a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 8321da177e4SLinus Torvalds nfs_zap_caches(inode); 833baf57a09STrond Myklebust desc->page_index = 0; 8341da177e4SLinus Torvalds desc->plus = 0; 835d1bacf9eSBryan Schumaker desc->eof = 0; 8361da177e4SLinus Torvalds continue; 8371da177e4SLinus Torvalds } 8381da177e4SLinus Torvalds if (res < 0) 8391da177e4SLinus Torvalds break; 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds res = nfs_do_filldir(desc, dirent, filldir); 842ece0b423STrond Myklebust if (res < 0) 8431da177e4SLinus Torvalds break; 84447c716cbSTrond Myklebust } while (!desc->eof); 845fccca7fcSTrond Myklebust out: 846565277f6STrond Myklebust nfs_unblock_sillyrename(dentry); 8471e7cb3dcSChuck Lever if (res > 0) 8481e7cb3dcSChuck Lever res = 0; 849aa49b4cfSTrond Myklebust dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n", 8501e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 8511e7cb3dcSChuck Lever res); 8521da177e4SLinus Torvalds return res; 8531da177e4SLinus Torvalds } 8541da177e4SLinus Torvalds 85510afec90STrond Myklebust static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 856f0dd2136STrond Myklebust { 857b84e06c5SChuck Lever struct dentry *dentry = filp->f_path.dentry; 858b84e06c5SChuck Lever struct inode *inode = dentry->d_inode; 859b84e06c5SChuck Lever 8606da24bc9SChuck Lever dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n", 861b84e06c5SChuck Lever dentry->d_parent->d_name.name, 862b84e06c5SChuck Lever dentry->d_name.name, 863b84e06c5SChuck Lever offset, origin); 864b84e06c5SChuck Lever 865b84e06c5SChuck Lever mutex_lock(&inode->i_mutex); 866f0dd2136STrond Myklebust switch (origin) { 867f0dd2136STrond Myklebust case 1: 868f0dd2136STrond Myklebust offset += filp->f_pos; 869f0dd2136STrond Myklebust case 0: 870f0dd2136STrond Myklebust if (offset >= 0) 871f0dd2136STrond Myklebust break; 872f0dd2136STrond Myklebust default: 873f0dd2136STrond Myklebust offset = -EINVAL; 874f0dd2136STrond Myklebust goto out; 875f0dd2136STrond Myklebust } 876f0dd2136STrond Myklebust if (offset != filp->f_pos) { 877f0dd2136STrond Myklebust filp->f_pos = offset; 878cd3758e3STrond Myklebust nfs_file_open_context(filp)->dir_cookie = 0; 879f0dd2136STrond Myklebust } 880f0dd2136STrond Myklebust out: 881b84e06c5SChuck Lever mutex_unlock(&inode->i_mutex); 882f0dd2136STrond Myklebust return offset; 883f0dd2136STrond Myklebust } 884f0dd2136STrond Myklebust 8851da177e4SLinus Torvalds /* 8861da177e4SLinus Torvalds * All directory operations under NFS are synchronous, so fsync() 8871da177e4SLinus Torvalds * is a dummy operation. 8881da177e4SLinus Torvalds */ 8897ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *filp, int datasync) 8901da177e4SLinus Torvalds { 8917ea80859SChristoph Hellwig struct dentry *dentry = filp->f_path.dentry; 8927ea80859SChristoph Hellwig 8936da24bc9SChuck Lever dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n", 8941e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 8951e7cb3dcSChuck Lever datasync); 8961e7cb3dcSChuck Lever 89754917786SChuck Lever nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC); 8981da177e4SLinus Torvalds return 0; 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 901bfc69a45STrond Myklebust /** 902bfc69a45STrond Myklebust * nfs_force_lookup_revalidate - Mark the directory as having changed 903bfc69a45STrond Myklebust * @dir - pointer to directory inode 904bfc69a45STrond Myklebust * 905bfc69a45STrond Myklebust * This forces the revalidation code in nfs_lookup_revalidate() to do a 906bfc69a45STrond Myklebust * full lookup on all child dentries of 'dir' whenever a change occurs 907bfc69a45STrond Myklebust * on the server that might have invalidated our dcache. 908bfc69a45STrond Myklebust * 909bfc69a45STrond Myklebust * The caller should be holding dir->i_lock 910bfc69a45STrond Myklebust */ 911bfc69a45STrond Myklebust void nfs_force_lookup_revalidate(struct inode *dir) 912bfc69a45STrond Myklebust { 913011935a0STrond Myklebust NFS_I(dir)->cache_change_attribute++; 914bfc69a45STrond Myklebust } 915bfc69a45STrond Myklebust 9161da177e4SLinus Torvalds /* 9171da177e4SLinus Torvalds * A check for whether or not the parent directory has changed. 9181da177e4SLinus Torvalds * In the case it has, we assume that the dentries are untrustworthy 9191da177e4SLinus Torvalds * and may need to be looked up again. 9201da177e4SLinus Torvalds */ 921c79ba787STrond Myklebust static int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 9221da177e4SLinus Torvalds { 9231da177e4SLinus Torvalds if (IS_ROOT(dentry)) 9241da177e4SLinus Torvalds return 1; 9254eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 9264eec952eSTrond Myklebust return 0; 927f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 9286ecc5e8fSTrond Myklebust return 0; 929f2c77f4eSTrond Myklebust /* Revalidate nfsi->cache_change_attribute before we declare a match */ 930f2c77f4eSTrond Myklebust if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 931f2c77f4eSTrond Myklebust return 0; 932f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 933f2c77f4eSTrond Myklebust return 0; 934f2c77f4eSTrond Myklebust return 1; 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds 9371da177e4SLinus Torvalds /* 9381d6757fbSTrond Myklebust * Return the intent data that applies to this particular path component 9391d6757fbSTrond Myklebust * 9401d6757fbSTrond Myklebust * Note that the current set of intents only apply to the very last 9411d6757fbSTrond Myklebust * component of the path. 9421d6757fbSTrond Myklebust * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 9431d6757fbSTrond Myklebust */ 9441d6757fbSTrond Myklebust static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask) 9451d6757fbSTrond Myklebust { 9461d6757fbSTrond Myklebust if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 9471d6757fbSTrond Myklebust return 0; 9481d6757fbSTrond Myklebust return nd->flags & mask; 9491d6757fbSTrond Myklebust } 9501d6757fbSTrond Myklebust 9511d6757fbSTrond Myklebust /* 952a12802caSTrond Myklebust * Use intent information to check whether or not we're going to do 953a12802caSTrond Myklebust * an O_EXCL create using this path component. 954a12802caSTrond Myklebust */ 955a12802caSTrond Myklebust static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 956a12802caSTrond Myklebust { 957a12802caSTrond Myklebust if (NFS_PROTO(dir)->version == 2) 958a12802caSTrond Myklebust return 0; 9593516586aSAl Viro return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL); 960a12802caSTrond Myklebust } 961a12802caSTrond Myklebust 962a12802caSTrond Myklebust /* 9631d6757fbSTrond Myklebust * Inode and filehandle revalidation for lookups. 9641d6757fbSTrond Myklebust * 9651d6757fbSTrond Myklebust * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 9661d6757fbSTrond Myklebust * or if the intent information indicates that we're about to open this 9671d6757fbSTrond Myklebust * particular file and the "nocto" mount flag is not set. 9681d6757fbSTrond Myklebust * 9691d6757fbSTrond Myklebust */ 9701da177e4SLinus Torvalds static inline 9711da177e4SLinus Torvalds int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 9721da177e4SLinus Torvalds { 9731da177e4SLinus Torvalds struct nfs_server *server = NFS_SERVER(inode); 9741da177e4SLinus Torvalds 9754e99a1ffSTrond Myklebust if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags)) 9764e99a1ffSTrond Myklebust return 0; 9771da177e4SLinus Torvalds if (nd != NULL) { 9781da177e4SLinus Torvalds /* VFS wants an on-the-wire revalidation */ 9791d6757fbSTrond Myklebust if (nd->flags & LOOKUP_REVAL) 9801da177e4SLinus Torvalds goto out_force; 9811da177e4SLinus Torvalds /* This is an open(2) */ 9821d6757fbSTrond Myklebust if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 9834e0641a7STrond Myklebust !(server->flags & NFS_MOUNT_NOCTO) && 9844e0641a7STrond Myklebust (S_ISREG(inode->i_mode) || 9854e0641a7STrond Myklebust S_ISDIR(inode->i_mode))) 9861da177e4SLinus Torvalds goto out_force; 9874f48af45STrond Myklebust return 0; 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds return nfs_revalidate_inode(server, inode); 9901da177e4SLinus Torvalds out_force: 9911da177e4SLinus Torvalds return __nfs_revalidate_inode(server, inode); 9921da177e4SLinus Torvalds } 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds /* 9951da177e4SLinus Torvalds * We judge how long we want to trust negative 9961da177e4SLinus Torvalds * dentries by looking at the parent inode mtime. 9971da177e4SLinus Torvalds * 9981da177e4SLinus Torvalds * If parent mtime has changed, we revalidate, else we wait for a 9991da177e4SLinus Torvalds * period corresponding to the parent's attribute cache timeout value. 10001da177e4SLinus Torvalds */ 10011da177e4SLinus Torvalds static inline 10021da177e4SLinus Torvalds int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 10031da177e4SLinus Torvalds struct nameidata *nd) 10041da177e4SLinus Torvalds { 10051da177e4SLinus Torvalds /* Don't revalidate a negative dentry if we're creating a new file */ 10061d6757fbSTrond Myklebust if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 10071da177e4SLinus Torvalds return 0; 10084eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 10094eec952eSTrond Myklebust return 1; 10101da177e4SLinus Torvalds return !nfs_check_verifier(dir, dentry); 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds /* 10141da177e4SLinus Torvalds * This is called every time the dcache has a lookup hit, 10151da177e4SLinus Torvalds * and we should check whether we can really trust that 10161da177e4SLinus Torvalds * lookup. 10171da177e4SLinus Torvalds * 10181da177e4SLinus Torvalds * NOTE! The hit can be a negative hit too, don't assume 10191da177e4SLinus Torvalds * we have an inode! 10201da177e4SLinus Torvalds * 10211da177e4SLinus Torvalds * If the parent directory is seen to have changed, we throw out the 10221da177e4SLinus Torvalds * cached dentry and do a new lookup. 10231da177e4SLinus Torvalds */ 10241da177e4SLinus Torvalds static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd) 10251da177e4SLinus Torvalds { 10261da177e4SLinus Torvalds struct inode *dir; 10271da177e4SLinus Torvalds struct inode *inode; 10281da177e4SLinus Torvalds struct dentry *parent; 1029e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1030e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 10311da177e4SLinus Torvalds int error; 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds parent = dget_parent(dentry); 10341da177e4SLinus Torvalds dir = parent->d_inode; 103591d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 10361da177e4SLinus Torvalds inode = dentry->d_inode; 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds if (!inode) { 10391da177e4SLinus Torvalds if (nfs_neg_need_reval(dir, dentry, nd)) 10401da177e4SLinus Torvalds goto out_bad; 10411da177e4SLinus Torvalds goto out_valid; 10421da177e4SLinus Torvalds } 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds if (is_bad_inode(inode)) { 10451e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 10463110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 10471e7cb3dcSChuck Lever dentry->d_name.name); 10481da177e4SLinus Torvalds goto out_bad; 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds 105115860ab1STrond Myklebust if (nfs_have_delegation(inode, FMODE_READ)) 105215860ab1STrond Myklebust goto out_set_verifier; 105315860ab1STrond Myklebust 10541da177e4SLinus Torvalds /* Force a full look up iff the parent directory has changed */ 1055a12802caSTrond Myklebust if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) { 10561da177e4SLinus Torvalds if (nfs_lookup_verify_inode(inode, nd)) 10571da177e4SLinus Torvalds goto out_zap_parent; 10581da177e4SLinus Torvalds goto out_valid; 10591da177e4SLinus Torvalds } 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds if (NFS_STALE(inode)) 10621da177e4SLinus Torvalds goto out_bad; 10631da177e4SLinus Torvalds 1064e1fb4d05STrond Myklebust error = -ENOMEM; 1065e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1066e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1067e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1068e1fb4d05STrond Myklebust goto out_error; 1069e1fb4d05STrond Myklebust 1070e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 10711da177e4SLinus Torvalds if (error) 10721da177e4SLinus Torvalds goto out_bad; 1073e1fb4d05STrond Myklebust if (nfs_compare_fh(NFS_FH(inode), fhandle)) 10741da177e4SLinus Torvalds goto out_bad; 1075e1fb4d05STrond Myklebust if ((error = nfs_refresh_inode(inode, fattr)) != 0) 10761da177e4SLinus Torvalds goto out_bad; 10771da177e4SLinus Torvalds 1078e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1079e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 108015860ab1STrond Myklebust out_set_verifier: 1081cf8ba45eSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 10821da177e4SLinus Torvalds out_valid: 10831da177e4SLinus Torvalds dput(parent); 10841e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 10853110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 10861e7cb3dcSChuck Lever dentry->d_name.name); 10871da177e4SLinus Torvalds return 1; 10881da177e4SLinus Torvalds out_zap_parent: 10891da177e4SLinus Torvalds nfs_zap_caches(dir); 10901da177e4SLinus Torvalds out_bad: 1091a1643a92STrond Myklebust nfs_mark_for_revalidate(dir); 10921da177e4SLinus Torvalds if (inode && S_ISDIR(inode->i_mode)) { 10931da177e4SLinus Torvalds /* Purge readdir caches. */ 10941da177e4SLinus Torvalds nfs_zap_caches(inode); 10951da177e4SLinus Torvalds /* If we have submounts, don't unhash ! */ 10961da177e4SLinus Torvalds if (have_submounts(dentry)) 10971da177e4SLinus Torvalds goto out_valid; 1098d9e80b7dSAl Viro if (dentry->d_flags & DCACHE_DISCONNECTED) 1099d9e80b7dSAl Viro goto out_valid; 11001da177e4SLinus Torvalds shrink_dcache_parent(dentry); 11011da177e4SLinus Torvalds } 11021da177e4SLinus Torvalds d_drop(dentry); 1103e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1104e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 11051da177e4SLinus Torvalds dput(parent); 11061e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 11073110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 11081e7cb3dcSChuck Lever dentry->d_name.name); 11091da177e4SLinus Torvalds return 0; 1110e1fb4d05STrond Myklebust out_error: 1111e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1112e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 1113e1fb4d05STrond Myklebust dput(parent); 1114e1fb4d05STrond Myklebust dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n", 1115e1fb4d05STrond Myklebust __func__, dentry->d_parent->d_name.name, 1116e1fb4d05STrond Myklebust dentry->d_name.name, error); 1117e1fb4d05STrond Myklebust return error; 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds /* 11211da177e4SLinus Torvalds * This is called from dput() when d_count is going to 0. 11221da177e4SLinus Torvalds */ 11231da177e4SLinus Torvalds static int nfs_dentry_delete(struct dentry *dentry) 11241da177e4SLinus Torvalds { 11251da177e4SLinus Torvalds dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 11261da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 11271da177e4SLinus Torvalds dentry->d_flags); 11281da177e4SLinus Torvalds 112977f11192STrond Myklebust /* Unhash any dentry with a stale inode */ 113077f11192STrond Myklebust if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 113177f11192STrond Myklebust return 1; 113277f11192STrond Myklebust 11331da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 11341da177e4SLinus Torvalds /* Unhash it, so that ->d_iput() would be called */ 11351da177e4SLinus Torvalds return 1; 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 11381da177e4SLinus Torvalds /* Unhash it, so that ancestors of killed async unlink 11391da177e4SLinus Torvalds * files will be cleaned up during umount */ 11401da177e4SLinus Torvalds return 1; 11411da177e4SLinus Torvalds } 11421da177e4SLinus Torvalds return 0; 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds 11461b83d707STrond Myklebust static void nfs_drop_nlink(struct inode *inode) 11471b83d707STrond Myklebust { 11481b83d707STrond Myklebust spin_lock(&inode->i_lock); 11491b83d707STrond Myklebust if (inode->i_nlink > 0) 11501b83d707STrond Myklebust drop_nlink(inode); 11511b83d707STrond Myklebust spin_unlock(&inode->i_lock); 11521b83d707STrond Myklebust } 11531b83d707STrond Myklebust 11541da177e4SLinus Torvalds /* 11551da177e4SLinus Torvalds * Called when the dentry loses inode. 11561da177e4SLinus Torvalds * We use it to clean up silly-renamed files. 11571da177e4SLinus Torvalds */ 11581da177e4SLinus Torvalds static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 11591da177e4SLinus Torvalds { 116083672d39SNeil Brown if (S_ISDIR(inode->i_mode)) 116183672d39SNeil Brown /* drop any readdir cache as it could easily be old */ 116283672d39SNeil Brown NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 116383672d39SNeil Brown 11641da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 11659a53c3a7SDave Hansen drop_nlink(inode); 1166e4eff1a6STrond Myklebust nfs_complete_unlink(dentry, inode); 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds iput(inode); 11691da177e4SLinus Torvalds } 11701da177e4SLinus Torvalds 1171f786aa90SAl Viro const struct dentry_operations nfs_dentry_operations = { 11721da177e4SLinus Torvalds .d_revalidate = nfs_lookup_revalidate, 11731da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 11741da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 11751da177e4SLinus Torvalds }; 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 11781da177e4SLinus Torvalds { 11791da177e4SLinus Torvalds struct dentry *res; 1180565277f6STrond Myklebust struct dentry *parent; 11811da177e4SLinus Torvalds struct inode *inode = NULL; 1182e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1183e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 11841da177e4SLinus Torvalds int error; 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds dfprintk(VFS, "NFS: lookup(%s/%s)\n", 11871da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 118891d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 11911da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 11921da177e4SLinus Torvalds goto out; 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 11951da177e4SLinus Torvalds 1196fd684071STrond Myklebust /* 1197fd684071STrond Myklebust * If we're doing an exclusive create, optimize away the lookup 1198fd684071STrond Myklebust * but don't hash the dentry. 1199fd684071STrond Myklebust */ 1200fd684071STrond Myklebust if (nfs_is_exclusive_create(dir, nd)) { 1201fd684071STrond Myklebust d_instantiate(dentry, NULL); 1202fd684071STrond Myklebust res = NULL; 1203fc0f684cSTrond Myklebust goto out; 1204fd684071STrond Myklebust } 12051da177e4SLinus Torvalds 1206e1fb4d05STrond Myklebust res = ERR_PTR(-ENOMEM); 1207e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1208e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1209e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1210e1fb4d05STrond Myklebust goto out; 1211e1fb4d05STrond Myklebust 1212565277f6STrond Myklebust parent = dentry->d_parent; 1213565277f6STrond Myklebust /* Protect against concurrent sillydeletes */ 1214565277f6STrond Myklebust nfs_block_sillyrename(parent); 1215e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 12161da177e4SLinus Torvalds if (error == -ENOENT) 12171da177e4SLinus Torvalds goto no_entry; 12181da177e4SLinus Torvalds if (error < 0) { 12191da177e4SLinus Torvalds res = ERR_PTR(error); 1220565277f6STrond Myklebust goto out_unblock_sillyrename; 12211da177e4SLinus Torvalds } 1222e1fb4d05STrond Myklebust inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1223bf0c84f1SNamhyung Kim res = ERR_CAST(inode); 122403f28e3aSTrond Myklebust if (IS_ERR(res)) 1225565277f6STrond Myklebust goto out_unblock_sillyrename; 122654ceac45SDavid Howells 12271da177e4SLinus Torvalds no_entry: 122854ceac45SDavid Howells res = d_materialise_unique(dentry, inode); 12299eaef27bSTrond Myklebust if (res != NULL) { 12309eaef27bSTrond Myklebust if (IS_ERR(res)) 1231565277f6STrond Myklebust goto out_unblock_sillyrename; 12321da177e4SLinus Torvalds dentry = res; 12339eaef27bSTrond Myklebust } 12341da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1235565277f6STrond Myklebust out_unblock_sillyrename: 1236565277f6STrond Myklebust nfs_unblock_sillyrename(parent); 12371da177e4SLinus Torvalds out: 1238e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1239e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 12401da177e4SLinus Torvalds return res; 12411da177e4SLinus Torvalds } 12421da177e4SLinus Torvalds 12431da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 12441da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *, struct nameidata *); 12451da177e4SLinus Torvalds 1246f786aa90SAl Viro const struct dentry_operations nfs4_dentry_operations = { 12471da177e4SLinus Torvalds .d_revalidate = nfs_open_revalidate, 12481da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 12491da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 12501da177e4SLinus Torvalds }; 12511da177e4SLinus Torvalds 12521d6757fbSTrond Myklebust /* 12531d6757fbSTrond Myklebust * Use intent information to determine whether we need to substitute 12541d6757fbSTrond Myklebust * the NFSv4-style stateful OPEN for the LOOKUP call 12551d6757fbSTrond Myklebust */ 12565584c306STrond Myklebust static int is_atomic_open(struct nameidata *nd) 12571da177e4SLinus Torvalds { 12581d6757fbSTrond Myklebust if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 12591da177e4SLinus Torvalds return 0; 12601da177e4SLinus Torvalds /* NFS does not (yet) have a stateful open for directories */ 12611da177e4SLinus Torvalds if (nd->flags & LOOKUP_DIRECTORY) 12621da177e4SLinus Torvalds return 0; 12631da177e4SLinus Torvalds /* Are we trying to write to a read only partition? */ 12642c463e95SDave Hansen if (__mnt_is_readonly(nd->path.mnt) && 12652c463e95SDave Hansen (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 12661da177e4SLinus Torvalds return 0; 12671da177e4SLinus Torvalds return 1; 12681da177e4SLinus Torvalds } 12691da177e4SLinus Torvalds 1270cd9a1c0eSTrond Myklebust static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd) 1271cd9a1c0eSTrond Myklebust { 1272cd9a1c0eSTrond Myklebust struct path path = { 1273cd9a1c0eSTrond Myklebust .mnt = nd->path.mnt, 1274cd9a1c0eSTrond Myklebust .dentry = dentry, 1275cd9a1c0eSTrond Myklebust }; 1276cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1277cd9a1c0eSTrond Myklebust struct rpc_cred *cred; 1278cd9a1c0eSTrond Myklebust fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1279cd9a1c0eSTrond Myklebust 1280cd9a1c0eSTrond Myklebust cred = rpc_lookup_cred(); 1281cd9a1c0eSTrond Myklebust if (IS_ERR(cred)) 1282cd9a1c0eSTrond Myklebust return ERR_CAST(cred); 1283cd9a1c0eSTrond Myklebust ctx = alloc_nfs_open_context(&path, cred, fmode); 1284cd9a1c0eSTrond Myklebust put_rpccred(cred); 1285cd9a1c0eSTrond Myklebust if (ctx == NULL) 1286cd9a1c0eSTrond Myklebust return ERR_PTR(-ENOMEM); 1287cd9a1c0eSTrond Myklebust return ctx; 1288cd9a1c0eSTrond Myklebust } 1289cd9a1c0eSTrond Myklebust 1290cd9a1c0eSTrond Myklebust static int do_open(struct inode *inode, struct file *filp) 1291cd9a1c0eSTrond Myklebust { 1292cd9a1c0eSTrond Myklebust nfs_fscache_set_inode_cookie(inode, filp); 1293cd9a1c0eSTrond Myklebust return 0; 1294cd9a1c0eSTrond Myklebust } 1295cd9a1c0eSTrond Myklebust 1296cd9a1c0eSTrond Myklebust static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx) 1297cd9a1c0eSTrond Myklebust { 1298cd9a1c0eSTrond Myklebust struct file *filp; 1299cd9a1c0eSTrond Myklebust int ret = 0; 1300cd9a1c0eSTrond Myklebust 1301cd9a1c0eSTrond Myklebust /* If the open_intent is for execute, we have an extra check to make */ 1302cd9a1c0eSTrond Myklebust if (ctx->mode & FMODE_EXEC) { 1303cd9a1c0eSTrond Myklebust ret = nfs_may_open(ctx->path.dentry->d_inode, 1304cd9a1c0eSTrond Myklebust ctx->cred, 1305cd9a1c0eSTrond Myklebust nd->intent.open.flags); 1306cd9a1c0eSTrond Myklebust if (ret < 0) 1307cd9a1c0eSTrond Myklebust goto out; 1308cd9a1c0eSTrond Myklebust } 1309cd9a1c0eSTrond Myklebust filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open); 1310cd9a1c0eSTrond Myklebust if (IS_ERR(filp)) 1311cd9a1c0eSTrond Myklebust ret = PTR_ERR(filp); 1312cd9a1c0eSTrond Myklebust else 1313cd9a1c0eSTrond Myklebust nfs_file_set_open_context(filp, ctx); 1314cd9a1c0eSTrond Myklebust out: 1315cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1316cd9a1c0eSTrond Myklebust return ret; 1317cd9a1c0eSTrond Myklebust } 1318cd9a1c0eSTrond Myklebust 13191da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 13201da177e4SLinus Torvalds { 1321cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1322cd9a1c0eSTrond Myklebust struct iattr attr; 13231da177e4SLinus Torvalds struct dentry *res = NULL; 1324f46e0bd3STrond Myklebust struct inode *inode; 1325cd9a1c0eSTrond Myklebust int open_flags; 1326898f635cSTrond Myklebust int err; 13271da177e4SLinus Torvalds 13281e7cb3dcSChuck Lever dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 13291e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 13301e7cb3dcSChuck Lever 13311da177e4SLinus Torvalds /* Check that we are indeed trying to open this file */ 13325584c306STrond Myklebust if (!is_atomic_open(nd)) 13331da177e4SLinus Torvalds goto no_open; 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 13361da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 13371da177e4SLinus Torvalds goto out; 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 13401da177e4SLinus Torvalds 1341d4d9cdcbSTrond Myklebust /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1342d4d9cdcbSTrond Myklebust * the dentry. */ 13433516586aSAl Viro if (nd->flags & LOOKUP_EXCL) { 1344d4d9cdcbSTrond Myklebust d_instantiate(dentry, NULL); 134502a913a7STrond Myklebust goto out; 134602a913a7STrond Myklebust } 13471da177e4SLinus Torvalds 1348cd9a1c0eSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1349cd9a1c0eSTrond Myklebust res = ERR_CAST(ctx); 1350cd9a1c0eSTrond Myklebust if (IS_ERR(ctx)) 1351cd9a1c0eSTrond Myklebust goto out; 1352cd9a1c0eSTrond Myklebust 1353cd9a1c0eSTrond Myklebust open_flags = nd->intent.open.flags; 1354cd9a1c0eSTrond Myklebust if (nd->flags & LOOKUP_CREATE) { 1355cd9a1c0eSTrond Myklebust attr.ia_mode = nd->intent.open.create_mode; 1356cd9a1c0eSTrond Myklebust attr.ia_valid = ATTR_MODE; 1357cd9a1c0eSTrond Myklebust attr.ia_mode &= ~current_umask(); 1358cd9a1c0eSTrond Myklebust } else { 1359898f635cSTrond Myklebust open_flags &= ~(O_EXCL | O_CREAT); 1360cd9a1c0eSTrond Myklebust attr.ia_valid = 0; 1361cd9a1c0eSTrond Myklebust } 1362cd9a1c0eSTrond Myklebust 13631da177e4SLinus Torvalds /* Open the file on the server */ 1364f46e0bd3STrond Myklebust nfs_block_sillyrename(dentry->d_parent); 13652b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1366f46e0bd3STrond Myklebust if (IS_ERR(inode)) { 1367f46e0bd3STrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1368cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1369f46e0bd3STrond Myklebust switch (PTR_ERR(inode)) { 13701da177e4SLinus Torvalds /* Make a negative dentry */ 13711da177e4SLinus Torvalds case -ENOENT: 1372f46e0bd3STrond Myklebust d_add(dentry, NULL); 137302a913a7STrond Myklebust res = NULL; 137402a913a7STrond Myklebust goto out; 13751da177e4SLinus Torvalds /* This turned out not to be a regular file */ 13766f926b5bSTrond Myklebust case -ENOTDIR: 13776f926b5bSTrond Myklebust goto no_open; 13781da177e4SLinus Torvalds case -ELOOP: 13791da177e4SLinus Torvalds if (!(nd->intent.open.flags & O_NOFOLLOW)) 13801da177e4SLinus Torvalds goto no_open; 138123ebbd9aSTrond Myklebust /* case -EISDIR: */ 13821da177e4SLinus Torvalds /* case -EINVAL: */ 13831da177e4SLinus Torvalds default: 1384f46e0bd3STrond Myklebust res = ERR_CAST(inode); 13851da177e4SLinus Torvalds goto out; 13861da177e4SLinus Torvalds } 1387cd9a1c0eSTrond Myklebust } 1388f46e0bd3STrond Myklebust res = d_add_unique(dentry, inode); 1389898f635cSTrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1390f46e0bd3STrond Myklebust if (res != NULL) { 1391f46e0bd3STrond Myklebust dput(ctx->path.dentry); 1392f46e0bd3STrond Myklebust ctx->path.dentry = dget(res); 13931da177e4SLinus Torvalds dentry = res; 1394f46e0bd3STrond Myklebust } 1395898f635cSTrond Myklebust err = nfs_intent_set_file(nd, ctx); 1396898f635cSTrond Myklebust if (err < 0) { 1397898f635cSTrond Myklebust if (res != NULL) 1398898f635cSTrond Myklebust dput(res); 1399898f635cSTrond Myklebust return ERR_PTR(err); 1400898f635cSTrond Myklebust } 14011da177e4SLinus Torvalds out: 1402f46e0bd3STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 14031da177e4SLinus Torvalds return res; 14041da177e4SLinus Torvalds no_open: 14051da177e4SLinus Torvalds return nfs_lookup(dir, dentry, nd); 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 14091da177e4SLinus Torvalds { 14101da177e4SLinus Torvalds struct dentry *parent = NULL; 14111da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14121da177e4SLinus Torvalds struct inode *dir; 1413b8d4caddSTrond Myklebust struct nfs_open_context *ctx; 14141da177e4SLinus Torvalds int openflags, ret = 0; 14151da177e4SLinus Torvalds 14161f063d2cSTrond Myklebust if (!is_atomic_open(nd) || d_mountpoint(dentry)) 14175584c306STrond Myklebust goto no_open; 14182b484297STrond Myklebust 14191da177e4SLinus Torvalds parent = dget_parent(dentry); 14201da177e4SLinus Torvalds dir = parent->d_inode; 14212b484297STrond Myklebust 14221da177e4SLinus Torvalds /* We can't create new files in nfs_open_revalidate(), so we 14231da177e4SLinus Torvalds * optimize away revalidation of negative dentries. 14241da177e4SLinus Torvalds */ 1425216d5d06STrond Myklebust if (inode == NULL) { 1426216d5d06STrond Myklebust if (!nfs_neg_need_reval(dir, dentry, nd)) 1427216d5d06STrond Myklebust ret = 1; 14281da177e4SLinus Torvalds goto out; 1429216d5d06STrond Myklebust } 1430216d5d06STrond Myklebust 14311da177e4SLinus Torvalds /* NFS only supports OPEN on regular files */ 14321da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 14335584c306STrond Myklebust goto no_open_dput; 14341da177e4SLinus Torvalds openflags = nd->intent.open.flags; 14351da177e4SLinus Torvalds /* We cannot do exclusive creation on a positive dentry */ 14361da177e4SLinus Torvalds if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 14375584c306STrond Myklebust goto no_open_dput; 14381da177e4SLinus Torvalds /* We can't create new files, or truncate existing ones here */ 14390a377cffSTrond Myklebust openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 14401da177e4SLinus Torvalds 1441b8d4caddSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1442b8d4caddSTrond Myklebust ret = PTR_ERR(ctx); 1443b8d4caddSTrond Myklebust if (IS_ERR(ctx)) 1444b8d4caddSTrond Myklebust goto out; 14451da177e4SLinus Torvalds /* 14461b1dcc1bSJes Sorensen * Note: we're not holding inode->i_mutex and so may be racing with 14471da177e4SLinus Torvalds * operations that change the directory. We therefore save the 14481da177e4SLinus Torvalds * change attribute *before* we do the RPC call. 14491da177e4SLinus Torvalds */ 14502b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1451535918f1STrond Myklebust if (IS_ERR(inode)) { 1452535918f1STrond Myklebust ret = PTR_ERR(inode); 1453535918f1STrond Myklebust switch (ret) { 1454535918f1STrond Myklebust case -EPERM: 1455535918f1STrond Myklebust case -EACCES: 1456535918f1STrond Myklebust case -EDQUOT: 1457535918f1STrond Myklebust case -ENOSPC: 1458535918f1STrond Myklebust case -EROFS: 1459535918f1STrond Myklebust goto out_put_ctx; 1460535918f1STrond Myklebust default: 1461535918f1STrond Myklebust goto out_drop; 1462535918f1STrond Myklebust } 1463535918f1STrond Myklebust } 1464535918f1STrond Myklebust iput(inode); 1465898f635cSTrond Myklebust if (inode != dentry->d_inode) 1466535918f1STrond Myklebust goto out_drop; 1467898f635cSTrond Myklebust 1468898f635cSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1469898f635cSTrond Myklebust ret = nfs_intent_set_file(nd, ctx); 1470898f635cSTrond Myklebust if (ret >= 0) 1471898f635cSTrond Myklebust ret = 1; 14721da177e4SLinus Torvalds out: 14731da177e4SLinus Torvalds dput(parent); 14741da177e4SLinus Torvalds return ret; 1475535918f1STrond Myklebust out_drop: 1476535918f1STrond Myklebust d_drop(dentry); 1477535918f1STrond Myklebust ret = 0; 1478535918f1STrond Myklebust out_put_ctx: 1479535918f1STrond Myklebust put_nfs_open_context(ctx); 1480535918f1STrond Myklebust goto out; 1481535918f1STrond Myklebust 14825584c306STrond Myklebust no_open_dput: 14831da177e4SLinus Torvalds dput(parent); 14845584c306STrond Myklebust no_open: 14851da177e4SLinus Torvalds return nfs_lookup_revalidate(dentry, nd); 14861da177e4SLinus Torvalds } 1487c0204fd2STrond Myklebust 1488c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1489c0204fd2STrond Myklebust struct nameidata *nd) 1490c0204fd2STrond Myklebust { 1491c0204fd2STrond Myklebust struct nfs_open_context *ctx = NULL; 1492c0204fd2STrond Myklebust struct iattr attr; 1493c0204fd2STrond Myklebust int error; 1494c0204fd2STrond Myklebust int open_flags = 0; 1495c0204fd2STrond Myklebust 1496c0204fd2STrond Myklebust dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1497c0204fd2STrond Myklebust dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1498c0204fd2STrond Myklebust 1499c0204fd2STrond Myklebust attr.ia_mode = mode; 1500c0204fd2STrond Myklebust attr.ia_valid = ATTR_MODE; 1501c0204fd2STrond Myklebust 1502c0204fd2STrond Myklebust if ((nd->flags & LOOKUP_CREATE) != 0) { 1503c0204fd2STrond Myklebust open_flags = nd->intent.open.flags; 1504c0204fd2STrond Myklebust 1505c0204fd2STrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1506c0204fd2STrond Myklebust error = PTR_ERR(ctx); 1507c0204fd2STrond Myklebust if (IS_ERR(ctx)) 1508898f635cSTrond Myklebust goto out_err_drop; 1509c0204fd2STrond Myklebust } 1510c0204fd2STrond Myklebust 1511c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1512c0204fd2STrond Myklebust if (error != 0) 1513c0204fd2STrond Myklebust goto out_put_ctx; 1514898f635cSTrond Myklebust if (ctx != NULL) { 1515898f635cSTrond Myklebust error = nfs_intent_set_file(nd, ctx); 1516898f635cSTrond Myklebust if (error < 0) 1517898f635cSTrond Myklebust goto out_err; 1518898f635cSTrond Myklebust } 1519c0204fd2STrond Myklebust return 0; 1520c0204fd2STrond Myklebust out_put_ctx: 1521c0204fd2STrond Myklebust if (ctx != NULL) 1522c0204fd2STrond Myklebust put_nfs_open_context(ctx); 1523898f635cSTrond Myklebust out_err_drop: 1524c0204fd2STrond Myklebust d_drop(dentry); 1525898f635cSTrond Myklebust out_err: 1526c0204fd2STrond Myklebust return error; 1527c0204fd2STrond Myklebust } 1528c0204fd2STrond Myklebust 15291da177e4SLinus Torvalds #endif /* CONFIG_NFSV4 */ 15301da177e4SLinus Torvalds 15311da177e4SLinus Torvalds /* 15321da177e4SLinus Torvalds * Code common to create, mkdir, and mknod. 15331da177e4SLinus Torvalds */ 15341da177e4SLinus Torvalds int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 15351da177e4SLinus Torvalds struct nfs_fattr *fattr) 15361da177e4SLinus Torvalds { 1537fab728e1STrond Myklebust struct dentry *parent = dget_parent(dentry); 1538fab728e1STrond Myklebust struct inode *dir = parent->d_inode; 15391da177e4SLinus Torvalds struct inode *inode; 15401da177e4SLinus Torvalds int error = -EACCES; 15411da177e4SLinus Torvalds 1542fab728e1STrond Myklebust d_drop(dentry); 1543fab728e1STrond Myklebust 15441da177e4SLinus Torvalds /* We may have been initialized further down */ 15451da177e4SLinus Torvalds if (dentry->d_inode) 1546fab728e1STrond Myklebust goto out; 15471da177e4SLinus Torvalds if (fhandle->size == 0) { 15481da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 15491da177e4SLinus Torvalds if (error) 1550fab728e1STrond Myklebust goto out_error; 15511da177e4SLinus Torvalds } 15525724ab37STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 15531da177e4SLinus Torvalds if (!(fattr->valid & NFS_ATTR_FATTR)) { 15541da177e4SLinus Torvalds struct nfs_server *server = NFS_SB(dentry->d_sb); 15558fa5c000SDavid Howells error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 15561da177e4SLinus Torvalds if (error < 0) 1557fab728e1STrond Myklebust goto out_error; 15581da177e4SLinus Torvalds } 15591da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 156003f28e3aSTrond Myklebust error = PTR_ERR(inode); 156103f28e3aSTrond Myklebust if (IS_ERR(inode)) 1562fab728e1STrond Myklebust goto out_error; 1563fab728e1STrond Myklebust d_add(dentry, inode); 1564fab728e1STrond Myklebust out: 1565fab728e1STrond Myklebust dput(parent); 15661da177e4SLinus Torvalds return 0; 1567fab728e1STrond Myklebust out_error: 1568fab728e1STrond Myklebust nfs_mark_for_revalidate(dir); 1569fab728e1STrond Myklebust dput(parent); 1570fab728e1STrond Myklebust return error; 15711da177e4SLinus Torvalds } 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds /* 15741da177e4SLinus Torvalds * Following a failed create operation, we drop the dentry rather 15751da177e4SLinus Torvalds * than retain a negative dentry. This avoids a problem in the event 15761da177e4SLinus Torvalds * that the operation succeeded on the server, but an error in the 15771da177e4SLinus Torvalds * reply path made it appear to have failed. 15781da177e4SLinus Torvalds */ 15791da177e4SLinus Torvalds static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 15801da177e4SLinus Torvalds struct nameidata *nd) 15811da177e4SLinus Torvalds { 15821da177e4SLinus Torvalds struct iattr attr; 15831da177e4SLinus Torvalds int error; 15841da177e4SLinus Torvalds 15851e7cb3dcSChuck Lever dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 15861e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 15871da177e4SLinus Torvalds 15881da177e4SLinus Torvalds attr.ia_mode = mode; 15891da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 15901da177e4SLinus Torvalds 1591c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL); 15921da177e4SLinus Torvalds if (error != 0) 15931da177e4SLinus Torvalds goto out_err; 15941da177e4SLinus Torvalds return 0; 15951da177e4SLinus Torvalds out_err: 15961da177e4SLinus Torvalds d_drop(dentry); 15971da177e4SLinus Torvalds return error; 15981da177e4SLinus Torvalds } 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds /* 16011da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 16021da177e4SLinus Torvalds */ 16031da177e4SLinus Torvalds static int 16041da177e4SLinus Torvalds nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 16051da177e4SLinus Torvalds { 16061da177e4SLinus Torvalds struct iattr attr; 16071da177e4SLinus Torvalds int status; 16081da177e4SLinus Torvalds 16091e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 16101e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds if (!new_valid_dev(rdev)) 16131da177e4SLinus Torvalds return -EINVAL; 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds attr.ia_mode = mode; 16161da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 16191da177e4SLinus Torvalds if (status != 0) 16201da177e4SLinus Torvalds goto out_err; 16211da177e4SLinus Torvalds return 0; 16221da177e4SLinus Torvalds out_err: 16231da177e4SLinus Torvalds d_drop(dentry); 16241da177e4SLinus Torvalds return status; 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds 16271da177e4SLinus Torvalds /* 16281da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 16291da177e4SLinus Torvalds */ 16301da177e4SLinus Torvalds static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 16311da177e4SLinus Torvalds { 16321da177e4SLinus Torvalds struct iattr attr; 16331da177e4SLinus Torvalds int error; 16341da177e4SLinus Torvalds 16351e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 16361e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 16391da177e4SLinus Torvalds attr.ia_mode = mode | S_IFDIR; 16401da177e4SLinus Torvalds 16411da177e4SLinus Torvalds error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 16421da177e4SLinus Torvalds if (error != 0) 16431da177e4SLinus Torvalds goto out_err; 16441da177e4SLinus Torvalds return 0; 16451da177e4SLinus Torvalds out_err: 16461da177e4SLinus Torvalds d_drop(dentry); 16471da177e4SLinus Torvalds return error; 16481da177e4SLinus Torvalds } 16491da177e4SLinus Torvalds 1650d45b9d8bSTrond Myklebust static void nfs_dentry_handle_enoent(struct dentry *dentry) 1651d45b9d8bSTrond Myklebust { 1652d45b9d8bSTrond Myklebust if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1653d45b9d8bSTrond Myklebust d_delete(dentry); 1654d45b9d8bSTrond Myklebust } 1655d45b9d8bSTrond Myklebust 16561da177e4SLinus Torvalds static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 16571da177e4SLinus Torvalds { 16581da177e4SLinus Torvalds int error; 16591da177e4SLinus Torvalds 16601e7cb3dcSChuck Lever dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 16611e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 16641da177e4SLinus Torvalds /* Ensure the VFS deletes this inode */ 16651da177e4SLinus Torvalds if (error == 0 && dentry->d_inode != NULL) 1666ce71ec36SDave Hansen clear_nlink(dentry->d_inode); 1667d45b9d8bSTrond Myklebust else if (error == -ENOENT) 1668d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds return error; 16711da177e4SLinus Torvalds } 16721da177e4SLinus Torvalds 16731da177e4SLinus Torvalds /* 16741da177e4SLinus Torvalds * Remove a file after making sure there are no pending writes, 16751da177e4SLinus Torvalds * and after checking that the file has only one user. 16761da177e4SLinus Torvalds * 16771da177e4SLinus Torvalds * We invalidate the attribute cache and free the inode prior to the operation 16781da177e4SLinus Torvalds * to avoid possible races if the server reuses the inode. 16791da177e4SLinus Torvalds */ 16801da177e4SLinus Torvalds static int nfs_safe_remove(struct dentry *dentry) 16811da177e4SLinus Torvalds { 16821da177e4SLinus Torvalds struct inode *dir = dentry->d_parent->d_inode; 16831da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 16841da177e4SLinus Torvalds int error = -EBUSY; 16851da177e4SLinus Torvalds 16861da177e4SLinus Torvalds dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 16871da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 16881da177e4SLinus Torvalds 16891da177e4SLinus Torvalds /* If the dentry was sillyrenamed, we simply call d_delete() */ 16901da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 16911da177e4SLinus Torvalds error = 0; 16921da177e4SLinus Torvalds goto out; 16931da177e4SLinus Torvalds } 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds if (inode != NULL) { 1696cae7a073STrond Myklebust nfs_inode_return_delegation(inode); 16971da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 16981da177e4SLinus Torvalds /* The VFS may want to delete this inode */ 16991da177e4SLinus Torvalds if (error == 0) 17001b83d707STrond Myklebust nfs_drop_nlink(inode); 17015ba7cc48STrond Myklebust nfs_mark_for_revalidate(inode); 17021da177e4SLinus Torvalds } else 17031da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1704d45b9d8bSTrond Myklebust if (error == -ENOENT) 1705d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 17061da177e4SLinus Torvalds out: 17071da177e4SLinus Torvalds return error; 17081da177e4SLinus Torvalds } 17091da177e4SLinus Torvalds 17101da177e4SLinus Torvalds /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 17111da177e4SLinus Torvalds * belongs to an active ".nfs..." file and we return -EBUSY. 17121da177e4SLinus Torvalds * 17131da177e4SLinus Torvalds * If sillyrename() returns 0, we do nothing, otherwise we unlink. 17141da177e4SLinus Torvalds */ 17151da177e4SLinus Torvalds static int nfs_unlink(struct inode *dir, struct dentry *dentry) 17161da177e4SLinus Torvalds { 17171da177e4SLinus Torvalds int error; 17181da177e4SLinus Torvalds int need_rehash = 0; 17191da177e4SLinus Torvalds 17201da177e4SLinus Torvalds dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 17211da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name); 17221da177e4SLinus Torvalds 17231da177e4SLinus Torvalds spin_lock(&dcache_lock); 17241da177e4SLinus Torvalds spin_lock(&dentry->d_lock); 17251da177e4SLinus Torvalds if (atomic_read(&dentry->d_count) > 1) { 17261da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 17271da177e4SLinus Torvalds spin_unlock(&dcache_lock); 1728ccfeb506STrond Myklebust /* Start asynchronous writeout of the inode */ 1729ccfeb506STrond Myklebust write_inode_now(dentry->d_inode, 0); 17301da177e4SLinus Torvalds error = nfs_sillyrename(dir, dentry); 17311da177e4SLinus Torvalds return error; 17321da177e4SLinus Torvalds } 17331da177e4SLinus Torvalds if (!d_unhashed(dentry)) { 17341da177e4SLinus Torvalds __d_drop(dentry); 17351da177e4SLinus Torvalds need_rehash = 1; 17361da177e4SLinus Torvalds } 17371da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 17381da177e4SLinus Torvalds spin_unlock(&dcache_lock); 17391da177e4SLinus Torvalds error = nfs_safe_remove(dentry); 1740d45b9d8bSTrond Myklebust if (!error || error == -ENOENT) { 17411da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 17421da177e4SLinus Torvalds } else if (need_rehash) 17431da177e4SLinus Torvalds d_rehash(dentry); 17441da177e4SLinus Torvalds return error; 17451da177e4SLinus Torvalds } 17461da177e4SLinus Torvalds 1747873101b3SChuck Lever /* 1748873101b3SChuck Lever * To create a symbolic link, most file systems instantiate a new inode, 1749873101b3SChuck Lever * add a page to it containing the path, then write it out to the disk 1750873101b3SChuck Lever * using prepare_write/commit_write. 1751873101b3SChuck Lever * 1752873101b3SChuck Lever * Unfortunately the NFS client can't create the in-core inode first 1753873101b3SChuck Lever * because it needs a file handle to create an in-core inode (see 1754873101b3SChuck Lever * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1755873101b3SChuck Lever * symlink request has completed on the server. 1756873101b3SChuck Lever * 1757873101b3SChuck Lever * So instead we allocate a raw page, copy the symname into it, then do 1758873101b3SChuck Lever * the SYMLINK request with the page as the buffer. If it succeeds, we 1759873101b3SChuck Lever * now have a new file handle and can instantiate an in-core NFS inode 1760873101b3SChuck Lever * and move the raw page into its mapping. 1761873101b3SChuck Lever */ 1762873101b3SChuck Lever static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 17631da177e4SLinus Torvalds { 1764873101b3SChuck Lever struct pagevec lru_pvec; 1765873101b3SChuck Lever struct page *page; 1766873101b3SChuck Lever char *kaddr; 17671da177e4SLinus Torvalds struct iattr attr; 1768873101b3SChuck Lever unsigned int pathlen = strlen(symname); 17691da177e4SLinus Torvalds int error; 17701da177e4SLinus Torvalds 17711da177e4SLinus Torvalds dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 17721da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name, symname); 17731da177e4SLinus Torvalds 1774873101b3SChuck Lever if (pathlen > PAGE_SIZE) 1775873101b3SChuck Lever return -ENAMETOOLONG; 17761da177e4SLinus Torvalds 1777873101b3SChuck Lever attr.ia_mode = S_IFLNK | S_IRWXUGO; 1778873101b3SChuck Lever attr.ia_valid = ATTR_MODE; 17791da177e4SLinus Torvalds 178083d93f22SJeff Layton page = alloc_page(GFP_HIGHUSER); 178176566991STrond Myklebust if (!page) 1782873101b3SChuck Lever return -ENOMEM; 1783873101b3SChuck Lever 1784873101b3SChuck Lever kaddr = kmap_atomic(page, KM_USER0); 1785873101b3SChuck Lever memcpy(kaddr, symname, pathlen); 1786873101b3SChuck Lever if (pathlen < PAGE_SIZE) 1787873101b3SChuck Lever memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1788873101b3SChuck Lever kunmap_atomic(kaddr, KM_USER0); 1789873101b3SChuck Lever 179094a6d753SChuck Lever error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1791873101b3SChuck Lever if (error != 0) { 1792873101b3SChuck Lever dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1793873101b3SChuck Lever dir->i_sb->s_id, dir->i_ino, 1794873101b3SChuck Lever dentry->d_name.name, symname, error); 17951da177e4SLinus Torvalds d_drop(dentry); 1796873101b3SChuck Lever __free_page(page); 17971da177e4SLinus Torvalds return error; 17981da177e4SLinus Torvalds } 17991da177e4SLinus Torvalds 1800873101b3SChuck Lever /* 1801873101b3SChuck Lever * No big deal if we can't add this page to the page cache here. 1802873101b3SChuck Lever * READLINK will get the missing page from the server if needed. 1803873101b3SChuck Lever */ 1804873101b3SChuck Lever pagevec_init(&lru_pvec, 0); 1805873101b3SChuck Lever if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1806873101b3SChuck Lever GFP_KERNEL)) { 180739cf8a13SChuck Lever pagevec_add(&lru_pvec, page); 18084f98a2feSRik van Riel pagevec_lru_add_file(&lru_pvec); 1809873101b3SChuck Lever SetPageUptodate(page); 1810873101b3SChuck Lever unlock_page(page); 1811873101b3SChuck Lever } else 1812873101b3SChuck Lever __free_page(page); 1813873101b3SChuck Lever 1814873101b3SChuck Lever return 0; 1815873101b3SChuck Lever } 1816873101b3SChuck Lever 18171da177e4SLinus Torvalds static int 18181da177e4SLinus Torvalds nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 18191da177e4SLinus Torvalds { 18201da177e4SLinus Torvalds struct inode *inode = old_dentry->d_inode; 18211da177e4SLinus Torvalds int error; 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 18241da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 18251da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 18261da177e4SLinus Torvalds 18279a3936aaSTrond Myklebust nfs_inode_return_delegation(inode); 18289a3936aaSTrond Myklebust 18299697d234STrond Myklebust d_drop(dentry); 18301da177e4SLinus Torvalds error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1831cf809556STrond Myklebust if (error == 0) { 18327de9c6eeSAl Viro ihold(inode); 18339697d234STrond Myklebust d_add(dentry, inode); 1834cf809556STrond Myklebust } 18351da177e4SLinus Torvalds return error; 18361da177e4SLinus Torvalds } 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds /* 18391da177e4SLinus Torvalds * RENAME 18401da177e4SLinus Torvalds * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 18411da177e4SLinus Torvalds * different file handle for the same inode after a rename (e.g. when 18421da177e4SLinus Torvalds * moving to a different directory). A fail-safe method to do so would 18431da177e4SLinus Torvalds * be to look up old_dir/old_name, create a link to new_dir/new_name and 18441da177e4SLinus Torvalds * rename the old file using the sillyrename stuff. This way, the original 18451da177e4SLinus Torvalds * file in old_dir will go away when the last process iput()s the inode. 18461da177e4SLinus Torvalds * 18471da177e4SLinus Torvalds * FIXED. 18481da177e4SLinus Torvalds * 18491da177e4SLinus Torvalds * It actually works quite well. One needs to have the possibility for 18501da177e4SLinus Torvalds * at least one ".nfs..." file in each directory the file ever gets 18511da177e4SLinus Torvalds * moved or linked to which happens automagically with the new 18521da177e4SLinus Torvalds * implementation that only depends on the dcache stuff instead of 18531da177e4SLinus Torvalds * using the inode layer 18541da177e4SLinus Torvalds * 18551da177e4SLinus Torvalds * Unfortunately, things are a little more complicated than indicated 18561da177e4SLinus Torvalds * above. For a cross-directory move, we want to make sure we can get 18571da177e4SLinus Torvalds * rid of the old inode after the operation. This means there must be 18581da177e4SLinus Torvalds * no pending writes (if it's a file), and the use count must be 1. 18591da177e4SLinus Torvalds * If these conditions are met, we can drop the dentries before doing 18601da177e4SLinus Torvalds * the rename. 18611da177e4SLinus Torvalds */ 18621da177e4SLinus Torvalds static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 18631da177e4SLinus Torvalds struct inode *new_dir, struct dentry *new_dentry) 18641da177e4SLinus Torvalds { 18651da177e4SLinus Torvalds struct inode *old_inode = old_dentry->d_inode; 18661da177e4SLinus Torvalds struct inode *new_inode = new_dentry->d_inode; 18671da177e4SLinus Torvalds struct dentry *dentry = NULL, *rehash = NULL; 18681da177e4SLinus Torvalds int error = -EBUSY; 18691da177e4SLinus Torvalds 18701da177e4SLinus Torvalds dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 18711da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 18721da177e4SLinus Torvalds new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 18731da177e4SLinus Torvalds atomic_read(&new_dentry->d_count)); 18741da177e4SLinus Torvalds 18751da177e4SLinus Torvalds /* 187628f79a1aSMiklos Szeredi * For non-directories, check whether the target is busy and if so, 187728f79a1aSMiklos Szeredi * make a copy of the dentry and then do a silly-rename. If the 187828f79a1aSMiklos Szeredi * silly-rename succeeds, the copied dentry is hashed and becomes 187928f79a1aSMiklos Szeredi * the new target. 18801da177e4SLinus Torvalds */ 188127226104SMiklos Szeredi if (new_inode && !S_ISDIR(new_inode->i_mode)) { 188227226104SMiklos Szeredi /* 188327226104SMiklos Szeredi * To prevent any new references to the target during the 188427226104SMiklos Szeredi * rename, we unhash the dentry in advance. 188527226104SMiklos Szeredi */ 188627226104SMiklos Szeredi if (!d_unhashed(new_dentry)) { 188727226104SMiklos Szeredi d_drop(new_dentry); 188827226104SMiklos Szeredi rehash = new_dentry; 188927226104SMiklos Szeredi } 189027226104SMiklos Szeredi 189127226104SMiklos Szeredi if (atomic_read(&new_dentry->d_count) > 2) { 18921da177e4SLinus Torvalds int err; 189327226104SMiklos Szeredi 18941da177e4SLinus Torvalds /* copy the target dentry's name */ 18951da177e4SLinus Torvalds dentry = d_alloc(new_dentry->d_parent, 18961da177e4SLinus Torvalds &new_dentry->d_name); 18971da177e4SLinus Torvalds if (!dentry) 18981da177e4SLinus Torvalds goto out; 18991da177e4SLinus Torvalds 19001da177e4SLinus Torvalds /* silly-rename the existing target ... */ 19011da177e4SLinus Torvalds err = nfs_sillyrename(new_dir, new_dentry); 190224e93025SMiklos Szeredi if (err) 19031da177e4SLinus Torvalds goto out; 190424e93025SMiklos Szeredi 190524e93025SMiklos Szeredi new_dentry = dentry; 190656335936SOGAWA Hirofumi rehash = NULL; 190724e93025SMiklos Szeredi new_inode = NULL; 1908b1e4adf4STrond Myklebust } 190927226104SMiklos Szeredi } 19101da177e4SLinus Torvalds 1911cae7a073STrond Myklebust nfs_inode_return_delegation(old_inode); 1912b1e4adf4STrond Myklebust if (new_inode != NULL) 191324174119STrond Myklebust nfs_inode_return_delegation(new_inode); 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 19161da177e4SLinus Torvalds new_dir, &new_dentry->d_name); 19175ba7cc48STrond Myklebust nfs_mark_for_revalidate(old_inode); 19181da177e4SLinus Torvalds out: 19191da177e4SLinus Torvalds if (rehash) 19201da177e4SLinus Torvalds d_rehash(rehash); 19211da177e4SLinus Torvalds if (!error) { 1922b1e4adf4STrond Myklebust if (new_inode != NULL) 1923b1e4adf4STrond Myklebust nfs_drop_nlink(new_inode); 19241da177e4SLinus Torvalds d_move(old_dentry, new_dentry); 19258fb559f8SChuck Lever nfs_set_verifier(new_dentry, 19268fb559f8SChuck Lever nfs_save_change_attribute(new_dir)); 1927d45b9d8bSTrond Myklebust } else if (error == -ENOENT) 1928d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(old_dentry); 19291da177e4SLinus Torvalds 19301da177e4SLinus Torvalds /* new dentry created? */ 19311da177e4SLinus Torvalds if (dentry) 19321da177e4SLinus Torvalds dput(dentry); 19331da177e4SLinus Torvalds return error; 19341da177e4SLinus Torvalds } 19351da177e4SLinus Torvalds 1936cfcea3e8STrond Myklebust static DEFINE_SPINLOCK(nfs_access_lru_lock); 1937cfcea3e8STrond Myklebust static LIST_HEAD(nfs_access_lru_list); 1938cfcea3e8STrond Myklebust static atomic_long_t nfs_access_nr_entries; 1939cfcea3e8STrond Myklebust 19401c3c07e9STrond Myklebust static void nfs_access_free_entry(struct nfs_access_entry *entry) 19411c3c07e9STrond Myklebust { 19421c3c07e9STrond Myklebust put_rpccred(entry->cred); 19431c3c07e9STrond Myklebust kfree(entry); 1944cfcea3e8STrond Myklebust smp_mb__before_atomic_dec(); 1945cfcea3e8STrond Myklebust atomic_long_dec(&nfs_access_nr_entries); 1946cfcea3e8STrond Myklebust smp_mb__after_atomic_dec(); 19471c3c07e9STrond Myklebust } 19481c3c07e9STrond Myklebust 19491a81bb8aSTrond Myklebust static void nfs_access_free_list(struct list_head *head) 19501a81bb8aSTrond Myklebust { 19511a81bb8aSTrond Myklebust struct nfs_access_entry *cache; 19521a81bb8aSTrond Myklebust 19531a81bb8aSTrond Myklebust while (!list_empty(head)) { 19541a81bb8aSTrond Myklebust cache = list_entry(head->next, struct nfs_access_entry, lru); 19551a81bb8aSTrond Myklebust list_del(&cache->lru); 19561a81bb8aSTrond Myklebust nfs_access_free_entry(cache); 19571a81bb8aSTrond Myklebust } 19581a81bb8aSTrond Myklebust } 19591a81bb8aSTrond Myklebust 19607f8275d0SDave Chinner int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1961979df72eSTrond Myklebust { 1962979df72eSTrond Myklebust LIST_HEAD(head); 1963aa510da5STrond Myklebust struct nfs_inode *nfsi, *next; 1964979df72eSTrond Myklebust struct nfs_access_entry *cache; 1965979df72eSTrond Myklebust 196661d5eb29STrond Myklebust if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 196761d5eb29STrond Myklebust return (nr_to_scan == 0) ? 0 : -1; 19689c7e7e23STrond Myklebust 1969a50f7951STrond Myklebust spin_lock(&nfs_access_lru_lock); 1970aa510da5STrond Myklebust list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1971979df72eSTrond Myklebust struct inode *inode; 1972979df72eSTrond Myklebust 1973979df72eSTrond Myklebust if (nr_to_scan-- == 0) 1974979df72eSTrond Myklebust break; 19759c7e7e23STrond Myklebust inode = &nfsi->vfs_inode; 1976979df72eSTrond Myklebust spin_lock(&inode->i_lock); 1977979df72eSTrond Myklebust if (list_empty(&nfsi->access_cache_entry_lru)) 1978979df72eSTrond Myklebust goto remove_lru_entry; 1979979df72eSTrond Myklebust cache = list_entry(nfsi->access_cache_entry_lru.next, 1980979df72eSTrond Myklebust struct nfs_access_entry, lru); 1981979df72eSTrond Myklebust list_move(&cache->lru, &head); 1982979df72eSTrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1983979df72eSTrond Myklebust if (!list_empty(&nfsi->access_cache_entry_lru)) 1984979df72eSTrond Myklebust list_move_tail(&nfsi->access_cache_inode_lru, 1985979df72eSTrond Myklebust &nfs_access_lru_list); 1986979df72eSTrond Myklebust else { 1987979df72eSTrond Myklebust remove_lru_entry: 1988979df72eSTrond Myklebust list_del_init(&nfsi->access_cache_inode_lru); 19899c7e7e23STrond Myklebust smp_mb__before_clear_bit(); 1990979df72eSTrond Myklebust clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 19919c7e7e23STrond Myklebust smp_mb__after_clear_bit(); 1992979df72eSTrond Myklebust } 199359844a9bSTrond Myklebust spin_unlock(&inode->i_lock); 1994979df72eSTrond Myklebust } 1995979df72eSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 19961a81bb8aSTrond Myklebust nfs_access_free_list(&head); 1997979df72eSTrond Myklebust return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 1998979df72eSTrond Myklebust } 1999979df72eSTrond Myklebust 20001a81bb8aSTrond Myklebust static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 20011c3c07e9STrond Myklebust { 20021c3c07e9STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 20031a81bb8aSTrond Myklebust struct rb_node *n; 20041c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20051c3c07e9STrond Myklebust 20061c3c07e9STrond Myklebust /* Unhook entries from the cache */ 20071c3c07e9STrond Myklebust while ((n = rb_first(root_node)) != NULL) { 20081c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 20091c3c07e9STrond Myklebust rb_erase(n, root_node); 20101a81bb8aSTrond Myklebust list_move(&entry->lru, head); 20111c3c07e9STrond Myklebust } 20121c3c07e9STrond Myklebust nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 20131c3c07e9STrond Myklebust } 20141c3c07e9STrond Myklebust 20151c3c07e9STrond Myklebust void nfs_access_zap_cache(struct inode *inode) 20161c3c07e9STrond Myklebust { 20171a81bb8aSTrond Myklebust LIST_HEAD(head); 20181a81bb8aSTrond Myklebust 20191a81bb8aSTrond Myklebust if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 20201a81bb8aSTrond Myklebust return; 2021cfcea3e8STrond Myklebust /* Remove from global LRU init */ 2022cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 20231a81bb8aSTrond Myklebust if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2024cfcea3e8STrond Myklebust list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2025cfcea3e8STrond Myklebust 20261c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20271a81bb8aSTrond Myklebust __nfs_access_zap_cache(NFS_I(inode), &head); 20281a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 20291a81bb8aSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 20301a81bb8aSTrond Myklebust nfs_access_free_list(&head); 20311c3c07e9STrond Myklebust } 20321c3c07e9STrond Myklebust 20331c3c07e9STrond Myklebust static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 20341c3c07e9STrond Myklebust { 20351c3c07e9STrond Myklebust struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 20361c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20371c3c07e9STrond Myklebust 20381c3c07e9STrond Myklebust while (n != NULL) { 20391c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 20401c3c07e9STrond Myklebust 20411c3c07e9STrond Myklebust if (cred < entry->cred) 20421c3c07e9STrond Myklebust n = n->rb_left; 20431c3c07e9STrond Myklebust else if (cred > entry->cred) 20441c3c07e9STrond Myklebust n = n->rb_right; 20451c3c07e9STrond Myklebust else 20461c3c07e9STrond Myklebust return entry; 20471c3c07e9STrond Myklebust } 20481c3c07e9STrond Myklebust return NULL; 20491c3c07e9STrond Myklebust } 20501c3c07e9STrond Myklebust 2051af22f94aSTrond Myklebust static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 20521da177e4SLinus Torvalds { 205355296809SChuck Lever struct nfs_inode *nfsi = NFS_I(inode); 20541c3c07e9STrond Myklebust struct nfs_access_entry *cache; 20551c3c07e9STrond Myklebust int err = -ENOENT; 20561da177e4SLinus Torvalds 20571c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20581c3c07e9STrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 20591c3c07e9STrond Myklebust goto out_zap; 20601c3c07e9STrond Myklebust cache = nfs_access_search_rbtree(inode, cred); 20611c3c07e9STrond Myklebust if (cache == NULL) 20621c3c07e9STrond Myklebust goto out; 2063b4d2314bSTrond Myklebust if (!nfs_have_delegated_attributes(inode) && 206464672d55SPeter Staubach !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 20651c3c07e9STrond Myklebust goto out_stale; 20661c3c07e9STrond Myklebust res->jiffies = cache->jiffies; 20671c3c07e9STrond Myklebust res->cred = cache->cred; 20681c3c07e9STrond Myklebust res->mask = cache->mask; 2069cfcea3e8STrond Myklebust list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 20701c3c07e9STrond Myklebust err = 0; 20711c3c07e9STrond Myklebust out: 20721c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 20731c3c07e9STrond Myklebust return err; 20741c3c07e9STrond Myklebust out_stale: 20751c3c07e9STrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 2076cfcea3e8STrond Myklebust list_del(&cache->lru); 20771c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 20781c3c07e9STrond Myklebust nfs_access_free_entry(cache); 20791da177e4SLinus Torvalds return -ENOENT; 20801c3c07e9STrond Myklebust out_zap: 20811a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 20821a81bb8aSTrond Myklebust nfs_access_zap_cache(inode); 20831c3c07e9STrond Myklebust return -ENOENT; 20841c3c07e9STrond Myklebust } 20851c3c07e9STrond Myklebust 20861c3c07e9STrond Myklebust static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 20871c3c07e9STrond Myklebust { 2088cfcea3e8STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 2089cfcea3e8STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 20901c3c07e9STrond Myklebust struct rb_node **p = &root_node->rb_node; 20911c3c07e9STrond Myklebust struct rb_node *parent = NULL; 20921c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20931c3c07e9STrond Myklebust 20941c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20951c3c07e9STrond Myklebust while (*p != NULL) { 20961c3c07e9STrond Myklebust parent = *p; 20971c3c07e9STrond Myklebust entry = rb_entry(parent, struct nfs_access_entry, rb_node); 20981c3c07e9STrond Myklebust 20991c3c07e9STrond Myklebust if (set->cred < entry->cred) 21001c3c07e9STrond Myklebust p = &parent->rb_left; 21011c3c07e9STrond Myklebust else if (set->cred > entry->cred) 21021c3c07e9STrond Myklebust p = &parent->rb_right; 21031c3c07e9STrond Myklebust else 21041c3c07e9STrond Myklebust goto found; 21051c3c07e9STrond Myklebust } 21061c3c07e9STrond Myklebust rb_link_node(&set->rb_node, parent, p); 21071c3c07e9STrond Myklebust rb_insert_color(&set->rb_node, root_node); 2108cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 21091c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 21101c3c07e9STrond Myklebust return; 21111c3c07e9STrond Myklebust found: 21121c3c07e9STrond Myklebust rb_replace_node(parent, &set->rb_node, root_node); 2113cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2114cfcea3e8STrond Myklebust list_del(&entry->lru); 21151c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 21161c3c07e9STrond Myklebust nfs_access_free_entry(entry); 21171da177e4SLinus Torvalds } 21181da177e4SLinus Torvalds 2119af22f94aSTrond Myklebust static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 21201da177e4SLinus Torvalds { 21211c3c07e9STrond Myklebust struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 21221c3c07e9STrond Myklebust if (cache == NULL) 21231c3c07e9STrond Myklebust return; 21241c3c07e9STrond Myklebust RB_CLEAR_NODE(&cache->rb_node); 21251da177e4SLinus Torvalds cache->jiffies = set->jiffies; 21261c3c07e9STrond Myklebust cache->cred = get_rpccred(set->cred); 21271da177e4SLinus Torvalds cache->mask = set->mask; 21281c3c07e9STrond Myklebust 21291c3c07e9STrond Myklebust nfs_access_add_rbtree(inode, cache); 2130cfcea3e8STrond Myklebust 2131cfcea3e8STrond Myklebust /* Update accounting */ 2132cfcea3e8STrond Myklebust smp_mb__before_atomic_inc(); 2133cfcea3e8STrond Myklebust atomic_long_inc(&nfs_access_nr_entries); 2134cfcea3e8STrond Myklebust smp_mb__after_atomic_inc(); 2135cfcea3e8STrond Myklebust 2136cfcea3e8STrond Myklebust /* Add inode to global LRU list */ 21371a81bb8aSTrond Myklebust if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2138cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 21391a81bb8aSTrond Myklebust if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 21401a81bb8aSTrond Myklebust list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 21411a81bb8aSTrond Myklebust &nfs_access_lru_list); 2142cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 2143cfcea3e8STrond Myklebust } 21441da177e4SLinus Torvalds } 21451da177e4SLinus Torvalds 21461da177e4SLinus Torvalds static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 21471da177e4SLinus Torvalds { 21481da177e4SLinus Torvalds struct nfs_access_entry cache; 21491da177e4SLinus Torvalds int status; 21501da177e4SLinus Torvalds 21511da177e4SLinus Torvalds status = nfs_access_get_cached(inode, cred, &cache); 21521da177e4SLinus Torvalds if (status == 0) 21531da177e4SLinus Torvalds goto out; 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds /* Be clever: ask server to check for all possible rights */ 21561da177e4SLinus Torvalds cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 21571da177e4SLinus Torvalds cache.cred = cred; 21581da177e4SLinus Torvalds cache.jiffies = jiffies; 21591da177e4SLinus Torvalds status = NFS_PROTO(inode)->access(inode, &cache); 2160a71ee337SSuresh Jayaraman if (status != 0) { 2161a71ee337SSuresh Jayaraman if (status == -ESTALE) { 2162a71ee337SSuresh Jayaraman nfs_zap_caches(inode); 2163a71ee337SSuresh Jayaraman if (!S_ISDIR(inode->i_mode)) 2164a71ee337SSuresh Jayaraman set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2165a71ee337SSuresh Jayaraman } 21661da177e4SLinus Torvalds return status; 2167a71ee337SSuresh Jayaraman } 21681da177e4SLinus Torvalds nfs_access_add_cache(inode, &cache); 21691da177e4SLinus Torvalds out: 2170e6305c43SAl Viro if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 21711da177e4SLinus Torvalds return 0; 21721da177e4SLinus Torvalds return -EACCES; 21731da177e4SLinus Torvalds } 21741da177e4SLinus Torvalds 2175af22f94aSTrond Myklebust static int nfs_open_permission_mask(int openflags) 2176af22f94aSTrond Myklebust { 2177af22f94aSTrond Myklebust int mask = 0; 2178af22f94aSTrond Myklebust 2179af22f94aSTrond Myklebust if (openflags & FMODE_READ) 2180af22f94aSTrond Myklebust mask |= MAY_READ; 2181af22f94aSTrond Myklebust if (openflags & FMODE_WRITE) 2182af22f94aSTrond Myklebust mask |= MAY_WRITE; 2183af22f94aSTrond Myklebust if (openflags & FMODE_EXEC) 2184af22f94aSTrond Myklebust mask |= MAY_EXEC; 2185af22f94aSTrond Myklebust return mask; 2186af22f94aSTrond Myklebust } 2187af22f94aSTrond Myklebust 2188af22f94aSTrond Myklebust int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2189af22f94aSTrond Myklebust { 2190af22f94aSTrond Myklebust return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2191af22f94aSTrond Myklebust } 2192af22f94aSTrond Myklebust 2193e6305c43SAl Viro int nfs_permission(struct inode *inode, int mask) 21941da177e4SLinus Torvalds { 21951da177e4SLinus Torvalds struct rpc_cred *cred; 21961da177e4SLinus Torvalds int res = 0; 21971da177e4SLinus Torvalds 219891d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSACCESS); 219991d5b470SChuck Lever 2200e6305c43SAl Viro if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 22011da177e4SLinus Torvalds goto out; 22021da177e4SLinus Torvalds /* Is this sys_access() ? */ 22039cfcac81SEric Paris if (mask & (MAY_ACCESS | MAY_CHDIR)) 22041da177e4SLinus Torvalds goto force_lookup; 22051da177e4SLinus Torvalds 22061da177e4SLinus Torvalds switch (inode->i_mode & S_IFMT) { 22071da177e4SLinus Torvalds case S_IFLNK: 22081da177e4SLinus Torvalds goto out; 22091da177e4SLinus Torvalds case S_IFREG: 22101da177e4SLinus Torvalds /* NFSv4 has atomic_open... */ 22111da177e4SLinus Torvalds if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 22127ee2cb7fSFrank Filz && (mask & MAY_OPEN) 22137ee2cb7fSFrank Filz && !(mask & MAY_EXEC)) 22141da177e4SLinus Torvalds goto out; 22151da177e4SLinus Torvalds break; 22161da177e4SLinus Torvalds case S_IFDIR: 22171da177e4SLinus Torvalds /* 22181da177e4SLinus Torvalds * Optimize away all write operations, since the server 22191da177e4SLinus Torvalds * will check permissions when we perform the op. 22201da177e4SLinus Torvalds */ 22211da177e4SLinus Torvalds if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 22221da177e4SLinus Torvalds goto out; 22231da177e4SLinus Torvalds } 22241da177e4SLinus Torvalds 22251da177e4SLinus Torvalds force_lookup: 22261da177e4SLinus Torvalds if (!NFS_PROTO(inode)->access) 22271da177e4SLinus Torvalds goto out_notsup; 22281da177e4SLinus Torvalds 222998a8e323STrond Myklebust cred = rpc_lookup_cred(); 22301da177e4SLinus Torvalds if (!IS_ERR(cred)) { 22311da177e4SLinus Torvalds res = nfs_do_access(inode, cred, mask); 22321da177e4SLinus Torvalds put_rpccred(cred); 22331da177e4SLinus Torvalds } else 22341da177e4SLinus Torvalds res = PTR_ERR(cred); 22351da177e4SLinus Torvalds out: 2236f696a365SMiklos Szeredi if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2237f696a365SMiklos Szeredi res = -EACCES; 2238f696a365SMiklos Szeredi 22391e7cb3dcSChuck Lever dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 22401e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino, mask, res); 22411da177e4SLinus Torvalds return res; 22421da177e4SLinus Torvalds out_notsup: 22431da177e4SLinus Torvalds res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 22441da177e4SLinus Torvalds if (res == 0) 22451da177e4SLinus Torvalds res = generic_permission(inode, mask, NULL); 22461e7cb3dcSChuck Lever goto out; 22471da177e4SLinus Torvalds } 22481da177e4SLinus Torvalds 22491da177e4SLinus Torvalds /* 22501da177e4SLinus Torvalds * Local variables: 22511da177e4SLinus Torvalds * version-control: t 22521da177e4SLinus Torvalds * kept-new-versions: 5 22531da177e4SLinus Torvalds * End: 22541da177e4SLinus Torvalds */ 2255