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> 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds #include "delegation.h" 3891d5b470SChuck Lever #include "iostat.h" 394c30d56eSAdrian Bunk #include "internal.h" 40cd9a1c0eSTrond Myklebust #include "fscache.h" 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds /* #define NFS_DEBUG_VERBOSE 1 */ 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds static int nfs_opendir(struct inode *, struct file *); 451da177e4SLinus Torvalds static int nfs_readdir(struct file *, void *, filldir_t); 461da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 471da177e4SLinus Torvalds static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *); 481da177e4SLinus Torvalds static int nfs_mkdir(struct inode *, struct dentry *, int); 491da177e4SLinus Torvalds static int nfs_rmdir(struct inode *, struct dentry *); 501da177e4SLinus Torvalds static int nfs_unlink(struct inode *, struct dentry *); 511da177e4SLinus Torvalds static int nfs_symlink(struct inode *, struct dentry *, const char *); 521da177e4SLinus Torvalds static int nfs_link(struct dentry *, struct inode *, struct dentry *); 531da177e4SLinus Torvalds static int nfs_mknod(struct inode *, struct dentry *, int, dev_t); 541da177e4SLinus Torvalds static int nfs_rename(struct inode *, struct dentry *, 551da177e4SLinus Torvalds struct inode *, struct dentry *); 567ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *, int); 57f0dd2136STrond Myklebust static loff_t nfs_llseek_dir(struct file *, loff_t, int); 58d1bacf9eSBryan Schumaker static int nfs_readdir_clear_array(struct page*, gfp_t); 591da177e4SLinus Torvalds 604b6f5d20SArjan van de Ven const struct file_operations nfs_dir_operations = { 61f0dd2136STrond Myklebust .llseek = nfs_llseek_dir, 621da177e4SLinus Torvalds .read = generic_read_dir, 631da177e4SLinus Torvalds .readdir = nfs_readdir, 641da177e4SLinus Torvalds .open = nfs_opendir, 651da177e4SLinus Torvalds .release = nfs_release, 661da177e4SLinus Torvalds .fsync = nfs_fsync_dir, 671da177e4SLinus Torvalds }; 681da177e4SLinus Torvalds 6992e1d5beSArjan van de Ven const struct inode_operations nfs_dir_inode_operations = { 701da177e4SLinus Torvalds .create = nfs_create, 711da177e4SLinus Torvalds .lookup = nfs_lookup, 721da177e4SLinus Torvalds .link = nfs_link, 731da177e4SLinus Torvalds .unlink = nfs_unlink, 741da177e4SLinus Torvalds .symlink = nfs_symlink, 751da177e4SLinus Torvalds .mkdir = nfs_mkdir, 761da177e4SLinus Torvalds .rmdir = nfs_rmdir, 771da177e4SLinus Torvalds .mknod = nfs_mknod, 781da177e4SLinus Torvalds .rename = nfs_rename, 791da177e4SLinus Torvalds .permission = nfs_permission, 801da177e4SLinus Torvalds .getattr = nfs_getattr, 811da177e4SLinus Torvalds .setattr = nfs_setattr, 821da177e4SLinus Torvalds }; 831da177e4SLinus Torvalds 84d1bacf9eSBryan Schumaker const struct address_space_operations nfs_dir_addr_space_ops = { 85d1bacf9eSBryan Schumaker .releasepage = nfs_readdir_clear_array, 86d1bacf9eSBryan Schumaker }; 87d1bacf9eSBryan Schumaker 88b7fa0554SAndreas Gruenbacher #ifdef CONFIG_NFS_V3 8992e1d5beSArjan van de Ven const struct inode_operations nfs3_dir_inode_operations = { 90b7fa0554SAndreas Gruenbacher .create = nfs_create, 91b7fa0554SAndreas Gruenbacher .lookup = nfs_lookup, 92b7fa0554SAndreas Gruenbacher .link = nfs_link, 93b7fa0554SAndreas Gruenbacher .unlink = nfs_unlink, 94b7fa0554SAndreas Gruenbacher .symlink = nfs_symlink, 95b7fa0554SAndreas Gruenbacher .mkdir = nfs_mkdir, 96b7fa0554SAndreas Gruenbacher .rmdir = nfs_rmdir, 97b7fa0554SAndreas Gruenbacher .mknod = nfs_mknod, 98b7fa0554SAndreas Gruenbacher .rename = nfs_rename, 99b7fa0554SAndreas Gruenbacher .permission = nfs_permission, 100b7fa0554SAndreas Gruenbacher .getattr = nfs_getattr, 101b7fa0554SAndreas Gruenbacher .setattr = nfs_setattr, 102b7fa0554SAndreas Gruenbacher .listxattr = nfs3_listxattr, 103b7fa0554SAndreas Gruenbacher .getxattr = nfs3_getxattr, 104b7fa0554SAndreas Gruenbacher .setxattr = nfs3_setxattr, 105b7fa0554SAndreas Gruenbacher .removexattr = nfs3_removexattr, 106b7fa0554SAndreas Gruenbacher }; 107b7fa0554SAndreas Gruenbacher #endif /* CONFIG_NFS_V3 */ 108b7fa0554SAndreas Gruenbacher 1091da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *); 112c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd); 11392e1d5beSArjan van de Ven const struct inode_operations nfs4_dir_inode_operations = { 114c0204fd2STrond Myklebust .create = nfs_open_create, 1151da177e4SLinus Torvalds .lookup = nfs_atomic_lookup, 1161da177e4SLinus Torvalds .link = nfs_link, 1171da177e4SLinus Torvalds .unlink = nfs_unlink, 1181da177e4SLinus Torvalds .symlink = nfs_symlink, 1191da177e4SLinus Torvalds .mkdir = nfs_mkdir, 1201da177e4SLinus Torvalds .rmdir = nfs_rmdir, 1211da177e4SLinus Torvalds .mknod = nfs_mknod, 1221da177e4SLinus Torvalds .rename = nfs_rename, 1231da177e4SLinus Torvalds .permission = nfs_permission, 1241da177e4SLinus Torvalds .getattr = nfs_getattr, 1251da177e4SLinus Torvalds .setattr = nfs_setattr, 1266b3b5496SJ. Bruce Fields .getxattr = nfs4_getxattr, 1276b3b5496SJ. Bruce Fields .setxattr = nfs4_setxattr, 1286b3b5496SJ. Bruce Fields .listxattr = nfs4_listxattr, 1291da177e4SLinus Torvalds }; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds #endif /* CONFIG_NFS_V4 */ 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds /* 1341da177e4SLinus Torvalds * Open file 1351da177e4SLinus Torvalds */ 1361da177e4SLinus Torvalds static int 1371da177e4SLinus Torvalds nfs_opendir(struct inode *inode, struct file *filp) 1381da177e4SLinus Torvalds { 1397451c4f0SCarsten Otte int res; 1401da177e4SLinus Torvalds 1416da24bc9SChuck Lever dfprintk(FILE, "NFS: open dir(%s/%s)\n", 142cc0dd2d1SChuck Lever filp->f_path.dentry->d_parent->d_name.name, 143cc0dd2d1SChuck Lever filp->f_path.dentry->d_name.name); 144cc0dd2d1SChuck Lever 145cc0dd2d1SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSOPEN); 1461e7cb3dcSChuck Lever 1471da177e4SLinus Torvalds /* Call generic open code in order to cache credentials */ 1481da177e4SLinus Torvalds res = nfs_open(inode, filp); 149f5a73672SNeil Brown if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 150f5a73672SNeil Brown /* This is a mountpoint, so d_revalidate will never 151f5a73672SNeil Brown * have been called, so we need to refresh the 152f5a73672SNeil Brown * inode (for close-open consistency) ourselves. 153f5a73672SNeil Brown */ 154f5a73672SNeil Brown __nfs_revalidate_inode(NFS_SERVER(inode), inode); 155f5a73672SNeil Brown } 1561da177e4SLinus Torvalds return res; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 159d1bacf9eSBryan Schumaker struct nfs_cache_array_entry { 160d1bacf9eSBryan Schumaker u64 cookie; 161d1bacf9eSBryan Schumaker u64 ino; 162d1bacf9eSBryan Schumaker struct qstr string; 163d1bacf9eSBryan Schumaker }; 164d1bacf9eSBryan Schumaker 165d1bacf9eSBryan Schumaker struct nfs_cache_array { 166d1bacf9eSBryan Schumaker unsigned int size; 167d1bacf9eSBryan Schumaker int eof_index; 168d1bacf9eSBryan Schumaker u64 last_cookie; 169d1bacf9eSBryan Schumaker struct nfs_cache_array_entry array[0]; 170d1bacf9eSBryan Schumaker }; 171d1bacf9eSBryan Schumaker 172d1bacf9eSBryan Schumaker #define MAX_READDIR_ARRAY ((PAGE_SIZE - sizeof(struct nfs_cache_array)) / sizeof(struct nfs_cache_array_entry)) 173d1bacf9eSBryan Schumaker 1740dbb4c67SAl Viro typedef __be32 * (*decode_dirent_t)(__be32 *, struct nfs_entry *, int); 1751da177e4SLinus Torvalds typedef struct { 1761da177e4SLinus Torvalds struct file *file; 1771da177e4SLinus Torvalds struct page *page; 1781da177e4SLinus Torvalds unsigned long page_index; 179f0dd2136STrond Myklebust u64 *dir_cookie; 180f0dd2136STrond Myklebust loff_t current_index; 1811da177e4SLinus Torvalds decode_dirent_t decode; 182d1bacf9eSBryan Schumaker 1831f4eab7eSNeil Brown unsigned long timestamp; 1844704f0e2STrond Myklebust unsigned long gencount; 185d1bacf9eSBryan Schumaker unsigned int cache_entry_index; 186d1bacf9eSBryan Schumaker unsigned int plus:1; 187d1bacf9eSBryan Schumaker unsigned int eof:1; 1881da177e4SLinus Torvalds } nfs_readdir_descriptor_t; 1891da177e4SLinus Torvalds 190d1bacf9eSBryan Schumaker /* 191d1bacf9eSBryan Schumaker * The caller is responsible for calling nfs_readdir_release_array(page) 1921da177e4SLinus Torvalds */ 1931da177e4SLinus Torvalds static 194d1bacf9eSBryan Schumaker struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 1951da177e4SLinus Torvalds { 196d1bacf9eSBryan Schumaker if (page == NULL) 197d1bacf9eSBryan Schumaker return ERR_PTR(-EIO); 198d1bacf9eSBryan Schumaker return (struct nfs_cache_array *)kmap(page); 199d1bacf9eSBryan Schumaker } 200d1bacf9eSBryan Schumaker 201d1bacf9eSBryan Schumaker static 202d1bacf9eSBryan Schumaker void nfs_readdir_release_array(struct page *page) 203d1bacf9eSBryan Schumaker { 204d1bacf9eSBryan Schumaker kunmap(page); 205d1bacf9eSBryan Schumaker } 206d1bacf9eSBryan Schumaker 207d1bacf9eSBryan Schumaker /* 208d1bacf9eSBryan Schumaker * we are freeing strings created by nfs_add_to_readdir_array() 209d1bacf9eSBryan Schumaker */ 210d1bacf9eSBryan Schumaker static 211d1bacf9eSBryan Schumaker int nfs_readdir_clear_array(struct page *page, gfp_t mask) 212d1bacf9eSBryan Schumaker { 213d1bacf9eSBryan Schumaker struct nfs_cache_array *array = nfs_readdir_get_array(page); 214d1bacf9eSBryan Schumaker int i; 215d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) 216d1bacf9eSBryan Schumaker kfree(array->array[i].string.name); 217d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 218d1bacf9eSBryan Schumaker return 0; 219d1bacf9eSBryan Schumaker } 220d1bacf9eSBryan Schumaker 221d1bacf9eSBryan Schumaker /* 222d1bacf9eSBryan Schumaker * the caller is responsible for freeing qstr.name 223d1bacf9eSBryan Schumaker * when called by nfs_readdir_add_to_array, the strings will be freed in 224d1bacf9eSBryan Schumaker * nfs_clear_readdir_array() 225d1bacf9eSBryan Schumaker */ 226d1bacf9eSBryan Schumaker static 227d1bacf9eSBryan Schumaker void nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 228d1bacf9eSBryan Schumaker { 229d1bacf9eSBryan Schumaker string->len = len; 230d1bacf9eSBryan Schumaker string->name = kmemdup(name, len, GFP_KERNEL); 231d1bacf9eSBryan Schumaker string->hash = full_name_hash(string->name, string->len); 232d1bacf9eSBryan Schumaker } 233d1bacf9eSBryan Schumaker 234d1bacf9eSBryan Schumaker static 235d1bacf9eSBryan Schumaker int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 236d1bacf9eSBryan Schumaker { 237d1bacf9eSBryan Schumaker struct nfs_cache_array *array = nfs_readdir_get_array(page); 238d1bacf9eSBryan Schumaker if (IS_ERR(array)) 239d1bacf9eSBryan Schumaker return PTR_ERR(array); 240d1bacf9eSBryan Schumaker if (array->size >= MAX_READDIR_ARRAY) { 241d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 242d1bacf9eSBryan Schumaker return -EIO; 243d1bacf9eSBryan Schumaker } 244d1bacf9eSBryan Schumaker 245d1bacf9eSBryan Schumaker array->array[array->size].cookie = entry->prev_cookie; 246d1bacf9eSBryan Schumaker array->last_cookie = entry->cookie; 247d1bacf9eSBryan Schumaker array->array[array->size].ino = entry->ino; 248d1bacf9eSBryan Schumaker nfs_readdir_make_qstr(&array->array[array->size].string, entry->name, entry->len); 249d1bacf9eSBryan Schumaker if (entry->eof == 1) 250d1bacf9eSBryan Schumaker array->eof_index = array->size; 251d1bacf9eSBryan Schumaker array->size++; 252d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 253d1bacf9eSBryan Schumaker return 0; 254d1bacf9eSBryan Schumaker } 255d1bacf9eSBryan Schumaker 256d1bacf9eSBryan Schumaker static 257d1bacf9eSBryan Schumaker int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 258d1bacf9eSBryan Schumaker { 259d1bacf9eSBryan Schumaker loff_t diff = desc->file->f_pos - desc->current_index; 260d1bacf9eSBryan Schumaker unsigned int index; 261d1bacf9eSBryan Schumaker 262d1bacf9eSBryan Schumaker if (diff < 0) 263d1bacf9eSBryan Schumaker goto out_eof; 264d1bacf9eSBryan Schumaker if (diff >= array->size) { 265d1bacf9eSBryan Schumaker if (array->eof_index > 0) 266d1bacf9eSBryan Schumaker goto out_eof; 267d1bacf9eSBryan Schumaker desc->current_index += array->size; 268d1bacf9eSBryan Schumaker return -EAGAIN; 269d1bacf9eSBryan Schumaker } 270d1bacf9eSBryan Schumaker 271d1bacf9eSBryan Schumaker index = (unsigned int)diff; 272d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[index].cookie; 273d1bacf9eSBryan Schumaker desc->cache_entry_index = index; 274d1bacf9eSBryan Schumaker if (index == array->eof_index) 275d1bacf9eSBryan Schumaker desc->eof = 1; 276d1bacf9eSBryan Schumaker return 0; 277d1bacf9eSBryan Schumaker out_eof: 278d1bacf9eSBryan Schumaker desc->eof = 1; 279d1bacf9eSBryan Schumaker return -EBADCOOKIE; 280d1bacf9eSBryan Schumaker } 281d1bacf9eSBryan Schumaker 282d1bacf9eSBryan Schumaker static 283d1bacf9eSBryan Schumaker int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 284d1bacf9eSBryan Schumaker { 285d1bacf9eSBryan Schumaker int i; 286d1bacf9eSBryan Schumaker int status = -EAGAIN; 287d1bacf9eSBryan Schumaker 288d1bacf9eSBryan Schumaker for (i = 0; i < array->size; i++) { 289d1bacf9eSBryan Schumaker if (i == array->eof_index) { 290d1bacf9eSBryan Schumaker desc->eof = 1; 291d1bacf9eSBryan Schumaker status = -EBADCOOKIE; 292d1bacf9eSBryan Schumaker } 293d1bacf9eSBryan Schumaker if (array->array[i].cookie == *desc->dir_cookie) { 294d1bacf9eSBryan Schumaker desc->cache_entry_index = i; 295d1bacf9eSBryan Schumaker status = 0; 296d1bacf9eSBryan Schumaker break; 297d1bacf9eSBryan Schumaker } 298d1bacf9eSBryan Schumaker } 299d1bacf9eSBryan Schumaker 300d1bacf9eSBryan Schumaker return status; 301d1bacf9eSBryan Schumaker } 302d1bacf9eSBryan Schumaker 303d1bacf9eSBryan Schumaker static 304d1bacf9eSBryan Schumaker int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 305d1bacf9eSBryan Schumaker { 306d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 307d1bacf9eSBryan Schumaker int status = -EBADCOOKIE; 308d1bacf9eSBryan Schumaker 309d1bacf9eSBryan Schumaker if (desc->dir_cookie == NULL) 310d1bacf9eSBryan Schumaker goto out; 311d1bacf9eSBryan Schumaker 312d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 313d1bacf9eSBryan Schumaker if (IS_ERR(array)) { 314d1bacf9eSBryan Schumaker status = PTR_ERR(array); 315d1bacf9eSBryan Schumaker goto out; 316d1bacf9eSBryan Schumaker } 317d1bacf9eSBryan Schumaker 318d1bacf9eSBryan Schumaker if (*desc->dir_cookie == 0) 319d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_pos(array, desc); 320d1bacf9eSBryan Schumaker else 321d1bacf9eSBryan Schumaker status = nfs_readdir_search_for_cookie(array, desc); 322d1bacf9eSBryan Schumaker 323d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 324d1bacf9eSBryan Schumaker out: 325d1bacf9eSBryan Schumaker return status; 326d1bacf9eSBryan Schumaker } 327d1bacf9eSBryan Schumaker 328d1bacf9eSBryan Schumaker /* Fill a page with xdr information before transferring to the cache page */ 329d1bacf9eSBryan Schumaker static 330d1bacf9eSBryan Schumaker int nfs_readdir_xdr_filler(struct page *xdr_page, nfs_readdir_descriptor_t *desc, 331d1bacf9eSBryan Schumaker struct nfs_entry *entry, struct file *file, struct inode *inode) 332d1bacf9eSBryan Schumaker { 3331da177e4SLinus Torvalds struct rpc_cred *cred = nfs_file_cred(file); 3344704f0e2STrond Myklebust unsigned long timestamp, gencount; 3351da177e4SLinus Torvalds int error; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds again: 3381da177e4SLinus Torvalds timestamp = jiffies; 3394704f0e2STrond Myklebust gencount = nfs_inc_attr_generation_counter(); 340d1bacf9eSBryan Schumaker error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, xdr_page, 3411da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, desc->plus); 3421da177e4SLinus Torvalds if (error < 0) { 3431da177e4SLinus Torvalds /* We requested READDIRPLUS, but the server doesn't grok it */ 3441da177e4SLinus Torvalds if (error == -ENOTSUPP && desc->plus) { 3451da177e4SLinus Torvalds NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 3463a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 3471da177e4SLinus Torvalds desc->plus = 0; 3481da177e4SLinus Torvalds goto again; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds goto error; 3511da177e4SLinus Torvalds } 3521f4eab7eSNeil Brown desc->timestamp = timestamp; 3534704f0e2STrond Myklebust desc->gencount = gencount; 354d1bacf9eSBryan Schumaker error: 355d1bacf9eSBryan Schumaker return error; 356d1bacf9eSBryan Schumaker } 357d1bacf9eSBryan Schumaker 358d1bacf9eSBryan Schumaker /* Fill in an entry based on the xdr code stored in desc->page */ 359d1bacf9eSBryan Schumaker static 360d1bacf9eSBryan Schumaker int xdr_decode(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, __be32 **ptr) 361d1bacf9eSBryan Schumaker { 362d1bacf9eSBryan Schumaker __be32 *p = *ptr; 363d1bacf9eSBryan Schumaker p = desc->decode(p, entry, desc->plus); 364d1bacf9eSBryan Schumaker if (IS_ERR(p)) 365d1bacf9eSBryan Schumaker return PTR_ERR(p); 366d1bacf9eSBryan Schumaker *ptr = p; 367d1bacf9eSBryan Schumaker 368d1bacf9eSBryan Schumaker entry->fattr->time_start = desc->timestamp; 369d1bacf9eSBryan Schumaker entry->fattr->gencount = desc->gencount; 370d1bacf9eSBryan Schumaker return 0; 371d1bacf9eSBryan Schumaker } 372d1bacf9eSBryan Schumaker 373d1bacf9eSBryan Schumaker /* Perform conversion from xdr to cache array */ 374d1bacf9eSBryan Schumaker static 375d1bacf9eSBryan Schumaker void nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, 376d1bacf9eSBryan Schumaker struct page *xdr_page, struct page *page) 377d1bacf9eSBryan Schumaker { 378d1bacf9eSBryan Schumaker __be32 *ptr = kmap(xdr_page); 379d1bacf9eSBryan Schumaker while (xdr_decode(desc, entry, &ptr) == 0) { 380d1bacf9eSBryan Schumaker if (nfs_readdir_add_to_array(entry, page) == -1) 381d1bacf9eSBryan Schumaker break; 382d1bacf9eSBryan Schumaker } 383d1bacf9eSBryan Schumaker kunmap(xdr_page); 384d1bacf9eSBryan Schumaker } 385d1bacf9eSBryan Schumaker 386d1bacf9eSBryan Schumaker static 387d1bacf9eSBryan Schumaker int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 388d1bacf9eSBryan Schumaker { 389d1bacf9eSBryan Schumaker struct page *xdr_page; 390d1bacf9eSBryan Schumaker struct nfs_entry entry; 391d1bacf9eSBryan Schumaker struct file *file = desc->file; 392d1bacf9eSBryan Schumaker struct nfs_cache_array *array; 393d1bacf9eSBryan Schumaker int status = 0; 394d1bacf9eSBryan Schumaker 395d1bacf9eSBryan Schumaker entry.prev_cookie = 0; 396d1bacf9eSBryan Schumaker entry.cookie = *desc->dir_cookie; 397d1bacf9eSBryan Schumaker entry.eof = 0; 398d1bacf9eSBryan Schumaker entry.fh = nfs_alloc_fhandle(); 399d1bacf9eSBryan Schumaker entry.fattr = nfs_alloc_fattr(); 400d1bacf9eSBryan Schumaker if (entry.fh == NULL || entry.fattr == NULL) 401d1bacf9eSBryan Schumaker goto out; 402d1bacf9eSBryan Schumaker 403d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(page); 404d1bacf9eSBryan Schumaker memset(array, 0, sizeof(struct nfs_cache_array)); 405d1bacf9eSBryan Schumaker array->eof_index = -1; 406d1bacf9eSBryan Schumaker 407d1bacf9eSBryan Schumaker xdr_page = alloc_page(GFP_KERNEL); 408d1bacf9eSBryan Schumaker if (!xdr_page) 409d1bacf9eSBryan Schumaker goto out_release_array; 410d1bacf9eSBryan Schumaker do { 411d1bacf9eSBryan Schumaker status = nfs_readdir_xdr_filler(xdr_page, desc, &entry, file, inode); 412d1bacf9eSBryan Schumaker if (status < 0) 413d1bacf9eSBryan Schumaker break; 414d1bacf9eSBryan Schumaker nfs_readdir_page_filler(desc, &entry, xdr_page, page); 415d1bacf9eSBryan Schumaker } while (array->eof_index < 0 && array->size < MAX_READDIR_ARRAY); 416d1bacf9eSBryan Schumaker 417d1bacf9eSBryan Schumaker put_page(xdr_page); 418d1bacf9eSBryan Schumaker out_release_array: 419d1bacf9eSBryan Schumaker nfs_readdir_release_array(page); 420d1bacf9eSBryan Schumaker out: 421d1bacf9eSBryan Schumaker nfs_free_fattr(entry.fattr); 422d1bacf9eSBryan Schumaker nfs_free_fhandle(entry.fh); 423d1bacf9eSBryan Schumaker return status; 424d1bacf9eSBryan Schumaker } 425d1bacf9eSBryan Schumaker 426d1bacf9eSBryan Schumaker /* 427d1bacf9eSBryan Schumaker * Now we cache directories properly, by converting xdr information 428d1bacf9eSBryan Schumaker * to an array that can be used for lookups later. This results in 429d1bacf9eSBryan Schumaker * fewer cache pages, since we can store more information on each page. 430d1bacf9eSBryan Schumaker * We only need to convert from xdr once so future lookups are much simpler 4311da177e4SLinus Torvalds */ 432d1bacf9eSBryan Schumaker static 433d1bacf9eSBryan Schumaker int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 434d1bacf9eSBryan Schumaker { 435d1bacf9eSBryan Schumaker struct inode *inode = desc->file->f_path.dentry->d_inode; 436d1bacf9eSBryan Schumaker 437d1bacf9eSBryan Schumaker if (nfs_readdir_xdr_to_array(desc, page, inode) == -1) 438d1bacf9eSBryan Schumaker goto error; 439d1bacf9eSBryan Schumaker SetPageUptodate(page); 440d1bacf9eSBryan Schumaker 4412aac05a9STrond Myklebust if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 442cd9ae2b6STrond Myklebust /* Should never happen */ 443cd9ae2b6STrond Myklebust nfs_zap_mapping(inode, inode->i_mapping); 444cd9ae2b6STrond Myklebust } 4451da177e4SLinus Torvalds unlock_page(page); 4461da177e4SLinus Torvalds return 0; 4471da177e4SLinus Torvalds error: 4481da177e4SLinus Torvalds unlock_page(page); 4491da177e4SLinus Torvalds return -EIO; 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds 452d1bacf9eSBryan Schumaker static 453d1bacf9eSBryan Schumaker void cache_page_release(nfs_readdir_descriptor_t *desc) 4541da177e4SLinus Torvalds { 4551da177e4SLinus Torvalds page_cache_release(desc->page); 4561da177e4SLinus Torvalds desc->page = NULL; 4571da177e4SLinus Torvalds } 4581da177e4SLinus Torvalds 459d1bacf9eSBryan Schumaker static 460d1bacf9eSBryan Schumaker struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 4611da177e4SLinus Torvalds { 4621da177e4SLinus Torvalds struct page *page; 463d1bacf9eSBryan Schumaker page = read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping, 464d1bacf9eSBryan Schumaker desc->page_index, (filler_t *)nfs_readdir_filler, desc); 465d1bacf9eSBryan Schumaker if (IS_ERR(page)) 466d1bacf9eSBryan Schumaker desc->eof = 1; 467d1bacf9eSBryan Schumaker return page; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* 471d1bacf9eSBryan Schumaker * Returns 0 if desc->dir_cookie was found on page desc->page_index 4721da177e4SLinus Torvalds */ 473d1bacf9eSBryan Schumaker static 474d1bacf9eSBryan Schumaker int find_cache_page(nfs_readdir_descriptor_t *desc) 475d1bacf9eSBryan Schumaker { 476d1bacf9eSBryan Schumaker int res; 477d1bacf9eSBryan Schumaker 478d1bacf9eSBryan Schumaker desc->page = get_cache_page(desc); 479d1bacf9eSBryan Schumaker if (IS_ERR(desc->page)) 480d1bacf9eSBryan Schumaker return PTR_ERR(desc->page); 481d1bacf9eSBryan Schumaker 482d1bacf9eSBryan Schumaker res = nfs_readdir_search_array(desc); 483d1bacf9eSBryan Schumaker if (res == 0) 484d1bacf9eSBryan Schumaker return 0; 485d1bacf9eSBryan Schumaker cache_page_release(desc); 486d1bacf9eSBryan Schumaker return res; 487d1bacf9eSBryan Schumaker } 488d1bacf9eSBryan Schumaker 489d1bacf9eSBryan Schumaker /* Search for desc->dir_cookie from the beginning of the page cache */ 4901da177e4SLinus Torvalds static inline 4911da177e4SLinus Torvalds int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 4921da177e4SLinus Torvalds { 493d1bacf9eSBryan Schumaker int res = -EAGAIN; 49400a92642SOlivier Galibert desc->page_index = 0; 49500a92642SOlivier Galibert 496d1bacf9eSBryan Schumaker if (*desc->dir_cookie == 0) 497d1bacf9eSBryan Schumaker desc->cache_entry_index = 0; 498d1bacf9eSBryan Schumaker 499d1bacf9eSBryan Schumaker while (1) { 500d1bacf9eSBryan Schumaker res = find_cache_page(desc); 5011da177e4SLinus Torvalds if (res != -EAGAIN) 5021da177e4SLinus Torvalds break; 5031da177e4SLinus Torvalds desc->page_index++; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds return res; 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds static inline unsigned int dt_type(struct inode *inode) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds return (inode->i_mode >> 12) & 15; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds /* 5141da177e4SLinus Torvalds * Once we've found the start of the dirent within a page: fill 'er up... 5151da177e4SLinus Torvalds */ 5161da177e4SLinus Torvalds static 5171da177e4SLinus Torvalds int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent, 5181da177e4SLinus Torvalds filldir_t filldir) 5191da177e4SLinus Torvalds { 5201da177e4SLinus Torvalds struct file *file = desc->file; 521d1bacf9eSBryan Schumaker int i = 0; 522d1bacf9eSBryan Schumaker int res = 0; 523d1bacf9eSBryan Schumaker struct nfs_cache_array *array = NULL; 524d1bacf9eSBryan Schumaker unsigned int d_type = DT_UNKNOWN; 5251da177e4SLinus Torvalds struct dentry *dentry = NULL; 5261da177e4SLinus Torvalds 527d1bacf9eSBryan Schumaker array = nfs_readdir_get_array(desc->page); 5281da177e4SLinus Torvalds 529d1bacf9eSBryan Schumaker for (i = desc->cache_entry_index; i < array->size; i++) { 530d1bacf9eSBryan Schumaker d_type = DT_UNKNOWN; 5311da177e4SLinus Torvalds 532d1bacf9eSBryan Schumaker res = filldir(dirent, array->array[i].string.name, 533d1bacf9eSBryan Schumaker array->array[i].string.len, file->f_pos, 534d1bacf9eSBryan Schumaker nfs_compat_user_ino64(array->array[i].ino), d_type); 5351da177e4SLinus Torvalds if (res < 0) 5361da177e4SLinus Torvalds break; 53700a92642SOlivier Galibert file->f_pos++; 538d1bacf9eSBryan Schumaker desc->cache_entry_index = i; 539d1bacf9eSBryan Schumaker if (i < (array->size-1)) 540d1bacf9eSBryan Schumaker *desc->dir_cookie = array->array[i+1].cookie; 541d1bacf9eSBryan Schumaker else 542d1bacf9eSBryan Schumaker *desc->dir_cookie = array->last_cookie; 543d1bacf9eSBryan Schumaker if (i == array->eof_index) { 544d1bacf9eSBryan Schumaker desc->eof = 1; 5451da177e4SLinus Torvalds break; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds } 548d1bacf9eSBryan Schumaker 549d1bacf9eSBryan Schumaker nfs_readdir_release_array(desc->page); 550d1bacf9eSBryan Schumaker cache_page_release(desc); 5511da177e4SLinus Torvalds if (dentry != NULL) 5521da177e4SLinus Torvalds dput(dentry); 5531e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 5541e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie, res); 5551da177e4SLinus Torvalds return res; 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds /* 5591da177e4SLinus Torvalds * If we cannot find a cookie in our cache, we suspect that this is 5601da177e4SLinus Torvalds * because it points to a deleted file, so we ask the server to return 5611da177e4SLinus Torvalds * whatever it thinks is the next entry. We then feed this to filldir. 5621da177e4SLinus Torvalds * If all goes well, we should then be able to find our way round the 5631da177e4SLinus Torvalds * cache on the next call to readdir_search_pagecache(); 5641da177e4SLinus Torvalds * 5651da177e4SLinus Torvalds * NOTE: we cannot add the anonymous page to the pagecache because 5661da177e4SLinus Torvalds * the data it contains might not be page aligned. Besides, 5671da177e4SLinus Torvalds * we should already have a complete representation of the 5681da177e4SLinus Torvalds * directory in the page cache by the time we get here. 5691da177e4SLinus Torvalds */ 5701da177e4SLinus Torvalds static inline 5711da177e4SLinus Torvalds int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent, 5721da177e4SLinus Torvalds filldir_t filldir) 5731da177e4SLinus Torvalds { 5741da177e4SLinus Torvalds struct page *page = NULL; 5751da177e4SLinus Torvalds int status; 576d1bacf9eSBryan Schumaker struct inode *inode = desc->file->f_path.dentry->d_inode; 5771da177e4SLinus Torvalds 5781e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 5791e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie); 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds page = alloc_page(GFP_HIGHUSER); 5821da177e4SLinus Torvalds if (!page) { 5831da177e4SLinus Torvalds status = -ENOMEM; 5841da177e4SLinus Torvalds goto out; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 587d1bacf9eSBryan Schumaker if (nfs_readdir_xdr_to_array(desc, page, inode) == -1) { 588d1bacf9eSBryan Schumaker status = -EIO; 589d1bacf9eSBryan Schumaker goto out_release; 590d1bacf9eSBryan Schumaker } 591d1bacf9eSBryan Schumaker 592d1bacf9eSBryan Schumaker desc->page = page; 5931da177e4SLinus Torvalds status = nfs_do_filldir(desc, dirent, filldir); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds out: 5961e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 5973110ff80SHarvey Harrison __func__, status); 5981da177e4SLinus Torvalds return status; 5991da177e4SLinus Torvalds out_release: 600d1bacf9eSBryan Schumaker cache_page_release(desc); 6011da177e4SLinus Torvalds goto out; 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds 60400a92642SOlivier Galibert /* The file offset position represents the dirent entry number. A 60500a92642SOlivier Galibert last cookie cache takes care of the common case of reading the 60600a92642SOlivier Galibert whole directory. 6071da177e4SLinus Torvalds */ 6081da177e4SLinus Torvalds static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 6091da177e4SLinus Torvalds { 61001cce933SJosef "Jeff" Sipek struct dentry *dentry = filp->f_path.dentry; 6111da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 6121da177e4SLinus Torvalds nfs_readdir_descriptor_t my_desc, 6131da177e4SLinus Torvalds *desc = &my_desc; 614aa49b4cfSTrond Myklebust int res = -ENOMEM; 6151da177e4SLinus Torvalds 6166da24bc9SChuck Lever dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n", 6171e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 6181e7cb3dcSChuck Lever (long long)filp->f_pos); 61991d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 62091d5b470SChuck Lever 6211da177e4SLinus Torvalds /* 62200a92642SOlivier Galibert * filp->f_pos points to the dirent entry number. 623f0dd2136STrond Myklebust * *desc->dir_cookie has the cookie for the next entry. We have 62400a92642SOlivier Galibert * to either find the entry with the appropriate number or 62500a92642SOlivier Galibert * revalidate the cookie. 6261da177e4SLinus Torvalds */ 6271da177e4SLinus Torvalds memset(desc, 0, sizeof(*desc)); 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds desc->file = filp; 630cd3758e3STrond Myklebust desc->dir_cookie = &nfs_file_open_context(filp)->dir_cookie; 6311da177e4SLinus Torvalds desc->decode = NFS_PROTO(inode)->decode_dirent; 6321da177e4SLinus Torvalds desc->plus = NFS_USE_READDIRPLUS(inode); 6331da177e4SLinus Torvalds 634565277f6STrond Myklebust nfs_block_sillyrename(dentry); 6351cda707dSTrond Myklebust res = nfs_revalidate_mapping(inode, filp->f_mapping); 636fccca7fcSTrond Myklebust if (res < 0) 637fccca7fcSTrond Myklebust goto out; 638fccca7fcSTrond Myklebust 639d1bacf9eSBryan Schumaker while (desc->eof != 1) { 6401da177e4SLinus Torvalds res = readdir_search_pagecache(desc); 64100a92642SOlivier Galibert 6421da177e4SLinus Torvalds if (res == -EBADCOOKIE) { 6431da177e4SLinus Torvalds /* This means either end of directory */ 644d1bacf9eSBryan Schumaker if (*desc->dir_cookie && desc->eof == 0) { 6451da177e4SLinus Torvalds /* Or that the server has 'lost' a cookie */ 6461da177e4SLinus Torvalds res = uncached_readdir(desc, dirent, filldir); 6471da177e4SLinus Torvalds if (res >= 0) 6481da177e4SLinus Torvalds continue; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds res = 0; 6511da177e4SLinus Torvalds break; 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds if (res == -ETOOSMALL && desc->plus) { 6543a10c30aSBenny Halevy clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 6551da177e4SLinus Torvalds nfs_zap_caches(inode); 6561da177e4SLinus Torvalds desc->plus = 0; 657d1bacf9eSBryan Schumaker desc->eof = 0; 6581da177e4SLinus Torvalds continue; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds if (res < 0) 6611da177e4SLinus Torvalds break; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds res = nfs_do_filldir(desc, dirent, filldir); 6641da177e4SLinus Torvalds if (res < 0) { 6651da177e4SLinus Torvalds res = 0; 6661da177e4SLinus Torvalds break; 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds } 669fccca7fcSTrond Myklebust out: 670565277f6STrond Myklebust nfs_unblock_sillyrename(dentry); 6711e7cb3dcSChuck Lever if (res > 0) 6721e7cb3dcSChuck Lever res = 0; 673aa49b4cfSTrond Myklebust dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n", 6741e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 6751e7cb3dcSChuck Lever res); 6761da177e4SLinus Torvalds return res; 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds 67910afec90STrond Myklebust static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 680f0dd2136STrond Myklebust { 681b84e06c5SChuck Lever struct dentry *dentry = filp->f_path.dentry; 682b84e06c5SChuck Lever struct inode *inode = dentry->d_inode; 683b84e06c5SChuck Lever 6846da24bc9SChuck Lever dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n", 685b84e06c5SChuck Lever dentry->d_parent->d_name.name, 686b84e06c5SChuck Lever dentry->d_name.name, 687b84e06c5SChuck Lever offset, origin); 688b84e06c5SChuck Lever 689b84e06c5SChuck Lever mutex_lock(&inode->i_mutex); 690f0dd2136STrond Myklebust switch (origin) { 691f0dd2136STrond Myklebust case 1: 692f0dd2136STrond Myklebust offset += filp->f_pos; 693f0dd2136STrond Myklebust case 0: 694f0dd2136STrond Myklebust if (offset >= 0) 695f0dd2136STrond Myklebust break; 696f0dd2136STrond Myklebust default: 697f0dd2136STrond Myklebust offset = -EINVAL; 698f0dd2136STrond Myklebust goto out; 699f0dd2136STrond Myklebust } 700f0dd2136STrond Myklebust if (offset != filp->f_pos) { 701f0dd2136STrond Myklebust filp->f_pos = offset; 702cd3758e3STrond Myklebust nfs_file_open_context(filp)->dir_cookie = 0; 703f0dd2136STrond Myklebust } 704f0dd2136STrond Myklebust out: 705b84e06c5SChuck Lever mutex_unlock(&inode->i_mutex); 706f0dd2136STrond Myklebust return offset; 707f0dd2136STrond Myklebust } 708f0dd2136STrond Myklebust 7091da177e4SLinus Torvalds /* 7101da177e4SLinus Torvalds * All directory operations under NFS are synchronous, so fsync() 7111da177e4SLinus Torvalds * is a dummy operation. 7121da177e4SLinus Torvalds */ 7137ea80859SChristoph Hellwig static int nfs_fsync_dir(struct file *filp, int datasync) 7141da177e4SLinus Torvalds { 7157ea80859SChristoph Hellwig struct dentry *dentry = filp->f_path.dentry; 7167ea80859SChristoph Hellwig 7176da24bc9SChuck Lever dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n", 7181e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 7191e7cb3dcSChuck Lever datasync); 7201e7cb3dcSChuck Lever 72154917786SChuck Lever nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC); 7221da177e4SLinus Torvalds return 0; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds 725bfc69a45STrond Myklebust /** 726bfc69a45STrond Myklebust * nfs_force_lookup_revalidate - Mark the directory as having changed 727bfc69a45STrond Myklebust * @dir - pointer to directory inode 728bfc69a45STrond Myklebust * 729bfc69a45STrond Myklebust * This forces the revalidation code in nfs_lookup_revalidate() to do a 730bfc69a45STrond Myklebust * full lookup on all child dentries of 'dir' whenever a change occurs 731bfc69a45STrond Myklebust * on the server that might have invalidated our dcache. 732bfc69a45STrond Myklebust * 733bfc69a45STrond Myklebust * The caller should be holding dir->i_lock 734bfc69a45STrond Myklebust */ 735bfc69a45STrond Myklebust void nfs_force_lookup_revalidate(struct inode *dir) 736bfc69a45STrond Myklebust { 737011935a0STrond Myklebust NFS_I(dir)->cache_change_attribute++; 738bfc69a45STrond Myklebust } 739bfc69a45STrond Myklebust 7401da177e4SLinus Torvalds /* 7411da177e4SLinus Torvalds * A check for whether or not the parent directory has changed. 7421da177e4SLinus Torvalds * In the case it has, we assume that the dentries are untrustworthy 7431da177e4SLinus Torvalds * and may need to be looked up again. 7441da177e4SLinus Torvalds */ 745c79ba787STrond Myklebust static int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 7461da177e4SLinus Torvalds { 7471da177e4SLinus Torvalds if (IS_ROOT(dentry)) 7481da177e4SLinus Torvalds return 1; 7494eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 7504eec952eSTrond Myklebust return 0; 751f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 7526ecc5e8fSTrond Myklebust return 0; 753f2c77f4eSTrond Myklebust /* Revalidate nfsi->cache_change_attribute before we declare a match */ 754f2c77f4eSTrond Myklebust if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 755f2c77f4eSTrond Myklebust return 0; 756f2c77f4eSTrond Myklebust if (!nfs_verify_change_attribute(dir, dentry->d_time)) 757f2c77f4eSTrond Myklebust return 0; 758f2c77f4eSTrond Myklebust return 1; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds /* 7621d6757fbSTrond Myklebust * Return the intent data that applies to this particular path component 7631d6757fbSTrond Myklebust * 7641d6757fbSTrond Myklebust * Note that the current set of intents only apply to the very last 7651d6757fbSTrond Myklebust * component of the path. 7661d6757fbSTrond Myklebust * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 7671d6757fbSTrond Myklebust */ 7681d6757fbSTrond Myklebust static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask) 7691d6757fbSTrond Myklebust { 7701d6757fbSTrond Myklebust if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 7711d6757fbSTrond Myklebust return 0; 7721d6757fbSTrond Myklebust return nd->flags & mask; 7731d6757fbSTrond Myklebust } 7741d6757fbSTrond Myklebust 7751d6757fbSTrond Myklebust /* 776a12802caSTrond Myklebust * Use intent information to check whether or not we're going to do 777a12802caSTrond Myklebust * an O_EXCL create using this path component. 778a12802caSTrond Myklebust */ 779a12802caSTrond Myklebust static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 780a12802caSTrond Myklebust { 781a12802caSTrond Myklebust if (NFS_PROTO(dir)->version == 2) 782a12802caSTrond Myklebust return 0; 7833516586aSAl Viro return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL); 784a12802caSTrond Myklebust } 785a12802caSTrond Myklebust 786a12802caSTrond Myklebust /* 7871d6757fbSTrond Myklebust * Inode and filehandle revalidation for lookups. 7881d6757fbSTrond Myklebust * 7891d6757fbSTrond Myklebust * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 7901d6757fbSTrond Myklebust * or if the intent information indicates that we're about to open this 7911d6757fbSTrond Myklebust * particular file and the "nocto" mount flag is not set. 7921d6757fbSTrond Myklebust * 7931d6757fbSTrond Myklebust */ 7941da177e4SLinus Torvalds static inline 7951da177e4SLinus Torvalds int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 7961da177e4SLinus Torvalds { 7971da177e4SLinus Torvalds struct nfs_server *server = NFS_SERVER(inode); 7981da177e4SLinus Torvalds 7994e99a1ffSTrond Myklebust if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags)) 8004e99a1ffSTrond Myklebust return 0; 8011da177e4SLinus Torvalds if (nd != NULL) { 8021da177e4SLinus Torvalds /* VFS wants an on-the-wire revalidation */ 8031d6757fbSTrond Myklebust if (nd->flags & LOOKUP_REVAL) 8041da177e4SLinus Torvalds goto out_force; 8051da177e4SLinus Torvalds /* This is an open(2) */ 8061d6757fbSTrond Myklebust if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 8074e0641a7STrond Myklebust !(server->flags & NFS_MOUNT_NOCTO) && 8084e0641a7STrond Myklebust (S_ISREG(inode->i_mode) || 8094e0641a7STrond Myklebust S_ISDIR(inode->i_mode))) 8101da177e4SLinus Torvalds goto out_force; 8114f48af45STrond Myklebust return 0; 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds return nfs_revalidate_inode(server, inode); 8141da177e4SLinus Torvalds out_force: 8151da177e4SLinus Torvalds return __nfs_revalidate_inode(server, inode); 8161da177e4SLinus Torvalds } 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* 8191da177e4SLinus Torvalds * We judge how long we want to trust negative 8201da177e4SLinus Torvalds * dentries by looking at the parent inode mtime. 8211da177e4SLinus Torvalds * 8221da177e4SLinus Torvalds * If parent mtime has changed, we revalidate, else we wait for a 8231da177e4SLinus Torvalds * period corresponding to the parent's attribute cache timeout value. 8241da177e4SLinus Torvalds */ 8251da177e4SLinus Torvalds static inline 8261da177e4SLinus Torvalds int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 8271da177e4SLinus Torvalds struct nameidata *nd) 8281da177e4SLinus Torvalds { 8291da177e4SLinus Torvalds /* Don't revalidate a negative dentry if we're creating a new file */ 8301d6757fbSTrond Myklebust if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 8311da177e4SLinus Torvalds return 0; 8324eec952eSTrond Myklebust if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 8334eec952eSTrond Myklebust return 1; 8341da177e4SLinus Torvalds return !nfs_check_verifier(dir, dentry); 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /* 8381da177e4SLinus Torvalds * This is called every time the dcache has a lookup hit, 8391da177e4SLinus Torvalds * and we should check whether we can really trust that 8401da177e4SLinus Torvalds * lookup. 8411da177e4SLinus Torvalds * 8421da177e4SLinus Torvalds * NOTE! The hit can be a negative hit too, don't assume 8431da177e4SLinus Torvalds * we have an inode! 8441da177e4SLinus Torvalds * 8451da177e4SLinus Torvalds * If the parent directory is seen to have changed, we throw out the 8461da177e4SLinus Torvalds * cached dentry and do a new lookup. 8471da177e4SLinus Torvalds */ 8481da177e4SLinus Torvalds static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd) 8491da177e4SLinus Torvalds { 8501da177e4SLinus Torvalds struct inode *dir; 8511da177e4SLinus Torvalds struct inode *inode; 8521da177e4SLinus Torvalds struct dentry *parent; 853e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 854e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 8551da177e4SLinus Torvalds int error; 8561da177e4SLinus Torvalds 8571da177e4SLinus Torvalds parent = dget_parent(dentry); 8581da177e4SLinus Torvalds dir = parent->d_inode; 85991d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 8601da177e4SLinus Torvalds inode = dentry->d_inode; 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds if (!inode) { 8631da177e4SLinus Torvalds if (nfs_neg_need_reval(dir, dentry, nd)) 8641da177e4SLinus Torvalds goto out_bad; 8651da177e4SLinus Torvalds goto out_valid; 8661da177e4SLinus Torvalds } 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds if (is_bad_inode(inode)) { 8691e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 8703110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 8711e7cb3dcSChuck Lever dentry->d_name.name); 8721da177e4SLinus Torvalds goto out_bad; 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds 87515860ab1STrond Myklebust if (nfs_have_delegation(inode, FMODE_READ)) 87615860ab1STrond Myklebust goto out_set_verifier; 87715860ab1STrond Myklebust 8781da177e4SLinus Torvalds /* Force a full look up iff the parent directory has changed */ 879a12802caSTrond Myklebust if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) { 8801da177e4SLinus Torvalds if (nfs_lookup_verify_inode(inode, nd)) 8811da177e4SLinus Torvalds goto out_zap_parent; 8821da177e4SLinus Torvalds goto out_valid; 8831da177e4SLinus Torvalds } 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds if (NFS_STALE(inode)) 8861da177e4SLinus Torvalds goto out_bad; 8871da177e4SLinus Torvalds 888e1fb4d05STrond Myklebust error = -ENOMEM; 889e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 890e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 891e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 892e1fb4d05STrond Myklebust goto out_error; 893e1fb4d05STrond Myklebust 894e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 8951da177e4SLinus Torvalds if (error) 8961da177e4SLinus Torvalds goto out_bad; 897e1fb4d05STrond Myklebust if (nfs_compare_fh(NFS_FH(inode), fhandle)) 8981da177e4SLinus Torvalds goto out_bad; 899e1fb4d05STrond Myklebust if ((error = nfs_refresh_inode(inode, fattr)) != 0) 9001da177e4SLinus Torvalds goto out_bad; 9011da177e4SLinus Torvalds 902e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 903e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 90415860ab1STrond Myklebust out_set_verifier: 905cf8ba45eSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 9061da177e4SLinus Torvalds out_valid: 9071da177e4SLinus Torvalds dput(parent); 9081e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 9093110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 9101e7cb3dcSChuck Lever dentry->d_name.name); 9111da177e4SLinus Torvalds return 1; 9121da177e4SLinus Torvalds out_zap_parent: 9131da177e4SLinus Torvalds nfs_zap_caches(dir); 9141da177e4SLinus Torvalds out_bad: 915a1643a92STrond Myklebust nfs_mark_for_revalidate(dir); 9161da177e4SLinus Torvalds if (inode && S_ISDIR(inode->i_mode)) { 9171da177e4SLinus Torvalds /* Purge readdir caches. */ 9181da177e4SLinus Torvalds nfs_zap_caches(inode); 9191da177e4SLinus Torvalds /* If we have submounts, don't unhash ! */ 9201da177e4SLinus Torvalds if (have_submounts(dentry)) 9211da177e4SLinus Torvalds goto out_valid; 922d9e80b7dSAl Viro if (dentry->d_flags & DCACHE_DISCONNECTED) 923d9e80b7dSAl Viro goto out_valid; 9241da177e4SLinus Torvalds shrink_dcache_parent(dentry); 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds d_drop(dentry); 927e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 928e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 9291da177e4SLinus Torvalds dput(parent); 9301e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 9313110ff80SHarvey Harrison __func__, dentry->d_parent->d_name.name, 9321e7cb3dcSChuck Lever dentry->d_name.name); 9331da177e4SLinus Torvalds return 0; 934e1fb4d05STrond Myklebust out_error: 935e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 936e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 937e1fb4d05STrond Myklebust dput(parent); 938e1fb4d05STrond Myklebust dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n", 939e1fb4d05STrond Myklebust __func__, dentry->d_parent->d_name.name, 940e1fb4d05STrond Myklebust dentry->d_name.name, error); 941e1fb4d05STrond Myklebust return error; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds /* 9451da177e4SLinus Torvalds * This is called from dput() when d_count is going to 0. 9461da177e4SLinus Torvalds */ 9471da177e4SLinus Torvalds static int nfs_dentry_delete(struct dentry *dentry) 9481da177e4SLinus Torvalds { 9491da177e4SLinus Torvalds dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 9501da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 9511da177e4SLinus Torvalds dentry->d_flags); 9521da177e4SLinus Torvalds 95377f11192STrond Myklebust /* Unhash any dentry with a stale inode */ 95477f11192STrond Myklebust if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 95577f11192STrond Myklebust return 1; 95677f11192STrond Myklebust 9571da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 9581da177e4SLinus Torvalds /* Unhash it, so that ->d_iput() would be called */ 9591da177e4SLinus Torvalds return 1; 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 9621da177e4SLinus Torvalds /* Unhash it, so that ancestors of killed async unlink 9631da177e4SLinus Torvalds * files will be cleaned up during umount */ 9641da177e4SLinus Torvalds return 1; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds return 0; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds } 9691da177e4SLinus Torvalds 9701b83d707STrond Myklebust static void nfs_drop_nlink(struct inode *inode) 9711b83d707STrond Myklebust { 9721b83d707STrond Myklebust spin_lock(&inode->i_lock); 9731b83d707STrond Myklebust if (inode->i_nlink > 0) 9741b83d707STrond Myklebust drop_nlink(inode); 9751b83d707STrond Myklebust spin_unlock(&inode->i_lock); 9761b83d707STrond Myklebust } 9771b83d707STrond Myklebust 9781da177e4SLinus Torvalds /* 9791da177e4SLinus Torvalds * Called when the dentry loses inode. 9801da177e4SLinus Torvalds * We use it to clean up silly-renamed files. 9811da177e4SLinus Torvalds */ 9821da177e4SLinus Torvalds static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 9831da177e4SLinus Torvalds { 98483672d39SNeil Brown if (S_ISDIR(inode->i_mode)) 98583672d39SNeil Brown /* drop any readdir cache as it could easily be old */ 98683672d39SNeil Brown NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 98783672d39SNeil Brown 9881da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 9899a53c3a7SDave Hansen drop_nlink(inode); 990e4eff1a6STrond Myklebust nfs_complete_unlink(dentry, inode); 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds iput(inode); 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 995f786aa90SAl Viro const struct dentry_operations nfs_dentry_operations = { 9961da177e4SLinus Torvalds .d_revalidate = nfs_lookup_revalidate, 9971da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 9981da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 9991da177e4SLinus Torvalds }; 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 10021da177e4SLinus Torvalds { 10031da177e4SLinus Torvalds struct dentry *res; 1004565277f6STrond Myklebust struct dentry *parent; 10051da177e4SLinus Torvalds struct inode *inode = NULL; 1006e1fb4d05STrond Myklebust struct nfs_fh *fhandle = NULL; 1007e1fb4d05STrond Myklebust struct nfs_fattr *fattr = NULL; 10081da177e4SLinus Torvalds int error; 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds dfprintk(VFS, "NFS: lookup(%s/%s)\n", 10111da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 101291d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 10131da177e4SLinus Torvalds 10141da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 10151da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 10161da177e4SLinus Torvalds goto out; 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 10191da177e4SLinus Torvalds 1020fd684071STrond Myklebust /* 1021fd684071STrond Myklebust * If we're doing an exclusive create, optimize away the lookup 1022fd684071STrond Myklebust * but don't hash the dentry. 1023fd684071STrond Myklebust */ 1024fd684071STrond Myklebust if (nfs_is_exclusive_create(dir, nd)) { 1025fd684071STrond Myklebust d_instantiate(dentry, NULL); 1026fd684071STrond Myklebust res = NULL; 1027fc0f684cSTrond Myklebust goto out; 1028fd684071STrond Myklebust } 10291da177e4SLinus Torvalds 1030e1fb4d05STrond Myklebust res = ERR_PTR(-ENOMEM); 1031e1fb4d05STrond Myklebust fhandle = nfs_alloc_fhandle(); 1032e1fb4d05STrond Myklebust fattr = nfs_alloc_fattr(); 1033e1fb4d05STrond Myklebust if (fhandle == NULL || fattr == NULL) 1034e1fb4d05STrond Myklebust goto out; 1035e1fb4d05STrond Myklebust 1036565277f6STrond Myklebust parent = dentry->d_parent; 1037565277f6STrond Myklebust /* Protect against concurrent sillydeletes */ 1038565277f6STrond Myklebust nfs_block_sillyrename(parent); 1039e1fb4d05STrond Myklebust error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 10401da177e4SLinus Torvalds if (error == -ENOENT) 10411da177e4SLinus Torvalds goto no_entry; 10421da177e4SLinus Torvalds if (error < 0) { 10431da177e4SLinus Torvalds res = ERR_PTR(error); 1044565277f6STrond Myklebust goto out_unblock_sillyrename; 10451da177e4SLinus Torvalds } 1046e1fb4d05STrond Myklebust inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 104703f28e3aSTrond Myklebust res = (struct dentry *)inode; 104803f28e3aSTrond Myklebust if (IS_ERR(res)) 1049565277f6STrond Myklebust goto out_unblock_sillyrename; 105054ceac45SDavid Howells 10511da177e4SLinus Torvalds no_entry: 105254ceac45SDavid Howells res = d_materialise_unique(dentry, inode); 10539eaef27bSTrond Myklebust if (res != NULL) { 10549eaef27bSTrond Myklebust if (IS_ERR(res)) 1055565277f6STrond Myklebust goto out_unblock_sillyrename; 10561da177e4SLinus Torvalds dentry = res; 10579eaef27bSTrond Myklebust } 10581da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1059565277f6STrond Myklebust out_unblock_sillyrename: 1060565277f6STrond Myklebust nfs_unblock_sillyrename(parent); 10611da177e4SLinus Torvalds out: 1062e1fb4d05STrond Myklebust nfs_free_fattr(fattr); 1063e1fb4d05STrond Myklebust nfs_free_fhandle(fhandle); 10641da177e4SLinus Torvalds return res; 10651da177e4SLinus Torvalds } 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 10681da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *, struct nameidata *); 10691da177e4SLinus Torvalds 1070f786aa90SAl Viro const struct dentry_operations nfs4_dentry_operations = { 10711da177e4SLinus Torvalds .d_revalidate = nfs_open_revalidate, 10721da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 10731da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 10741da177e4SLinus Torvalds }; 10751da177e4SLinus Torvalds 10761d6757fbSTrond Myklebust /* 10771d6757fbSTrond Myklebust * Use intent information to determine whether we need to substitute 10781d6757fbSTrond Myklebust * the NFSv4-style stateful OPEN for the LOOKUP call 10791d6757fbSTrond Myklebust */ 10805584c306STrond Myklebust static int is_atomic_open(struct nameidata *nd) 10811da177e4SLinus Torvalds { 10821d6757fbSTrond Myklebust if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 10831da177e4SLinus Torvalds return 0; 10841da177e4SLinus Torvalds /* NFS does not (yet) have a stateful open for directories */ 10851da177e4SLinus Torvalds if (nd->flags & LOOKUP_DIRECTORY) 10861da177e4SLinus Torvalds return 0; 10871da177e4SLinus Torvalds /* Are we trying to write to a read only partition? */ 10882c463e95SDave Hansen if (__mnt_is_readonly(nd->path.mnt) && 10892c463e95SDave Hansen (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 10901da177e4SLinus Torvalds return 0; 10911da177e4SLinus Torvalds return 1; 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds 1094cd9a1c0eSTrond Myklebust static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd) 1095cd9a1c0eSTrond Myklebust { 1096cd9a1c0eSTrond Myklebust struct path path = { 1097cd9a1c0eSTrond Myklebust .mnt = nd->path.mnt, 1098cd9a1c0eSTrond Myklebust .dentry = dentry, 1099cd9a1c0eSTrond Myklebust }; 1100cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1101cd9a1c0eSTrond Myklebust struct rpc_cred *cred; 1102cd9a1c0eSTrond Myklebust fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1103cd9a1c0eSTrond Myklebust 1104cd9a1c0eSTrond Myklebust cred = rpc_lookup_cred(); 1105cd9a1c0eSTrond Myklebust if (IS_ERR(cred)) 1106cd9a1c0eSTrond Myklebust return ERR_CAST(cred); 1107cd9a1c0eSTrond Myklebust ctx = alloc_nfs_open_context(&path, cred, fmode); 1108cd9a1c0eSTrond Myklebust put_rpccred(cred); 1109cd9a1c0eSTrond Myklebust if (ctx == NULL) 1110cd9a1c0eSTrond Myklebust return ERR_PTR(-ENOMEM); 1111cd9a1c0eSTrond Myklebust return ctx; 1112cd9a1c0eSTrond Myklebust } 1113cd9a1c0eSTrond Myklebust 1114cd9a1c0eSTrond Myklebust static int do_open(struct inode *inode, struct file *filp) 1115cd9a1c0eSTrond Myklebust { 1116cd9a1c0eSTrond Myklebust nfs_fscache_set_inode_cookie(inode, filp); 1117cd9a1c0eSTrond Myklebust return 0; 1118cd9a1c0eSTrond Myklebust } 1119cd9a1c0eSTrond Myklebust 1120cd9a1c0eSTrond Myklebust static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx) 1121cd9a1c0eSTrond Myklebust { 1122cd9a1c0eSTrond Myklebust struct file *filp; 1123cd9a1c0eSTrond Myklebust int ret = 0; 1124cd9a1c0eSTrond Myklebust 1125cd9a1c0eSTrond Myklebust /* If the open_intent is for execute, we have an extra check to make */ 1126cd9a1c0eSTrond Myklebust if (ctx->mode & FMODE_EXEC) { 1127cd9a1c0eSTrond Myklebust ret = nfs_may_open(ctx->path.dentry->d_inode, 1128cd9a1c0eSTrond Myklebust ctx->cred, 1129cd9a1c0eSTrond Myklebust nd->intent.open.flags); 1130cd9a1c0eSTrond Myklebust if (ret < 0) 1131cd9a1c0eSTrond Myklebust goto out; 1132cd9a1c0eSTrond Myklebust } 1133cd9a1c0eSTrond Myklebust filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open); 1134cd9a1c0eSTrond Myklebust if (IS_ERR(filp)) 1135cd9a1c0eSTrond Myklebust ret = PTR_ERR(filp); 1136cd9a1c0eSTrond Myklebust else 1137cd9a1c0eSTrond Myklebust nfs_file_set_open_context(filp, ctx); 1138cd9a1c0eSTrond Myklebust out: 1139cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1140cd9a1c0eSTrond Myklebust return ret; 1141cd9a1c0eSTrond Myklebust } 1142cd9a1c0eSTrond Myklebust 11431da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 11441da177e4SLinus Torvalds { 1145cd9a1c0eSTrond Myklebust struct nfs_open_context *ctx; 1146cd9a1c0eSTrond Myklebust struct iattr attr; 11471da177e4SLinus Torvalds struct dentry *res = NULL; 1148f46e0bd3STrond Myklebust struct inode *inode; 1149cd9a1c0eSTrond Myklebust int open_flags; 1150898f635cSTrond Myklebust int err; 11511da177e4SLinus Torvalds 11521e7cb3dcSChuck Lever dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 11531e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 11541e7cb3dcSChuck Lever 11551da177e4SLinus Torvalds /* Check that we are indeed trying to open this file */ 11565584c306STrond Myklebust if (!is_atomic_open(nd)) 11571da177e4SLinus Torvalds goto no_open; 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 11601da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 11611da177e4SLinus Torvalds goto out; 11621da177e4SLinus Torvalds } 11631da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 11641da177e4SLinus Torvalds 1165d4d9cdcbSTrond Myklebust /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1166d4d9cdcbSTrond Myklebust * the dentry. */ 11673516586aSAl Viro if (nd->flags & LOOKUP_EXCL) { 1168d4d9cdcbSTrond Myklebust d_instantiate(dentry, NULL); 116902a913a7STrond Myklebust goto out; 117002a913a7STrond Myklebust } 11711da177e4SLinus Torvalds 1172cd9a1c0eSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1173cd9a1c0eSTrond Myklebust res = ERR_CAST(ctx); 1174cd9a1c0eSTrond Myklebust if (IS_ERR(ctx)) 1175cd9a1c0eSTrond Myklebust goto out; 1176cd9a1c0eSTrond Myklebust 1177cd9a1c0eSTrond Myklebust open_flags = nd->intent.open.flags; 1178cd9a1c0eSTrond Myklebust if (nd->flags & LOOKUP_CREATE) { 1179cd9a1c0eSTrond Myklebust attr.ia_mode = nd->intent.open.create_mode; 1180cd9a1c0eSTrond Myklebust attr.ia_valid = ATTR_MODE; 1181cd9a1c0eSTrond Myklebust if (!IS_POSIXACL(dir)) 1182cd9a1c0eSTrond Myklebust attr.ia_mode &= ~current_umask(); 1183cd9a1c0eSTrond Myklebust } else { 1184898f635cSTrond Myklebust open_flags &= ~(O_EXCL | O_CREAT); 1185cd9a1c0eSTrond Myklebust attr.ia_valid = 0; 1186cd9a1c0eSTrond Myklebust } 1187cd9a1c0eSTrond Myklebust 11881da177e4SLinus Torvalds /* Open the file on the server */ 1189f46e0bd3STrond Myklebust nfs_block_sillyrename(dentry->d_parent); 11902b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1191f46e0bd3STrond Myklebust if (IS_ERR(inode)) { 1192f46e0bd3STrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1193cd9a1c0eSTrond Myklebust put_nfs_open_context(ctx); 1194f46e0bd3STrond Myklebust switch (PTR_ERR(inode)) { 11951da177e4SLinus Torvalds /* Make a negative dentry */ 11961da177e4SLinus Torvalds case -ENOENT: 1197f46e0bd3STrond Myklebust d_add(dentry, NULL); 119802a913a7STrond Myklebust res = NULL; 119902a913a7STrond Myklebust goto out; 12001da177e4SLinus Torvalds /* This turned out not to be a regular file */ 120180e60639STrond Myklebust case -EISDIR: 12026f926b5bSTrond Myklebust case -ENOTDIR: 12036f926b5bSTrond Myklebust goto no_open; 12041da177e4SLinus Torvalds case -ELOOP: 12051da177e4SLinus Torvalds if (!(nd->intent.open.flags & O_NOFOLLOW)) 12061da177e4SLinus Torvalds goto no_open; 12071da177e4SLinus Torvalds /* case -EINVAL: */ 12081da177e4SLinus Torvalds default: 1209f46e0bd3STrond Myklebust res = ERR_CAST(inode); 12101da177e4SLinus Torvalds goto out; 12111da177e4SLinus Torvalds } 1212cd9a1c0eSTrond Myklebust } 1213f46e0bd3STrond Myklebust res = d_add_unique(dentry, inode); 1214898f635cSTrond Myklebust nfs_unblock_sillyrename(dentry->d_parent); 1215f46e0bd3STrond Myklebust if (res != NULL) { 1216f46e0bd3STrond Myklebust dput(ctx->path.dentry); 1217f46e0bd3STrond Myklebust ctx->path.dentry = dget(res); 12181da177e4SLinus Torvalds dentry = res; 1219f46e0bd3STrond Myklebust } 1220898f635cSTrond Myklebust err = nfs_intent_set_file(nd, ctx); 1221898f635cSTrond Myklebust if (err < 0) { 1222898f635cSTrond Myklebust if (res != NULL) 1223898f635cSTrond Myklebust dput(res); 1224898f635cSTrond Myklebust return ERR_PTR(err); 1225898f635cSTrond Myklebust } 12261da177e4SLinus Torvalds out: 1227f46e0bd3STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 12281da177e4SLinus Torvalds return res; 12291da177e4SLinus Torvalds no_open: 12301da177e4SLinus Torvalds return nfs_lookup(dir, dentry, nd); 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 12341da177e4SLinus Torvalds { 12351da177e4SLinus Torvalds struct dentry *parent = NULL; 12361da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 12371da177e4SLinus Torvalds struct inode *dir; 1238b8d4caddSTrond Myklebust struct nfs_open_context *ctx; 12391da177e4SLinus Torvalds int openflags, ret = 0; 12401da177e4SLinus Torvalds 12411f063d2cSTrond Myklebust if (!is_atomic_open(nd) || d_mountpoint(dentry)) 12425584c306STrond Myklebust goto no_open; 12432b484297STrond Myklebust 12441da177e4SLinus Torvalds parent = dget_parent(dentry); 12451da177e4SLinus Torvalds dir = parent->d_inode; 12462b484297STrond Myklebust 12471da177e4SLinus Torvalds /* We can't create new files in nfs_open_revalidate(), so we 12481da177e4SLinus Torvalds * optimize away revalidation of negative dentries. 12491da177e4SLinus Torvalds */ 1250216d5d06STrond Myklebust if (inode == NULL) { 1251216d5d06STrond Myklebust if (!nfs_neg_need_reval(dir, dentry, nd)) 1252216d5d06STrond Myklebust ret = 1; 12531da177e4SLinus Torvalds goto out; 1254216d5d06STrond Myklebust } 1255216d5d06STrond Myklebust 12561da177e4SLinus Torvalds /* NFS only supports OPEN on regular files */ 12571da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 12585584c306STrond Myklebust goto no_open_dput; 12591da177e4SLinus Torvalds openflags = nd->intent.open.flags; 12601da177e4SLinus Torvalds /* We cannot do exclusive creation on a positive dentry */ 12611da177e4SLinus Torvalds if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 12625584c306STrond Myklebust goto no_open_dput; 12631da177e4SLinus Torvalds /* We can't create new files, or truncate existing ones here */ 12640a377cffSTrond Myklebust openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 12651da177e4SLinus Torvalds 1266b8d4caddSTrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1267b8d4caddSTrond Myklebust ret = PTR_ERR(ctx); 1268b8d4caddSTrond Myklebust if (IS_ERR(ctx)) 1269b8d4caddSTrond Myklebust goto out; 12701da177e4SLinus Torvalds /* 12711b1dcc1bSJes Sorensen * Note: we're not holding inode->i_mutex and so may be racing with 12721da177e4SLinus Torvalds * operations that change the directory. We therefore save the 12731da177e4SLinus Torvalds * change attribute *before* we do the RPC call. 12741da177e4SLinus Torvalds */ 12752b484297STrond Myklebust inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1276535918f1STrond Myklebust if (IS_ERR(inode)) { 1277535918f1STrond Myklebust ret = PTR_ERR(inode); 1278535918f1STrond Myklebust switch (ret) { 1279535918f1STrond Myklebust case -EPERM: 1280535918f1STrond Myklebust case -EACCES: 1281535918f1STrond Myklebust case -EDQUOT: 1282535918f1STrond Myklebust case -ENOSPC: 1283535918f1STrond Myklebust case -EROFS: 1284535918f1STrond Myklebust goto out_put_ctx; 1285535918f1STrond Myklebust default: 1286535918f1STrond Myklebust goto out_drop; 1287535918f1STrond Myklebust } 1288535918f1STrond Myklebust } 1289535918f1STrond Myklebust iput(inode); 1290898f635cSTrond Myklebust if (inode != dentry->d_inode) 1291535918f1STrond Myklebust goto out_drop; 1292898f635cSTrond Myklebust 1293898f635cSTrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1294898f635cSTrond Myklebust ret = nfs_intent_set_file(nd, ctx); 1295898f635cSTrond Myklebust if (ret >= 0) 1296898f635cSTrond Myklebust ret = 1; 12971da177e4SLinus Torvalds out: 12981da177e4SLinus Torvalds dput(parent); 12991da177e4SLinus Torvalds return ret; 1300535918f1STrond Myklebust out_drop: 1301535918f1STrond Myklebust d_drop(dentry); 1302535918f1STrond Myklebust ret = 0; 1303535918f1STrond Myklebust out_put_ctx: 1304535918f1STrond Myklebust put_nfs_open_context(ctx); 1305535918f1STrond Myklebust goto out; 1306535918f1STrond Myklebust 13075584c306STrond Myklebust no_open_dput: 13081da177e4SLinus Torvalds dput(parent); 13095584c306STrond Myklebust no_open: 13101da177e4SLinus Torvalds return nfs_lookup_revalidate(dentry, nd); 13111da177e4SLinus Torvalds } 1312c0204fd2STrond Myklebust 1313c0204fd2STrond Myklebust static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1314c0204fd2STrond Myklebust struct nameidata *nd) 1315c0204fd2STrond Myklebust { 1316c0204fd2STrond Myklebust struct nfs_open_context *ctx = NULL; 1317c0204fd2STrond Myklebust struct iattr attr; 1318c0204fd2STrond Myklebust int error; 1319c0204fd2STrond Myklebust int open_flags = 0; 1320c0204fd2STrond Myklebust 1321c0204fd2STrond Myklebust dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1322c0204fd2STrond Myklebust dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1323c0204fd2STrond Myklebust 1324c0204fd2STrond Myklebust attr.ia_mode = mode; 1325c0204fd2STrond Myklebust attr.ia_valid = ATTR_MODE; 1326c0204fd2STrond Myklebust 1327c0204fd2STrond Myklebust if ((nd->flags & LOOKUP_CREATE) != 0) { 1328c0204fd2STrond Myklebust open_flags = nd->intent.open.flags; 1329c0204fd2STrond Myklebust 1330c0204fd2STrond Myklebust ctx = nameidata_to_nfs_open_context(dentry, nd); 1331c0204fd2STrond Myklebust error = PTR_ERR(ctx); 1332c0204fd2STrond Myklebust if (IS_ERR(ctx)) 1333898f635cSTrond Myklebust goto out_err_drop; 1334c0204fd2STrond Myklebust } 1335c0204fd2STrond Myklebust 1336c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1337c0204fd2STrond Myklebust if (error != 0) 1338c0204fd2STrond Myklebust goto out_put_ctx; 1339898f635cSTrond Myklebust if (ctx != NULL) { 1340898f635cSTrond Myklebust error = nfs_intent_set_file(nd, ctx); 1341898f635cSTrond Myklebust if (error < 0) 1342898f635cSTrond Myklebust goto out_err; 1343898f635cSTrond Myklebust } 1344c0204fd2STrond Myklebust return 0; 1345c0204fd2STrond Myklebust out_put_ctx: 1346c0204fd2STrond Myklebust if (ctx != NULL) 1347c0204fd2STrond Myklebust put_nfs_open_context(ctx); 1348898f635cSTrond Myklebust out_err_drop: 1349c0204fd2STrond Myklebust d_drop(dentry); 1350898f635cSTrond Myklebust out_err: 1351c0204fd2STrond Myklebust return error; 1352c0204fd2STrond Myklebust } 1353c0204fd2STrond Myklebust 13541da177e4SLinus Torvalds #endif /* CONFIG_NFSV4 */ 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds /* 13571da177e4SLinus Torvalds * Code common to create, mkdir, and mknod. 13581da177e4SLinus Torvalds */ 13591da177e4SLinus Torvalds int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 13601da177e4SLinus Torvalds struct nfs_fattr *fattr) 13611da177e4SLinus Torvalds { 1362fab728e1STrond Myklebust struct dentry *parent = dget_parent(dentry); 1363fab728e1STrond Myklebust struct inode *dir = parent->d_inode; 13641da177e4SLinus Torvalds struct inode *inode; 13651da177e4SLinus Torvalds int error = -EACCES; 13661da177e4SLinus Torvalds 1367fab728e1STrond Myklebust d_drop(dentry); 1368fab728e1STrond Myklebust 13691da177e4SLinus Torvalds /* We may have been initialized further down */ 13701da177e4SLinus Torvalds if (dentry->d_inode) 1371fab728e1STrond Myklebust goto out; 13721da177e4SLinus Torvalds if (fhandle->size == 0) { 13731da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 13741da177e4SLinus Torvalds if (error) 1375fab728e1STrond Myklebust goto out_error; 13761da177e4SLinus Torvalds } 13775724ab37STrond Myklebust nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 13781da177e4SLinus Torvalds if (!(fattr->valid & NFS_ATTR_FATTR)) { 13791da177e4SLinus Torvalds struct nfs_server *server = NFS_SB(dentry->d_sb); 13808fa5c000SDavid Howells error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 13811da177e4SLinus Torvalds if (error < 0) 1382fab728e1STrond Myklebust goto out_error; 13831da177e4SLinus Torvalds } 13841da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 138503f28e3aSTrond Myklebust error = PTR_ERR(inode); 138603f28e3aSTrond Myklebust if (IS_ERR(inode)) 1387fab728e1STrond Myklebust goto out_error; 1388fab728e1STrond Myklebust d_add(dentry, inode); 1389fab728e1STrond Myklebust out: 1390fab728e1STrond Myklebust dput(parent); 13911da177e4SLinus Torvalds return 0; 1392fab728e1STrond Myklebust out_error: 1393fab728e1STrond Myklebust nfs_mark_for_revalidate(dir); 1394fab728e1STrond Myklebust dput(parent); 1395fab728e1STrond Myklebust return error; 13961da177e4SLinus Torvalds } 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds /* 13991da177e4SLinus Torvalds * Following a failed create operation, we drop the dentry rather 14001da177e4SLinus Torvalds * than retain a negative dentry. This avoids a problem in the event 14011da177e4SLinus Torvalds * that the operation succeeded on the server, but an error in the 14021da177e4SLinus Torvalds * reply path made it appear to have failed. 14031da177e4SLinus Torvalds */ 14041da177e4SLinus Torvalds static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 14051da177e4SLinus Torvalds struct nameidata *nd) 14061da177e4SLinus Torvalds { 14071da177e4SLinus Torvalds struct iattr attr; 14081da177e4SLinus Torvalds int error; 14091da177e4SLinus Torvalds 14101e7cb3dcSChuck Lever dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 14111e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 14121da177e4SLinus Torvalds 14131da177e4SLinus Torvalds attr.ia_mode = mode; 14141da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 14151da177e4SLinus Torvalds 1416c0204fd2STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL); 14171da177e4SLinus Torvalds if (error != 0) 14181da177e4SLinus Torvalds goto out_err; 14191da177e4SLinus Torvalds return 0; 14201da177e4SLinus Torvalds out_err: 14211da177e4SLinus Torvalds d_drop(dentry); 14221da177e4SLinus Torvalds return error; 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds /* 14261da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 14271da177e4SLinus Torvalds */ 14281da177e4SLinus Torvalds static int 14291da177e4SLinus Torvalds nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 14301da177e4SLinus Torvalds { 14311da177e4SLinus Torvalds struct iattr attr; 14321da177e4SLinus Torvalds int status; 14331da177e4SLinus Torvalds 14341e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 14351e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds if (!new_valid_dev(rdev)) 14381da177e4SLinus Torvalds return -EINVAL; 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds attr.ia_mode = mode; 14411da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 14441da177e4SLinus Torvalds if (status != 0) 14451da177e4SLinus Torvalds goto out_err; 14461da177e4SLinus Torvalds return 0; 14471da177e4SLinus Torvalds out_err: 14481da177e4SLinus Torvalds d_drop(dentry); 14491da177e4SLinus Torvalds return status; 14501da177e4SLinus Torvalds } 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds /* 14531da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 14541da177e4SLinus Torvalds */ 14551da177e4SLinus Torvalds static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 14561da177e4SLinus Torvalds { 14571da177e4SLinus Torvalds struct iattr attr; 14581da177e4SLinus Torvalds int error; 14591da177e4SLinus Torvalds 14601e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 14611e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 14641da177e4SLinus Torvalds attr.ia_mode = mode | S_IFDIR; 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 14671da177e4SLinus Torvalds if (error != 0) 14681da177e4SLinus Torvalds goto out_err; 14691da177e4SLinus Torvalds return 0; 14701da177e4SLinus Torvalds out_err: 14711da177e4SLinus Torvalds d_drop(dentry); 14721da177e4SLinus Torvalds return error; 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds 1475d45b9d8bSTrond Myklebust static void nfs_dentry_handle_enoent(struct dentry *dentry) 1476d45b9d8bSTrond Myklebust { 1477d45b9d8bSTrond Myklebust if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1478d45b9d8bSTrond Myklebust d_delete(dentry); 1479d45b9d8bSTrond Myklebust } 1480d45b9d8bSTrond Myklebust 14811da177e4SLinus Torvalds static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 14821da177e4SLinus Torvalds { 14831da177e4SLinus Torvalds int error; 14841da177e4SLinus Torvalds 14851e7cb3dcSChuck Lever dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 14861e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 14891da177e4SLinus Torvalds /* Ensure the VFS deletes this inode */ 14901da177e4SLinus Torvalds if (error == 0 && dentry->d_inode != NULL) 1491ce71ec36SDave Hansen clear_nlink(dentry->d_inode); 1492d45b9d8bSTrond Myklebust else if (error == -ENOENT) 1493d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds return error; 14961da177e4SLinus Torvalds } 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds /* 14991da177e4SLinus Torvalds * Remove a file after making sure there are no pending writes, 15001da177e4SLinus Torvalds * and after checking that the file has only one user. 15011da177e4SLinus Torvalds * 15021da177e4SLinus Torvalds * We invalidate the attribute cache and free the inode prior to the operation 15031da177e4SLinus Torvalds * to avoid possible races if the server reuses the inode. 15041da177e4SLinus Torvalds */ 15051da177e4SLinus Torvalds static int nfs_safe_remove(struct dentry *dentry) 15061da177e4SLinus Torvalds { 15071da177e4SLinus Torvalds struct inode *dir = dentry->d_parent->d_inode; 15081da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 15091da177e4SLinus Torvalds int error = -EBUSY; 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 15121da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds /* If the dentry was sillyrenamed, we simply call d_delete() */ 15151da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 15161da177e4SLinus Torvalds error = 0; 15171da177e4SLinus Torvalds goto out; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds if (inode != NULL) { 1521cae7a073STrond Myklebust nfs_inode_return_delegation(inode); 15221da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 15231da177e4SLinus Torvalds /* The VFS may want to delete this inode */ 15241da177e4SLinus Torvalds if (error == 0) 15251b83d707STrond Myklebust nfs_drop_nlink(inode); 15265ba7cc48STrond Myklebust nfs_mark_for_revalidate(inode); 15271da177e4SLinus Torvalds } else 15281da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1529d45b9d8bSTrond Myklebust if (error == -ENOENT) 1530d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(dentry); 15311da177e4SLinus Torvalds out: 15321da177e4SLinus Torvalds return error; 15331da177e4SLinus Torvalds } 15341da177e4SLinus Torvalds 15351da177e4SLinus Torvalds /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 15361da177e4SLinus Torvalds * belongs to an active ".nfs..." file and we return -EBUSY. 15371da177e4SLinus Torvalds * 15381da177e4SLinus Torvalds * If sillyrename() returns 0, we do nothing, otherwise we unlink. 15391da177e4SLinus Torvalds */ 15401da177e4SLinus Torvalds static int nfs_unlink(struct inode *dir, struct dentry *dentry) 15411da177e4SLinus Torvalds { 15421da177e4SLinus Torvalds int error; 15431da177e4SLinus Torvalds int need_rehash = 0; 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 15461da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name); 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds spin_lock(&dcache_lock); 15491da177e4SLinus Torvalds spin_lock(&dentry->d_lock); 15501da177e4SLinus Torvalds if (atomic_read(&dentry->d_count) > 1) { 15511da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 15521da177e4SLinus Torvalds spin_unlock(&dcache_lock); 1553ccfeb506STrond Myklebust /* Start asynchronous writeout of the inode */ 1554ccfeb506STrond Myklebust write_inode_now(dentry->d_inode, 0); 15551da177e4SLinus Torvalds error = nfs_sillyrename(dir, dentry); 15561da177e4SLinus Torvalds return error; 15571da177e4SLinus Torvalds } 15581da177e4SLinus Torvalds if (!d_unhashed(dentry)) { 15591da177e4SLinus Torvalds __d_drop(dentry); 15601da177e4SLinus Torvalds need_rehash = 1; 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 15631da177e4SLinus Torvalds spin_unlock(&dcache_lock); 15641da177e4SLinus Torvalds error = nfs_safe_remove(dentry); 1565d45b9d8bSTrond Myklebust if (!error || error == -ENOENT) { 15661da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 15671da177e4SLinus Torvalds } else if (need_rehash) 15681da177e4SLinus Torvalds d_rehash(dentry); 15691da177e4SLinus Torvalds return error; 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds 1572873101b3SChuck Lever /* 1573873101b3SChuck Lever * To create a symbolic link, most file systems instantiate a new inode, 1574873101b3SChuck Lever * add a page to it containing the path, then write it out to the disk 1575873101b3SChuck Lever * using prepare_write/commit_write. 1576873101b3SChuck Lever * 1577873101b3SChuck Lever * Unfortunately the NFS client can't create the in-core inode first 1578873101b3SChuck Lever * because it needs a file handle to create an in-core inode (see 1579873101b3SChuck Lever * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1580873101b3SChuck Lever * symlink request has completed on the server. 1581873101b3SChuck Lever * 1582873101b3SChuck Lever * So instead we allocate a raw page, copy the symname into it, then do 1583873101b3SChuck Lever * the SYMLINK request with the page as the buffer. If it succeeds, we 1584873101b3SChuck Lever * now have a new file handle and can instantiate an in-core NFS inode 1585873101b3SChuck Lever * and move the raw page into its mapping. 1586873101b3SChuck Lever */ 1587873101b3SChuck Lever static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 15881da177e4SLinus Torvalds { 1589873101b3SChuck Lever struct pagevec lru_pvec; 1590873101b3SChuck Lever struct page *page; 1591873101b3SChuck Lever char *kaddr; 15921da177e4SLinus Torvalds struct iattr attr; 1593873101b3SChuck Lever unsigned int pathlen = strlen(symname); 15941da177e4SLinus Torvalds int error; 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 15971da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name, symname); 15981da177e4SLinus Torvalds 1599873101b3SChuck Lever if (pathlen > PAGE_SIZE) 1600873101b3SChuck Lever return -ENAMETOOLONG; 16011da177e4SLinus Torvalds 1602873101b3SChuck Lever attr.ia_mode = S_IFLNK | S_IRWXUGO; 1603873101b3SChuck Lever attr.ia_valid = ATTR_MODE; 16041da177e4SLinus Torvalds 160583d93f22SJeff Layton page = alloc_page(GFP_HIGHUSER); 160676566991STrond Myklebust if (!page) 1607873101b3SChuck Lever return -ENOMEM; 1608873101b3SChuck Lever 1609873101b3SChuck Lever kaddr = kmap_atomic(page, KM_USER0); 1610873101b3SChuck Lever memcpy(kaddr, symname, pathlen); 1611873101b3SChuck Lever if (pathlen < PAGE_SIZE) 1612873101b3SChuck Lever memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1613873101b3SChuck Lever kunmap_atomic(kaddr, KM_USER0); 1614873101b3SChuck Lever 161594a6d753SChuck Lever error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1616873101b3SChuck Lever if (error != 0) { 1617873101b3SChuck Lever dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1618873101b3SChuck Lever dir->i_sb->s_id, dir->i_ino, 1619873101b3SChuck Lever dentry->d_name.name, symname, error); 16201da177e4SLinus Torvalds d_drop(dentry); 1621873101b3SChuck Lever __free_page(page); 16221da177e4SLinus Torvalds return error; 16231da177e4SLinus Torvalds } 16241da177e4SLinus Torvalds 1625873101b3SChuck Lever /* 1626873101b3SChuck Lever * No big deal if we can't add this page to the page cache here. 1627873101b3SChuck Lever * READLINK will get the missing page from the server if needed. 1628873101b3SChuck Lever */ 1629873101b3SChuck Lever pagevec_init(&lru_pvec, 0); 1630873101b3SChuck Lever if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1631873101b3SChuck Lever GFP_KERNEL)) { 163239cf8a13SChuck Lever pagevec_add(&lru_pvec, page); 16334f98a2feSRik van Riel pagevec_lru_add_file(&lru_pvec); 1634873101b3SChuck Lever SetPageUptodate(page); 1635873101b3SChuck Lever unlock_page(page); 1636873101b3SChuck Lever } else 1637873101b3SChuck Lever __free_page(page); 1638873101b3SChuck Lever 1639873101b3SChuck Lever return 0; 1640873101b3SChuck Lever } 1641873101b3SChuck Lever 16421da177e4SLinus Torvalds static int 16431da177e4SLinus Torvalds nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 16441da177e4SLinus Torvalds { 16451da177e4SLinus Torvalds struct inode *inode = old_dentry->d_inode; 16461da177e4SLinus Torvalds int error; 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 16491da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 16501da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 16511da177e4SLinus Torvalds 16529a3936aaSTrond Myklebust nfs_inode_return_delegation(inode); 16539a3936aaSTrond Myklebust 16549697d234STrond Myklebust d_drop(dentry); 16551da177e4SLinus Torvalds error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1656cf809556STrond Myklebust if (error == 0) { 1657cf809556STrond Myklebust atomic_inc(&inode->i_count); 16589697d234STrond Myklebust d_add(dentry, inode); 1659cf809556STrond Myklebust } 16601da177e4SLinus Torvalds return error; 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds /* 16641da177e4SLinus Torvalds * RENAME 16651da177e4SLinus Torvalds * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 16661da177e4SLinus Torvalds * different file handle for the same inode after a rename (e.g. when 16671da177e4SLinus Torvalds * moving to a different directory). A fail-safe method to do so would 16681da177e4SLinus Torvalds * be to look up old_dir/old_name, create a link to new_dir/new_name and 16691da177e4SLinus Torvalds * rename the old file using the sillyrename stuff. This way, the original 16701da177e4SLinus Torvalds * file in old_dir will go away when the last process iput()s the inode. 16711da177e4SLinus Torvalds * 16721da177e4SLinus Torvalds * FIXED. 16731da177e4SLinus Torvalds * 16741da177e4SLinus Torvalds * It actually works quite well. One needs to have the possibility for 16751da177e4SLinus Torvalds * at least one ".nfs..." file in each directory the file ever gets 16761da177e4SLinus Torvalds * moved or linked to which happens automagically with the new 16771da177e4SLinus Torvalds * implementation that only depends on the dcache stuff instead of 16781da177e4SLinus Torvalds * using the inode layer 16791da177e4SLinus Torvalds * 16801da177e4SLinus Torvalds * Unfortunately, things are a little more complicated than indicated 16811da177e4SLinus Torvalds * above. For a cross-directory move, we want to make sure we can get 16821da177e4SLinus Torvalds * rid of the old inode after the operation. This means there must be 16831da177e4SLinus Torvalds * no pending writes (if it's a file), and the use count must be 1. 16841da177e4SLinus Torvalds * If these conditions are met, we can drop the dentries before doing 16851da177e4SLinus Torvalds * the rename. 16861da177e4SLinus Torvalds */ 16871da177e4SLinus Torvalds static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 16881da177e4SLinus Torvalds struct inode *new_dir, struct dentry *new_dentry) 16891da177e4SLinus Torvalds { 16901da177e4SLinus Torvalds struct inode *old_inode = old_dentry->d_inode; 16911da177e4SLinus Torvalds struct inode *new_inode = new_dentry->d_inode; 16921da177e4SLinus Torvalds struct dentry *dentry = NULL, *rehash = NULL; 16931da177e4SLinus Torvalds int error = -EBUSY; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 16961da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 16971da177e4SLinus Torvalds new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 16981da177e4SLinus Torvalds atomic_read(&new_dentry->d_count)); 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds /* 170128f79a1aSMiklos Szeredi * For non-directories, check whether the target is busy and if so, 170228f79a1aSMiklos Szeredi * make a copy of the dentry and then do a silly-rename. If the 170328f79a1aSMiklos Szeredi * silly-rename succeeds, the copied dentry is hashed and becomes 170428f79a1aSMiklos Szeredi * the new target. 17051da177e4SLinus Torvalds */ 170627226104SMiklos Szeredi if (new_inode && !S_ISDIR(new_inode->i_mode)) { 170727226104SMiklos Szeredi /* 170827226104SMiklos Szeredi * To prevent any new references to the target during the 170927226104SMiklos Szeredi * rename, we unhash the dentry in advance. 171027226104SMiklos Szeredi */ 171127226104SMiklos Szeredi if (!d_unhashed(new_dentry)) { 171227226104SMiklos Szeredi d_drop(new_dentry); 171327226104SMiklos Szeredi rehash = new_dentry; 171427226104SMiklos Szeredi } 171527226104SMiklos Szeredi 171627226104SMiklos Szeredi if (atomic_read(&new_dentry->d_count) > 2) { 17171da177e4SLinus Torvalds int err; 171827226104SMiklos Szeredi 17191da177e4SLinus Torvalds /* copy the target dentry's name */ 17201da177e4SLinus Torvalds dentry = d_alloc(new_dentry->d_parent, 17211da177e4SLinus Torvalds &new_dentry->d_name); 17221da177e4SLinus Torvalds if (!dentry) 17231da177e4SLinus Torvalds goto out; 17241da177e4SLinus Torvalds 17251da177e4SLinus Torvalds /* silly-rename the existing target ... */ 17261da177e4SLinus Torvalds err = nfs_sillyrename(new_dir, new_dentry); 172724e93025SMiklos Szeredi if (err) 17281da177e4SLinus Torvalds goto out; 172924e93025SMiklos Szeredi 173024e93025SMiklos Szeredi new_dentry = dentry; 173156335936SOGAWA Hirofumi rehash = NULL; 173224e93025SMiklos Szeredi new_inode = NULL; 1733b1e4adf4STrond Myklebust } 173427226104SMiklos Szeredi } 17351da177e4SLinus Torvalds 1736cae7a073STrond Myklebust nfs_inode_return_delegation(old_inode); 1737b1e4adf4STrond Myklebust if (new_inode != NULL) 173824174119STrond Myklebust nfs_inode_return_delegation(new_inode); 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 17411da177e4SLinus Torvalds new_dir, &new_dentry->d_name); 17425ba7cc48STrond Myklebust nfs_mark_for_revalidate(old_inode); 17431da177e4SLinus Torvalds out: 17441da177e4SLinus Torvalds if (rehash) 17451da177e4SLinus Torvalds d_rehash(rehash); 17461da177e4SLinus Torvalds if (!error) { 1747b1e4adf4STrond Myklebust if (new_inode != NULL) 1748b1e4adf4STrond Myklebust nfs_drop_nlink(new_inode); 17491da177e4SLinus Torvalds d_move(old_dentry, new_dentry); 17508fb559f8SChuck Lever nfs_set_verifier(new_dentry, 17518fb559f8SChuck Lever nfs_save_change_attribute(new_dir)); 1752d45b9d8bSTrond Myklebust } else if (error == -ENOENT) 1753d45b9d8bSTrond Myklebust nfs_dentry_handle_enoent(old_dentry); 17541da177e4SLinus Torvalds 17551da177e4SLinus Torvalds /* new dentry created? */ 17561da177e4SLinus Torvalds if (dentry) 17571da177e4SLinus Torvalds dput(dentry); 17581da177e4SLinus Torvalds return error; 17591da177e4SLinus Torvalds } 17601da177e4SLinus Torvalds 1761cfcea3e8STrond Myklebust static DEFINE_SPINLOCK(nfs_access_lru_lock); 1762cfcea3e8STrond Myklebust static LIST_HEAD(nfs_access_lru_list); 1763cfcea3e8STrond Myklebust static atomic_long_t nfs_access_nr_entries; 1764cfcea3e8STrond Myklebust 17651c3c07e9STrond Myklebust static void nfs_access_free_entry(struct nfs_access_entry *entry) 17661c3c07e9STrond Myklebust { 17671c3c07e9STrond Myklebust put_rpccred(entry->cred); 17681c3c07e9STrond Myklebust kfree(entry); 1769cfcea3e8STrond Myklebust smp_mb__before_atomic_dec(); 1770cfcea3e8STrond Myklebust atomic_long_dec(&nfs_access_nr_entries); 1771cfcea3e8STrond Myklebust smp_mb__after_atomic_dec(); 17721c3c07e9STrond Myklebust } 17731c3c07e9STrond Myklebust 17741a81bb8aSTrond Myklebust static void nfs_access_free_list(struct list_head *head) 17751a81bb8aSTrond Myklebust { 17761a81bb8aSTrond Myklebust struct nfs_access_entry *cache; 17771a81bb8aSTrond Myklebust 17781a81bb8aSTrond Myklebust while (!list_empty(head)) { 17791a81bb8aSTrond Myklebust cache = list_entry(head->next, struct nfs_access_entry, lru); 17801a81bb8aSTrond Myklebust list_del(&cache->lru); 17811a81bb8aSTrond Myklebust nfs_access_free_entry(cache); 17821a81bb8aSTrond Myklebust } 17831a81bb8aSTrond Myklebust } 17841a81bb8aSTrond Myklebust 17857f8275d0SDave Chinner int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1786979df72eSTrond Myklebust { 1787979df72eSTrond Myklebust LIST_HEAD(head); 1788aa510da5STrond Myklebust struct nfs_inode *nfsi, *next; 1789979df72eSTrond Myklebust struct nfs_access_entry *cache; 1790979df72eSTrond Myklebust 179161d5eb29STrond Myklebust if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 179261d5eb29STrond Myklebust return (nr_to_scan == 0) ? 0 : -1; 17939c7e7e23STrond Myklebust 1794a50f7951STrond Myklebust spin_lock(&nfs_access_lru_lock); 1795aa510da5STrond Myklebust list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1796979df72eSTrond Myklebust struct inode *inode; 1797979df72eSTrond Myklebust 1798979df72eSTrond Myklebust if (nr_to_scan-- == 0) 1799979df72eSTrond Myklebust break; 18009c7e7e23STrond Myklebust inode = &nfsi->vfs_inode; 1801979df72eSTrond Myklebust spin_lock(&inode->i_lock); 1802979df72eSTrond Myklebust if (list_empty(&nfsi->access_cache_entry_lru)) 1803979df72eSTrond Myklebust goto remove_lru_entry; 1804979df72eSTrond Myklebust cache = list_entry(nfsi->access_cache_entry_lru.next, 1805979df72eSTrond Myklebust struct nfs_access_entry, lru); 1806979df72eSTrond Myklebust list_move(&cache->lru, &head); 1807979df72eSTrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1808979df72eSTrond Myklebust if (!list_empty(&nfsi->access_cache_entry_lru)) 1809979df72eSTrond Myklebust list_move_tail(&nfsi->access_cache_inode_lru, 1810979df72eSTrond Myklebust &nfs_access_lru_list); 1811979df72eSTrond Myklebust else { 1812979df72eSTrond Myklebust remove_lru_entry: 1813979df72eSTrond Myklebust list_del_init(&nfsi->access_cache_inode_lru); 18149c7e7e23STrond Myklebust smp_mb__before_clear_bit(); 1815979df72eSTrond Myklebust clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 18169c7e7e23STrond Myklebust smp_mb__after_clear_bit(); 1817979df72eSTrond Myklebust } 181859844a9bSTrond Myklebust spin_unlock(&inode->i_lock); 1819979df72eSTrond Myklebust } 1820979df72eSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 18211a81bb8aSTrond Myklebust nfs_access_free_list(&head); 1822979df72eSTrond Myklebust return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 1823979df72eSTrond Myklebust } 1824979df72eSTrond Myklebust 18251a81bb8aSTrond Myklebust static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 18261c3c07e9STrond Myklebust { 18271c3c07e9STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 18281a81bb8aSTrond Myklebust struct rb_node *n; 18291c3c07e9STrond Myklebust struct nfs_access_entry *entry; 18301c3c07e9STrond Myklebust 18311c3c07e9STrond Myklebust /* Unhook entries from the cache */ 18321c3c07e9STrond Myklebust while ((n = rb_first(root_node)) != NULL) { 18331c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 18341c3c07e9STrond Myklebust rb_erase(n, root_node); 18351a81bb8aSTrond Myklebust list_move(&entry->lru, head); 18361c3c07e9STrond Myklebust } 18371c3c07e9STrond Myklebust nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 18381c3c07e9STrond Myklebust } 18391c3c07e9STrond Myklebust 18401c3c07e9STrond Myklebust void nfs_access_zap_cache(struct inode *inode) 18411c3c07e9STrond Myklebust { 18421a81bb8aSTrond Myklebust LIST_HEAD(head); 18431a81bb8aSTrond Myklebust 18441a81bb8aSTrond Myklebust if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 18451a81bb8aSTrond Myklebust return; 1846cfcea3e8STrond Myklebust /* Remove from global LRU init */ 1847cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 18481a81bb8aSTrond Myklebust if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 1849cfcea3e8STrond Myklebust list_del_init(&NFS_I(inode)->access_cache_inode_lru); 1850cfcea3e8STrond Myklebust 18511c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 18521a81bb8aSTrond Myklebust __nfs_access_zap_cache(NFS_I(inode), &head); 18531a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 18541a81bb8aSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 18551a81bb8aSTrond Myklebust nfs_access_free_list(&head); 18561c3c07e9STrond Myklebust } 18571c3c07e9STrond Myklebust 18581c3c07e9STrond Myklebust static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 18591c3c07e9STrond Myklebust { 18601c3c07e9STrond Myklebust struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 18611c3c07e9STrond Myklebust struct nfs_access_entry *entry; 18621c3c07e9STrond Myklebust 18631c3c07e9STrond Myklebust while (n != NULL) { 18641c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 18651c3c07e9STrond Myklebust 18661c3c07e9STrond Myklebust if (cred < entry->cred) 18671c3c07e9STrond Myklebust n = n->rb_left; 18681c3c07e9STrond Myklebust else if (cred > entry->cred) 18691c3c07e9STrond Myklebust n = n->rb_right; 18701c3c07e9STrond Myklebust else 18711c3c07e9STrond Myklebust return entry; 18721c3c07e9STrond Myklebust } 18731c3c07e9STrond Myklebust return NULL; 18741c3c07e9STrond Myklebust } 18751c3c07e9STrond Myklebust 1876af22f94aSTrond Myklebust static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 18771da177e4SLinus Torvalds { 187855296809SChuck Lever struct nfs_inode *nfsi = NFS_I(inode); 18791c3c07e9STrond Myklebust struct nfs_access_entry *cache; 18801c3c07e9STrond Myklebust int err = -ENOENT; 18811da177e4SLinus Torvalds 18821c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 18831c3c07e9STrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 18841c3c07e9STrond Myklebust goto out_zap; 18851c3c07e9STrond Myklebust cache = nfs_access_search_rbtree(inode, cred); 18861c3c07e9STrond Myklebust if (cache == NULL) 18871c3c07e9STrond Myklebust goto out; 1888b4d2314bSTrond Myklebust if (!nfs_have_delegated_attributes(inode) && 188964672d55SPeter Staubach !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 18901c3c07e9STrond Myklebust goto out_stale; 18911c3c07e9STrond Myklebust res->jiffies = cache->jiffies; 18921c3c07e9STrond Myklebust res->cred = cache->cred; 18931c3c07e9STrond Myklebust res->mask = cache->mask; 1894cfcea3e8STrond Myklebust list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 18951c3c07e9STrond Myklebust err = 0; 18961c3c07e9STrond Myklebust out: 18971c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 18981c3c07e9STrond Myklebust return err; 18991c3c07e9STrond Myklebust out_stale: 19001c3c07e9STrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1901cfcea3e8STrond Myklebust list_del(&cache->lru); 19021c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 19031c3c07e9STrond Myklebust nfs_access_free_entry(cache); 19041da177e4SLinus Torvalds return -ENOENT; 19051c3c07e9STrond Myklebust out_zap: 19061a81bb8aSTrond Myklebust spin_unlock(&inode->i_lock); 19071a81bb8aSTrond Myklebust nfs_access_zap_cache(inode); 19081c3c07e9STrond Myklebust return -ENOENT; 19091c3c07e9STrond Myklebust } 19101c3c07e9STrond Myklebust 19111c3c07e9STrond Myklebust static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 19121c3c07e9STrond Myklebust { 1913cfcea3e8STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 1914cfcea3e8STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 19151c3c07e9STrond Myklebust struct rb_node **p = &root_node->rb_node; 19161c3c07e9STrond Myklebust struct rb_node *parent = NULL; 19171c3c07e9STrond Myklebust struct nfs_access_entry *entry; 19181c3c07e9STrond Myklebust 19191c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 19201c3c07e9STrond Myklebust while (*p != NULL) { 19211c3c07e9STrond Myklebust parent = *p; 19221c3c07e9STrond Myklebust entry = rb_entry(parent, struct nfs_access_entry, rb_node); 19231c3c07e9STrond Myklebust 19241c3c07e9STrond Myklebust if (set->cred < entry->cred) 19251c3c07e9STrond Myklebust p = &parent->rb_left; 19261c3c07e9STrond Myklebust else if (set->cred > entry->cred) 19271c3c07e9STrond Myklebust p = &parent->rb_right; 19281c3c07e9STrond Myklebust else 19291c3c07e9STrond Myklebust goto found; 19301c3c07e9STrond Myklebust } 19311c3c07e9STrond Myklebust rb_link_node(&set->rb_node, parent, p); 19321c3c07e9STrond Myklebust rb_insert_color(&set->rb_node, root_node); 1933cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 19341c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 19351c3c07e9STrond Myklebust return; 19361c3c07e9STrond Myklebust found: 19371c3c07e9STrond Myklebust rb_replace_node(parent, &set->rb_node, root_node); 1938cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 1939cfcea3e8STrond Myklebust list_del(&entry->lru); 19401c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 19411c3c07e9STrond Myklebust nfs_access_free_entry(entry); 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds 1944af22f94aSTrond Myklebust static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 19451da177e4SLinus Torvalds { 19461c3c07e9STrond Myklebust struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 19471c3c07e9STrond Myklebust if (cache == NULL) 19481c3c07e9STrond Myklebust return; 19491c3c07e9STrond Myklebust RB_CLEAR_NODE(&cache->rb_node); 19501da177e4SLinus Torvalds cache->jiffies = set->jiffies; 19511c3c07e9STrond Myklebust cache->cred = get_rpccred(set->cred); 19521da177e4SLinus Torvalds cache->mask = set->mask; 19531c3c07e9STrond Myklebust 19541c3c07e9STrond Myklebust nfs_access_add_rbtree(inode, cache); 1955cfcea3e8STrond Myklebust 1956cfcea3e8STrond Myklebust /* Update accounting */ 1957cfcea3e8STrond Myklebust smp_mb__before_atomic_inc(); 1958cfcea3e8STrond Myklebust atomic_long_inc(&nfs_access_nr_entries); 1959cfcea3e8STrond Myklebust smp_mb__after_atomic_inc(); 1960cfcea3e8STrond Myklebust 1961cfcea3e8STrond Myklebust /* Add inode to global LRU list */ 19621a81bb8aSTrond Myklebust if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 1963cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 19641a81bb8aSTrond Myklebust if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 19651a81bb8aSTrond Myklebust list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 19661a81bb8aSTrond Myklebust &nfs_access_lru_list); 1967cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 1968cfcea3e8STrond Myklebust } 19691da177e4SLinus Torvalds } 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 19721da177e4SLinus Torvalds { 19731da177e4SLinus Torvalds struct nfs_access_entry cache; 19741da177e4SLinus Torvalds int status; 19751da177e4SLinus Torvalds 19761da177e4SLinus Torvalds status = nfs_access_get_cached(inode, cred, &cache); 19771da177e4SLinus Torvalds if (status == 0) 19781da177e4SLinus Torvalds goto out; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds /* Be clever: ask server to check for all possible rights */ 19811da177e4SLinus Torvalds cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 19821da177e4SLinus Torvalds cache.cred = cred; 19831da177e4SLinus Torvalds cache.jiffies = jiffies; 19841da177e4SLinus Torvalds status = NFS_PROTO(inode)->access(inode, &cache); 1985a71ee337SSuresh Jayaraman if (status != 0) { 1986a71ee337SSuresh Jayaraman if (status == -ESTALE) { 1987a71ee337SSuresh Jayaraman nfs_zap_caches(inode); 1988a71ee337SSuresh Jayaraman if (!S_ISDIR(inode->i_mode)) 1989a71ee337SSuresh Jayaraman set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 1990a71ee337SSuresh Jayaraman } 19911da177e4SLinus Torvalds return status; 1992a71ee337SSuresh Jayaraman } 19931da177e4SLinus Torvalds nfs_access_add_cache(inode, &cache); 19941da177e4SLinus Torvalds out: 1995e6305c43SAl Viro if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 19961da177e4SLinus Torvalds return 0; 19971da177e4SLinus Torvalds return -EACCES; 19981da177e4SLinus Torvalds } 19991da177e4SLinus Torvalds 2000af22f94aSTrond Myklebust static int nfs_open_permission_mask(int openflags) 2001af22f94aSTrond Myklebust { 2002af22f94aSTrond Myklebust int mask = 0; 2003af22f94aSTrond Myklebust 2004af22f94aSTrond Myklebust if (openflags & FMODE_READ) 2005af22f94aSTrond Myklebust mask |= MAY_READ; 2006af22f94aSTrond Myklebust if (openflags & FMODE_WRITE) 2007af22f94aSTrond Myklebust mask |= MAY_WRITE; 2008af22f94aSTrond Myklebust if (openflags & FMODE_EXEC) 2009af22f94aSTrond Myklebust mask |= MAY_EXEC; 2010af22f94aSTrond Myklebust return mask; 2011af22f94aSTrond Myklebust } 2012af22f94aSTrond Myklebust 2013af22f94aSTrond Myklebust int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2014af22f94aSTrond Myklebust { 2015af22f94aSTrond Myklebust return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2016af22f94aSTrond Myklebust } 2017af22f94aSTrond Myklebust 2018e6305c43SAl Viro int nfs_permission(struct inode *inode, int mask) 20191da177e4SLinus Torvalds { 20201da177e4SLinus Torvalds struct rpc_cred *cred; 20211da177e4SLinus Torvalds int res = 0; 20221da177e4SLinus Torvalds 202391d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSACCESS); 202491d5b470SChuck Lever 2025e6305c43SAl Viro if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 20261da177e4SLinus Torvalds goto out; 20271da177e4SLinus Torvalds /* Is this sys_access() ? */ 20289cfcac81SEric Paris if (mask & (MAY_ACCESS | MAY_CHDIR)) 20291da177e4SLinus Torvalds goto force_lookup; 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds switch (inode->i_mode & S_IFMT) { 20321da177e4SLinus Torvalds case S_IFLNK: 20331da177e4SLinus Torvalds goto out; 20341da177e4SLinus Torvalds case S_IFREG: 20351da177e4SLinus Torvalds /* NFSv4 has atomic_open... */ 20361da177e4SLinus Torvalds if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 20377ee2cb7fSFrank Filz && (mask & MAY_OPEN) 20387ee2cb7fSFrank Filz && !(mask & MAY_EXEC)) 20391da177e4SLinus Torvalds goto out; 20401da177e4SLinus Torvalds break; 20411da177e4SLinus Torvalds case S_IFDIR: 20421da177e4SLinus Torvalds /* 20431da177e4SLinus Torvalds * Optimize away all write operations, since the server 20441da177e4SLinus Torvalds * will check permissions when we perform the op. 20451da177e4SLinus Torvalds */ 20461da177e4SLinus Torvalds if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 20471da177e4SLinus Torvalds goto out; 20481da177e4SLinus Torvalds } 20491da177e4SLinus Torvalds 20501da177e4SLinus Torvalds force_lookup: 20511da177e4SLinus Torvalds if (!NFS_PROTO(inode)->access) 20521da177e4SLinus Torvalds goto out_notsup; 20531da177e4SLinus Torvalds 205498a8e323STrond Myklebust cred = rpc_lookup_cred(); 20551da177e4SLinus Torvalds if (!IS_ERR(cred)) { 20561da177e4SLinus Torvalds res = nfs_do_access(inode, cred, mask); 20571da177e4SLinus Torvalds put_rpccred(cred); 20581da177e4SLinus Torvalds } else 20591da177e4SLinus Torvalds res = PTR_ERR(cred); 20601da177e4SLinus Torvalds out: 2061f696a365SMiklos Szeredi if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2062f696a365SMiklos Szeredi res = -EACCES; 2063f696a365SMiklos Szeredi 20641e7cb3dcSChuck Lever dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 20651e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino, mask, res); 20661da177e4SLinus Torvalds return res; 20671da177e4SLinus Torvalds out_notsup: 20681da177e4SLinus Torvalds res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 20691da177e4SLinus Torvalds if (res == 0) 20701da177e4SLinus Torvalds res = generic_permission(inode, mask, NULL); 20711e7cb3dcSChuck Lever goto out; 20721da177e4SLinus Torvalds } 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds /* 20751da177e4SLinus Torvalds * Local variables: 20761da177e4SLinus Torvalds * version-control: t 20771da177e4SLinus Torvalds * kept-new-versions: 5 20781da177e4SLinus Torvalds * End: 20791da177e4SLinus Torvalds */ 2080