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> 37*04e4bd1cSCatalin Marinas #include <linux/kmemleak.h> 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds #include "delegation.h" 4091d5b470SChuck Lever #include "iostat.h" 414c30d56eSAdrian Bunk #include "internal.h" 42cd9a1c0eSTrond Myklebust #include "fscache.h" 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds /* #define NFS_DEBUG_VERBOSE 1 */ 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds static int nfs_opendir(struct inode *, struct file *); 471da177e4SLinus Torvalds static int nfs_readdir(struct file *, void *, filldir_t); 481da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 491da177e4SLinus Torvalds static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *); 501da177e4SLinus Torvalds static int nfs_mkdir(struct inode *, struct dentry *, int); 511da177e4SLinus Torvalds static int nfs_rmdir(struct inode *, struct dentry *); 521da177e4SLinus Torvalds static int nfs_unlink(struct inode *, struct dentry *); 531da177e4SLinus Torvalds static int nfs_symlink(struct inode *, struct dentry *, const char *); 541da177e4SLinus Torvalds static int nfs_link(struct dentry *, struct inode *, struct dentry *); 551da177e4SLinus Torvalds static int nfs_mknod(struct inode *, struct dentry *, int, dev_t); 561da177e4SLinus Torvalds static int nfs_rename(struct inode *, struct dentry *, 571da177e4SLinus Torvalds struct inode *, struct dentry *); 587ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *, int); 59f0dd2136STrond Myklebust static loff_t nfs_llseek_dir(struct file *, loff_t, int); 60d1bacf9eSBryan Schumaker static int nfs_readdir_clear_array(struct page*, gfp_t); 611da177e4SLinus Torvalds 624b6f5d20SArjan van de Ven const struct file_operations nfs_dir_operations = { 63f0dd2136STrond Myklebust .llseek = nfs_llseek_dir, 641da177e4SLinus Torvalds .read = generic_read_dir, 651da177e4SLinus Torvalds .readdir = nfs_readdir, 661da177e4SLinus Torvalds .open = nfs_opendir, 671da177e4SLinus Torvalds .release = nfs_release, 681da177e4SLinus Torvalds .fsync = nfs_fsync_dir, 691da177e4SLinus Torvalds }; 701da177e4SLinus Torvalds 7192e1d5beSArjan van de Ven const struct inode_operations nfs_dir_inode_operations = { 721da177e4SLinus Torvalds .create = nfs_create, 731da177e4SLinus Torvalds .lookup = nfs_lookup, 741da177e4SLinus Torvalds .link = nfs_link, 751da177e4SLinus Torvalds .unlink = nfs_unlink, 761da177e4SLinus Torvalds .symlink = nfs_symlink, 771da177e4SLinus Torvalds .mkdir = nfs_mkdir, 781da177e4SLinus Torvalds .rmdir = nfs_rmdir, 791da177e4SLinus Torvalds .mknod = nfs_mknod, 801da177e4SLinus Torvalds .rename = nfs_rename, 811da177e4SLinus Torvalds .permission = nfs_permission, 821da177e4SLinus Torvalds .getattr = nfs_getattr, 831da177e4SLinus Torvalds .setattr = nfs_setattr, 841da177e4SLinus Torvalds }; 851da177e4SLinus Torvalds 86d1bacf9eSBryan Schumaker const struct address_space_operations nfs_dir_addr_space_ops = { 87d1bacf9eSBryan Schumaker .releasepage = nfs_readdir_clear_array, 88d1bacf9eSBryan Schumaker }; 89d1bacf9eSBryan Schumaker 90b7fa0554SAndreas Gruenbacher #ifdef CONFIG_NFS_V3 9192e1d5beSArjan van de Ven const struct inode_operations nfs3_dir_inode_operations = { 92b7fa0554SAndreas Gruenbacher .create = nfs_create, 93b7fa0554SAndreas Gruenbacher .lookup = nfs_lookup, 94b7fa0554SAndreas Gruenbacher .link = nfs_link, 95b7fa0554SAndreas Gruenbacher .unlink = nfs_unlink, 96b7fa0554SAndreas Gruenbacher .symlink = nfs_symlink, 97b7fa0554SAndreas Gruenbacher .mkdir = nfs_mkdir, 98b7fa0554SAndreas Gruenbacher .rmdir = nfs_rmdir, 99b7fa0554SAndreas Gruenbacher .mknod = nfs_mknod, 100b7fa0554SAndreas Gruenbacher .rename = nfs_rename, 101b7fa0554SAndreas Gruenbacher .permission = nfs_permission, 102b7fa0554SAndreas Gruenbacher .getattr = nfs_getattr, 103b7fa0554SAndreas Gruenbacher .setattr = nfs_setattr, 104b7fa0554SAndreas Gruenbacher .listxattr = nfs3_listxattr, 105b7fa0554SAndreas Gruenbacher .getxattr = nfs3_getxattr, 106b7fa0554SAndreas Gruenbacher .setxattr = nfs3_setxattr, 107b7fa0554SAndreas Gruenbacher .removexattr = nfs3_removexattr, 108b7fa0554SAndreas Gruenbacher }; 109b7fa0554SAndreas Gruenbacher #endif /* CONFIG_NFS_V3 */ 110b7fa0554SAndreas Gruenbacher 1111da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *); 114c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd); 11592e1d5beSArjan van de Ven const struct inode_operations nfs4_dir_inode_operations = { 116c0204fd2STrond Myklebust .create = nfs_open_create, 1171da177e4SLinus Torvalds .lookup = nfs_atomic_lookup, 1181da177e4SLinus Torvalds .link = nfs_link, 1191da177e4SLinus Torvalds .unlink = nfs_unlink, 1201da177e4SLinus Torvalds .symlink = nfs_symlink, 1211da177e4SLinus Torvalds .mkdir = nfs_mkdir, 1221da177e4SLinus Torvalds .rmdir = nfs_rmdir, 1231da177e4SLinus Torvalds .mknod = nfs_mknod, 1241da177e4SLinus Torvalds .rename = nfs_rename, 1251da177e4SLinus Torvalds .permission = nfs_permission, 1261da177e4SLinus Torvalds .getattr = nfs_getattr, 1271da177e4SLinus Torvalds .setattr = nfs_setattr, 1286b3b5496SJ. Bruce Fields .getxattr = nfs4_getxattr, 1296b3b5496SJ. Bruce Fields .setxattr = nfs4_setxattr, 1306b3b5496SJ. Bruce Fields .listxattr = nfs4_listxattr, 1311da177e4SLinus Torvalds }; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds #endif /* CONFIG_NFS_V4 */ 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds /* 1361da177e4SLinus Torvalds * Open file 1371da177e4SLinus Torvalds */ 1381da177e4SLinus Torvalds static int 1391da177e4SLinus Torvalds nfs_opendir(struct inode *inode, struct file *filp) 1401da177e4SLinus Torvalds { 1417451c4f0SCarsten Otte int res; 1421da177e4SLinus Torvalds 1436da24bc9SChuck Lever dfprintk(FILE, "NFS: open dir(%s/%s)\n", 144cc0dd2d1SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 145cc0dd2d1SChuck Lever filp->f_path.dentry->d_name.name); 146cc0dd2d1SChuck Lever 147cc0dd2d1SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 1481e7cb3dcSChuck Lever 1491da177e4SLinus Torvalds /* Call generic open code in order to cache credentials */ 1501da177e4SLinus Torvalds res = nfs_open(inode, filp); 151f5a73672SNeil Brown if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 152f5a73672SNeil Brown /* This is a mountpoint, so d_revalidate will never 153f5a73672SNeil Brown * have been called, so we need to refresh the 154f5a73672SNeil Brown * inode (for close-open consistency) ourselves. 155f5a73672SNeil Brown */ 156f5a73672SNeil Brown __nfs_revalidate_inode(NFS_SERVER(inode), inode); 157f5a73672SNeil Brown } 1581da177e4SLinus Torvalds return res; 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 161d1bacf9eSBryan Schumaker struct nfs_cache_array_entry { 162d1bacf9eSBryan Schumaker u64 cookie; 163d1bacf9eSBryan Schumaker u64 ino; 164d1bacf9eSBryan Schumaker struct qstr string; 165d1bacf9eSBryan Schumaker }; 166d1bacf9eSBryan Schumaker 167d1bacf9eSBryan Schumaker struct nfs_cache_array { 168d1bacf9eSBryan Schumaker unsigned int size; 169d1bacf9eSBryan Schumaker int eof_index; 170d1bacf9eSBryan Schumaker u64 last_cookie; 171d1bacf9eSBryan Schumaker struct nfs_cache_array_entry array[0]; 172d1bacf9eSBryan Schumaker }; 173d1bacf9eSBryan Schumaker 174d1bacf9eSBryan Schumaker #define MAX_READDIR_ARRAY ((PAGE_SIZE - sizeof(struct nfs_cache_array)) / sizeof(struct nfs_cache_array_entry)) 175d1bacf9eSBryan Schumaker 17682f2e547SBryan Schumaker typedef __be32 * (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, struct nfs_server *, int); 1771da177e4SLinus Torvalds typedef struct { 1781da177e4SLinus Torvalds struct file *file; 1791da177e4SLinus Torvalds struct page *page; 1801da177e4SLinus Torvalds unsigned long page_index; 181f0dd2136STrond Myklebust u64 *dir_cookie; 182f0dd2136STrond Myklebust loff_t current_index; 1831da177e4SLinus Torvalds decode_dirent_t decode; 184d1bacf9eSBryan Schumaker 1851f4eab7eSNeil Brown unsigned long timestamp; 1864704f0e2STrond Myklebust unsigned long gencount; 187d1bacf9eSBryan Schumaker unsigned int cache_entry_index; 188d1bacf9eSBryan Schumaker unsigned int plus:1; 189d1bacf9eSBryan Schumaker unsigned int eof:1; 1901da177e4SLinus Torvalds } nfs_readdir_descriptor_t; 1911da177e4SLinus Torvalds 192d1bacf9eSBryan Schumaker /* 193d1bacf9eSBryan Schumaker * The caller is responsible for calling nfs_readdir_release_array(page) 1941da177e4SLinus Torvalds */ 1951da177e4SLinus Torvalds static 196d1bacf9eSBryan Schumaker struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 1971da177e4SLinus Torvalds { 1988cd51a0cSTrond Myklebust void *ptr; 199d1bacf9eSBryan Schumaker if (page == NULL) 200d1bacf9eSBryan Schumaker return ERR_PTR(-EIO); 2018cd51a0cSTrond Myklebust ptr = kmap(page); 2028cd51a0cSTrond Myklebust if (ptr == NULL) 2038cd51a0cSTrond Myklebust return ERR_PTR(-ENOMEM); 2048cd51a0cSTrond Myklebust return ptr; 205d1bacf9eSBryan Schumaker } 206d1bacf9eSBryan Schumaker 207d1bacf9eSBryan Schumaker static 208d1bacf9eSBryan Schumaker void nfs_readdir_release_array(struct page *page) 209d1bacf9eSBryan Schumaker { 210d1bacf9eSBryan Schumaker kunmap(page); 211d1bacf9eSBryan Schumaker } 212d1bacf9eSBryan Schumaker 213d1bacf9eSBryan Schumaker /* 214d1bacf9eSBryan Schumaker * we are freeing strings created by nfs_add_to_readdir_array() 215d1bacf9eSBryan Schumaker */ 216d1bacf9eSBryan Schumaker static 217d1bacf9eSBryan Schumaker int nfs_readdir_clear_array(struct page *page, gfp_t mask) 218d1bacf9eSBryan Schumaker { 219d1bacf9eSBryan Schumaker struct nfs_cache_array *array = nfs_readdir_get_array(page); 220d1bacf9eSBryan Schumaker int i; 2218cd51a0cSTrond Myklebust 2228cd51a0cSTrond Myklebust if (IS_ERR(array)) 2238cd51a0cSTrond Myklebust return PTR_ERR(array); 224d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) 225d1bacf9eSBryan Schumaker kfree(array->array[i].string.name); 226d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 227d1bacf9eSBryan Schumaker return 0; 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; 242*04e4bd1cSCatalin Marinas /* 243*04e4bd1cSCatalin Marinas * Avoid a kmemleak false positive. The pointer to the name is stored 244*04e4bd1cSCatalin Marinas * in a page cache page which kmemleak does not scan. 245*04e4bd1cSCatalin Marinas */ 246*04e4bd1cSCatalin 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); 2608cd51a0cSTrond Myklebust ret = -ENOSPC; 2614a201d6eSTrond Myklebust if (array->size >= MAX_READDIR_ARRAY) 2624a201d6eSTrond Myklebust goto out; 263d1bacf9eSBryan Schumaker 2644a201d6eSTrond Myklebust cache_entry = &array->array[array->size]; 2654a201d6eSTrond Myklebust cache_entry->cookie = entry->prev_cookie; 2664a201d6eSTrond Myklebust cache_entry->ino = entry->ino; 2674a201d6eSTrond Myklebust ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 2684a201d6eSTrond Myklebust if (ret) 2694a201d6eSTrond Myklebust goto out; 270d1bacf9eSBryan Schumaker array->last_cookie = entry->cookie; 2718cd51a0cSTrond Myklebust array->size++; 272d1bacf9eSBryan Schumaker if (entry->eof == 1) 273d1bacf9eSBryan Schumaker array->eof_index = array->size; 2744a201d6eSTrond Myklebust out: 275d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 2764a201d6eSTrond Myklebust return ret; 277d1bacf9eSBryan Schumaker } 278d1bacf9eSBryan Schumaker 279d1bacf9eSBryan Schumaker static 280d1bacf9eSBryan Schumaker int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 281d1bacf9eSBryan Schumaker { 282d1bacf9eSBryan Schumaker loff_t diff = desc->file->f_pos - desc->current_index; 283d1bacf9eSBryan Schumaker unsigned int index; 284d1bacf9eSBryan Schumaker 285d1bacf9eSBryan Schumaker if (diff < 0) 286d1bacf9eSBryan Schumaker goto out_eof; 287d1bacf9eSBryan Schumaker if (diff >= array->size) { 2888cd51a0cSTrond Myklebust if (array->eof_index >= 0) 289d1bacf9eSBryan Schumaker goto out_eof; 290d1bacf9eSBryan Schumaker desc->current_index += array->size; 291d1bacf9eSBryan Schumaker return -EAGAIN; 292d1bacf9eSBryan Schumaker } 293d1bacf9eSBryan Schumaker 294d1bacf9eSBryan Schumaker index = (unsigned int)diff; 295d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[index].cookie; 296d1bacf9eSBryan Schumaker desc->cache_entry_index = index; 297d1bacf9eSBryan Schumaker return 0; 298d1bacf9eSBryan Schumaker out_eof: 299d1bacf9eSBryan Schumaker desc->eof = 1; 300d1bacf9eSBryan Schumaker return -EBADCOOKIE; 301d1bacf9eSBryan Schumaker } 302d1bacf9eSBryan Schumaker 303d1bacf9eSBryan Schumaker static 304d1bacf9eSBryan Schumaker int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 305d1bacf9eSBryan Schumaker { 306d1bacf9eSBryan Schumaker int i; 307d1bacf9eSBryan Schumaker int status = -EAGAIN; 308d1bacf9eSBryan Schumaker 309d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) { 3108cd51a0cSTrond Myklebust if (array->array[i].cookie == *desc->dir_cookie) { 3118cd51a0cSTrond Myklebust desc->cache_entry_index = i; 3128cd51a0cSTrond Myklebust status = 0; 3138cd51a0cSTrond Myklebust goto out; 3148cd51a0cSTrond Myklebust } 3158cd51a0cSTrond Myklebust } 316d1bacf9eSBryan Schumaker if (i == array->eof_index) { 317d1bacf9eSBryan Schumaker desc->eof = 1; 318d1bacf9eSBryan Schumaker status = -EBADCOOKIE; 319d1bacf9eSBryan Schumaker } 3208cd51a0cSTrond Myklebust out: 321d1bacf9eSBryan Schumaker return status; 322d1bacf9eSBryan Schumaker } 323d1bacf9eSBryan Schumaker 324d1bacf9eSBryan Schumaker static 325d1bacf9eSBryan Schumaker int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 326d1bacf9eSBryan Schumaker { 327d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 328d1bacf9eSBryan Schumaker int status = -EBADCOOKIE; 329d1bacf9eSBryan Schumaker 330d1bacf9eSBryan Schumaker if (desc->dir_cookie == NULL) 331d1bacf9eSBryan Schumaker goto out; 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 344d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 345d1bacf9eSBryan Schumaker out: 346d1bacf9eSBryan Schumaker return status; 347d1bacf9eSBryan Schumaker } 348d1bacf9eSBryan Schumaker 349d1bacf9eSBryan Schumaker /* Fill a page with xdr information before transferring to the cache page */ 350d1bacf9eSBryan Schumaker static 35156e4ebf8SBryan Schumaker int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 352d1bacf9eSBryan Schumaker struct nfs_entry *entry, struct file *file, struct inode *inode) 353d1bacf9eSBryan Schumaker { 3541da177e4SLinus Torvalds struct rpc_cred *cred = nfs_file_cred(file); 3554704f0e2STrond Myklebust unsigned long timestamp, gencount; 3561da177e4SLinus Torvalds int error; 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds again: 3591da177e4SLinus Torvalds timestamp = jiffies; 3604704f0e2STrond Myklebust gencount = nfs_inc_attr_generation_counter(); 36156e4ebf8SBryan Schumaker error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages, 3621da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, desc->plus); 3631da177e4SLinus Torvalds if (error < 0) { 3641da177e4SLinus Torvalds /* We requested READDIRPLUS, but the server doesn't grok it */ 3651da177e4SLinus Torvalds if (error == -ENOTSUPP && desc->plus) { 3661da177e4SLinus Torvalds NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 3673a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 3681da177e4SLinus Torvalds desc->plus = 0; 3691da177e4SLinus Torvalds goto again; 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds goto error; 3721da177e4SLinus Torvalds } 3731f4eab7eSNeil Brown desc->timestamp = timestamp; 3744704f0e2STrond Myklebust desc->gencount = gencount; 375d1bacf9eSBryan Schumaker error: 376d1bacf9eSBryan Schumaker return error; 377d1bacf9eSBryan Schumaker } 378d1bacf9eSBryan Schumaker 379d1bacf9eSBryan Schumaker /* Fill in an entry based on the xdr code stored in desc->page */ 380d1bacf9eSBryan Schumaker static 381babddc72SBryan Schumaker int xdr_decode(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, struct xdr_stream *stream) 382d1bacf9eSBryan Schumaker { 38382f2e547SBryan Schumaker __be32 *p = desc->decode(stream, entry, NFS_SERVER(desc->file->f_path.dentry->d_inode), desc->plus); 384d1bacf9eSBryan Schumaker if (IS_ERR(p)) 385d1bacf9eSBryan Schumaker return PTR_ERR(p); 386d1bacf9eSBryan Schumaker 387d1bacf9eSBryan Schumaker entry->fattr->time_start = desc->timestamp; 388d1bacf9eSBryan Schumaker entry->fattr->gencount = desc->gencount; 389d1bacf9eSBryan Schumaker return 0; 390d1bacf9eSBryan Schumaker } 391d1bacf9eSBryan Schumaker 392d39ab9deSBryan Schumaker static 393d39ab9deSBryan Schumaker int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 394d39ab9deSBryan Schumaker { 395d39ab9deSBryan Schumaker struct nfs_inode *node; 396d39ab9deSBryan Schumaker if (dentry->d_inode == NULL) 397d39ab9deSBryan Schumaker goto different; 398d39ab9deSBryan Schumaker node = NFS_I(dentry->d_inode); 399d39ab9deSBryan Schumaker if (node->fh.size != entry->fh->size) 400d39ab9deSBryan Schumaker goto different; 401d39ab9deSBryan Schumaker if (strncmp(node->fh.data, entry->fh->data, node->fh.size) != 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 int status; 47099424380SBryan Schumaker struct nfs_cache_array *array; 471babddc72SBryan Schumaker 472babddc72SBryan Schumaker buf.head->iov_base = xdr_page; 473babddc72SBryan Schumaker buf.head->iov_len = buflen; 474babddc72SBryan Schumaker buf.tail->iov_len = 0; 475babddc72SBryan Schumaker buf.page_base = 0; 476babddc72SBryan Schumaker buf.page_len = 0; 477babddc72SBryan Schumaker buf.buflen = buf.head->iov_len; 478babddc72SBryan Schumaker buf.len = buf.head->iov_len; 479babddc72SBryan Schumaker 480babddc72SBryan Schumaker xdr_init_decode(&stream, &buf, ptr); 481babddc72SBryan Schumaker 48299424380SBryan Schumaker 48399424380SBryan Schumaker do { 48499424380SBryan Schumaker status = xdr_decode(desc, entry, &stream); 4858cd51a0cSTrond Myklebust if (status != 0) { 4868cd51a0cSTrond Myklebust if (status == -EAGAIN) 4878cd51a0cSTrond Myklebust status = 0; 48899424380SBryan Schumaker break; 4898cd51a0cSTrond Myklebust } 49099424380SBryan Schumaker 491d39ab9deSBryan Schumaker if (desc->plus == 1) 492d39ab9deSBryan Schumaker nfs_prime_dcache(desc->file->f_path.dentry, entry); 4938cd51a0cSTrond Myklebust 4948cd51a0cSTrond Myklebust status = nfs_readdir_add_to_array(entry, page); 4958cd51a0cSTrond Myklebust if (status != 0) 4968cd51a0cSTrond Myklebust break; 49799424380SBryan Schumaker } while (!entry->eof); 49899424380SBryan Schumaker 49999424380SBryan Schumaker if (status == -EBADCOOKIE && entry->eof) { 50099424380SBryan Schumaker array = nfs_readdir_get_array(page); 5018cd51a0cSTrond Myklebust if (!IS_ERR(array)) { 5028cd51a0cSTrond Myklebust array->eof_index = array->size; 50399424380SBryan Schumaker status = 0; 50499424380SBryan Schumaker nfs_readdir_release_array(page); 505d1bacf9eSBryan Schumaker } 50656e4ebf8SBryan Schumaker } 5078cd51a0cSTrond Myklebust return status; 5088cd51a0cSTrond Myklebust } 50956e4ebf8SBryan Schumaker 51056e4ebf8SBryan Schumaker static 51156e4ebf8SBryan Schumaker void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages) 51256e4ebf8SBryan Schumaker { 51356e4ebf8SBryan Schumaker unsigned int i; 51456e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) 51556e4ebf8SBryan Schumaker put_page(pages[i]); 51656e4ebf8SBryan Schumaker } 51756e4ebf8SBryan Schumaker 51856e4ebf8SBryan Schumaker static 51956e4ebf8SBryan Schumaker void nfs_readdir_free_large_page(void *ptr, struct page **pages, 52056e4ebf8SBryan Schumaker unsigned int npages) 52156e4ebf8SBryan Schumaker { 52256e4ebf8SBryan Schumaker vm_unmap_ram(ptr, npages); 52356e4ebf8SBryan Schumaker nfs_readdir_free_pagearray(pages, npages); 52456e4ebf8SBryan Schumaker } 52556e4ebf8SBryan Schumaker 52656e4ebf8SBryan Schumaker /* 52756e4ebf8SBryan Schumaker * nfs_readdir_large_page will allocate pages that must be freed with a call 52856e4ebf8SBryan Schumaker * to nfs_readdir_free_large_page 52956e4ebf8SBryan Schumaker */ 53056e4ebf8SBryan Schumaker static 53156e4ebf8SBryan Schumaker void *nfs_readdir_large_page(struct page **pages, unsigned int npages) 53256e4ebf8SBryan Schumaker { 53356e4ebf8SBryan Schumaker void *ptr; 53456e4ebf8SBryan Schumaker unsigned int i; 53556e4ebf8SBryan Schumaker 53656e4ebf8SBryan Schumaker for (i = 0; i < npages; i++) { 53756e4ebf8SBryan Schumaker struct page *page = alloc_page(GFP_KERNEL); 53856e4ebf8SBryan Schumaker if (page == NULL) 53956e4ebf8SBryan Schumaker goto out_freepages; 54056e4ebf8SBryan Schumaker pages[i] = page; 54156e4ebf8SBryan Schumaker } 54256e4ebf8SBryan Schumaker 5434a201d6eSTrond Myklebust ptr = vm_map_ram(pages, npages, 0, PAGE_KERNEL); 54456e4ebf8SBryan Schumaker if (!IS_ERR_OR_NULL(ptr)) 54556e4ebf8SBryan Schumaker return ptr; 54656e4ebf8SBryan Schumaker out_freepages: 54756e4ebf8SBryan Schumaker nfs_readdir_free_pagearray(pages, i); 54856e4ebf8SBryan Schumaker return NULL; 549d1bacf9eSBryan Schumaker } 550d1bacf9eSBryan Schumaker 551d1bacf9eSBryan Schumaker static 552d1bacf9eSBryan Schumaker int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 553d1bacf9eSBryan Schumaker { 55456e4ebf8SBryan Schumaker struct page *pages[NFS_MAX_READDIR_PAGES]; 55556e4ebf8SBryan Schumaker void *pages_ptr = NULL; 556d1bacf9eSBryan Schumaker struct nfs_entry entry; 557d1bacf9eSBryan Schumaker struct file *file = desc->file; 558d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 5598cd51a0cSTrond Myklebust int status = -ENOMEM; 56056e4ebf8SBryan Schumaker unsigned int array_size = ARRAY_SIZE(pages); 561d1bacf9eSBryan Schumaker 562d1bacf9eSBryan Schumaker entry.prev_cookie = 0; 563d1bacf9eSBryan Schumaker entry.cookie = *desc->dir_cookie; 564d1bacf9eSBryan Schumaker entry.eof = 0; 565d1bacf9eSBryan Schumaker entry.fh = nfs_alloc_fhandle(); 566d1bacf9eSBryan Schumaker entry.fattr = nfs_alloc_fattr(); 567d1bacf9eSBryan Schumaker if (entry.fh == NULL || entry.fattr == NULL) 568d1bacf9eSBryan Schumaker goto out; 569d1bacf9eSBryan Schumaker 570d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(page); 5718cd51a0cSTrond Myklebust if (IS_ERR(array)) { 5728cd51a0cSTrond Myklebust status = PTR_ERR(array); 5738cd51a0cSTrond Myklebust goto out; 5748cd51a0cSTrond Myklebust } 575d1bacf9eSBryan Schumaker memset(array, 0, sizeof(struct nfs_cache_array)); 576d1bacf9eSBryan Schumaker array->eof_index = -1; 577d1bacf9eSBryan Schumaker 57856e4ebf8SBryan Schumaker pages_ptr = nfs_readdir_large_page(pages, array_size); 57956e4ebf8SBryan Schumaker if (!pages_ptr) 580d1bacf9eSBryan Schumaker goto out_release_array; 581d1bacf9eSBryan Schumaker do { 582ac396128STrond Myklebust unsigned int pglen; 58356e4ebf8SBryan Schumaker status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode); 584babddc72SBryan Schumaker 585d1bacf9eSBryan Schumaker if (status < 0) 586d1bacf9eSBryan Schumaker break; 587ac396128STrond Myklebust pglen = status; 588ac396128STrond Myklebust status = nfs_readdir_page_filler(desc, &entry, pages_ptr, page, pglen); 5898cd51a0cSTrond Myklebust if (status < 0) { 5908cd51a0cSTrond Myklebust if (status == -ENOSPC) 5918cd51a0cSTrond Myklebust status = 0; 5928cd51a0cSTrond Myklebust break; 5938cd51a0cSTrond Myklebust } 5948cd51a0cSTrond Myklebust } while (array->eof_index < 0); 595d1bacf9eSBryan Schumaker 59656e4ebf8SBryan Schumaker nfs_readdir_free_large_page(pages_ptr, pages, array_size); 597d1bacf9eSBryan Schumaker out_release_array: 598d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 599d1bacf9eSBryan Schumaker out: 600d1bacf9eSBryan Schumaker nfs_free_fattr(entry.fattr); 601d1bacf9eSBryan Schumaker nfs_free_fhandle(entry.fh); 602d1bacf9eSBryan Schumaker return status; 603d1bacf9eSBryan Schumaker } 604d1bacf9eSBryan Schumaker 605d1bacf9eSBryan Schumaker /* 606d1bacf9eSBryan Schumaker * Now we cache directories properly, by converting xdr information 607d1bacf9eSBryan Schumaker * to an array that can be used for lookups later. This results in 608d1bacf9eSBryan Schumaker * fewer cache pages, since we can store more information on each page. 609d1bacf9eSBryan Schumaker * We only need to convert from xdr once so future lookups are much simpler 6101da177e4SLinus Torvalds */ 611d1bacf9eSBryan Schumaker static 612d1bacf9eSBryan Schumaker int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 613d1bacf9eSBryan Schumaker { 614d1bacf9eSBryan Schumaker struct inode *inode = desc->file->f_path.dentry->d_inode; 6158cd51a0cSTrond Myklebust int ret; 616d1bacf9eSBryan Schumaker 6178cd51a0cSTrond Myklebust ret = nfs_readdir_xdr_to_array(desc, page, inode); 6188cd51a0cSTrond Myklebust if (ret < 0) 619d1bacf9eSBryan Schumaker goto error; 620d1bacf9eSBryan Schumaker SetPageUptodate(page); 621d1bacf9eSBryan Schumaker 6222aac05a9STrond Myklebust if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 623cd9ae2b6STrond Myklebust /* Should never happen */ 624cd9ae2b6STrond Myklebust nfs_zap_mapping(inode, inode->i_mapping); 625cd9ae2b6STrond Myklebust } 6261da177e4SLinus Torvalds unlock_page(page); 6271da177e4SLinus Torvalds return 0; 6281da177e4SLinus Torvalds error: 6291da177e4SLinus Torvalds unlock_page(page); 6308cd51a0cSTrond Myklebust return ret; 6311da177e4SLinus Torvalds } 6321da177e4SLinus Torvalds 633d1bacf9eSBryan Schumaker static 634d1bacf9eSBryan Schumaker void cache_page_release(nfs_readdir_descriptor_t *desc) 6351da177e4SLinus Torvalds { 6361da177e4SLinus Torvalds page_cache_release(desc->page); 6371da177e4SLinus Torvalds desc->page = NULL; 6381da177e4SLinus Torvalds } 6391da177e4SLinus Torvalds 640d1bacf9eSBryan Schumaker static 641d1bacf9eSBryan Schumaker struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 6421da177e4SLinus Torvalds { 6438cd51a0cSTrond Myklebust return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping, 644d1bacf9eSBryan Schumaker desc->page_index, (filler_t *)nfs_readdir_filler, desc); 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds /* 648d1bacf9eSBryan Schumaker * Returns 0 if desc->dir_cookie was found on page desc->page_index 6491da177e4SLinus Torvalds */ 650d1bacf9eSBryan Schumaker static 651d1bacf9eSBryan Schumaker int find_cache_page(nfs_readdir_descriptor_t *desc) 652d1bacf9eSBryan Schumaker { 653d1bacf9eSBryan Schumaker int res; 654d1bacf9eSBryan Schumaker 655d1bacf9eSBryan Schumaker desc->page = get_cache_page(desc); 656d1bacf9eSBryan Schumaker if (IS_ERR(desc->page)) 657d1bacf9eSBryan Schumaker return PTR_ERR(desc->page); 658d1bacf9eSBryan Schumaker 659d1bacf9eSBryan Schumaker res = nfs_readdir_search_array(desc); 660d1bacf9eSBryan Schumaker if (res == 0) 661d1bacf9eSBryan Schumaker return 0; 662d1bacf9eSBryan Schumaker cache_page_release(desc); 663d1bacf9eSBryan Schumaker return res; 664d1bacf9eSBryan Schumaker } 665d1bacf9eSBryan Schumaker 666d1bacf9eSBryan Schumaker /* Search for desc->dir_cookie from the beginning of the page cache */ 6671da177e4SLinus Torvalds static inline 6681da177e4SLinus Torvalds int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 6691da177e4SLinus Torvalds { 6708cd51a0cSTrond Myklebust int res; 671d1bacf9eSBryan Schumaker 6728cd51a0cSTrond Myklebust if (desc->page_index == 0) 6738cd51a0cSTrond Myklebust desc->current_index = 0; 674d1bacf9eSBryan Schumaker while (1) { 675d1bacf9eSBryan Schumaker res = find_cache_page(desc); 6761da177e4SLinus Torvalds if (res != -EAGAIN) 6771da177e4SLinus Torvalds break; 6781da177e4SLinus Torvalds desc->page_index++; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds return res; 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds static inline unsigned int dt_type(struct inode *inode) 6841da177e4SLinus Torvalds { 6851da177e4SLinus Torvalds return (inode->i_mode >> 12) & 15; 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; 699d1bacf9eSBryan Schumaker unsigned int d_type = DT_UNKNOWN; 7001da177e4SLinus Torvalds struct dentry *dentry = NULL; 7011da177e4SLinus Torvalds 702d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 7038cd51a0cSTrond Myklebust if (IS_ERR(array)) 7048cd51a0cSTrond Myklebust return PTR_ERR(array); 7051da177e4SLinus Torvalds 706d1bacf9eSBryan Schumaker for (i = desc->cache_entry_index; i < array->size; i++) { 707d1bacf9eSBryan Schumaker d_type = DT_UNKNOWN; 7081da177e4SLinus Torvalds 709d1bacf9eSBryan Schumaker res = filldir(dirent, array->array[i].string.name, 710d1bacf9eSBryan Schumaker array->array[i].string.len, file->f_pos, 711d1bacf9eSBryan Schumaker nfs_compat_user_ino64(array->array[i].ino), d_type); 7121da177e4SLinus Torvalds if (res < 0) 7131da177e4SLinus Torvalds break; 71400a92642SOlivier Galibert file->f_pos++; 715d1bacf9eSBryan Schumaker desc->cache_entry_index = i; 716d1bacf9eSBryan Schumaker if (i < (array->size-1)) 717d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[i+1].cookie; 718d1bacf9eSBryan Schumaker else 719d1bacf9eSBryan Schumaker *desc->dir_cookie = array->last_cookie; 7208cd51a0cSTrond Myklebust } 7218cd51a0cSTrond Myklebust if (i == array->eof_index) 722d1bacf9eSBryan Schumaker desc->eof = 1; 723d1bacf9eSBryan Schumaker 724d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 725d1bacf9eSBryan Schumaker cache_page_release(desc); 7261da177e4SLinus Torvalds if (dentry != NULL) 7271da177e4SLinus Torvalds dput(dentry); 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 762d1bacf9eSBryan Schumaker if (nfs_readdir_xdr_to_array(desc, page, inode) == -1) { 763d1bacf9eSBryan Schumaker status = -EIO; 764d1bacf9eSBryan Schumaker goto out_release; 765d1bacf9eSBryan Schumaker } 766d1bacf9eSBryan Schumaker 767baf57a09STrond Myklebust desc->page_index = 0; 768d1bacf9eSBryan Schumaker desc->page = page; 7691da177e4SLinus Torvalds status = nfs_do_filldir(desc, dirent, filldir); 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds out: 7721e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 7733110ff80SHarvey Harrison __func__, status); 7741da177e4SLinus Torvalds return status; 7751da177e4SLinus Torvalds out_release: 776d1bacf9eSBryan Schumaker cache_page_release(desc); 7771da177e4SLinus Torvalds goto out; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds 78000a92642SOlivier Galibert /* The file offset position represents the dirent entry number. A 78100a92642SOlivier Galibert last cookie cache takes care of the common case of reading the 78200a92642SOlivier Galibert whole directory. 7831da177e4SLinus Torvalds */ 7841da177e4SLinus Torvalds static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 7851da177e4SLinus Torvalds { 78601cce933SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 7871da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 7881da177e4SLinus Torvalds nfs_readdir_descriptor_t my_desc, 7891da177e4SLinus Torvalds *desc = &my_desc; 790aa49b4cfSTrond Myklebust int res = -ENOMEM; 7911da177e4SLinus Torvalds 7926da24bc9SChuck Lever dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n", 7931e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 7941e7cb3dcSChuck Lever (long long)filp->f_pos); 79591d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 79691d5b470SChuck Lever 7971da177e4SLinus Torvalds /* 79800a92642SOlivier Galibert * filp->f_pos points to the dirent entry number. 799f0dd2136STrond Myklebust * *desc->dir_cookie has the cookie for the next entry. We have 80000a92642SOlivier Galibert * to either find the entry with the appropriate number or 80100a92642SOlivier Galibert * revalidate the cookie. 8021da177e4SLinus Torvalds */ 8031da177e4SLinus Torvalds memset(desc, 0, sizeof(*desc)); 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds desc->file = filp; 806cd3758e3STrond Myklebust desc->dir_cookie = &nfs_file_open_context(filp)->dir_cookie; 8071da177e4SLinus Torvalds desc->decode = NFS_PROTO(inode)->decode_dirent; 8081da177e4SLinus Torvalds desc->plus = NFS_USE_READDIRPLUS(inode); 8091da177e4SLinus Torvalds 810565277f6STrond Myklebust nfs_block_sillyrename(dentry); 8111cda707dSTrond Myklebust res = nfs_revalidate_mapping(inode, filp->f_mapping); 812fccca7fcSTrond Myklebust if (res < 0) 813fccca7fcSTrond Myklebust goto out; 814fccca7fcSTrond Myklebust 815d1bacf9eSBryan Schumaker while (desc->eof != 1) { 8161da177e4SLinus Torvalds res = readdir_search_pagecache(desc); 81700a92642SOlivier Galibert 8181da177e4SLinus Torvalds if (res == -EBADCOOKIE) { 8191da177e4SLinus Torvalds /* This means either end of directory */ 820d1bacf9eSBryan Schumaker if (*desc->dir_cookie && desc->eof == 0) { 8211da177e4SLinus Torvalds /* Or that the server has 'lost' a cookie */ 8221da177e4SLinus Torvalds res = uncached_readdir(desc, dirent, filldir); 8231da177e4SLinus Torvalds if (res >= 0) 8241da177e4SLinus Torvalds continue; 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds res = 0; 8271da177e4SLinus Torvalds break; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds if (res == -ETOOSMALL && desc->plus) { 8303a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 8311da177e4SLinus Torvalds nfs_zap_caches(inode); 832baf57a09STrond Myklebust desc->page_index = 0; 8331da177e4SLinus Torvalds desc->plus = 0; 834d1bacf9eSBryan Schumaker desc->eof = 0; 8351da177e4SLinus Torvalds continue; 8361da177e4SLinus Torvalds } 8371da177e4SLinus Torvalds if (res < 0) 8381da177e4SLinus Torvalds break; 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds res = nfs_do_filldir(desc, dirent, filldir); 8411da177e4SLinus Torvalds if (res < 0) { 8421da177e4SLinus Torvalds res = 0; 8431da177e4SLinus Torvalds break; 8441da177e4SLinus Torvalds } 8451da177e4SLinus Torvalds } 846fccca7fcSTrond Myklebust out: 847565277f6STrond Myklebust nfs_unblock_sillyrename(dentry); 8481e7cb3dcSChuck Lever if (res > 0) 8491e7cb3dcSChuck Lever res = 0; 850aa49b4cfSTrond Myklebust dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n", 8511e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 8521e7cb3dcSChuck Lever res); 8531da177e4SLinus Torvalds return res; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds 85610afec90STrond Myklebust static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 857f0dd2136STrond Myklebust { 858b84e06c5SChuck Lever struct dentry *dentry = filp->f_path.dentry; 859b84e06c5SChuck Lever struct inode *inode = dentry->d_inode; 860b84e06c5SChuck Lever 8616da24bc9SChuck Lever dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n", 862b84e06c5SChuck Lever dentry->d_parent->d_name.name, 863b84e06c5SChuck Lever dentry->d_name.name, 864b84e06c5SChuck Lever offset, origin); 865b84e06c5SChuck Lever 866b84e06c5SChuck Lever mutex_lock(&inode->i_mutex); 867f0dd2136STrond Myklebust switch (origin) { 868f0dd2136STrond Myklebust case 1: 869f0dd2136STrond Myklebust offset += filp->f_pos; 870f0dd2136STrond Myklebust case 0: 871f0dd2136STrond Myklebust if (offset >= 0) 872f0dd2136STrond Myklebust break; 873f0dd2136STrond Myklebust default: 874f0dd2136STrond Myklebust offset = -EINVAL; 875f0dd2136STrond Myklebust goto out; 876f0dd2136STrond Myklebust } 877f0dd2136STrond Myklebust if (offset != filp->f_pos) { 878f0dd2136STrond Myklebust filp->f_pos = offset; 879cd3758e3STrond Myklebust nfs_file_open_context(filp)->dir_cookie = 0; 880f0dd2136STrond Myklebust } 881f0dd2136STrond Myklebust out: 882b84e06c5SChuck Lever mutex_unlock(&inode->i_mutex); 883f0dd2136STrond Myklebust return offset; 884f0dd2136STrond Myklebust } 885f0dd2136STrond Myklebust 8861da177e4SLinus Torvalds /* 8871da177e4SLinus Torvalds * All directory operations under NFS are synchronous, so fsync() 8881da177e4SLinus Torvalds * is a dummy operation. 8891da177e4SLinus Torvalds */ 8907ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *filp, int datasync) 8911da177e4SLinus Torvalds { 8927ea80859SChristoph Hellwig struct dentry *dentry = filp->f_path.dentry; 8937ea80859SChristoph Hellwig 8946da24bc9SChuck Lever dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n", 8951e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 8961e7cb3dcSChuck Lever datasync); 8971e7cb3dcSChuck Lever 89854917786SChuck Lever nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC); 8991da177e4SLinus Torvalds return 0; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 902bfc69a45STrond Myklebust /** 903bfc69a45STrond Myklebust * nfs_force_lookup_revalidate - Mark the directory as having changed 904bfc69a45STrond Myklebust * @dir - pointer to directory inode 905bfc69a45STrond Myklebust * 906bfc69a45STrond Myklebust * This forces the revalidation code in nfs_lookup_revalidate() to do a 907bfc69a45STrond Myklebust * full lookup on all child dentries of 'dir' whenever a change occurs 908bfc69a45STrond Myklebust * on the server that might have invalidated our dcache. 909bfc69a45STrond Myklebust * 910bfc69a45STrond Myklebust * The caller should be holding dir->i_lock 911bfc69a45STrond Myklebust */ 912bfc69a45STrond Myklebust void nfs_force_lookup_revalidate(struct inode *dir) 913bfc69a45STrond Myklebust { 914011935a0STrond Myklebust NFS_I(dir)->cache_change_attribute++; 915bfc69a45STrond Myklebust } 916bfc69a45STrond Myklebust 9171da177e4SLinus Torvalds /* 9181da177e4SLinus Torvalds * A check for whether or not the parent directory has changed. 9191da177e4SLinus Torvalds * In the case it has, we assume that the dentries are untrustworthy 9201da177e4SLinus Torvalds * and may need to be looked up again. 9211da177e4SLinus Torvalds */ 922c79ba787STrond Myklebust static int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 9231da177e4SLinus Torvalds { 9241da177e4SLinus Torvalds if (IS_ROOT(dentry)) 9251da177e4SLinus Torvalds return 1; 9264eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 9274eec952eSTrond Myklebust return 0; 928f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 9296ecc5e8fSTrond Myklebust return 0; 930f2c77f4eSTrond Myklebust /* Revalidate nfsi->cache_change_attribute before we declare a match */ 931f2c77f4eSTrond Myklebust if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 932f2c77f4eSTrond Myklebust return 0; 933f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 934f2c77f4eSTrond Myklebust return 0; 935f2c77f4eSTrond Myklebust return 1; 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds /* 9391d6757fbSTrond Myklebust * Return the intent data that applies to this particular path component 9401d6757fbSTrond Myklebust * 9411d6757fbSTrond Myklebust * Note that the current set of intents only apply to the very last 9421d6757fbSTrond Myklebust * component of the path. 9431d6757fbSTrond Myklebust * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 9441d6757fbSTrond Myklebust */ 9451d6757fbSTrond Myklebust static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask) 9461d6757fbSTrond Myklebust { 9471d6757fbSTrond Myklebust if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 9481d6757fbSTrond Myklebust return 0; 9491d6757fbSTrond Myklebust return nd->flags & mask; 9501d6757fbSTrond Myklebust } 9511d6757fbSTrond Myklebust 9521d6757fbSTrond Myklebust /* 953a12802caSTrond Myklebust * Use intent information to check whether or not we're going to do 954a12802caSTrond Myklebust * an O_EXCL create using this path component. 955a12802caSTrond Myklebust */ 956a12802caSTrond Myklebust static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 957a12802caSTrond Myklebust { 958a12802caSTrond Myklebust if (NFS_PROTO(dir)->version == 2) 959a12802caSTrond Myklebust return 0; 9603516586aSAl Viro return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL); 961a12802caSTrond Myklebust } 962a12802caSTrond Myklebust 963a12802caSTrond Myklebust /* 9641d6757fbSTrond Myklebust * Inode and filehandle revalidation for lookups. 9651d6757fbSTrond Myklebust * 9661d6757fbSTrond Myklebust * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 9671d6757fbSTrond Myklebust * or if the intent information indicates that we're about to open this 9681d6757fbSTrond Myklebust * particular file and the "nocto" mount flag is not set. 9691d6757fbSTrond Myklebust * 9701d6757fbSTrond Myklebust */ 9711da177e4SLinus Torvalds static inline 9721da177e4SLinus Torvalds int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 9731da177e4SLinus Torvalds { 9741da177e4SLinus Torvalds struct nfs_server *server = NFS_SERVER(inode); 9751da177e4SLinus Torvalds 9764e99a1ffSTrond Myklebust if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags)) 9774e99a1ffSTrond Myklebust return 0; 9781da177e4SLinus Torvalds if (nd != NULL) { 9791da177e4SLinus Torvalds /* VFS wants an on-the-wire revalidation */ 9801d6757fbSTrond Myklebust if (nd->flags & LOOKUP_REVAL) 9811da177e4SLinus Torvalds goto out_force; 9821da177e4SLinus Torvalds /* This is an open(2) */ 9831d6757fbSTrond Myklebust if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 9844e0641a7STrond Myklebust !(server->flags & NFS_MOUNT_NOCTO) && 9854e0641a7STrond Myklebust (S_ISREG(inode->i_mode) || 9864e0641a7STrond Myklebust S_ISDIR(inode->i_mode))) 9871da177e4SLinus Torvalds goto out_force; 9884f48af45STrond Myklebust return 0; 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds return nfs_revalidate_inode(server, inode); 9911da177e4SLinus Torvalds out_force: 9921da177e4SLinus Torvalds return __nfs_revalidate_inode(server, inode); 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds /* 9961da177e4SLinus Torvalds * We judge how long we want to trust negative 9971da177e4SLinus Torvalds * dentries by looking at the parent inode mtime. 9981da177e4SLinus Torvalds * 9991da177e4SLinus Torvalds * If parent mtime has changed, we revalidate, else we wait for a 10001da177e4SLinus Torvalds * period corresponding to the parent's attribute cache timeout value. 10011da177e4SLinus Torvalds */ 10021da177e4SLinus Torvalds static inline 10031da177e4SLinus Torvalds int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 10041da177e4SLinus Torvalds struct nameidata *nd) 10051da177e4SLinus Torvalds { 10061da177e4SLinus Torvalds /* Don't revalidate a negative dentry if we're creating a new file */ 10071d6757fbSTrond Myklebust if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 10081da177e4SLinus Torvalds return 0; 10094eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 10104eec952eSTrond Myklebust return 1; 10111da177e4SLinus Torvalds return !nfs_check_verifier(dir, dentry); 10121da177e4SLinus Torvalds } 10131da177e4SLinus Torvalds 10141da177e4SLinus Torvalds /* 10151da177e4SLinus Torvalds * This is called every time the dcache has a lookup hit, 10161da177e4SLinus Torvalds * and we should check whether we can really trust that 10171da177e4SLinus Torvalds * lookup. 10181da177e4SLinus Torvalds * 10191da177e4SLinus Torvalds * NOTE! The hit can be a negative hit too, don't assume 10201da177e4SLinus Torvalds * we have an inode! 10211da177e4SLinus Torvalds * 10221da177e4SLinus Torvalds * If the parent directory is seen to have changed, we throw out the 10231da177e4SLinus Torvalds * cached dentry and do a new lookup. 10241da177e4SLinus Torvalds */ 10251da177e4SLinus Torvalds static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd) 10261da177e4SLinus Torvalds { 10271da177e4SLinus Torvalds struct inode *dir; 10281da177e4SLinus Torvalds struct inode *inode; 10291da177e4SLinus Torvalds struct dentry *parent; 1030e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1031e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 10321da177e4SLinus Torvalds int error; 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds parent = dget_parent(dentry); 10351da177e4SLinus Torvalds dir = parent->d_inode; 103691d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 10371da177e4SLinus Torvalds inode = dentry->d_inode; 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds if (!inode) { 10401da177e4SLinus Torvalds if (nfs_neg_need_reval(dir, dentry, nd)) 10411da177e4SLinus Torvalds goto out_bad; 10421da177e4SLinus Torvalds goto out_valid; 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds if (is_bad_inode(inode)) { 10461e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 10473110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 10481e7cb3dcSChuck Lever dentry->d_name.name); 10491da177e4SLinus Torvalds goto out_bad; 10501da177e4SLinus Torvalds } 10511da177e4SLinus Torvalds 105215860ab1STrond Myklebust if (nfs_have_delegation(inode, FMODE_READ)) 105315860ab1STrond Myklebust goto out_set_verifier; 105415860ab1STrond Myklebust 10551da177e4SLinus Torvalds /* Force a full look up iff the parent directory has changed */ 1056a12802caSTrond Myklebust if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) { 10571da177e4SLinus Torvalds if (nfs_lookup_verify_inode(inode, nd)) 10581da177e4SLinus Torvalds goto out_zap_parent; 10591da177e4SLinus Torvalds goto out_valid; 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds if (NFS_STALE(inode)) 10631da177e4SLinus Torvalds goto out_bad; 10641da177e4SLinus Torvalds 1065e1fb4d05STrond Myklebust error = -ENOMEM; 1066e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1067e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1068e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1069e1fb4d05STrond Myklebust goto out_error; 1070e1fb4d05STrond Myklebust 1071e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 10721da177e4SLinus Torvalds if (error) 10731da177e4SLinus Torvalds goto out_bad; 1074e1fb4d05STrond Myklebust if (nfs_compare_fh(NFS_FH(inode), fhandle)) 10751da177e4SLinus Torvalds goto out_bad; 1076e1fb4d05STrond Myklebust if ((error = nfs_refresh_inode(inode, fattr)) != 0) 10771da177e4SLinus Torvalds goto out_bad; 10781da177e4SLinus Torvalds 1079e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1080e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 108115860ab1STrond Myklebust out_set_verifier: 1082cf8ba45eSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 10831da177e4SLinus Torvalds out_valid: 10841da177e4SLinus Torvalds dput(parent); 10851e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 10863110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 10871e7cb3dcSChuck Lever dentry->d_name.name); 10881da177e4SLinus Torvalds return 1; 10891da177e4SLinus Torvalds out_zap_parent: 10901da177e4SLinus Torvalds nfs_zap_caches(dir); 10911da177e4SLinus Torvalds out_bad: 1092a1643a92STrond Myklebust nfs_mark_for_revalidate(dir); 10931da177e4SLinus Torvalds if (inode && S_ISDIR(inode->i_mode)) { 10941da177e4SLinus Torvalds /* Purge readdir caches. */ 10951da177e4SLinus Torvalds nfs_zap_caches(inode); 10961da177e4SLinus Torvalds /* If we have submounts, don't unhash ! */ 10971da177e4SLinus Torvalds if (have_submounts(dentry)) 10981da177e4SLinus Torvalds goto out_valid; 1099d9e80b7dSAl Viro if (dentry->d_flags & DCACHE_DISCONNECTED) 1100d9e80b7dSAl Viro goto out_valid; 11011da177e4SLinus Torvalds shrink_dcache_parent(dentry); 11021da177e4SLinus Torvalds } 11031da177e4SLinus Torvalds d_drop(dentry); 1104e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1105e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 11061da177e4SLinus Torvalds dput(parent); 11071e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 11083110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 11091e7cb3dcSChuck Lever dentry->d_name.name); 11101da177e4SLinus Torvalds return 0; 1111e1fb4d05STrond Myklebust out_error: 1112e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1113e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 1114e1fb4d05STrond Myklebust dput(parent); 1115e1fb4d05STrond Myklebust dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n", 1116e1fb4d05STrond Myklebust __func__, dentry->d_parent->d_name.name, 1117e1fb4d05STrond Myklebust dentry->d_name.name, error); 1118e1fb4d05STrond Myklebust return error; 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds /* 11221da177e4SLinus Torvalds * This is called from dput() when d_count is going to 0. 11231da177e4SLinus Torvalds */ 11241da177e4SLinus Torvalds static int nfs_dentry_delete(struct dentry *dentry) 11251da177e4SLinus Torvalds { 11261da177e4SLinus Torvalds dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 11271da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 11281da177e4SLinus Torvalds dentry->d_flags); 11291da177e4SLinus Torvalds 113077f11192STrond Myklebust /* Unhash any dentry with a stale inode */ 113177f11192STrond Myklebust if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 113277f11192STrond Myklebust return 1; 113377f11192STrond Myklebust 11341da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 11351da177e4SLinus Torvalds /* Unhash it, so that ->d_iput() would be called */ 11361da177e4SLinus Torvalds return 1; 11371da177e4SLinus Torvalds } 11381da177e4SLinus Torvalds if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 11391da177e4SLinus Torvalds /* Unhash it, so that ancestors of killed async unlink 11401da177e4SLinus Torvalds * files will be cleaned up during umount */ 11411da177e4SLinus Torvalds return 1; 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds return 0; 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds 11471b83d707STrond Myklebust static void nfs_drop_nlink(struct inode *inode) 11481b83d707STrond Myklebust { 11491b83d707STrond Myklebust spin_lock(&inode->i_lock); 11501b83d707STrond Myklebust if (inode->i_nlink > 0) 11511b83d707STrond Myklebust drop_nlink(inode); 11521b83d707STrond Myklebust spin_unlock(&inode->i_lock); 11531b83d707STrond Myklebust } 11541b83d707STrond Myklebust 11551da177e4SLinus Torvalds /* 11561da177e4SLinus Torvalds * Called when the dentry loses inode. 11571da177e4SLinus Torvalds * We use it to clean up silly-renamed files. 11581da177e4SLinus Torvalds */ 11591da177e4SLinus Torvalds static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 11601da177e4SLinus Torvalds { 116183672d39SNeil Brown if (S_ISDIR(inode->i_mode)) 116283672d39SNeil Brown /* drop any readdir cache as it could easily be old */ 116383672d39SNeil Brown NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 116483672d39SNeil Brown 11651da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 11669a53c3a7SDave Hansen drop_nlink(inode); 1167e4eff1a6STrond Myklebust nfs_complete_unlink(dentry, inode); 11681da177e4SLinus Torvalds } 11691da177e4SLinus Torvalds iput(inode); 11701da177e4SLinus Torvalds } 11711da177e4SLinus Torvalds 1172f786aa90SAl Viro const struct dentry_operations nfs_dentry_operations = { 11731da177e4SLinus Torvalds .d_revalidate = nfs_lookup_revalidate, 11741da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 11751da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 11761da177e4SLinus Torvalds }; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 11791da177e4SLinus Torvalds { 11801da177e4SLinus Torvalds struct dentry *res; 1181565277f6STrond Myklebust struct dentry *parent; 11821da177e4SLinus Torvalds struct inode *inode = NULL; 1183e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1184e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 11851da177e4SLinus Torvalds int error; 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds dfprintk(VFS, "NFS: lookup(%s/%s)\n", 11881da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 118991d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 11921da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 11931da177e4SLinus Torvalds goto out; 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 11961da177e4SLinus Torvalds 1197fd684071STrond Myklebust /* 1198fd684071STrond Myklebust * If we're doing an exclusive create, optimize away the lookup 1199fd684071STrond Myklebust * but don't hash the dentry. 1200fd684071STrond Myklebust */ 1201fd684071STrond Myklebust if (nfs_is_exclusive_create(dir, nd)) { 1202fd684071STrond Myklebust d_instantiate(dentry, NULL); 1203fd684071STrond Myklebust res = NULL; 1204fc0f684cSTrond Myklebust goto out; 1205fd684071STrond Myklebust } 12061da177e4SLinus Torvalds 1207e1fb4d05STrond Myklebust res = ERR_PTR(-ENOMEM); 1208e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1209e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1210e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1211e1fb4d05STrond Myklebust goto out; 1212e1fb4d05STrond Myklebust 1213565277f6STrond Myklebust parent = dentry->d_parent; 1214565277f6STrond Myklebust /* Protect against concurrent sillydeletes */ 1215565277f6STrond Myklebust nfs_block_sillyrename(parent); 1216e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 12171da177e4SLinus Torvalds if (error == -ENOENT) 12181da177e4SLinus Torvalds goto no_entry; 12191da177e4SLinus Torvalds if (error < 0) { 12201da177e4SLinus Torvalds res = ERR_PTR(error); 1221565277f6STrond Myklebust goto out_unblock_sillyrename; 12221da177e4SLinus Torvalds } 1223e1fb4d05STrond Myklebust inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 122403f28e3aSTrond Myklebust res = (struct dentry *)inode; 122503f28e3aSTrond Myklebust if (IS_ERR(res)) 1226565277f6STrond Myklebust goto out_unblock_sillyrename; 122754ceac45SDavid Howells 12281da177e4SLinus Torvalds no_entry: 122954ceac45SDavid Howells res = d_materialise_unique(dentry, inode); 12309eaef27bSTrond Myklebust if (res != NULL) { 12319eaef27bSTrond Myklebust if (IS_ERR(res)) 1232565277f6STrond Myklebust goto out_unblock_sillyrename; 12331da177e4SLinus Torvalds dentry = res; 12349eaef27bSTrond Myklebust } 12351da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1236565277f6STrond Myklebust out_unblock_sillyrename: 1237565277f6STrond Myklebust nfs_unblock_sillyrename(parent); 12381da177e4SLinus Torvalds out: 1239e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1240e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 12411da177e4SLinus Torvalds return res; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 12451da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *, struct nameidata *); 12461da177e4SLinus Torvalds 1247f786aa90SAl Viro const struct dentry_operations nfs4_dentry_operations = { 12481da177e4SLinus Torvalds .d_revalidate = nfs_open_revalidate, 12491da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 12501da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 12511da177e4SLinus Torvalds }; 12521da177e4SLinus Torvalds 12531d6757fbSTrond Myklebust /* 12541d6757fbSTrond Myklebust * Use intent information to determine whether we need to substitute 12551d6757fbSTrond Myklebust * the NFSv4-style stateful OPEN for the LOOKUP call 12561d6757fbSTrond Myklebust */ 12575584c306STrond Myklebust static int is_atomic_open(struct nameidata *nd) 12581da177e4SLinus Torvalds { 12591d6757fbSTrond Myklebust if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 12601da177e4SLinus Torvalds return 0; 12611da177e4SLinus Torvalds /* NFS does not (yet) have a stateful open for directories */ 12621da177e4SLinus Torvalds if (nd->flags & LOOKUP_DIRECTORY) 12631da177e4SLinus Torvalds return 0; 12641da177e4SLinus Torvalds /* Are we trying to write to a read only partition? */ 12652c463e95SDave Hansen if (__mnt_is_readonly(nd->path.mnt) && 12662c463e95SDave Hansen (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 12671da177e4SLinus Torvalds return 0; 12681da177e4SLinus Torvalds return 1; 12691da177e4SLinus Torvalds } 12701da177e4SLinus Torvalds 1271cd9a1c0eSTrond Myklebust static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd) 1272cd9a1c0eSTrond Myklebust { 1273cd9a1c0eSTrond Myklebust struct path path = { 1274cd9a1c0eSTrond Myklebust .mnt = nd->path.mnt, 1275cd9a1c0eSTrond Myklebust .dentry = dentry, 1276cd9a1c0eSTrond Myklebust }; 1277cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1278cd9a1c0eSTrond Myklebust struct rpc_cred *cred; 1279cd9a1c0eSTrond Myklebust fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1280cd9a1c0eSTrond Myklebust 1281cd9a1c0eSTrond Myklebust cred = rpc_lookup_cred(); 1282cd9a1c0eSTrond Myklebust if (IS_ERR(cred)) 1283cd9a1c0eSTrond Myklebust return ERR_CAST(cred); 1284cd9a1c0eSTrond Myklebust ctx = alloc_nfs_open_context(&path, cred, fmode); 1285cd9a1c0eSTrond Myklebust put_rpccred(cred); 1286cd9a1c0eSTrond Myklebust if (ctx == NULL) 1287cd9a1c0eSTrond Myklebust return ERR_PTR(-ENOMEM); 1288cd9a1c0eSTrond Myklebust return ctx; 1289cd9a1c0eSTrond Myklebust } 1290cd9a1c0eSTrond Myklebust 1291cd9a1c0eSTrond Myklebust static int do_open(struct inode *inode, struct file *filp) 1292cd9a1c0eSTrond Myklebust { 1293cd9a1c0eSTrond Myklebust nfs_fscache_set_inode_cookie(inode, filp); 1294cd9a1c0eSTrond Myklebust return 0; 1295cd9a1c0eSTrond Myklebust } 1296cd9a1c0eSTrond Myklebust 1297cd9a1c0eSTrond Myklebust static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx) 1298cd9a1c0eSTrond Myklebust { 1299cd9a1c0eSTrond Myklebust struct file *filp; 1300cd9a1c0eSTrond Myklebust int ret = 0; 1301cd9a1c0eSTrond Myklebust 1302cd9a1c0eSTrond Myklebust /* If the open_intent is for execute, we have an extra check to make */ 1303cd9a1c0eSTrond Myklebust if (ctx->mode & FMODE_EXEC) { 1304cd9a1c0eSTrond Myklebust ret = nfs_may_open(ctx->path.dentry->d_inode, 1305cd9a1c0eSTrond Myklebust ctx->cred, 1306cd9a1c0eSTrond Myklebust nd->intent.open.flags); 1307cd9a1c0eSTrond Myklebust if (ret < 0) 1308cd9a1c0eSTrond Myklebust goto out; 1309cd9a1c0eSTrond Myklebust } 1310cd9a1c0eSTrond Myklebust filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open); 1311cd9a1c0eSTrond Myklebust if (IS_ERR(filp)) 1312cd9a1c0eSTrond Myklebust ret = PTR_ERR(filp); 1313cd9a1c0eSTrond Myklebust else 1314cd9a1c0eSTrond Myklebust nfs_file_set_open_context(filp, ctx); 1315cd9a1c0eSTrond Myklebust out: 1316cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1317cd9a1c0eSTrond Myklebust return ret; 1318cd9a1c0eSTrond Myklebust } 1319cd9a1c0eSTrond Myklebust 13201da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 13211da177e4SLinus Torvalds { 1322cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1323cd9a1c0eSTrond Myklebust struct iattr attr; 13241da177e4SLinus Torvalds struct dentry *res = NULL; 1325f46e0bd3STrond Myklebust struct inode *inode; 1326cd9a1c0eSTrond Myklebust int open_flags; 1327898f635cSTrond Myklebust int err; 13281da177e4SLinus Torvalds 13291e7cb3dcSChuck Lever dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 13301e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 13311e7cb3dcSChuck Lever 13321da177e4SLinus Torvalds /* Check that we are indeed trying to open this file */ 13335584c306STrond Myklebust if (!is_atomic_open(nd)) 13341da177e4SLinus Torvalds goto no_open; 13351da177e4SLinus Torvalds 13361da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 13371da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 13381da177e4SLinus Torvalds goto out; 13391da177e4SLinus Torvalds } 13401da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 13411da177e4SLinus Torvalds 1342d4d9cdcbSTrond Myklebust /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1343d4d9cdcbSTrond Myklebust * the dentry. */ 13443516586aSAl Viro if (nd->flags & LOOKUP_EXCL) { 1345d4d9cdcbSTrond Myklebust d_instantiate(dentry, NULL); 134602a913a7STrond Myklebust goto out; 134702a913a7STrond Myklebust } 13481da177e4SLinus Torvalds 1349cd9a1c0eSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1350cd9a1c0eSTrond Myklebust res = ERR_CAST(ctx); 1351cd9a1c0eSTrond Myklebust if (IS_ERR(ctx)) 1352cd9a1c0eSTrond Myklebust goto out; 1353cd9a1c0eSTrond Myklebust 1354cd9a1c0eSTrond Myklebust open_flags = nd->intent.open.flags; 1355cd9a1c0eSTrond Myklebust if (nd->flags & LOOKUP_CREATE) { 1356cd9a1c0eSTrond Myklebust attr.ia_mode = nd->intent.open.create_mode; 1357cd9a1c0eSTrond Myklebust attr.ia_valid = ATTR_MODE; 1358cd9a1c0eSTrond Myklebust if (!IS_POSIXACL(dir)) 1359cd9a1c0eSTrond Myklebust attr.ia_mode &= ~current_umask(); 1360cd9a1c0eSTrond Myklebust } else { 1361898f635cSTrond Myklebust open_flags &= ~(O_EXCL | O_CREAT); 1362cd9a1c0eSTrond Myklebust attr.ia_valid = 0; 1363cd9a1c0eSTrond Myklebust } 1364cd9a1c0eSTrond Myklebust 13651da177e4SLinus Torvalds /* Open the file on the server */ 1366f46e0bd3STrond Myklebust nfs_block_sillyrename(dentry->d_parent); 13672b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1368f46e0bd3STrond Myklebust if (IS_ERR(inode)) { 1369f46e0bd3STrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1370cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1371f46e0bd3STrond Myklebust switch (PTR_ERR(inode)) { 13721da177e4SLinus Torvalds /* Make a negative dentry */ 13731da177e4SLinus Torvalds case -ENOENT: 1374f46e0bd3STrond Myklebust d_add(dentry, NULL); 137502a913a7STrond Myklebust res = NULL; 137602a913a7STrond Myklebust goto out; 13771da177e4SLinus Torvalds /* This turned out not to be a regular file */ 13786f926b5bSTrond Myklebust case -ENOTDIR: 13796f926b5bSTrond Myklebust goto no_open; 13801da177e4SLinus Torvalds case -ELOOP: 13811da177e4SLinus Torvalds if (!(nd->intent.open.flags & O_NOFOLLOW)) 13821da177e4SLinus Torvalds goto no_open; 138323ebbd9aSTrond Myklebust /* case -EISDIR: */ 13841da177e4SLinus Torvalds /* case -EINVAL: */ 13851da177e4SLinus Torvalds default: 1386f46e0bd3STrond Myklebust res = ERR_CAST(inode); 13871da177e4SLinus Torvalds goto out; 13881da177e4SLinus Torvalds } 1389cd9a1c0eSTrond Myklebust } 1390f46e0bd3STrond Myklebust res = d_add_unique(dentry, inode); 1391898f635cSTrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1392f46e0bd3STrond Myklebust if (res != NULL) { 1393f46e0bd3STrond Myklebust dput(ctx->path.dentry); 1394f46e0bd3STrond Myklebust ctx->path.dentry = dget(res); 13951da177e4SLinus Torvalds dentry = res; 1396f46e0bd3STrond Myklebust } 1397898f635cSTrond Myklebust err = nfs_intent_set_file(nd, ctx); 1398898f635cSTrond Myklebust if (err < 0) { 1399898f635cSTrond Myklebust if (res != NULL) 1400898f635cSTrond Myklebust dput(res); 1401898f635cSTrond Myklebust return ERR_PTR(err); 1402898f635cSTrond Myklebust } 14031da177e4SLinus Torvalds out: 1404f46e0bd3STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 14051da177e4SLinus Torvalds return res; 14061da177e4SLinus Torvalds no_open: 14071da177e4SLinus Torvalds return nfs_lookup(dir, dentry, nd); 14081da177e4SLinus Torvalds } 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 14111da177e4SLinus Torvalds { 14121da177e4SLinus Torvalds struct dentry *parent = NULL; 14131da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 14141da177e4SLinus Torvalds struct inode *dir; 1415b8d4caddSTrond Myklebust struct nfs_open_context *ctx; 14161da177e4SLinus Torvalds int openflags, ret = 0; 14171da177e4SLinus Torvalds 14181f063d2cSTrond Myklebust if (!is_atomic_open(nd) || d_mountpoint(dentry)) 14195584c306STrond Myklebust goto no_open; 14202b484297STrond Myklebust 14211da177e4SLinus Torvalds parent = dget_parent(dentry); 14221da177e4SLinus Torvalds dir = parent->d_inode; 14232b484297STrond Myklebust 14241da177e4SLinus Torvalds /* We can't create new files in nfs_open_revalidate(), so we 14251da177e4SLinus Torvalds * optimize away revalidation of negative dentries. 14261da177e4SLinus Torvalds */ 1427216d5d06STrond Myklebust if (inode == NULL) { 1428216d5d06STrond Myklebust if (!nfs_neg_need_reval(dir, dentry, nd)) 1429216d5d06STrond Myklebust ret = 1; 14301da177e4SLinus Torvalds goto out; 1431216d5d06STrond Myklebust } 1432216d5d06STrond Myklebust 14331da177e4SLinus Torvalds /* NFS only supports OPEN on regular files */ 14341da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 14355584c306STrond Myklebust goto no_open_dput; 14361da177e4SLinus Torvalds openflags = nd->intent.open.flags; 14371da177e4SLinus Torvalds /* We cannot do exclusive creation on a positive dentry */ 14381da177e4SLinus Torvalds if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 14395584c306STrond Myklebust goto no_open_dput; 14401da177e4SLinus Torvalds /* We can't create new files, or truncate existing ones here */ 14410a377cffSTrond Myklebust openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 14421da177e4SLinus Torvalds 1443b8d4caddSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1444b8d4caddSTrond Myklebust ret = PTR_ERR(ctx); 1445b8d4caddSTrond Myklebust if (IS_ERR(ctx)) 1446b8d4caddSTrond Myklebust goto out; 14471da177e4SLinus Torvalds /* 14481b1dcc1bSJes Sorensen * Note: we're not holding inode->i_mutex and so may be racing with 14491da177e4SLinus Torvalds * operations that change the directory. We therefore save the 14501da177e4SLinus Torvalds * change attribute *before* we do the RPC call. 14511da177e4SLinus Torvalds */ 14522b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1453535918f1STrond Myklebust if (IS_ERR(inode)) { 1454535918f1STrond Myklebust ret = PTR_ERR(inode); 1455535918f1STrond Myklebust switch (ret) { 1456535918f1STrond Myklebust case -EPERM: 1457535918f1STrond Myklebust case -EACCES: 1458535918f1STrond Myklebust case -EDQUOT: 1459535918f1STrond Myklebust case -ENOSPC: 1460535918f1STrond Myklebust case -EROFS: 1461535918f1STrond Myklebust goto out_put_ctx; 1462535918f1STrond Myklebust default: 1463535918f1STrond Myklebust goto out_drop; 1464535918f1STrond Myklebust } 1465535918f1STrond Myklebust } 1466535918f1STrond Myklebust iput(inode); 1467898f635cSTrond Myklebust if (inode != dentry->d_inode) 1468535918f1STrond Myklebust goto out_drop; 1469898f635cSTrond Myklebust 1470898f635cSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1471898f635cSTrond Myklebust ret = nfs_intent_set_file(nd, ctx); 1472898f635cSTrond Myklebust if (ret >= 0) 1473898f635cSTrond Myklebust ret = 1; 14741da177e4SLinus Torvalds out: 14751da177e4SLinus Torvalds dput(parent); 14761da177e4SLinus Torvalds return ret; 1477535918f1STrond Myklebust out_drop: 1478535918f1STrond Myklebust d_drop(dentry); 1479535918f1STrond Myklebust ret = 0; 1480535918f1STrond Myklebust out_put_ctx: 1481535918f1STrond Myklebust put_nfs_open_context(ctx); 1482535918f1STrond Myklebust goto out; 1483535918f1STrond Myklebust 14845584c306STrond Myklebust no_open_dput: 14851da177e4SLinus Torvalds dput(parent); 14865584c306STrond Myklebust no_open: 14871da177e4SLinus Torvalds return nfs_lookup_revalidate(dentry, nd); 14881da177e4SLinus Torvalds } 1489c0204fd2STrond Myklebust 1490c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1491c0204fd2STrond Myklebust struct nameidata *nd) 1492c0204fd2STrond Myklebust { 1493c0204fd2STrond Myklebust struct nfs_open_context *ctx = NULL; 1494c0204fd2STrond Myklebust struct iattr attr; 1495c0204fd2STrond Myklebust int error; 1496c0204fd2STrond Myklebust int open_flags = 0; 1497c0204fd2STrond Myklebust 1498c0204fd2STrond Myklebust dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1499c0204fd2STrond Myklebust dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1500c0204fd2STrond Myklebust 1501c0204fd2STrond Myklebust attr.ia_mode = mode; 1502c0204fd2STrond Myklebust attr.ia_valid = ATTR_MODE; 1503c0204fd2STrond Myklebust 1504c0204fd2STrond Myklebust if ((nd->flags & LOOKUP_CREATE) != 0) { 1505c0204fd2STrond Myklebust open_flags = nd->intent.open.flags; 1506c0204fd2STrond Myklebust 1507c0204fd2STrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1508c0204fd2STrond Myklebust error = PTR_ERR(ctx); 1509c0204fd2STrond Myklebust if (IS_ERR(ctx)) 1510898f635cSTrond Myklebust goto out_err_drop; 1511c0204fd2STrond Myklebust } 1512c0204fd2STrond Myklebust 1513c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1514c0204fd2STrond Myklebust if (error != 0) 1515c0204fd2STrond Myklebust goto out_put_ctx; 1516898f635cSTrond Myklebust if (ctx != NULL) { 1517898f635cSTrond Myklebust error = nfs_intent_set_file(nd, ctx); 1518898f635cSTrond Myklebust if (error < 0) 1519898f635cSTrond Myklebust goto out_err; 1520898f635cSTrond Myklebust } 1521c0204fd2STrond Myklebust return 0; 1522c0204fd2STrond Myklebust out_put_ctx: 1523c0204fd2STrond Myklebust if (ctx != NULL) 1524c0204fd2STrond Myklebust put_nfs_open_context(ctx); 1525898f635cSTrond Myklebust out_err_drop: 1526c0204fd2STrond Myklebust d_drop(dentry); 1527898f635cSTrond Myklebust out_err: 1528c0204fd2STrond Myklebust return error; 1529c0204fd2STrond Myklebust } 1530c0204fd2STrond Myklebust 15311da177e4SLinus Torvalds #endif /* CONFIG_NFSV4 */ 15321da177e4SLinus Torvalds 15331da177e4SLinus Torvalds /* 15341da177e4SLinus Torvalds * Code common to create, mkdir, and mknod. 15351da177e4SLinus Torvalds */ 15361da177e4SLinus Torvalds int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 15371da177e4SLinus Torvalds struct nfs_fattr *fattr) 15381da177e4SLinus Torvalds { 1539fab728e1STrond Myklebust struct dentry *parent = dget_parent(dentry); 1540fab728e1STrond Myklebust struct inode *dir = parent->d_inode; 15411da177e4SLinus Torvalds struct inode *inode; 15421da177e4SLinus Torvalds int error = -EACCES; 15431da177e4SLinus Torvalds 1544fab728e1STrond Myklebust d_drop(dentry); 1545fab728e1STrond Myklebust 15461da177e4SLinus Torvalds /* We may have been initialized further down */ 15471da177e4SLinus Torvalds if (dentry->d_inode) 1548fab728e1STrond Myklebust goto out; 15491da177e4SLinus Torvalds if (fhandle->size == 0) { 15501da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 15511da177e4SLinus Torvalds if (error) 1552fab728e1STrond Myklebust goto out_error; 15531da177e4SLinus Torvalds } 15545724ab37STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 15551da177e4SLinus Torvalds if (!(fattr->valid & NFS_ATTR_FATTR)) { 15561da177e4SLinus Torvalds struct nfs_server *server = NFS_SB(dentry->d_sb); 15578fa5c000SDavid Howells error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 15581da177e4SLinus Torvalds if (error < 0) 1559fab728e1STrond Myklebust goto out_error; 15601da177e4SLinus Torvalds } 15611da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 156203f28e3aSTrond Myklebust error = PTR_ERR(inode); 156303f28e3aSTrond Myklebust if (IS_ERR(inode)) 1564fab728e1STrond Myklebust goto out_error; 1565fab728e1STrond Myklebust d_add(dentry, inode); 1566fab728e1STrond Myklebust out: 1567fab728e1STrond Myklebust dput(parent); 15681da177e4SLinus Torvalds return 0; 1569fab728e1STrond Myklebust out_error: 1570fab728e1STrond Myklebust nfs_mark_for_revalidate(dir); 1571fab728e1STrond Myklebust dput(parent); 1572fab728e1STrond Myklebust return error; 15731da177e4SLinus Torvalds } 15741da177e4SLinus Torvalds 15751da177e4SLinus Torvalds /* 15761da177e4SLinus Torvalds * Following a failed create operation, we drop the dentry rather 15771da177e4SLinus Torvalds * than retain a negative dentry. This avoids a problem in the event 15781da177e4SLinus Torvalds * that the operation succeeded on the server, but an error in the 15791da177e4SLinus Torvalds * reply path made it appear to have failed. 15801da177e4SLinus Torvalds */ 15811da177e4SLinus Torvalds static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 15821da177e4SLinus Torvalds struct nameidata *nd) 15831da177e4SLinus Torvalds { 15841da177e4SLinus Torvalds struct iattr attr; 15851da177e4SLinus Torvalds int error; 15861da177e4SLinus Torvalds 15871e7cb3dcSChuck Lever dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 15881e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds attr.ia_mode = mode; 15911da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 15921da177e4SLinus Torvalds 1593c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL); 15941da177e4SLinus Torvalds if (error != 0) 15951da177e4SLinus Torvalds goto out_err; 15961da177e4SLinus Torvalds return 0; 15971da177e4SLinus Torvalds out_err: 15981da177e4SLinus Torvalds d_drop(dentry); 15991da177e4SLinus Torvalds return error; 16001da177e4SLinus Torvalds } 16011da177e4SLinus Torvalds 16021da177e4SLinus Torvalds /* 16031da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 16041da177e4SLinus Torvalds */ 16051da177e4SLinus Torvalds static int 16061da177e4SLinus Torvalds nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 16071da177e4SLinus Torvalds { 16081da177e4SLinus Torvalds struct iattr attr; 16091da177e4SLinus Torvalds int status; 16101da177e4SLinus Torvalds 16111e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 16121e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds if (!new_valid_dev(rdev)) 16151da177e4SLinus Torvalds return -EINVAL; 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds attr.ia_mode = mode; 16181da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 16211da177e4SLinus Torvalds if (status != 0) 16221da177e4SLinus Torvalds goto out_err; 16231da177e4SLinus Torvalds return 0; 16241da177e4SLinus Torvalds out_err: 16251da177e4SLinus Torvalds d_drop(dentry); 16261da177e4SLinus Torvalds return status; 16271da177e4SLinus Torvalds } 16281da177e4SLinus Torvalds 16291da177e4SLinus Torvalds /* 16301da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 16311da177e4SLinus Torvalds */ 16321da177e4SLinus Torvalds static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 16331da177e4SLinus Torvalds { 16341da177e4SLinus Torvalds struct iattr attr; 16351da177e4SLinus Torvalds int error; 16361da177e4SLinus Torvalds 16371e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 16381e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 16411da177e4SLinus Torvalds attr.ia_mode = mode | S_IFDIR; 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 16441da177e4SLinus Torvalds if (error != 0) 16451da177e4SLinus Torvalds goto out_err; 16461da177e4SLinus Torvalds return 0; 16471da177e4SLinus Torvalds out_err: 16481da177e4SLinus Torvalds d_drop(dentry); 16491da177e4SLinus Torvalds return error; 16501da177e4SLinus Torvalds } 16511da177e4SLinus Torvalds 1652d45b9d8bSTrond Myklebust static void nfs_dentry_handle_enoent(struct dentry *dentry) 1653d45b9d8bSTrond Myklebust { 1654d45b9d8bSTrond Myklebust if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1655d45b9d8bSTrond Myklebust d_delete(dentry); 1656d45b9d8bSTrond Myklebust } 1657d45b9d8bSTrond Myklebust 16581da177e4SLinus Torvalds static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 16591da177e4SLinus Torvalds { 16601da177e4SLinus Torvalds int error; 16611da177e4SLinus Torvalds 16621e7cb3dcSChuck Lever dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 16631e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 16661da177e4SLinus Torvalds /* Ensure the VFS deletes this inode */ 16671da177e4SLinus Torvalds if (error == 0 && dentry->d_inode != NULL) 1668ce71ec36SDave Hansen clear_nlink(dentry->d_inode); 1669d45b9d8bSTrond Myklebust else if (error == -ENOENT) 1670d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds return error; 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds 16751da177e4SLinus Torvalds /* 16761da177e4SLinus Torvalds * Remove a file after making sure there are no pending writes, 16771da177e4SLinus Torvalds * and after checking that the file has only one user. 16781da177e4SLinus Torvalds * 16791da177e4SLinus Torvalds * We invalidate the attribute cache and free the inode prior to the operation 16801da177e4SLinus Torvalds * to avoid possible races if the server reuses the inode. 16811da177e4SLinus Torvalds */ 16821da177e4SLinus Torvalds static int nfs_safe_remove(struct dentry *dentry) 16831da177e4SLinus Torvalds { 16841da177e4SLinus Torvalds struct inode *dir = dentry->d_parent->d_inode; 16851da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 16861da177e4SLinus Torvalds int error = -EBUSY; 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 16891da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 16901da177e4SLinus Torvalds 16911da177e4SLinus Torvalds /* If the dentry was sillyrenamed, we simply call d_delete() */ 16921da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 16931da177e4SLinus Torvalds error = 0; 16941da177e4SLinus Torvalds goto out; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds if (inode != NULL) { 1698cae7a073STrond Myklebust nfs_inode_return_delegation(inode); 16991da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 17001da177e4SLinus Torvalds /* The VFS may want to delete this inode */ 17011da177e4SLinus Torvalds if (error == 0) 17021b83d707STrond Myklebust nfs_drop_nlink(inode); 17035ba7cc48STrond Myklebust nfs_mark_for_revalidate(inode); 17041da177e4SLinus Torvalds } else 17051da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1706d45b9d8bSTrond Myklebust if (error == -ENOENT) 1707d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 17081da177e4SLinus Torvalds out: 17091da177e4SLinus Torvalds return error; 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 17131da177e4SLinus Torvalds * belongs to an active ".nfs..." file and we return -EBUSY. 17141da177e4SLinus Torvalds * 17151da177e4SLinus Torvalds * If sillyrename() returns 0, we do nothing, otherwise we unlink. 17161da177e4SLinus Torvalds */ 17171da177e4SLinus Torvalds static int nfs_unlink(struct inode *dir, struct dentry *dentry) 17181da177e4SLinus Torvalds { 17191da177e4SLinus Torvalds int error; 17201da177e4SLinus Torvalds int need_rehash = 0; 17211da177e4SLinus Torvalds 17221da177e4SLinus Torvalds dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 17231da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name); 17241da177e4SLinus Torvalds 17251da177e4SLinus Torvalds spin_lock(&dcache_lock); 17261da177e4SLinus Torvalds spin_lock(&dentry->d_lock); 17271da177e4SLinus Torvalds if (atomic_read(&dentry->d_count) > 1) { 17281da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 17291da177e4SLinus Torvalds spin_unlock(&dcache_lock); 1730ccfeb506STrond Myklebust /* Start asynchronous writeout of the inode */ 1731ccfeb506STrond Myklebust write_inode_now(dentry->d_inode, 0); 17321da177e4SLinus Torvalds error = nfs_sillyrename(dir, dentry); 17331da177e4SLinus Torvalds return error; 17341da177e4SLinus Torvalds } 17351da177e4SLinus Torvalds if (!d_unhashed(dentry)) { 17361da177e4SLinus Torvalds __d_drop(dentry); 17371da177e4SLinus Torvalds need_rehash = 1; 17381da177e4SLinus Torvalds } 17391da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 17401da177e4SLinus Torvalds spin_unlock(&dcache_lock); 17411da177e4SLinus Torvalds error = nfs_safe_remove(dentry); 1742d45b9d8bSTrond Myklebust if (!error || error == -ENOENT) { 17431da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 17441da177e4SLinus Torvalds } else if (need_rehash) 17451da177e4SLinus Torvalds d_rehash(dentry); 17461da177e4SLinus Torvalds return error; 17471da177e4SLinus Torvalds } 17481da177e4SLinus Torvalds 1749873101b3SChuck Lever /* 1750873101b3SChuck Lever * To create a symbolic link, most file systems instantiate a new inode, 1751873101b3SChuck Lever * add a page to it containing the path, then write it out to the disk 1752873101b3SChuck Lever * using prepare_write/commit_write. 1753873101b3SChuck Lever * 1754873101b3SChuck Lever * Unfortunately the NFS client can't create the in-core inode first 1755873101b3SChuck Lever * because it needs a file handle to create an in-core inode (see 1756873101b3SChuck Lever * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1757873101b3SChuck Lever * symlink request has completed on the server. 1758873101b3SChuck Lever * 1759873101b3SChuck Lever * So instead we allocate a raw page, copy the symname into it, then do 1760873101b3SChuck Lever * the SYMLINK request with the page as the buffer. If it succeeds, we 1761873101b3SChuck Lever * now have a new file handle and can instantiate an in-core NFS inode 1762873101b3SChuck Lever * and move the raw page into its mapping. 1763873101b3SChuck Lever */ 1764873101b3SChuck Lever static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 17651da177e4SLinus Torvalds { 1766873101b3SChuck Lever struct pagevec lru_pvec; 1767873101b3SChuck Lever struct page *page; 1768873101b3SChuck Lever char *kaddr; 17691da177e4SLinus Torvalds struct iattr attr; 1770873101b3SChuck Lever unsigned int pathlen = strlen(symname); 17711da177e4SLinus Torvalds int error; 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 17741da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name, symname); 17751da177e4SLinus Torvalds 1776873101b3SChuck Lever if (pathlen > PAGE_SIZE) 1777873101b3SChuck Lever return -ENAMETOOLONG; 17781da177e4SLinus Torvalds 1779873101b3SChuck Lever attr.ia_mode = S_IFLNK | S_IRWXUGO; 1780873101b3SChuck Lever attr.ia_valid = ATTR_MODE; 17811da177e4SLinus Torvalds 178283d93f22SJeff Layton page = alloc_page(GFP_HIGHUSER); 178376566991STrond Myklebust if (!page) 1784873101b3SChuck Lever return -ENOMEM; 1785873101b3SChuck Lever 1786873101b3SChuck Lever kaddr = kmap_atomic(page, KM_USER0); 1787873101b3SChuck Lever memcpy(kaddr, symname, pathlen); 1788873101b3SChuck Lever if (pathlen < PAGE_SIZE) 1789873101b3SChuck Lever memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1790873101b3SChuck Lever kunmap_atomic(kaddr, KM_USER0); 1791873101b3SChuck Lever 179294a6d753SChuck Lever error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1793873101b3SChuck Lever if (error != 0) { 1794873101b3SChuck Lever dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1795873101b3SChuck Lever dir->i_sb->s_id, dir->i_ino, 1796873101b3SChuck Lever dentry->d_name.name, symname, error); 17971da177e4SLinus Torvalds d_drop(dentry); 1798873101b3SChuck Lever __free_page(page); 17991da177e4SLinus Torvalds return error; 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 1802873101b3SChuck Lever /* 1803873101b3SChuck Lever * No big deal if we can't add this page to the page cache here. 1804873101b3SChuck Lever * READLINK will get the missing page from the server if needed. 1805873101b3SChuck Lever */ 1806873101b3SChuck Lever pagevec_init(&lru_pvec, 0); 1807873101b3SChuck Lever if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1808873101b3SChuck Lever GFP_KERNEL)) { 180939cf8a13SChuck Lever pagevec_add(&lru_pvec, page); 18104f98a2feSRik van Riel pagevec_lru_add_file(&lru_pvec); 1811873101b3SChuck Lever SetPageUptodate(page); 1812873101b3SChuck Lever unlock_page(page); 1813873101b3SChuck Lever } else 1814873101b3SChuck Lever __free_page(page); 1815873101b3SChuck Lever 1816873101b3SChuck Lever return 0; 1817873101b3SChuck Lever } 1818873101b3SChuck Lever 18191da177e4SLinus Torvalds static int 18201da177e4SLinus Torvalds nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 18211da177e4SLinus Torvalds { 18221da177e4SLinus Torvalds struct inode *inode = old_dentry->d_inode; 18231da177e4SLinus Torvalds int error; 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 18261da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 18271da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 18281da177e4SLinus Torvalds 18299a3936aaSTrond Myklebust nfs_inode_return_delegation(inode); 18309a3936aaSTrond Myklebust 18319697d234STrond Myklebust d_drop(dentry); 18321da177e4SLinus Torvalds error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1833cf809556STrond Myklebust if (error == 0) { 18347de9c6eeSAl Viro ihold(inode); 18359697d234STrond Myklebust d_add(dentry, inode); 1836cf809556STrond Myklebust } 18371da177e4SLinus Torvalds return error; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds /* 18411da177e4SLinus Torvalds * RENAME 18421da177e4SLinus Torvalds * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 18431da177e4SLinus Torvalds * different file handle for the same inode after a rename (e.g. when 18441da177e4SLinus Torvalds * moving to a different directory). A fail-safe method to do so would 18451da177e4SLinus Torvalds * be to look up old_dir/old_name, create a link to new_dir/new_name and 18461da177e4SLinus Torvalds * rename the old file using the sillyrename stuff. This way, the original 18471da177e4SLinus Torvalds * file in old_dir will go away when the last process iput()s the inode. 18481da177e4SLinus Torvalds * 18491da177e4SLinus Torvalds * FIXED. 18501da177e4SLinus Torvalds * 18511da177e4SLinus Torvalds * It actually works quite well. One needs to have the possibility for 18521da177e4SLinus Torvalds * at least one ".nfs..." file in each directory the file ever gets 18531da177e4SLinus Torvalds * moved or linked to which happens automagically with the new 18541da177e4SLinus Torvalds * implementation that only depends on the dcache stuff instead of 18551da177e4SLinus Torvalds * using the inode layer 18561da177e4SLinus Torvalds * 18571da177e4SLinus Torvalds * Unfortunately, things are a little more complicated than indicated 18581da177e4SLinus Torvalds * above. For a cross-directory move, we want to make sure we can get 18591da177e4SLinus Torvalds * rid of the old inode after the operation. This means there must be 18601da177e4SLinus Torvalds * no pending writes (if it's a file), and the use count must be 1. 18611da177e4SLinus Torvalds * If these conditions are met, we can drop the dentries before doing 18621da177e4SLinus Torvalds * the rename. 18631da177e4SLinus Torvalds */ 18641da177e4SLinus Torvalds static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 18651da177e4SLinus Torvalds struct inode *new_dir, struct dentry *new_dentry) 18661da177e4SLinus Torvalds { 18671da177e4SLinus Torvalds struct inode *old_inode = old_dentry->d_inode; 18681da177e4SLinus Torvalds struct inode *new_inode = new_dentry->d_inode; 18691da177e4SLinus Torvalds struct dentry *dentry = NULL, *rehash = NULL; 18701da177e4SLinus Torvalds int error = -EBUSY; 18711da177e4SLinus Torvalds 18721da177e4SLinus Torvalds dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 18731da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 18741da177e4SLinus Torvalds new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 18751da177e4SLinus Torvalds atomic_read(&new_dentry->d_count)); 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds /* 187828f79a1aSMiklos Szeredi * For non-directories, check whether the target is busy and if so, 187928f79a1aSMiklos Szeredi * make a copy of the dentry and then do a silly-rename. If the 188028f79a1aSMiklos Szeredi * silly-rename succeeds, the copied dentry is hashed and becomes 188128f79a1aSMiklos Szeredi * the new target. 18821da177e4SLinus Torvalds */ 188327226104SMiklos Szeredi if (new_inode && !S_ISDIR(new_inode->i_mode)) { 188427226104SMiklos Szeredi /* 188527226104SMiklos Szeredi * To prevent any new references to the target during the 188627226104SMiklos Szeredi * rename, we unhash the dentry in advance. 188727226104SMiklos Szeredi */ 188827226104SMiklos Szeredi if (!d_unhashed(new_dentry)) { 188927226104SMiklos Szeredi d_drop(new_dentry); 189027226104SMiklos Szeredi rehash = new_dentry; 189127226104SMiklos Szeredi } 189227226104SMiklos Szeredi 189327226104SMiklos Szeredi if (atomic_read(&new_dentry->d_count) > 2) { 18941da177e4SLinus Torvalds int err; 189527226104SMiklos Szeredi 18961da177e4SLinus Torvalds /* copy the target dentry's name */ 18971da177e4SLinus Torvalds dentry = d_alloc(new_dentry->d_parent, 18981da177e4SLinus Torvalds &new_dentry->d_name); 18991da177e4SLinus Torvalds if (!dentry) 19001da177e4SLinus Torvalds goto out; 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds /* silly-rename the existing target ... */ 19031da177e4SLinus Torvalds err = nfs_sillyrename(new_dir, new_dentry); 190424e93025SMiklos Szeredi if (err) 19051da177e4SLinus Torvalds goto out; 190624e93025SMiklos Szeredi 190724e93025SMiklos Szeredi new_dentry = dentry; 190856335936SOGAWA Hirofumi rehash = NULL; 190924e93025SMiklos Szeredi new_inode = NULL; 1910b1e4adf4STrond Myklebust } 191127226104SMiklos Szeredi } 19121da177e4SLinus Torvalds 1913cae7a073STrond Myklebust nfs_inode_return_delegation(old_inode); 1914b1e4adf4STrond Myklebust if (new_inode != NULL) 191524174119STrond Myklebust nfs_inode_return_delegation(new_inode); 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 19181da177e4SLinus Torvalds new_dir, &new_dentry->d_name); 19195ba7cc48STrond Myklebust nfs_mark_for_revalidate(old_inode); 19201da177e4SLinus Torvalds out: 19211da177e4SLinus Torvalds if (rehash) 19221da177e4SLinus Torvalds d_rehash(rehash); 19231da177e4SLinus Torvalds if (!error) { 1924b1e4adf4STrond Myklebust if (new_inode != NULL) 1925b1e4adf4STrond Myklebust nfs_drop_nlink(new_inode); 19261da177e4SLinus Torvalds d_move(old_dentry, new_dentry); 19278fb559f8SChuck Lever nfs_set_verifier(new_dentry, 19288fb559f8SChuck Lever nfs_save_change_attribute(new_dir)); 1929d45b9d8bSTrond Myklebust } else if (error == -ENOENT) 1930d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(old_dentry); 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds /* new dentry created? */ 19331da177e4SLinus Torvalds if (dentry) 19341da177e4SLinus Torvalds dput(dentry); 19351da177e4SLinus Torvalds return error; 19361da177e4SLinus Torvalds } 19371da177e4SLinus Torvalds 1938cfcea3e8STrond Myklebust static DEFINE_SPINLOCK(nfs_access_lru_lock); 1939cfcea3e8STrond Myklebust static LIST_HEAD(nfs_access_lru_list); 1940cfcea3e8STrond Myklebust static atomic_long_t nfs_access_nr_entries; 1941cfcea3e8STrond Myklebust 19421c3c07e9STrond Myklebust static void nfs_access_free_entry(struct nfs_access_entry *entry) 19431c3c07e9STrond Myklebust { 19441c3c07e9STrond Myklebust put_rpccred(entry->cred); 19451c3c07e9STrond Myklebust kfree(entry); 1946cfcea3e8STrond Myklebust smp_mb__before_atomic_dec(); 1947cfcea3e8STrond Myklebust atomic_long_dec(&nfs_access_nr_entries); 1948cfcea3e8STrond Myklebust smp_mb__after_atomic_dec(); 19491c3c07e9STrond Myklebust } 19501c3c07e9STrond Myklebust 19511a81bb8aSTrond Myklebust static void nfs_access_free_list(struct list_head *head) 19521a81bb8aSTrond Myklebust { 19531a81bb8aSTrond Myklebust struct nfs_access_entry *cache; 19541a81bb8aSTrond Myklebust 19551a81bb8aSTrond Myklebust while (!list_empty(head)) { 19561a81bb8aSTrond Myklebust cache = list_entry(head->next, struct nfs_access_entry, lru); 19571a81bb8aSTrond Myklebust list_del(&cache->lru); 19581a81bb8aSTrond Myklebust nfs_access_free_entry(cache); 19591a81bb8aSTrond Myklebust } 19601a81bb8aSTrond Myklebust } 19611a81bb8aSTrond Myklebust 19627f8275d0SDave Chinner int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1963979df72eSTrond Myklebust { 1964979df72eSTrond Myklebust LIST_HEAD(head); 1965aa510da5STrond Myklebust struct nfs_inode *nfsi, *next; 1966979df72eSTrond Myklebust struct nfs_access_entry *cache; 1967979df72eSTrond Myklebust 196861d5eb29STrond Myklebust if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 196961d5eb29STrond Myklebust return (nr_to_scan == 0) ? 0 : -1; 19709c7e7e23STrond Myklebust 1971a50f7951STrond Myklebust spin_lock(&nfs_access_lru_lock); 1972aa510da5STrond Myklebust list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1973979df72eSTrond Myklebust struct inode *inode; 1974979df72eSTrond Myklebust 1975979df72eSTrond Myklebust if (nr_to_scan-- == 0) 1976979df72eSTrond Myklebust break; 19779c7e7e23STrond Myklebust inode = &nfsi->vfs_inode; 1978979df72eSTrond Myklebust spin_lock(&inode->i_lock); 1979979df72eSTrond Myklebust if (list_empty(&nfsi->access_cache_entry_lru)) 1980979df72eSTrond Myklebust goto remove_lru_entry; 1981979df72eSTrond Myklebust cache = list_entry(nfsi->access_cache_entry_lru.next, 1982979df72eSTrond Myklebust struct nfs_access_entry, lru); 1983979df72eSTrond Myklebust list_move(&cache->lru, &head); 1984979df72eSTrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1985979df72eSTrond Myklebust if (!list_empty(&nfsi->access_cache_entry_lru)) 1986979df72eSTrond Myklebust list_move_tail(&nfsi->access_cache_inode_lru, 1987979df72eSTrond Myklebust &nfs_access_lru_list); 1988979df72eSTrond Myklebust else { 1989979df72eSTrond Myklebust remove_lru_entry: 1990979df72eSTrond Myklebust list_del_init(&nfsi->access_cache_inode_lru); 19919c7e7e23STrond Myklebust smp_mb__before_clear_bit(); 1992979df72eSTrond Myklebust clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 19939c7e7e23STrond Myklebust smp_mb__after_clear_bit(); 1994979df72eSTrond Myklebust } 199559844a9bSTrond Myklebust spin_unlock(&inode->i_lock); 1996979df72eSTrond Myklebust } 1997979df72eSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 19981a81bb8aSTrond Myklebust nfs_access_free_list(&head); 1999979df72eSTrond Myklebust return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 2000979df72eSTrond Myklebust } 2001979df72eSTrond Myklebust 20021a81bb8aSTrond Myklebust static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 20031c3c07e9STrond Myklebust { 20041c3c07e9STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 20051a81bb8aSTrond Myklebust struct rb_node *n; 20061c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20071c3c07e9STrond Myklebust 20081c3c07e9STrond Myklebust /* Unhook entries from the cache */ 20091c3c07e9STrond Myklebust while ((n = rb_first(root_node)) != NULL) { 20101c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 20111c3c07e9STrond Myklebust rb_erase(n, root_node); 20121a81bb8aSTrond Myklebust list_move(&entry->lru, head); 20131c3c07e9STrond Myklebust } 20141c3c07e9STrond Myklebust nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 20151c3c07e9STrond Myklebust } 20161c3c07e9STrond Myklebust 20171c3c07e9STrond Myklebust void nfs_access_zap_cache(struct inode *inode) 20181c3c07e9STrond Myklebust { 20191a81bb8aSTrond Myklebust LIST_HEAD(head); 20201a81bb8aSTrond Myklebust 20211a81bb8aSTrond Myklebust if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 20221a81bb8aSTrond Myklebust return; 2023cfcea3e8STrond Myklebust /* Remove from global LRU init */ 2024cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 20251a81bb8aSTrond Myklebust if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2026cfcea3e8STrond Myklebust list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2027cfcea3e8STrond Myklebust 20281c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20291a81bb8aSTrond Myklebust __nfs_access_zap_cache(NFS_I(inode), &head); 20301a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 20311a81bb8aSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 20321a81bb8aSTrond Myklebust nfs_access_free_list(&head); 20331c3c07e9STrond Myklebust } 20341c3c07e9STrond Myklebust 20351c3c07e9STrond Myklebust static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 20361c3c07e9STrond Myklebust { 20371c3c07e9STrond Myklebust struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 20381c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20391c3c07e9STrond Myklebust 20401c3c07e9STrond Myklebust while (n != NULL) { 20411c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 20421c3c07e9STrond Myklebust 20431c3c07e9STrond Myklebust if (cred < entry->cred) 20441c3c07e9STrond Myklebust n = n->rb_left; 20451c3c07e9STrond Myklebust else if (cred > entry->cred) 20461c3c07e9STrond Myklebust n = n->rb_right; 20471c3c07e9STrond Myklebust else 20481c3c07e9STrond Myklebust return entry; 20491c3c07e9STrond Myklebust } 20501c3c07e9STrond Myklebust return NULL; 20511c3c07e9STrond Myklebust } 20521c3c07e9STrond Myklebust 2053af22f94aSTrond Myklebust static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 20541da177e4SLinus Torvalds { 205555296809SChuck Lever struct nfs_inode *nfsi = NFS_I(inode); 20561c3c07e9STrond Myklebust struct nfs_access_entry *cache; 20571c3c07e9STrond Myklebust int err = -ENOENT; 20581da177e4SLinus Torvalds 20591c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20601c3c07e9STrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 20611c3c07e9STrond Myklebust goto out_zap; 20621c3c07e9STrond Myklebust cache = nfs_access_search_rbtree(inode, cred); 20631c3c07e9STrond Myklebust if (cache == NULL) 20641c3c07e9STrond Myklebust goto out; 2065b4d2314bSTrond Myklebust if (!nfs_have_delegated_attributes(inode) && 206664672d55SPeter Staubach !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 20671c3c07e9STrond Myklebust goto out_stale; 20681c3c07e9STrond Myklebust res->jiffies = cache->jiffies; 20691c3c07e9STrond Myklebust res->cred = cache->cred; 20701c3c07e9STrond Myklebust res->mask = cache->mask; 2071cfcea3e8STrond Myklebust list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 20721c3c07e9STrond Myklebust err = 0; 20731c3c07e9STrond Myklebust out: 20741c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 20751c3c07e9STrond Myklebust return err; 20761c3c07e9STrond Myklebust out_stale: 20771c3c07e9STrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 2078cfcea3e8STrond Myklebust list_del(&cache->lru); 20791c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 20801c3c07e9STrond Myklebust nfs_access_free_entry(cache); 20811da177e4SLinus Torvalds return -ENOENT; 20821c3c07e9STrond Myklebust out_zap: 20831a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 20841a81bb8aSTrond Myklebust nfs_access_zap_cache(inode); 20851c3c07e9STrond Myklebust return -ENOENT; 20861c3c07e9STrond Myklebust } 20871c3c07e9STrond Myklebust 20881c3c07e9STrond Myklebust static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 20891c3c07e9STrond Myklebust { 2090cfcea3e8STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 2091cfcea3e8STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 20921c3c07e9STrond Myklebust struct rb_node **p = &root_node->rb_node; 20931c3c07e9STrond Myklebust struct rb_node *parent = NULL; 20941c3c07e9STrond Myklebust struct nfs_access_entry *entry; 20951c3c07e9STrond Myklebust 20961c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 20971c3c07e9STrond Myklebust while (*p != NULL) { 20981c3c07e9STrond Myklebust parent = *p; 20991c3c07e9STrond Myklebust entry = rb_entry(parent, struct nfs_access_entry, rb_node); 21001c3c07e9STrond Myklebust 21011c3c07e9STrond Myklebust if (set->cred < entry->cred) 21021c3c07e9STrond Myklebust p = &parent->rb_left; 21031c3c07e9STrond Myklebust else if (set->cred > entry->cred) 21041c3c07e9STrond Myklebust p = &parent->rb_right; 21051c3c07e9STrond Myklebust else 21061c3c07e9STrond Myklebust goto found; 21071c3c07e9STrond Myklebust } 21081c3c07e9STrond Myklebust rb_link_node(&set->rb_node, parent, p); 21091c3c07e9STrond Myklebust rb_insert_color(&set->rb_node, root_node); 2110cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 21111c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 21121c3c07e9STrond Myklebust return; 21131c3c07e9STrond Myklebust found: 21141c3c07e9STrond Myklebust rb_replace_node(parent, &set->rb_node, root_node); 2115cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2116cfcea3e8STrond Myklebust list_del(&entry->lru); 21171c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 21181c3c07e9STrond Myklebust nfs_access_free_entry(entry); 21191da177e4SLinus Torvalds } 21201da177e4SLinus Torvalds 2121af22f94aSTrond Myklebust static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 21221da177e4SLinus Torvalds { 21231c3c07e9STrond Myklebust struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 21241c3c07e9STrond Myklebust if (cache == NULL) 21251c3c07e9STrond Myklebust return; 21261c3c07e9STrond Myklebust RB_CLEAR_NODE(&cache->rb_node); 21271da177e4SLinus Torvalds cache->jiffies = set->jiffies; 21281c3c07e9STrond Myklebust cache->cred = get_rpccred(set->cred); 21291da177e4SLinus Torvalds cache->mask = set->mask; 21301c3c07e9STrond Myklebust 21311c3c07e9STrond Myklebust nfs_access_add_rbtree(inode, cache); 2132cfcea3e8STrond Myklebust 2133cfcea3e8STrond Myklebust /* Update accounting */ 2134cfcea3e8STrond Myklebust smp_mb__before_atomic_inc(); 2135cfcea3e8STrond Myklebust atomic_long_inc(&nfs_access_nr_entries); 2136cfcea3e8STrond Myklebust smp_mb__after_atomic_inc(); 2137cfcea3e8STrond Myklebust 2138cfcea3e8STrond Myklebust /* Add inode to global LRU list */ 21391a81bb8aSTrond Myklebust if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2140cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 21411a81bb8aSTrond Myklebust if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 21421a81bb8aSTrond Myklebust list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 21431a81bb8aSTrond Myklebust &nfs_access_lru_list); 2144cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 2145cfcea3e8STrond Myklebust } 21461da177e4SLinus Torvalds } 21471da177e4SLinus Torvalds 21481da177e4SLinus Torvalds static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 21491da177e4SLinus Torvalds { 21501da177e4SLinus Torvalds struct nfs_access_entry cache; 21511da177e4SLinus Torvalds int status; 21521da177e4SLinus Torvalds 21531da177e4SLinus Torvalds status = nfs_access_get_cached(inode, cred, &cache); 21541da177e4SLinus Torvalds if (status == 0) 21551da177e4SLinus Torvalds goto out; 21561da177e4SLinus Torvalds 21571da177e4SLinus Torvalds /* Be clever: ask server to check for all possible rights */ 21581da177e4SLinus Torvalds cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 21591da177e4SLinus Torvalds cache.cred = cred; 21601da177e4SLinus Torvalds cache.jiffies = jiffies; 21611da177e4SLinus Torvalds status = NFS_PROTO(inode)->access(inode, &cache); 2162a71ee337SSuresh Jayaraman if (status != 0) { 2163a71ee337SSuresh Jayaraman if (status == -ESTALE) { 2164a71ee337SSuresh Jayaraman nfs_zap_caches(inode); 2165a71ee337SSuresh Jayaraman if (!S_ISDIR(inode->i_mode)) 2166a71ee337SSuresh Jayaraman set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2167a71ee337SSuresh Jayaraman } 21681da177e4SLinus Torvalds return status; 2169a71ee337SSuresh Jayaraman } 21701da177e4SLinus Torvalds nfs_access_add_cache(inode, &cache); 21711da177e4SLinus Torvalds out: 2172e6305c43SAl Viro if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 21731da177e4SLinus Torvalds return 0; 21741da177e4SLinus Torvalds return -EACCES; 21751da177e4SLinus Torvalds } 21761da177e4SLinus Torvalds 2177af22f94aSTrond Myklebust static int nfs_open_permission_mask(int openflags) 2178af22f94aSTrond Myklebust { 2179af22f94aSTrond Myklebust int mask = 0; 2180af22f94aSTrond Myklebust 2181af22f94aSTrond Myklebust if (openflags & FMODE_READ) 2182af22f94aSTrond Myklebust mask |= MAY_READ; 2183af22f94aSTrond Myklebust if (openflags & FMODE_WRITE) 2184af22f94aSTrond Myklebust mask |= MAY_WRITE; 2185af22f94aSTrond Myklebust if (openflags & FMODE_EXEC) 2186af22f94aSTrond Myklebust mask |= MAY_EXEC; 2187af22f94aSTrond Myklebust return mask; 2188af22f94aSTrond Myklebust } 2189af22f94aSTrond Myklebust 2190af22f94aSTrond Myklebust int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2191af22f94aSTrond Myklebust { 2192af22f94aSTrond Myklebust return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2193af22f94aSTrond Myklebust } 2194af22f94aSTrond Myklebust 2195e6305c43SAl Viro int nfs_permission(struct inode *inode, int mask) 21961da177e4SLinus Torvalds { 21971da177e4SLinus Torvalds struct rpc_cred *cred; 21981da177e4SLinus Torvalds int res = 0; 21991da177e4SLinus Torvalds 220091d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSACCESS); 220191d5b470SChuck Lever 2202e6305c43SAl Viro if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 22031da177e4SLinus Torvalds goto out; 22041da177e4SLinus Torvalds /* Is this sys_access() ? */ 22059cfcac81SEric Paris if (mask & (MAY_ACCESS | MAY_CHDIR)) 22061da177e4SLinus Torvalds goto force_lookup; 22071da177e4SLinus Torvalds 22081da177e4SLinus Torvalds switch (inode->i_mode & S_IFMT) { 22091da177e4SLinus Torvalds case S_IFLNK: 22101da177e4SLinus Torvalds goto out; 22111da177e4SLinus Torvalds case S_IFREG: 22121da177e4SLinus Torvalds /* NFSv4 has atomic_open... */ 22131da177e4SLinus Torvalds if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 22147ee2cb7fSFrank Filz && (mask & MAY_OPEN) 22157ee2cb7fSFrank Filz && !(mask & MAY_EXEC)) 22161da177e4SLinus Torvalds goto out; 22171da177e4SLinus Torvalds break; 22181da177e4SLinus Torvalds case S_IFDIR: 22191da177e4SLinus Torvalds /* 22201da177e4SLinus Torvalds * Optimize away all write operations, since the server 22211da177e4SLinus Torvalds * will check permissions when we perform the op. 22221da177e4SLinus Torvalds */ 22231da177e4SLinus Torvalds if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 22241da177e4SLinus Torvalds goto out; 22251da177e4SLinus Torvalds } 22261da177e4SLinus Torvalds 22271da177e4SLinus Torvalds force_lookup: 22281da177e4SLinus Torvalds if (!NFS_PROTO(inode)->access) 22291da177e4SLinus Torvalds goto out_notsup; 22301da177e4SLinus Torvalds 223198a8e323STrond Myklebust cred = rpc_lookup_cred(); 22321da177e4SLinus Torvalds if (!IS_ERR(cred)) { 22331da177e4SLinus Torvalds res = nfs_do_access(inode, cred, mask); 22341da177e4SLinus Torvalds put_rpccred(cred); 22351da177e4SLinus Torvalds } else 22361da177e4SLinus Torvalds res = PTR_ERR(cred); 22371da177e4SLinus Torvalds out: 2238f696a365SMiklos Szeredi if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2239f696a365SMiklos Szeredi res = -EACCES; 2240f696a365SMiklos Szeredi 22411e7cb3dcSChuck Lever dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 22421e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino, mask, res); 22431da177e4SLinus Torvalds return res; 22441da177e4SLinus Torvalds out_notsup: 22451da177e4SLinus Torvalds res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 22461da177e4SLinus Torvalds if (res == 0) 22471da177e4SLinus Torvalds res = generic_permission(inode, mask, NULL); 22481e7cb3dcSChuck Lever goto out; 22491da177e4SLinus Torvalds } 22501da177e4SLinus Torvalds 22511da177e4SLinus Torvalds /* 22521da177e4SLinus Torvalds * Local variables: 22531da177e4SLinus Torvalds * version-control: t 22541da177e4SLinus Torvalds * kept-new-versions: 5 22551da177e4SLinus Torvalds * End: 22561da177e4SLinus Torvalds */ 2257