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> 321da177e4SLinus Torvalds #include <linux/smp_lock.h> 331da177e4SLinus Torvalds #include <linux/namei.h> 3454ceac45SDavid Howells #include <linux/mount.h> 351da177e4SLinus Torvalds 364ce79717STrond Myklebust #include "nfs4_fs.h" 371da177e4SLinus Torvalds #include "delegation.h" 3891d5b470SChuck Lever #include "iostat.h" 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds #define NFS_PARANOIA 1 411da177e4SLinus Torvalds /* #define NFS_DEBUG_VERBOSE 1 */ 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds static int nfs_opendir(struct inode *, struct file *); 441da177e4SLinus Torvalds static int nfs_readdir(struct file *, void *, filldir_t); 451da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 461da177e4SLinus Torvalds static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *); 471da177e4SLinus Torvalds static int nfs_mkdir(struct inode *, struct dentry *, int); 481da177e4SLinus Torvalds static int nfs_rmdir(struct inode *, struct dentry *); 491da177e4SLinus Torvalds static int nfs_unlink(struct inode *, struct dentry *); 501da177e4SLinus Torvalds static int nfs_symlink(struct inode *, struct dentry *, const char *); 511da177e4SLinus Torvalds static int nfs_link(struct dentry *, struct inode *, struct dentry *); 521da177e4SLinus Torvalds static int nfs_mknod(struct inode *, struct dentry *, int, dev_t); 531da177e4SLinus Torvalds static int nfs_rename(struct inode *, struct dentry *, 541da177e4SLinus Torvalds struct inode *, struct dentry *); 551da177e4SLinus Torvalds static int nfs_fsync_dir(struct file *, struct dentry *, int); 56f0dd2136STrond Myklebust static loff_t nfs_llseek_dir(struct file *, loff_t, int); 571da177e4SLinus Torvalds 584b6f5d20SArjan van de Ven const struct file_operations nfs_dir_operations = { 59f0dd2136STrond Myklebust .llseek = nfs_llseek_dir, 601da177e4SLinus Torvalds .read = generic_read_dir, 611da177e4SLinus Torvalds .readdir = nfs_readdir, 621da177e4SLinus Torvalds .open = nfs_opendir, 631da177e4SLinus Torvalds .release = nfs_release, 641da177e4SLinus Torvalds .fsync = nfs_fsync_dir, 651da177e4SLinus Torvalds }; 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds struct inode_operations nfs_dir_inode_operations = { 681da177e4SLinus Torvalds .create = nfs_create, 691da177e4SLinus Torvalds .lookup = nfs_lookup, 701da177e4SLinus Torvalds .link = nfs_link, 711da177e4SLinus Torvalds .unlink = nfs_unlink, 721da177e4SLinus Torvalds .symlink = nfs_symlink, 731da177e4SLinus Torvalds .mkdir = nfs_mkdir, 741da177e4SLinus Torvalds .rmdir = nfs_rmdir, 751da177e4SLinus Torvalds .mknod = nfs_mknod, 761da177e4SLinus Torvalds .rename = nfs_rename, 771da177e4SLinus Torvalds .permission = nfs_permission, 781da177e4SLinus Torvalds .getattr = nfs_getattr, 791da177e4SLinus Torvalds .setattr = nfs_setattr, 801da177e4SLinus Torvalds }; 811da177e4SLinus Torvalds 82b7fa0554SAndreas Gruenbacher #ifdef CONFIG_NFS_V3 83b7fa0554SAndreas Gruenbacher struct inode_operations nfs3_dir_inode_operations = { 84b7fa0554SAndreas Gruenbacher .create = nfs_create, 85b7fa0554SAndreas Gruenbacher .lookup = nfs_lookup, 86b7fa0554SAndreas Gruenbacher .link = nfs_link, 87b7fa0554SAndreas Gruenbacher .unlink = nfs_unlink, 88b7fa0554SAndreas Gruenbacher .symlink = nfs_symlink, 89b7fa0554SAndreas Gruenbacher .mkdir = nfs_mkdir, 90b7fa0554SAndreas Gruenbacher .rmdir = nfs_rmdir, 91b7fa0554SAndreas Gruenbacher .mknod = nfs_mknod, 92b7fa0554SAndreas Gruenbacher .rename = nfs_rename, 93b7fa0554SAndreas Gruenbacher .permission = nfs_permission, 94b7fa0554SAndreas Gruenbacher .getattr = nfs_getattr, 95b7fa0554SAndreas Gruenbacher .setattr = nfs_setattr, 96b7fa0554SAndreas Gruenbacher .listxattr = nfs3_listxattr, 97b7fa0554SAndreas Gruenbacher .getxattr = nfs3_getxattr, 98b7fa0554SAndreas Gruenbacher .setxattr = nfs3_setxattr, 99b7fa0554SAndreas Gruenbacher .removexattr = nfs3_removexattr, 100b7fa0554SAndreas Gruenbacher }; 101b7fa0554SAndreas Gruenbacher #endif /* CONFIG_NFS_V3 */ 102b7fa0554SAndreas Gruenbacher 1031da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *); 1061da177e4SLinus Torvalds struct inode_operations nfs4_dir_inode_operations = { 1071da177e4SLinus Torvalds .create = nfs_create, 1081da177e4SLinus Torvalds .lookup = nfs_atomic_lookup, 1091da177e4SLinus Torvalds .link = nfs_link, 1101da177e4SLinus Torvalds .unlink = nfs_unlink, 1111da177e4SLinus Torvalds .symlink = nfs_symlink, 1121da177e4SLinus Torvalds .mkdir = nfs_mkdir, 1131da177e4SLinus Torvalds .rmdir = nfs_rmdir, 1141da177e4SLinus Torvalds .mknod = nfs_mknod, 1151da177e4SLinus Torvalds .rename = nfs_rename, 1161da177e4SLinus Torvalds .permission = nfs_permission, 1171da177e4SLinus Torvalds .getattr = nfs_getattr, 1181da177e4SLinus Torvalds .setattr = nfs_setattr, 1196b3b5496SJ. Bruce Fields .getxattr = nfs4_getxattr, 1206b3b5496SJ. Bruce Fields .setxattr = nfs4_setxattr, 1216b3b5496SJ. Bruce Fields .listxattr = nfs4_listxattr, 1221da177e4SLinus Torvalds }; 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds #endif /* CONFIG_NFS_V4 */ 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds /* 1271da177e4SLinus Torvalds * Open file 1281da177e4SLinus Torvalds */ 1291da177e4SLinus Torvalds static int 1301da177e4SLinus Torvalds nfs_opendir(struct inode *inode, struct file *filp) 1311da177e4SLinus Torvalds { 1327451c4f0SCarsten Otte int res; 1331da177e4SLinus Torvalds 1341e7cb3dcSChuck Lever dfprintk(VFS, "NFS: opendir(%s/%ld)\n", 1351e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino); 1361e7cb3dcSChuck Lever 1371da177e4SLinus Torvalds lock_kernel(); 1381da177e4SLinus Torvalds /* Call generic open code in order to cache credentials */ 1391da177e4SLinus Torvalds res = nfs_open(inode, filp); 1401da177e4SLinus Torvalds unlock_kernel(); 1411da177e4SLinus Torvalds return res; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds typedef u32 * (*decode_dirent_t)(u32 *, struct nfs_entry *, int); 1451da177e4SLinus Torvalds typedef struct { 1461da177e4SLinus Torvalds struct file *file; 1471da177e4SLinus Torvalds struct page *page; 1481da177e4SLinus Torvalds unsigned long page_index; 1491da177e4SLinus Torvalds u32 *ptr; 150f0dd2136STrond Myklebust u64 *dir_cookie; 151f0dd2136STrond Myklebust loff_t current_index; 1521da177e4SLinus Torvalds struct nfs_entry *entry; 1531da177e4SLinus Torvalds decode_dirent_t decode; 1541da177e4SLinus Torvalds int plus; 1551da177e4SLinus Torvalds int error; 1561da177e4SLinus Torvalds } nfs_readdir_descriptor_t; 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds /* Now we cache directories properly, by stuffing the dirent 1591da177e4SLinus Torvalds * data directly in the page cache. 1601da177e4SLinus Torvalds * 1611da177e4SLinus Torvalds * Inode invalidation due to refresh etc. takes care of 1621da177e4SLinus Torvalds * _everything_, no sloppy entry flushing logic, no extraneous 1631da177e4SLinus Torvalds * copying, network direct to page cache, the way it was meant 1641da177e4SLinus Torvalds * to be. 1651da177e4SLinus Torvalds * 1661da177e4SLinus Torvalds * NOTE: Dirent information verification is done always by the 1671da177e4SLinus Torvalds * page-in of the RPC reply, nowhere else, this simplies 1681da177e4SLinus Torvalds * things substantially. 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds static 1711da177e4SLinus Torvalds int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page) 1721da177e4SLinus Torvalds { 1731da177e4SLinus Torvalds struct file *file = desc->file; 1741da177e4SLinus Torvalds struct inode *inode = file->f_dentry->d_inode; 1751da177e4SLinus Torvalds struct rpc_cred *cred = nfs_file_cred(file); 1761da177e4SLinus Torvalds unsigned long timestamp; 1771da177e4SLinus Torvalds int error; 1781da177e4SLinus Torvalds 1791e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n", 1801e7cb3dcSChuck Lever __FUNCTION__, (long long)desc->entry->cookie, 1811e7cb3dcSChuck Lever page->index); 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds again: 1841da177e4SLinus Torvalds timestamp = jiffies; 1851da177e4SLinus Torvalds error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, desc->entry->cookie, page, 1861da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, desc->plus); 1871da177e4SLinus Torvalds if (error < 0) { 1881da177e4SLinus Torvalds /* We requested READDIRPLUS, but the server doesn't grok it */ 1891da177e4SLinus Torvalds if (error == -ENOTSUPP && desc->plus) { 1901da177e4SLinus Torvalds NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 191412d582eSChuck Lever clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); 1921da177e4SLinus Torvalds desc->plus = 0; 1931da177e4SLinus Torvalds goto again; 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds goto error; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds SetPageUptodate(page); 198dc59250cSChuck Lever spin_lock(&inode->i_lock); 19955296809SChuck Lever NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME; 200dc59250cSChuck Lever spin_unlock(&inode->i_lock); 2011da177e4SLinus Torvalds /* Ensure consistent page alignment of the data. 2021da177e4SLinus Torvalds * Note: assumes we have exclusive access to this mapping either 2031b1dcc1bSJes Sorensen * through inode->i_mutex or some other mechanism. 2041da177e4SLinus Torvalds */ 205a656db99STrond Myklebust if (page->index == 0) 206a656db99STrond Myklebust invalidate_inode_pages2_range(inode->i_mapping, PAGE_CACHE_SIZE, -1); 2071da177e4SLinus Torvalds unlock_page(page); 2081da177e4SLinus Torvalds return 0; 2091da177e4SLinus Torvalds error: 2101da177e4SLinus Torvalds SetPageError(page); 2111da177e4SLinus Torvalds unlock_page(page); 2121da177e4SLinus Torvalds nfs_zap_caches(inode); 2131da177e4SLinus Torvalds desc->error = error; 2141da177e4SLinus Torvalds return -EIO; 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds static inline 2181da177e4SLinus Torvalds int dir_decode(nfs_readdir_descriptor_t *desc) 2191da177e4SLinus Torvalds { 2201da177e4SLinus Torvalds u32 *p = desc->ptr; 2211da177e4SLinus Torvalds p = desc->decode(p, desc->entry, desc->plus); 2221da177e4SLinus Torvalds if (IS_ERR(p)) 2231da177e4SLinus Torvalds return PTR_ERR(p); 2241da177e4SLinus Torvalds desc->ptr = p; 2251da177e4SLinus Torvalds return 0; 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds static inline 2291da177e4SLinus Torvalds void dir_page_release(nfs_readdir_descriptor_t *desc) 2301da177e4SLinus Torvalds { 2311da177e4SLinus Torvalds kunmap(desc->page); 2321da177e4SLinus Torvalds page_cache_release(desc->page); 2331da177e4SLinus Torvalds desc->page = NULL; 2341da177e4SLinus Torvalds desc->ptr = NULL; 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds /* 2381da177e4SLinus Torvalds * Given a pointer to a buffer that has already been filled by a call 239f0dd2136STrond Myklebust * to readdir, find the next entry with cookie '*desc->dir_cookie'. 2401da177e4SLinus Torvalds * 2411da177e4SLinus Torvalds * If the end of the buffer has been reached, return -EAGAIN, if not, 2421da177e4SLinus Torvalds * return the offset within the buffer of the next entry to be 2431da177e4SLinus Torvalds * read. 2441da177e4SLinus Torvalds */ 2451da177e4SLinus Torvalds static inline 24600a92642SOlivier Galibert int find_dirent(nfs_readdir_descriptor_t *desc) 2471da177e4SLinus Torvalds { 2481da177e4SLinus Torvalds struct nfs_entry *entry = desc->entry; 2491da177e4SLinus Torvalds int loop_count = 0, 2501da177e4SLinus Torvalds status; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds while((status = dir_decode(desc)) == 0) { 2531e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n", 2541e7cb3dcSChuck Lever __FUNCTION__, (unsigned long long)entry->cookie); 255f0dd2136STrond Myklebust if (entry->prev_cookie == *desc->dir_cookie) 2561da177e4SLinus Torvalds break; 2571da177e4SLinus Torvalds if (loop_count++ > 200) { 2581da177e4SLinus Torvalds loop_count = 0; 2591da177e4SLinus Torvalds schedule(); 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds } 2621da177e4SLinus Torvalds return status; 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds 2651da177e4SLinus Torvalds /* 26600a92642SOlivier Galibert * Given a pointer to a buffer that has already been filled by a call 267f0dd2136STrond Myklebust * to readdir, find the entry at offset 'desc->file->f_pos'. 26800a92642SOlivier Galibert * 26900a92642SOlivier Galibert * If the end of the buffer has been reached, return -EAGAIN, if not, 27000a92642SOlivier Galibert * return the offset within the buffer of the next entry to be 27100a92642SOlivier Galibert * read. 27200a92642SOlivier Galibert */ 27300a92642SOlivier Galibert static inline 27400a92642SOlivier Galibert int find_dirent_index(nfs_readdir_descriptor_t *desc) 27500a92642SOlivier Galibert { 27600a92642SOlivier Galibert struct nfs_entry *entry = desc->entry; 27700a92642SOlivier Galibert int loop_count = 0, 27800a92642SOlivier Galibert status; 27900a92642SOlivier Galibert 28000a92642SOlivier Galibert for(;;) { 28100a92642SOlivier Galibert status = dir_decode(desc); 28200a92642SOlivier Galibert if (status) 28300a92642SOlivier Galibert break; 28400a92642SOlivier Galibert 2851e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: found cookie %Lu at index %Ld\n", 2861e7cb3dcSChuck Lever (unsigned long long)entry->cookie, desc->current_index); 28700a92642SOlivier Galibert 288f0dd2136STrond Myklebust if (desc->file->f_pos == desc->current_index) { 289f0dd2136STrond Myklebust *desc->dir_cookie = entry->cookie; 29000a92642SOlivier Galibert break; 29100a92642SOlivier Galibert } 29200a92642SOlivier Galibert desc->current_index++; 29300a92642SOlivier Galibert if (loop_count++ > 200) { 29400a92642SOlivier Galibert loop_count = 0; 29500a92642SOlivier Galibert schedule(); 29600a92642SOlivier Galibert } 29700a92642SOlivier Galibert } 29800a92642SOlivier Galibert return status; 29900a92642SOlivier Galibert } 30000a92642SOlivier Galibert 30100a92642SOlivier Galibert /* 30200a92642SOlivier Galibert * Find the given page, and call find_dirent() or find_dirent_index in 30300a92642SOlivier Galibert * order to try to return the next entry. 3041da177e4SLinus Torvalds */ 3051da177e4SLinus Torvalds static inline 3061da177e4SLinus Torvalds int find_dirent_page(nfs_readdir_descriptor_t *desc) 3071da177e4SLinus Torvalds { 3081da177e4SLinus Torvalds struct inode *inode = desc->file->f_dentry->d_inode; 3091da177e4SLinus Torvalds struct page *page; 3101da177e4SLinus Torvalds int status; 3111da177e4SLinus Torvalds 3121e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n", 3131e7cb3dcSChuck Lever __FUNCTION__, desc->page_index, 3141e7cb3dcSChuck Lever (long long) *desc->dir_cookie); 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds page = read_cache_page(inode->i_mapping, desc->page_index, 3171da177e4SLinus Torvalds (filler_t *)nfs_readdir_filler, desc); 3181da177e4SLinus Torvalds if (IS_ERR(page)) { 3191da177e4SLinus Torvalds status = PTR_ERR(page); 3201da177e4SLinus Torvalds goto out; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds if (!PageUptodate(page)) 3231da177e4SLinus Torvalds goto read_error; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds /* NOTE: Someone else may have changed the READDIRPLUS flag */ 3261da177e4SLinus Torvalds desc->page = page; 3271da177e4SLinus Torvalds desc->ptr = kmap(page); /* matching kunmap in nfs_do_filldir */ 328f0dd2136STrond Myklebust if (*desc->dir_cookie != 0) 32900a92642SOlivier Galibert status = find_dirent(desc); 33000a92642SOlivier Galibert else 33100a92642SOlivier Galibert status = find_dirent_index(desc); 3321da177e4SLinus Torvalds if (status < 0) 3331da177e4SLinus Torvalds dir_page_release(desc); 3341da177e4SLinus Torvalds out: 3351e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, status); 3361da177e4SLinus Torvalds return status; 3371da177e4SLinus Torvalds read_error: 3381da177e4SLinus Torvalds page_cache_release(page); 3391da177e4SLinus Torvalds return -EIO; 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds /* 3431da177e4SLinus Torvalds * Recurse through the page cache pages, and return a 3441da177e4SLinus Torvalds * filled nfs_entry structure of the next directory entry if possible. 3451da177e4SLinus Torvalds * 346f0dd2136STrond Myklebust * The target for the search is '*desc->dir_cookie' if non-0, 347f0dd2136STrond Myklebust * 'desc->file->f_pos' otherwise 3481da177e4SLinus Torvalds */ 3491da177e4SLinus Torvalds static inline 3501da177e4SLinus Torvalds int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 3511da177e4SLinus Torvalds { 3521da177e4SLinus Torvalds int loop_count = 0; 3531da177e4SLinus Torvalds int res; 3541da177e4SLinus Torvalds 35500a92642SOlivier Galibert /* Always search-by-index from the beginning of the cache */ 356f0dd2136STrond Myklebust if (*desc->dir_cookie == 0) { 3571e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for offset %Ld\n", 3581e7cb3dcSChuck Lever (long long)desc->file->f_pos); 35900a92642SOlivier Galibert desc->page_index = 0; 36000a92642SOlivier Galibert desc->entry->cookie = desc->entry->prev_cookie = 0; 36100a92642SOlivier Galibert desc->entry->eof = 0; 36200a92642SOlivier Galibert desc->current_index = 0; 363f0dd2136STrond Myklebust } else 3641e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: readdir_search_pagecache() searching for cookie %Lu\n", 3651e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie); 36600a92642SOlivier Galibert 3671da177e4SLinus Torvalds for (;;) { 3681da177e4SLinus Torvalds res = find_dirent_page(desc); 3691da177e4SLinus Torvalds if (res != -EAGAIN) 3701da177e4SLinus Torvalds break; 3711da177e4SLinus Torvalds /* Align to beginning of next page */ 3721da177e4SLinus Torvalds desc->page_index ++; 3731da177e4SLinus Torvalds if (loop_count++ > 200) { 3741da177e4SLinus Torvalds loop_count = 0; 3751da177e4SLinus Torvalds schedule(); 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds } 3781e7cb3dcSChuck Lever 3791e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, res); 3801da177e4SLinus Torvalds return res; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds static inline unsigned int dt_type(struct inode *inode) 3841da177e4SLinus Torvalds { 3851da177e4SLinus Torvalds return (inode->i_mode >> 12) & 15; 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc); 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* 3911da177e4SLinus Torvalds * Once we've found the start of the dirent within a page: fill 'er up... 3921da177e4SLinus Torvalds */ 3931da177e4SLinus Torvalds static 3941da177e4SLinus Torvalds int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent, 3951da177e4SLinus Torvalds filldir_t filldir) 3961da177e4SLinus Torvalds { 3971da177e4SLinus Torvalds struct file *file = desc->file; 3981da177e4SLinus Torvalds struct nfs_entry *entry = desc->entry; 3991da177e4SLinus Torvalds struct dentry *dentry = NULL; 4001da177e4SLinus Torvalds unsigned long fileid; 4011da177e4SLinus Torvalds int loop_count = 0, 4021da177e4SLinus Torvalds res; 4031da177e4SLinus Torvalds 4041e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling starting @ cookie %Lu\n", 4051e7cb3dcSChuck Lever (unsigned long long)entry->cookie); 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds for(;;) { 4081da177e4SLinus Torvalds unsigned d_type = DT_UNKNOWN; 4091da177e4SLinus Torvalds /* Note: entry->prev_cookie contains the cookie for 4101da177e4SLinus Torvalds * retrieving the current dirent on the server */ 4111da177e4SLinus Torvalds fileid = nfs_fileid_to_ino_t(entry->ino); 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds /* Get a dentry if we have one */ 4141da177e4SLinus Torvalds if (dentry != NULL) 4151da177e4SLinus Torvalds dput(dentry); 4161da177e4SLinus Torvalds dentry = nfs_readdir_lookup(desc); 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds /* Use readdirplus info */ 4191da177e4SLinus Torvalds if (dentry != NULL && dentry->d_inode != NULL) { 4201da177e4SLinus Torvalds d_type = dt_type(dentry->d_inode); 4211da177e4SLinus Torvalds fileid = dentry->d_inode->i_ino; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds res = filldir(dirent, entry->name, entry->len, 42500a92642SOlivier Galibert file->f_pos, fileid, d_type); 4261da177e4SLinus Torvalds if (res < 0) 4271da177e4SLinus Torvalds break; 42800a92642SOlivier Galibert file->f_pos++; 429f0dd2136STrond Myklebust *desc->dir_cookie = entry->cookie; 4301da177e4SLinus Torvalds if (dir_decode(desc) != 0) { 4311da177e4SLinus Torvalds desc->page_index ++; 4321da177e4SLinus Torvalds break; 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds if (loop_count++ > 200) { 4351da177e4SLinus Torvalds loop_count = 0; 4361da177e4SLinus Torvalds schedule(); 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds dir_page_release(desc); 4401da177e4SLinus Torvalds if (dentry != NULL) 4411da177e4SLinus Torvalds dput(dentry); 4421e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 4431e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie, res); 4441da177e4SLinus Torvalds return res; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds /* 4481da177e4SLinus Torvalds * If we cannot find a cookie in our cache, we suspect that this is 4491da177e4SLinus Torvalds * because it points to a deleted file, so we ask the server to return 4501da177e4SLinus Torvalds * whatever it thinks is the next entry. We then feed this to filldir. 4511da177e4SLinus Torvalds * If all goes well, we should then be able to find our way round the 4521da177e4SLinus Torvalds * cache on the next call to readdir_search_pagecache(); 4531da177e4SLinus Torvalds * 4541da177e4SLinus Torvalds * NOTE: we cannot add the anonymous page to the pagecache because 4551da177e4SLinus Torvalds * the data it contains might not be page aligned. Besides, 4561da177e4SLinus Torvalds * we should already have a complete representation of the 4571da177e4SLinus Torvalds * directory in the page cache by the time we get here. 4581da177e4SLinus Torvalds */ 4591da177e4SLinus Torvalds static inline 4601da177e4SLinus Torvalds int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent, 4611da177e4SLinus Torvalds filldir_t filldir) 4621da177e4SLinus Torvalds { 4631da177e4SLinus Torvalds struct file *file = desc->file; 4641da177e4SLinus Torvalds struct inode *inode = file->f_dentry->d_inode; 4651da177e4SLinus Torvalds struct rpc_cred *cred = nfs_file_cred(file); 4661da177e4SLinus Torvalds struct page *page = NULL; 4671da177e4SLinus Torvalds int status; 4681da177e4SLinus Torvalds 4691e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 4701e7cb3dcSChuck Lever (unsigned long long)*desc->dir_cookie); 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds page = alloc_page(GFP_HIGHUSER); 4731da177e4SLinus Torvalds if (!page) { 4741da177e4SLinus Torvalds status = -ENOMEM; 4751da177e4SLinus Torvalds goto out; 4761da177e4SLinus Torvalds } 477f0dd2136STrond Myklebust desc->error = NFS_PROTO(inode)->readdir(file->f_dentry, cred, *desc->dir_cookie, 4781da177e4SLinus Torvalds page, 4791da177e4SLinus Torvalds NFS_SERVER(inode)->dtsize, 4801da177e4SLinus Torvalds desc->plus); 481dc59250cSChuck Lever spin_lock(&inode->i_lock); 48255296809SChuck Lever NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME; 483dc59250cSChuck Lever spin_unlock(&inode->i_lock); 4841da177e4SLinus Torvalds desc->page = page; 4851da177e4SLinus Torvalds desc->ptr = kmap(page); /* matching kunmap in nfs_do_filldir */ 4861da177e4SLinus Torvalds if (desc->error >= 0) { 4871da177e4SLinus Torvalds if ((status = dir_decode(desc)) == 0) 488f0dd2136STrond Myklebust desc->entry->prev_cookie = *desc->dir_cookie; 4891da177e4SLinus Torvalds } else 4901da177e4SLinus Torvalds status = -EIO; 4911da177e4SLinus Torvalds if (status < 0) 4921da177e4SLinus Torvalds goto out_release; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds status = nfs_do_filldir(desc, dirent, filldir); 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds /* Reset read descriptor so it searches the page cache from 4971da177e4SLinus Torvalds * the start upon the next call to readdir_search_pagecache() */ 4981da177e4SLinus Torvalds desc->page_index = 0; 4991da177e4SLinus Torvalds desc->entry->cookie = desc->entry->prev_cookie = 0; 5001da177e4SLinus Torvalds desc->entry->eof = 0; 5011da177e4SLinus Torvalds out: 5021e7cb3dcSChuck Lever dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 5031e7cb3dcSChuck Lever __FUNCTION__, status); 5041da177e4SLinus Torvalds return status; 5051da177e4SLinus Torvalds out_release: 5061da177e4SLinus Torvalds dir_page_release(desc); 5071da177e4SLinus Torvalds goto out; 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 51000a92642SOlivier Galibert /* The file offset position represents the dirent entry number. A 51100a92642SOlivier Galibert last cookie cache takes care of the common case of reading the 51200a92642SOlivier Galibert whole directory. 5131da177e4SLinus Torvalds */ 5141da177e4SLinus Torvalds static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 5151da177e4SLinus Torvalds { 5161da177e4SLinus Torvalds struct dentry *dentry = filp->f_dentry; 5171da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 5181da177e4SLinus Torvalds nfs_readdir_descriptor_t my_desc, 5191da177e4SLinus Torvalds *desc = &my_desc; 5201da177e4SLinus Torvalds struct nfs_entry my_entry; 5211da177e4SLinus Torvalds struct nfs_fh fh; 5221da177e4SLinus Torvalds struct nfs_fattr fattr; 5231da177e4SLinus Torvalds long res; 5241da177e4SLinus Torvalds 5251e7cb3dcSChuck Lever dfprintk(VFS, "NFS: readdir(%s/%s) starting at cookie %Lu\n", 5261e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 5271e7cb3dcSChuck Lever (long long)filp->f_pos); 52891d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 52991d5b470SChuck Lever 5301da177e4SLinus Torvalds lock_kernel(); 5311da177e4SLinus Torvalds 53244b11874STrond Myklebust res = nfs_revalidate_mapping(inode, filp->f_mapping); 5331da177e4SLinus Torvalds if (res < 0) { 5341da177e4SLinus Torvalds unlock_kernel(); 5351da177e4SLinus Torvalds return res; 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds /* 53900a92642SOlivier Galibert * filp->f_pos points to the dirent entry number. 540f0dd2136STrond Myklebust * *desc->dir_cookie has the cookie for the next entry. We have 54100a92642SOlivier Galibert * to either find the entry with the appropriate number or 54200a92642SOlivier Galibert * revalidate the cookie. 5431da177e4SLinus Torvalds */ 5441da177e4SLinus Torvalds memset(desc, 0, sizeof(*desc)); 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds desc->file = filp; 547f0dd2136STrond Myklebust desc->dir_cookie = &((struct nfs_open_context *)filp->private_data)->dir_cookie; 5481da177e4SLinus Torvalds desc->decode = NFS_PROTO(inode)->decode_dirent; 5491da177e4SLinus Torvalds desc->plus = NFS_USE_READDIRPLUS(inode); 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds my_entry.cookie = my_entry.prev_cookie = 0; 5521da177e4SLinus Torvalds my_entry.eof = 0; 5531da177e4SLinus Torvalds my_entry.fh = &fh; 5541da177e4SLinus Torvalds my_entry.fattr = &fattr; 5550e574af1STrond Myklebust nfs_fattr_init(&fattr); 5561da177e4SLinus Torvalds desc->entry = &my_entry; 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds while(!desc->entry->eof) { 5591da177e4SLinus Torvalds res = readdir_search_pagecache(desc); 56000a92642SOlivier Galibert 5611da177e4SLinus Torvalds if (res == -EBADCOOKIE) { 5621da177e4SLinus Torvalds /* This means either end of directory */ 563f0dd2136STrond Myklebust if (*desc->dir_cookie && desc->entry->cookie != *desc->dir_cookie) { 5641da177e4SLinus Torvalds /* Or that the server has 'lost' a cookie */ 5651da177e4SLinus Torvalds res = uncached_readdir(desc, dirent, filldir); 5661da177e4SLinus Torvalds if (res >= 0) 5671da177e4SLinus Torvalds continue; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds res = 0; 5701da177e4SLinus Torvalds break; 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds if (res == -ETOOSMALL && desc->plus) { 573412d582eSChuck Lever clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); 5741da177e4SLinus Torvalds nfs_zap_caches(inode); 5751da177e4SLinus Torvalds desc->plus = 0; 5761da177e4SLinus Torvalds desc->entry->eof = 0; 5771da177e4SLinus Torvalds continue; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds if (res < 0) 5801da177e4SLinus Torvalds break; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds res = nfs_do_filldir(desc, dirent, filldir); 5831da177e4SLinus Torvalds if (res < 0) { 5841da177e4SLinus Torvalds res = 0; 5851da177e4SLinus Torvalds break; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds unlock_kernel(); 5891e7cb3dcSChuck Lever if (res > 0) 5901e7cb3dcSChuck Lever res = 0; 5911e7cb3dcSChuck Lever dfprintk(VFS, "NFS: readdir(%s/%s) returns %ld\n", 5921e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 5931e7cb3dcSChuck Lever res); 5941da177e4SLinus Torvalds return res; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 597f0dd2136STrond Myklebust loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 598f0dd2136STrond Myklebust { 5991b1dcc1bSJes Sorensen mutex_lock(&filp->f_dentry->d_inode->i_mutex); 600f0dd2136STrond Myklebust switch (origin) { 601f0dd2136STrond Myklebust case 1: 602f0dd2136STrond Myklebust offset += filp->f_pos; 603f0dd2136STrond Myklebust case 0: 604f0dd2136STrond Myklebust if (offset >= 0) 605f0dd2136STrond Myklebust break; 606f0dd2136STrond Myklebust default: 607f0dd2136STrond Myklebust offset = -EINVAL; 608f0dd2136STrond Myklebust goto out; 609f0dd2136STrond Myklebust } 610f0dd2136STrond Myklebust if (offset != filp->f_pos) { 611f0dd2136STrond Myklebust filp->f_pos = offset; 612f0dd2136STrond Myklebust ((struct nfs_open_context *)filp->private_data)->dir_cookie = 0; 613f0dd2136STrond Myklebust } 614f0dd2136STrond Myklebust out: 6151b1dcc1bSJes Sorensen mutex_unlock(&filp->f_dentry->d_inode->i_mutex); 616f0dd2136STrond Myklebust return offset; 617f0dd2136STrond Myklebust } 618f0dd2136STrond Myklebust 6191da177e4SLinus Torvalds /* 6201da177e4SLinus Torvalds * All directory operations under NFS are synchronous, so fsync() 6211da177e4SLinus Torvalds * is a dummy operation. 6221da177e4SLinus Torvalds */ 6231da177e4SLinus Torvalds int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync) 6241da177e4SLinus Torvalds { 6251e7cb3dcSChuck Lever dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n", 6261e7cb3dcSChuck Lever dentry->d_parent->d_name.name, dentry->d_name.name, 6271e7cb3dcSChuck Lever datasync); 6281e7cb3dcSChuck Lever 6291da177e4SLinus Torvalds return 0; 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds /* 6331da177e4SLinus Torvalds * A check for whether or not the parent directory has changed. 6341da177e4SLinus Torvalds * In the case it has, we assume that the dentries are untrustworthy 6351da177e4SLinus Torvalds * and may need to be looked up again. 6361da177e4SLinus Torvalds */ 6371da177e4SLinus Torvalds static inline int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 6381da177e4SLinus Torvalds { 6391da177e4SLinus Torvalds if (IS_ROOT(dentry)) 6401da177e4SLinus Torvalds return 1; 64155296809SChuck Lever if ((NFS_I(dir)->cache_validity & NFS_INO_INVALID_ATTR) != 0 6421da177e4SLinus Torvalds || nfs_attribute_timeout(dir)) 6431da177e4SLinus Torvalds return 0; 6441da177e4SLinus Torvalds return nfs_verify_change_attribute(dir, (unsigned long)dentry->d_fsdata); 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf) 6481da177e4SLinus Torvalds { 6491da177e4SLinus Torvalds dentry->d_fsdata = (void *)verf; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /* 6531da177e4SLinus Torvalds * Whenever an NFS operation succeeds, we know that the dentry 6541da177e4SLinus Torvalds * is valid, so we update the revalidation timestamp. 6551da177e4SLinus Torvalds */ 6561da177e4SLinus Torvalds static inline void nfs_renew_times(struct dentry * dentry) 6571da177e4SLinus Torvalds { 6581da177e4SLinus Torvalds dentry->d_time = jiffies; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6611d6757fbSTrond Myklebust /* 6621d6757fbSTrond Myklebust * Return the intent data that applies to this particular path component 6631d6757fbSTrond Myklebust * 6641d6757fbSTrond Myklebust * Note that the current set of intents only apply to the very last 6651d6757fbSTrond Myklebust * component of the path. 6661d6757fbSTrond Myklebust * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 6671d6757fbSTrond Myklebust */ 6681d6757fbSTrond Myklebust static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask) 6691d6757fbSTrond Myklebust { 6701d6757fbSTrond Myklebust if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 6711d6757fbSTrond Myklebust return 0; 6721d6757fbSTrond Myklebust return nd->flags & mask; 6731d6757fbSTrond Myklebust } 6741d6757fbSTrond Myklebust 6751d6757fbSTrond Myklebust /* 6761d6757fbSTrond Myklebust * Inode and filehandle revalidation for lookups. 6771d6757fbSTrond Myklebust * 6781d6757fbSTrond Myklebust * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 6791d6757fbSTrond Myklebust * or if the intent information indicates that we're about to open this 6801d6757fbSTrond Myklebust * particular file and the "nocto" mount flag is not set. 6811d6757fbSTrond Myklebust * 6821d6757fbSTrond Myklebust */ 6831da177e4SLinus Torvalds static inline 6841da177e4SLinus Torvalds int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 6851da177e4SLinus Torvalds { 6861da177e4SLinus Torvalds struct nfs_server *server = NFS_SERVER(inode); 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds if (nd != NULL) { 6891da177e4SLinus Torvalds /* VFS wants an on-the-wire revalidation */ 6901d6757fbSTrond Myklebust if (nd->flags & LOOKUP_REVAL) 6911da177e4SLinus Torvalds goto out_force; 6921da177e4SLinus Torvalds /* This is an open(2) */ 6931d6757fbSTrond Myklebust if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 6944e0641a7STrond Myklebust !(server->flags & NFS_MOUNT_NOCTO) && 6954e0641a7STrond Myklebust (S_ISREG(inode->i_mode) || 6964e0641a7STrond Myklebust S_ISDIR(inode->i_mode))) 6971da177e4SLinus Torvalds goto out_force; 6981da177e4SLinus Torvalds } 6991da177e4SLinus Torvalds return nfs_revalidate_inode(server, inode); 7001da177e4SLinus Torvalds out_force: 7011da177e4SLinus Torvalds return __nfs_revalidate_inode(server, inode); 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds /* 7051da177e4SLinus Torvalds * We judge how long we want to trust negative 7061da177e4SLinus Torvalds * dentries by looking at the parent inode mtime. 7071da177e4SLinus Torvalds * 7081da177e4SLinus Torvalds * If parent mtime has changed, we revalidate, else we wait for a 7091da177e4SLinus Torvalds * period corresponding to the parent's attribute cache timeout value. 7101da177e4SLinus Torvalds */ 7111da177e4SLinus Torvalds static inline 7121da177e4SLinus Torvalds int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 7131da177e4SLinus Torvalds struct nameidata *nd) 7141da177e4SLinus Torvalds { 7151da177e4SLinus Torvalds /* Don't revalidate a negative dentry if we're creating a new file */ 7161d6757fbSTrond Myklebust if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 7171da177e4SLinus Torvalds return 0; 7181da177e4SLinus Torvalds return !nfs_check_verifier(dir, dentry); 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds /* 7221da177e4SLinus Torvalds * This is called every time the dcache has a lookup hit, 7231da177e4SLinus Torvalds * and we should check whether we can really trust that 7241da177e4SLinus Torvalds * lookup. 7251da177e4SLinus Torvalds * 7261da177e4SLinus Torvalds * NOTE! The hit can be a negative hit too, don't assume 7271da177e4SLinus Torvalds * we have an inode! 7281da177e4SLinus Torvalds * 7291da177e4SLinus Torvalds * If the parent directory is seen to have changed, we throw out the 7301da177e4SLinus Torvalds * cached dentry and do a new lookup. 7311da177e4SLinus Torvalds */ 7321da177e4SLinus Torvalds static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd) 7331da177e4SLinus Torvalds { 7341da177e4SLinus Torvalds struct inode *dir; 7351da177e4SLinus Torvalds struct inode *inode; 7361da177e4SLinus Torvalds struct dentry *parent; 7371da177e4SLinus Torvalds int error; 7381da177e4SLinus Torvalds struct nfs_fh fhandle; 7391da177e4SLinus Torvalds struct nfs_fattr fattr; 7401da177e4SLinus Torvalds unsigned long verifier; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds parent = dget_parent(dentry); 7431da177e4SLinus Torvalds lock_kernel(); 7441da177e4SLinus Torvalds dir = parent->d_inode; 74591d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 7461da177e4SLinus Torvalds inode = dentry->d_inode; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (!inode) { 7491da177e4SLinus Torvalds if (nfs_neg_need_reval(dir, dentry, nd)) 7501da177e4SLinus Torvalds goto out_bad; 7511da177e4SLinus Torvalds goto out_valid; 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds if (is_bad_inode(inode)) { 7551e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 7561e7cb3dcSChuck Lever __FUNCTION__, dentry->d_parent->d_name.name, 7571e7cb3dcSChuck Lever dentry->d_name.name); 7581da177e4SLinus Torvalds goto out_bad; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds /* Revalidate parent directory attribute cache */ 7621da177e4SLinus Torvalds if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 7631da177e4SLinus Torvalds goto out_zap_parent; 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds /* Force a full look up iff the parent directory has changed */ 7661da177e4SLinus Torvalds if (nfs_check_verifier(dir, dentry)) { 7671da177e4SLinus Torvalds if (nfs_lookup_verify_inode(inode, nd)) 7681da177e4SLinus Torvalds goto out_zap_parent; 7691da177e4SLinus Torvalds goto out_valid; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds if (NFS_STALE(inode)) 7731da177e4SLinus Torvalds goto out_bad; 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds verifier = nfs_save_change_attribute(dir); 7761da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr); 7771da177e4SLinus Torvalds if (error) 7781da177e4SLinus Torvalds goto out_bad; 7791da177e4SLinus Torvalds if (nfs_compare_fh(NFS_FH(inode), &fhandle)) 7801da177e4SLinus Torvalds goto out_bad; 7811da177e4SLinus Torvalds if ((error = nfs_refresh_inode(inode, &fattr)) != 0) 7821da177e4SLinus Torvalds goto out_bad; 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds nfs_renew_times(dentry); 7851da177e4SLinus Torvalds nfs_set_verifier(dentry, verifier); 7861da177e4SLinus Torvalds out_valid: 7871da177e4SLinus Torvalds unlock_kernel(); 7881da177e4SLinus Torvalds dput(parent); 7891e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 7901e7cb3dcSChuck Lever __FUNCTION__, dentry->d_parent->d_name.name, 7911e7cb3dcSChuck Lever dentry->d_name.name); 7921da177e4SLinus Torvalds return 1; 7931da177e4SLinus Torvalds out_zap_parent: 7941da177e4SLinus Torvalds nfs_zap_caches(dir); 7951da177e4SLinus Torvalds out_bad: 7961da177e4SLinus Torvalds NFS_CACHEINV(dir); 7971da177e4SLinus Torvalds if (inode && S_ISDIR(inode->i_mode)) { 7981da177e4SLinus Torvalds /* Purge readdir caches. */ 7991da177e4SLinus Torvalds nfs_zap_caches(inode); 8001da177e4SLinus Torvalds /* If we have submounts, don't unhash ! */ 8011da177e4SLinus Torvalds if (have_submounts(dentry)) 8021da177e4SLinus Torvalds goto out_valid; 8031da177e4SLinus Torvalds shrink_dcache_parent(dentry); 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds d_drop(dentry); 8061da177e4SLinus Torvalds unlock_kernel(); 8071da177e4SLinus Torvalds dput(parent); 8081e7cb3dcSChuck Lever dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 8091e7cb3dcSChuck Lever __FUNCTION__, dentry->d_parent->d_name.name, 8101e7cb3dcSChuck Lever dentry->d_name.name); 8111da177e4SLinus Torvalds return 0; 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds /* 8151da177e4SLinus Torvalds * This is called from dput() when d_count is going to 0. 8161da177e4SLinus Torvalds */ 8171da177e4SLinus Torvalds static int nfs_dentry_delete(struct dentry *dentry) 8181da177e4SLinus Torvalds { 8191da177e4SLinus Torvalds dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 8201da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 8211da177e4SLinus Torvalds dentry->d_flags); 8221da177e4SLinus Torvalds 8231da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 8241da177e4SLinus Torvalds /* Unhash it, so that ->d_iput() would be called */ 8251da177e4SLinus Torvalds return 1; 8261da177e4SLinus Torvalds } 8271da177e4SLinus Torvalds if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 8281da177e4SLinus Torvalds /* Unhash it, so that ancestors of killed async unlink 8291da177e4SLinus Torvalds * files will be cleaned up during umount */ 8301da177e4SLinus Torvalds return 1; 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds return 0; 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds /* 8371da177e4SLinus Torvalds * Called when the dentry loses inode. 8381da177e4SLinus Torvalds * We use it to clean up silly-renamed files. 8391da177e4SLinus Torvalds */ 8401da177e4SLinus Torvalds static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 8411da177e4SLinus Torvalds { 842cae7a073STrond Myklebust nfs_inode_return_delegation(inode); 8431da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 8441da177e4SLinus Torvalds lock_kernel(); 8451da177e4SLinus Torvalds inode->i_nlink--; 8461da177e4SLinus Torvalds nfs_complete_unlink(dentry); 8471da177e4SLinus Torvalds unlock_kernel(); 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds /* When creating a negative dentry, we want to renew d_time */ 8501da177e4SLinus Torvalds nfs_renew_times(dentry); 8511da177e4SLinus Torvalds iput(inode); 8521da177e4SLinus Torvalds } 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds struct dentry_operations nfs_dentry_operations = { 8551da177e4SLinus Torvalds .d_revalidate = nfs_lookup_revalidate, 8561da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 8571da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 8581da177e4SLinus Torvalds }; 8591da177e4SLinus Torvalds 8601d6757fbSTrond Myklebust /* 8611d6757fbSTrond Myklebust * Use intent information to check whether or not we're going to do 8621d6757fbSTrond Myklebust * an O_EXCL create using this path component. 8631d6757fbSTrond Myklebust */ 8641da177e4SLinus Torvalds static inline 8651da177e4SLinus Torvalds int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 8661da177e4SLinus Torvalds { 8671da177e4SLinus Torvalds if (NFS_PROTO(dir)->version == 2) 8681da177e4SLinus Torvalds return 0; 8691d6757fbSTrond Myklebust if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_CREATE) == 0) 8701da177e4SLinus Torvalds return 0; 8711da177e4SLinus Torvalds return (nd->intent.open.flags & O_EXCL) != 0; 8721da177e4SLinus Torvalds } 8731da177e4SLinus Torvalds 87454ceac45SDavid Howells static inline int nfs_reval_fsid(struct vfsmount *mnt, struct inode *dir, 87555a97593STrond Myklebust struct nfs_fh *fh, struct nfs_fattr *fattr) 87655a97593STrond Myklebust { 87755a97593STrond Myklebust struct nfs_server *server = NFS_SERVER(dir); 87855a97593STrond Myklebust 87955a97593STrond Myklebust if (!nfs_fsid_equal(&server->fsid, &fattr->fsid)) 88055a97593STrond Myklebust /* Revalidate fsid on root dir */ 88154ceac45SDavid Howells return __nfs_revalidate_inode(server, mnt->mnt_root->d_inode); 88255a97593STrond Myklebust return 0; 88355a97593STrond Myklebust } 88455a97593STrond Myklebust 8851da177e4SLinus Torvalds static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 8861da177e4SLinus Torvalds { 8871da177e4SLinus Torvalds struct dentry *res; 8881da177e4SLinus Torvalds struct inode *inode = NULL; 8891da177e4SLinus Torvalds int error; 8901da177e4SLinus Torvalds struct nfs_fh fhandle; 8911da177e4SLinus Torvalds struct nfs_fattr fattr; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds dfprintk(VFS, "NFS: lookup(%s/%s)\n", 8941da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 89591d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 8981da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 8991da177e4SLinus Torvalds goto out; 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds res = ERR_PTR(-ENOMEM); 9021da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 9031da177e4SLinus Torvalds 9041da177e4SLinus Torvalds lock_kernel(); 9051da177e4SLinus Torvalds 9061da177e4SLinus Torvalds /* If we're doing an exclusive create, optimize away the lookup */ 9071da177e4SLinus Torvalds if (nfs_is_exclusive_create(dir, nd)) 9081da177e4SLinus Torvalds goto no_entry; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr); 9111da177e4SLinus Torvalds if (error == -ENOENT) 9121da177e4SLinus Torvalds goto no_entry; 9131da177e4SLinus Torvalds if (error < 0) { 9141da177e4SLinus Torvalds res = ERR_PTR(error); 9151da177e4SLinus Torvalds goto out_unlock; 9161da177e4SLinus Torvalds } 91754ceac45SDavid Howells error = nfs_reval_fsid(nd->mnt, dir, &fhandle, &fattr); 91855a97593STrond Myklebust if (error < 0) { 91955a97593STrond Myklebust res = ERR_PTR(error); 92055a97593STrond Myklebust goto out_unlock; 92155a97593STrond Myklebust } 9221da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, &fhandle, &fattr); 92303f28e3aSTrond Myklebust res = (struct dentry *)inode; 92403f28e3aSTrond Myklebust if (IS_ERR(res)) 9251da177e4SLinus Torvalds goto out_unlock; 92654ceac45SDavid Howells 9271da177e4SLinus Torvalds no_entry: 92854ceac45SDavid Howells res = d_materialise_unique(dentry, inode); 9291da177e4SLinus Torvalds if (res != NULL) 9301da177e4SLinus Torvalds dentry = res; 9311da177e4SLinus Torvalds nfs_renew_times(dentry); 9321da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 9331da177e4SLinus Torvalds out_unlock: 9341da177e4SLinus Torvalds unlock_kernel(); 9351da177e4SLinus Torvalds out: 9361da177e4SLinus Torvalds return res; 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds #ifdef CONFIG_NFS_V4 9401da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *, struct nameidata *); 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds struct dentry_operations nfs4_dentry_operations = { 9431da177e4SLinus Torvalds .d_revalidate = nfs_open_revalidate, 9441da177e4SLinus Torvalds .d_delete = nfs_dentry_delete, 9451da177e4SLinus Torvalds .d_iput = nfs_dentry_iput, 9461da177e4SLinus Torvalds }; 9471da177e4SLinus Torvalds 9481d6757fbSTrond Myklebust /* 9491d6757fbSTrond Myklebust * Use intent information to determine whether we need to substitute 9501d6757fbSTrond Myklebust * the NFSv4-style stateful OPEN for the LOOKUP call 9511d6757fbSTrond Myklebust */ 9521da177e4SLinus Torvalds static int is_atomic_open(struct inode *dir, struct nameidata *nd) 9531da177e4SLinus Torvalds { 9541d6757fbSTrond Myklebust if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 9551da177e4SLinus Torvalds return 0; 9561da177e4SLinus Torvalds /* NFS does not (yet) have a stateful open for directories */ 9571da177e4SLinus Torvalds if (nd->flags & LOOKUP_DIRECTORY) 9581da177e4SLinus Torvalds return 0; 9591da177e4SLinus Torvalds /* Are we trying to write to a read only partition? */ 9601da177e4SLinus Torvalds if (IS_RDONLY(dir) && (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 9611da177e4SLinus Torvalds return 0; 9621da177e4SLinus Torvalds return 1; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 9661da177e4SLinus Torvalds { 9671da177e4SLinus Torvalds struct dentry *res = NULL; 9681da177e4SLinus Torvalds int error; 9691da177e4SLinus Torvalds 9701e7cb3dcSChuck Lever dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 9711e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 9721e7cb3dcSChuck Lever 9731da177e4SLinus Torvalds /* Check that we are indeed trying to open this file */ 9741da177e4SLinus Torvalds if (!is_atomic_open(dir, nd)) 9751da177e4SLinus Torvalds goto no_open; 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 9781da177e4SLinus Torvalds res = ERR_PTR(-ENAMETOOLONG); 9791da177e4SLinus Torvalds goto out; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds /* Let vfs_create() deal with O_EXCL */ 98402a913a7STrond Myklebust if (nd->intent.open.flags & O_EXCL) { 98502a913a7STrond Myklebust d_add(dentry, NULL); 98602a913a7STrond Myklebust goto out; 98702a913a7STrond Myklebust } 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds /* Open the file on the server */ 9901da177e4SLinus Torvalds lock_kernel(); 9911da177e4SLinus Torvalds /* Revalidate parent directory attribute cache */ 9921da177e4SLinus Torvalds error = nfs_revalidate_inode(NFS_SERVER(dir), dir); 9931da177e4SLinus Torvalds if (error < 0) { 9941da177e4SLinus Torvalds res = ERR_PTR(error); 99501c314a0SSteve Dickson unlock_kernel(); 9961da177e4SLinus Torvalds goto out; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds if (nd->intent.open.flags & O_CREAT) { 10001da177e4SLinus Torvalds nfs_begin_data_update(dir); 100102a913a7STrond Myklebust res = nfs4_atomic_open(dir, dentry, nd); 10021da177e4SLinus Torvalds nfs_end_data_update(dir); 10031da177e4SLinus Torvalds } else 100402a913a7STrond Myklebust res = nfs4_atomic_open(dir, dentry, nd); 10051da177e4SLinus Torvalds unlock_kernel(); 100602a913a7STrond Myklebust if (IS_ERR(res)) { 100702a913a7STrond Myklebust error = PTR_ERR(res); 10081da177e4SLinus Torvalds switch (error) { 10091da177e4SLinus Torvalds /* Make a negative dentry */ 10101da177e4SLinus Torvalds case -ENOENT: 101102a913a7STrond Myklebust res = NULL; 101202a913a7STrond Myklebust goto out; 10131da177e4SLinus Torvalds /* This turned out not to be a regular file */ 10146f926b5bSTrond Myklebust case -EISDIR: 10156f926b5bSTrond Myklebust case -ENOTDIR: 10166f926b5bSTrond Myklebust goto no_open; 10171da177e4SLinus Torvalds case -ELOOP: 10181da177e4SLinus Torvalds if (!(nd->intent.open.flags & O_NOFOLLOW)) 10191da177e4SLinus Torvalds goto no_open; 10201da177e4SLinus Torvalds /* case -EINVAL: */ 10211da177e4SLinus Torvalds default: 10221da177e4SLinus Torvalds goto out; 10231da177e4SLinus Torvalds } 102402a913a7STrond Myklebust } else if (res != NULL) 10251da177e4SLinus Torvalds dentry = res; 10261da177e4SLinus Torvalds nfs_renew_times(dentry); 10271da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 10281da177e4SLinus Torvalds out: 10291da177e4SLinus Torvalds return res; 10301da177e4SLinus Torvalds no_open: 10311da177e4SLinus Torvalds return nfs_lookup(dir, dentry, nd); 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 10351da177e4SLinus Torvalds { 10361da177e4SLinus Torvalds struct dentry *parent = NULL; 10371da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 10381da177e4SLinus Torvalds struct inode *dir; 10391da177e4SLinus Torvalds unsigned long verifier; 10401da177e4SLinus Torvalds int openflags, ret = 0; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds parent = dget_parent(dentry); 10431da177e4SLinus Torvalds dir = parent->d_inode; 10441da177e4SLinus Torvalds if (!is_atomic_open(dir, nd)) 10451da177e4SLinus Torvalds goto no_open; 10461da177e4SLinus Torvalds /* We can't create new files in nfs_open_revalidate(), so we 10471da177e4SLinus Torvalds * optimize away revalidation of negative dentries. 10481da177e4SLinus Torvalds */ 10491da177e4SLinus Torvalds if (inode == NULL) 10501da177e4SLinus Torvalds goto out; 10511da177e4SLinus Torvalds /* NFS only supports OPEN on regular files */ 10521da177e4SLinus Torvalds if (!S_ISREG(inode->i_mode)) 10531da177e4SLinus Torvalds goto no_open; 10541da177e4SLinus Torvalds openflags = nd->intent.open.flags; 10551da177e4SLinus Torvalds /* We cannot do exclusive creation on a positive dentry */ 10561da177e4SLinus Torvalds if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 10571da177e4SLinus Torvalds goto no_open; 10581da177e4SLinus Torvalds /* We can't create new files, or truncate existing ones here */ 10591da177e4SLinus Torvalds openflags &= ~(O_CREAT|O_TRUNC); 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds /* 10621b1dcc1bSJes Sorensen * Note: we're not holding inode->i_mutex and so may be racing with 10631da177e4SLinus Torvalds * operations that change the directory. We therefore save the 10641da177e4SLinus Torvalds * change attribute *before* we do the RPC call. 10651da177e4SLinus Torvalds */ 10661da177e4SLinus Torvalds lock_kernel(); 10671da177e4SLinus Torvalds verifier = nfs_save_change_attribute(dir); 106802a913a7STrond Myklebust ret = nfs4_open_revalidate(dir, dentry, openflags, nd); 10691da177e4SLinus Torvalds if (!ret) 10701da177e4SLinus Torvalds nfs_set_verifier(dentry, verifier); 10711da177e4SLinus Torvalds unlock_kernel(); 10721da177e4SLinus Torvalds out: 10731da177e4SLinus Torvalds dput(parent); 10741da177e4SLinus Torvalds if (!ret) 10751da177e4SLinus Torvalds d_drop(dentry); 10761da177e4SLinus Torvalds return ret; 10771da177e4SLinus Torvalds no_open: 10781da177e4SLinus Torvalds dput(parent); 10791da177e4SLinus Torvalds if (inode != NULL && nfs_have_delegation(inode, FMODE_READ)) 10801da177e4SLinus Torvalds return 1; 10811da177e4SLinus Torvalds return nfs_lookup_revalidate(dentry, nd); 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds #endif /* CONFIG_NFSV4 */ 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc) 10861da177e4SLinus Torvalds { 10871da177e4SLinus Torvalds struct dentry *parent = desc->file->f_dentry; 10881da177e4SLinus Torvalds struct inode *dir = parent->d_inode; 10891da177e4SLinus Torvalds struct nfs_entry *entry = desc->entry; 10901da177e4SLinus Torvalds struct dentry *dentry, *alias; 10911da177e4SLinus Torvalds struct qstr name = { 10921da177e4SLinus Torvalds .name = entry->name, 10931da177e4SLinus Torvalds .len = entry->len, 10941da177e4SLinus Torvalds }; 10951da177e4SLinus Torvalds struct inode *inode; 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds switch (name.len) { 10981da177e4SLinus Torvalds case 2: 10991da177e4SLinus Torvalds if (name.name[0] == '.' && name.name[1] == '.') 11001da177e4SLinus Torvalds return dget_parent(parent); 11011da177e4SLinus Torvalds break; 11021da177e4SLinus Torvalds case 1: 11031da177e4SLinus Torvalds if (name.name[0] == '.') 11041da177e4SLinus Torvalds return dget(parent); 11051da177e4SLinus Torvalds } 11061da177e4SLinus Torvalds name.hash = full_name_hash(name.name, name.len); 11071da177e4SLinus Torvalds dentry = d_lookup(parent, &name); 11081da177e4SLinus Torvalds if (dentry != NULL) 11091da177e4SLinus Torvalds return dentry; 11101da177e4SLinus Torvalds if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR)) 11111da177e4SLinus Torvalds return NULL; 11121b1dcc1bSJes Sorensen /* Note: caller is already holding the dir->i_mutex! */ 11131da177e4SLinus Torvalds dentry = d_alloc(parent, &name); 11141da177e4SLinus Torvalds if (dentry == NULL) 11151da177e4SLinus Torvalds return NULL; 11161da177e4SLinus Torvalds dentry->d_op = NFS_PROTO(dir)->dentry_ops; 11171da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 111803f28e3aSTrond Myklebust if (IS_ERR(inode)) { 11191da177e4SLinus Torvalds dput(dentry); 11201da177e4SLinus Torvalds return NULL; 11211da177e4SLinus Torvalds } 112254ceac45SDavid Howells 112354ceac45SDavid Howells alias = d_materialise_unique(dentry, inode); 11241da177e4SLinus Torvalds if (alias != NULL) { 11251da177e4SLinus Torvalds dput(dentry); 11261da177e4SLinus Torvalds dentry = alias; 11271da177e4SLinus Torvalds } 112854ceac45SDavid Howells 11291da177e4SLinus Torvalds nfs_renew_times(dentry); 11301da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 11311da177e4SLinus Torvalds return dentry; 11321da177e4SLinus Torvalds } 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds /* 11351da177e4SLinus Torvalds * Code common to create, mkdir, and mknod. 11361da177e4SLinus Torvalds */ 11371da177e4SLinus Torvalds int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 11381da177e4SLinus Torvalds struct nfs_fattr *fattr) 11391da177e4SLinus Torvalds { 11401da177e4SLinus Torvalds struct inode *inode; 11411da177e4SLinus Torvalds int error = -EACCES; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds /* We may have been initialized further down */ 11441da177e4SLinus Torvalds if (dentry->d_inode) 11451da177e4SLinus Torvalds return 0; 11461da177e4SLinus Torvalds if (fhandle->size == 0) { 11471da177e4SLinus Torvalds struct inode *dir = dentry->d_parent->d_inode; 11481da177e4SLinus Torvalds error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 11491da177e4SLinus Torvalds if (error) 11504f390c15SChuck Lever return error; 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds if (!(fattr->valid & NFS_ATTR_FATTR)) { 11531da177e4SLinus Torvalds struct nfs_server *server = NFS_SB(dentry->d_sb); 11548fa5c000SDavid Howells error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 11551da177e4SLinus Torvalds if (error < 0) 11564f390c15SChuck Lever return error; 11571da177e4SLinus Torvalds } 11581da177e4SLinus Torvalds inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 115903f28e3aSTrond Myklebust error = PTR_ERR(inode); 116003f28e3aSTrond Myklebust if (IS_ERR(inode)) 11614f390c15SChuck Lever return error; 11621da177e4SLinus Torvalds d_instantiate(dentry, inode); 11631da177e4SLinus Torvalds return 0; 11641da177e4SLinus Torvalds } 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds /* 11671da177e4SLinus Torvalds * Following a failed create operation, we drop the dentry rather 11681da177e4SLinus Torvalds * than retain a negative dentry. This avoids a problem in the event 11691da177e4SLinus Torvalds * that the operation succeeded on the server, but an error in the 11701da177e4SLinus Torvalds * reply path made it appear to have failed. 11711da177e4SLinus Torvalds */ 11721da177e4SLinus Torvalds static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 11731da177e4SLinus Torvalds struct nameidata *nd) 11741da177e4SLinus Torvalds { 11751da177e4SLinus Torvalds struct iattr attr; 11761da177e4SLinus Torvalds int error; 11771da177e4SLinus Torvalds int open_flags = 0; 11781da177e4SLinus Torvalds 11791e7cb3dcSChuck Lever dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 11801e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds attr.ia_mode = mode; 11831da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 11841da177e4SLinus Torvalds 11851da177e4SLinus Torvalds if (nd && (nd->flags & LOOKUP_CREATE)) 11861da177e4SLinus Torvalds open_flags = nd->intent.open.flags; 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds lock_kernel(); 11891da177e4SLinus Torvalds nfs_begin_data_update(dir); 119002a913a7STrond Myklebust error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, nd); 11911da177e4SLinus Torvalds nfs_end_data_update(dir); 11921da177e4SLinus Torvalds if (error != 0) 11931da177e4SLinus Torvalds goto out_err; 11941da177e4SLinus Torvalds nfs_renew_times(dentry); 11951da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 11961da177e4SLinus Torvalds unlock_kernel(); 11971da177e4SLinus Torvalds return 0; 11981da177e4SLinus Torvalds out_err: 11991da177e4SLinus Torvalds unlock_kernel(); 12001da177e4SLinus Torvalds d_drop(dentry); 12011da177e4SLinus Torvalds return error; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds /* 12051da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 12061da177e4SLinus Torvalds */ 12071da177e4SLinus Torvalds static int 12081da177e4SLinus Torvalds nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 12091da177e4SLinus Torvalds { 12101da177e4SLinus Torvalds struct iattr attr; 12111da177e4SLinus Torvalds int status; 12121da177e4SLinus Torvalds 12131e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 12141e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds if (!new_valid_dev(rdev)) 12171da177e4SLinus Torvalds return -EINVAL; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds attr.ia_mode = mode; 12201da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds lock_kernel(); 12231da177e4SLinus Torvalds nfs_begin_data_update(dir); 12241da177e4SLinus Torvalds status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 12251da177e4SLinus Torvalds nfs_end_data_update(dir); 12261da177e4SLinus Torvalds if (status != 0) 12271da177e4SLinus Torvalds goto out_err; 12281da177e4SLinus Torvalds nfs_renew_times(dentry); 12291da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 12301da177e4SLinus Torvalds unlock_kernel(); 12311da177e4SLinus Torvalds return 0; 12321da177e4SLinus Torvalds out_err: 12331da177e4SLinus Torvalds unlock_kernel(); 12341da177e4SLinus Torvalds d_drop(dentry); 12351da177e4SLinus Torvalds return status; 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds /* 12391da177e4SLinus Torvalds * See comments for nfs_proc_create regarding failed operations. 12401da177e4SLinus Torvalds */ 12411da177e4SLinus Torvalds static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 12421da177e4SLinus Torvalds { 12431da177e4SLinus Torvalds struct iattr attr; 12441da177e4SLinus Torvalds int error; 12451da177e4SLinus Torvalds 12461e7cb3dcSChuck Lever dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 12471e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 12501da177e4SLinus Torvalds attr.ia_mode = mode | S_IFDIR; 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds lock_kernel(); 12531da177e4SLinus Torvalds nfs_begin_data_update(dir); 12541da177e4SLinus Torvalds error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 12551da177e4SLinus Torvalds nfs_end_data_update(dir); 12561da177e4SLinus Torvalds if (error != 0) 12571da177e4SLinus Torvalds goto out_err; 12581da177e4SLinus Torvalds nfs_renew_times(dentry); 12591da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 12601da177e4SLinus Torvalds unlock_kernel(); 12611da177e4SLinus Torvalds return 0; 12621da177e4SLinus Torvalds out_err: 12631da177e4SLinus Torvalds d_drop(dentry); 12641da177e4SLinus Torvalds unlock_kernel(); 12651da177e4SLinus Torvalds return error; 12661da177e4SLinus Torvalds } 12671da177e4SLinus Torvalds 12681da177e4SLinus Torvalds static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 12691da177e4SLinus Torvalds { 12701da177e4SLinus Torvalds int error; 12711da177e4SLinus Torvalds 12721e7cb3dcSChuck Lever dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 12731e7cb3dcSChuck Lever dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds lock_kernel(); 12761da177e4SLinus Torvalds nfs_begin_data_update(dir); 12771da177e4SLinus Torvalds error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 12781da177e4SLinus Torvalds /* Ensure the VFS deletes this inode */ 12791da177e4SLinus Torvalds if (error == 0 && dentry->d_inode != NULL) 12801da177e4SLinus Torvalds dentry->d_inode->i_nlink = 0; 12811da177e4SLinus Torvalds nfs_end_data_update(dir); 12821da177e4SLinus Torvalds unlock_kernel(); 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds return error; 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds static int nfs_sillyrename(struct inode *dir, struct dentry *dentry) 12881da177e4SLinus Torvalds { 12891da177e4SLinus Torvalds static unsigned int sillycounter; 12901da177e4SLinus Torvalds const int i_inosize = sizeof(dir->i_ino)*2; 12911da177e4SLinus Torvalds const int countersize = sizeof(sillycounter)*2; 12921da177e4SLinus Torvalds const int slen = sizeof(".nfs") + i_inosize + countersize - 1; 12931da177e4SLinus Torvalds char silly[slen+1]; 12941da177e4SLinus Torvalds struct qstr qsilly; 12951da177e4SLinus Torvalds struct dentry *sdentry; 12961da177e4SLinus Torvalds int error = -EIO; 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n", 12991da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name, 13001da177e4SLinus Torvalds atomic_read(&dentry->d_count)); 130191d5b470SChuck Lever nfs_inc_stats(dir, NFSIOS_SILLYRENAME); 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds #ifdef NFS_PARANOIA 13041da177e4SLinus Torvalds if (!dentry->d_inode) 13051da177e4SLinus Torvalds printk("NFS: silly-renaming %s/%s, negative dentry??\n", 13061da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 13071da177e4SLinus Torvalds #endif 13081da177e4SLinus Torvalds /* 13091da177e4SLinus Torvalds * We don't allow a dentry to be silly-renamed twice. 13101da177e4SLinus Torvalds */ 13111da177e4SLinus Torvalds error = -EBUSY; 13121da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 13131da177e4SLinus Torvalds goto out; 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds sprintf(silly, ".nfs%*.*lx", 13161da177e4SLinus Torvalds i_inosize, i_inosize, dentry->d_inode->i_ino); 13171da177e4SLinus Torvalds 131834ea8188STrond Myklebust /* Return delegation in anticipation of the rename */ 131934ea8188STrond Myklebust nfs_inode_return_delegation(dentry->d_inode); 132034ea8188STrond Myklebust 13211da177e4SLinus Torvalds sdentry = NULL; 13221da177e4SLinus Torvalds do { 13231da177e4SLinus Torvalds char *suffix = silly + slen - countersize; 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds dput(sdentry); 13261da177e4SLinus Torvalds sillycounter++; 13271da177e4SLinus Torvalds sprintf(suffix, "%*.*x", countersize, countersize, sillycounter); 13281da177e4SLinus Torvalds 13291e7cb3dcSChuck Lever dfprintk(VFS, "NFS: trying to rename %s to %s\n", 13301da177e4SLinus Torvalds dentry->d_name.name, silly); 13311da177e4SLinus Torvalds 13321da177e4SLinus Torvalds sdentry = lookup_one_len(silly, dentry->d_parent, slen); 13331da177e4SLinus Torvalds /* 13341da177e4SLinus Torvalds * N.B. Better to return EBUSY here ... it could be 13351da177e4SLinus Torvalds * dangerous to delete the file while it's in use. 13361da177e4SLinus Torvalds */ 13371da177e4SLinus Torvalds if (IS_ERR(sdentry)) 13381da177e4SLinus Torvalds goto out; 13391da177e4SLinus Torvalds } while(sdentry->d_inode != NULL); /* need negative lookup */ 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds qsilly.name = silly; 13421da177e4SLinus Torvalds qsilly.len = strlen(silly); 13431da177e4SLinus Torvalds nfs_begin_data_update(dir); 13441da177e4SLinus Torvalds if (dentry->d_inode) { 13451da177e4SLinus Torvalds nfs_begin_data_update(dentry->d_inode); 13461da177e4SLinus Torvalds error = NFS_PROTO(dir)->rename(dir, &dentry->d_name, 13471da177e4SLinus Torvalds dir, &qsilly); 13485ba7cc48STrond Myklebust nfs_mark_for_revalidate(dentry->d_inode); 13491da177e4SLinus Torvalds nfs_end_data_update(dentry->d_inode); 13501da177e4SLinus Torvalds } else 13511da177e4SLinus Torvalds error = NFS_PROTO(dir)->rename(dir, &dentry->d_name, 13521da177e4SLinus Torvalds dir, &qsilly); 13531da177e4SLinus Torvalds nfs_end_data_update(dir); 13541da177e4SLinus Torvalds if (!error) { 13551da177e4SLinus Torvalds nfs_renew_times(dentry); 13561da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 13571da177e4SLinus Torvalds d_move(dentry, sdentry); 13581da177e4SLinus Torvalds error = nfs_async_unlink(dentry); 13591da177e4SLinus Torvalds /* If we return 0 we don't unlink */ 13601da177e4SLinus Torvalds } 13611da177e4SLinus Torvalds dput(sdentry); 13621da177e4SLinus Torvalds out: 13631da177e4SLinus Torvalds return error; 13641da177e4SLinus Torvalds } 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds /* 13671da177e4SLinus Torvalds * Remove a file after making sure there are no pending writes, 13681da177e4SLinus Torvalds * and after checking that the file has only one user. 13691da177e4SLinus Torvalds * 13701da177e4SLinus Torvalds * We invalidate the attribute cache and free the inode prior to the operation 13711da177e4SLinus Torvalds * to avoid possible races if the server reuses the inode. 13721da177e4SLinus Torvalds */ 13731da177e4SLinus Torvalds static int nfs_safe_remove(struct dentry *dentry) 13741da177e4SLinus Torvalds { 13751da177e4SLinus Torvalds struct inode *dir = dentry->d_parent->d_inode; 13761da177e4SLinus Torvalds struct inode *inode = dentry->d_inode; 13771da177e4SLinus Torvalds int error = -EBUSY; 13781da177e4SLinus Torvalds 13791da177e4SLinus Torvalds dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 13801da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds /* If the dentry was sillyrenamed, we simply call d_delete() */ 13831da177e4SLinus Torvalds if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 13841da177e4SLinus Torvalds error = 0; 13851da177e4SLinus Torvalds goto out; 13861da177e4SLinus Torvalds } 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds nfs_begin_data_update(dir); 13891da177e4SLinus Torvalds if (inode != NULL) { 1390cae7a073STrond Myklebust nfs_inode_return_delegation(inode); 13911da177e4SLinus Torvalds nfs_begin_data_update(inode); 13921da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 13931da177e4SLinus Torvalds /* The VFS may want to delete this inode */ 13941da177e4SLinus Torvalds if (error == 0) 13951da177e4SLinus Torvalds inode->i_nlink--; 13965ba7cc48STrond Myklebust nfs_mark_for_revalidate(inode); 13971da177e4SLinus Torvalds nfs_end_data_update(inode); 13981da177e4SLinus Torvalds } else 13991da177e4SLinus Torvalds error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 14001da177e4SLinus Torvalds nfs_end_data_update(dir); 14011da177e4SLinus Torvalds out: 14021da177e4SLinus Torvalds return error; 14031da177e4SLinus Torvalds } 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 14061da177e4SLinus Torvalds * belongs to an active ".nfs..." file and we return -EBUSY. 14071da177e4SLinus Torvalds * 14081da177e4SLinus Torvalds * If sillyrename() returns 0, we do nothing, otherwise we unlink. 14091da177e4SLinus Torvalds */ 14101da177e4SLinus Torvalds static int nfs_unlink(struct inode *dir, struct dentry *dentry) 14111da177e4SLinus Torvalds { 14121da177e4SLinus Torvalds int error; 14131da177e4SLinus Torvalds int need_rehash = 0; 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 14161da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name); 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds lock_kernel(); 14191da177e4SLinus Torvalds spin_lock(&dcache_lock); 14201da177e4SLinus Torvalds spin_lock(&dentry->d_lock); 14211da177e4SLinus Torvalds if (atomic_read(&dentry->d_count) > 1) { 14221da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 14231da177e4SLinus Torvalds spin_unlock(&dcache_lock); 14241da177e4SLinus Torvalds error = nfs_sillyrename(dir, dentry); 14251da177e4SLinus Torvalds unlock_kernel(); 14261da177e4SLinus Torvalds return error; 14271da177e4SLinus Torvalds } 14281da177e4SLinus Torvalds if (!d_unhashed(dentry)) { 14291da177e4SLinus Torvalds __d_drop(dentry); 14301da177e4SLinus Torvalds need_rehash = 1; 14311da177e4SLinus Torvalds } 14321da177e4SLinus Torvalds spin_unlock(&dentry->d_lock); 14331da177e4SLinus Torvalds spin_unlock(&dcache_lock); 14341da177e4SLinus Torvalds error = nfs_safe_remove(dentry); 14351da177e4SLinus Torvalds if (!error) { 14361da177e4SLinus Torvalds nfs_renew_times(dentry); 14371da177e4SLinus Torvalds nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 14381da177e4SLinus Torvalds } else if (need_rehash) 14391da177e4SLinus Torvalds d_rehash(dentry); 14401da177e4SLinus Torvalds unlock_kernel(); 14411da177e4SLinus Torvalds return error; 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds static int 14451da177e4SLinus Torvalds nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 14461da177e4SLinus Torvalds { 14471da177e4SLinus Torvalds struct iattr attr; 14481da177e4SLinus Torvalds struct qstr qsymname; 14491da177e4SLinus Torvalds int error; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 14521da177e4SLinus Torvalds dir->i_ino, dentry->d_name.name, symname); 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds #ifdef NFS_PARANOIA 14551da177e4SLinus Torvalds if (dentry->d_inode) 14561da177e4SLinus Torvalds printk("nfs_proc_symlink: %s/%s not negative!\n", 14571da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 14581da177e4SLinus Torvalds #endif 14591da177e4SLinus Torvalds /* 14601da177e4SLinus Torvalds * Fill in the sattr for the call. 14611da177e4SLinus Torvalds * Note: SunOS 4.1.2 crashes if the mode isn't initialized! 14621da177e4SLinus Torvalds */ 14631da177e4SLinus Torvalds attr.ia_valid = ATTR_MODE; 14641da177e4SLinus Torvalds attr.ia_mode = S_IFLNK | S_IRWXUGO; 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds qsymname.name = symname; 14671da177e4SLinus Torvalds qsymname.len = strlen(symname); 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds lock_kernel(); 14701da177e4SLinus Torvalds nfs_begin_data_update(dir); 14714f390c15SChuck Lever error = NFS_PROTO(dir)->symlink(dir, dentry, &qsymname, &attr); 14721da177e4SLinus Torvalds nfs_end_data_update(dir); 1473d3db90e2SChuck Lever if (!error) 14741da177e4SLinus Torvalds d_drop(dentry); 14751da177e4SLinus Torvalds unlock_kernel(); 14761da177e4SLinus Torvalds return error; 14771da177e4SLinus Torvalds } 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds static int 14801da177e4SLinus Torvalds nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 14811da177e4SLinus Torvalds { 14821da177e4SLinus Torvalds struct inode *inode = old_dentry->d_inode; 14831da177e4SLinus Torvalds int error; 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 14861da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 14871da177e4SLinus Torvalds dentry->d_parent->d_name.name, dentry->d_name.name); 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds lock_kernel(); 14901da177e4SLinus Torvalds nfs_begin_data_update(dir); 14911da177e4SLinus Torvalds nfs_begin_data_update(inode); 14921da177e4SLinus Torvalds error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1493cf809556STrond Myklebust if (error == 0) { 1494cf809556STrond Myklebust atomic_inc(&inode->i_count); 1495cf809556STrond Myklebust d_instantiate(dentry, inode); 1496cf809556STrond Myklebust } 14971da177e4SLinus Torvalds nfs_end_data_update(inode); 14981da177e4SLinus Torvalds nfs_end_data_update(dir); 14991da177e4SLinus Torvalds unlock_kernel(); 15001da177e4SLinus Torvalds return error; 15011da177e4SLinus Torvalds } 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds /* 15041da177e4SLinus Torvalds * RENAME 15051da177e4SLinus Torvalds * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 15061da177e4SLinus Torvalds * different file handle for the same inode after a rename (e.g. when 15071da177e4SLinus Torvalds * moving to a different directory). A fail-safe method to do so would 15081da177e4SLinus Torvalds * be to look up old_dir/old_name, create a link to new_dir/new_name and 15091da177e4SLinus Torvalds * rename the old file using the sillyrename stuff. This way, the original 15101da177e4SLinus Torvalds * file in old_dir will go away when the last process iput()s the inode. 15111da177e4SLinus Torvalds * 15121da177e4SLinus Torvalds * FIXED. 15131da177e4SLinus Torvalds * 15141da177e4SLinus Torvalds * It actually works quite well. One needs to have the possibility for 15151da177e4SLinus Torvalds * at least one ".nfs..." file in each directory the file ever gets 15161da177e4SLinus Torvalds * moved or linked to which happens automagically with the new 15171da177e4SLinus Torvalds * implementation that only depends on the dcache stuff instead of 15181da177e4SLinus Torvalds * using the inode layer 15191da177e4SLinus Torvalds * 15201da177e4SLinus Torvalds * Unfortunately, things are a little more complicated than indicated 15211da177e4SLinus Torvalds * above. For a cross-directory move, we want to make sure we can get 15221da177e4SLinus Torvalds * rid of the old inode after the operation. This means there must be 15231da177e4SLinus Torvalds * no pending writes (if it's a file), and the use count must be 1. 15241da177e4SLinus Torvalds * If these conditions are met, we can drop the dentries before doing 15251da177e4SLinus Torvalds * the rename. 15261da177e4SLinus Torvalds */ 15271da177e4SLinus Torvalds static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 15281da177e4SLinus Torvalds struct inode *new_dir, struct dentry *new_dentry) 15291da177e4SLinus Torvalds { 15301da177e4SLinus Torvalds struct inode *old_inode = old_dentry->d_inode; 15311da177e4SLinus Torvalds struct inode *new_inode = new_dentry->d_inode; 15321da177e4SLinus Torvalds struct dentry *dentry = NULL, *rehash = NULL; 15331da177e4SLinus Torvalds int error = -EBUSY; 15341da177e4SLinus Torvalds 15351da177e4SLinus Torvalds /* 15361da177e4SLinus Torvalds * To prevent any new references to the target during the rename, 15371da177e4SLinus Torvalds * we unhash the dentry and free the inode in advance. 15381da177e4SLinus Torvalds */ 15391da177e4SLinus Torvalds lock_kernel(); 15401da177e4SLinus Torvalds if (!d_unhashed(new_dentry)) { 15411da177e4SLinus Torvalds d_drop(new_dentry); 15421da177e4SLinus Torvalds rehash = new_dentry; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 15461da177e4SLinus Torvalds old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 15471da177e4SLinus Torvalds new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 15481da177e4SLinus Torvalds atomic_read(&new_dentry->d_count)); 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds /* 15511da177e4SLinus Torvalds * First check whether the target is busy ... we can't 15521da177e4SLinus Torvalds * safely do _any_ rename if the target is in use. 15531da177e4SLinus Torvalds * 15541da177e4SLinus Torvalds * For files, make a copy of the dentry and then do a 15551da177e4SLinus Torvalds * silly-rename. If the silly-rename succeeds, the 15561da177e4SLinus Torvalds * copied dentry is hashed and becomes the new target. 15571da177e4SLinus Torvalds */ 15581da177e4SLinus Torvalds if (!new_inode) 15591da177e4SLinus Torvalds goto go_ahead; 15606fe43f9eSTrond Myklebust if (S_ISDIR(new_inode->i_mode)) { 15616fe43f9eSTrond Myklebust error = -EISDIR; 15626fe43f9eSTrond Myklebust if (!S_ISDIR(old_inode->i_mode)) 15631da177e4SLinus Torvalds goto out; 15646fe43f9eSTrond Myklebust } else if (atomic_read(&new_dentry->d_count) > 2) { 15651da177e4SLinus Torvalds int err; 15661da177e4SLinus Torvalds /* copy the target dentry's name */ 15671da177e4SLinus Torvalds dentry = d_alloc(new_dentry->d_parent, 15681da177e4SLinus Torvalds &new_dentry->d_name); 15691da177e4SLinus Torvalds if (!dentry) 15701da177e4SLinus Torvalds goto out; 15711da177e4SLinus Torvalds 15721da177e4SLinus Torvalds /* silly-rename the existing target ... */ 15731da177e4SLinus Torvalds err = nfs_sillyrename(new_dir, new_dentry); 15741da177e4SLinus Torvalds if (!err) { 15751da177e4SLinus Torvalds new_dentry = rehash = dentry; 15761da177e4SLinus Torvalds new_inode = NULL; 15771da177e4SLinus Torvalds /* instantiate the replacement target */ 15781da177e4SLinus Torvalds d_instantiate(new_dentry, NULL); 15791da177e4SLinus Torvalds } else if (atomic_read(&new_dentry->d_count) > 1) { 15801da177e4SLinus Torvalds /* dentry still busy? */ 15811da177e4SLinus Torvalds #ifdef NFS_PARANOIA 15821da177e4SLinus Torvalds printk("nfs_rename: target %s/%s busy, d_count=%d\n", 15831da177e4SLinus Torvalds new_dentry->d_parent->d_name.name, 15841da177e4SLinus Torvalds new_dentry->d_name.name, 15851da177e4SLinus Torvalds atomic_read(&new_dentry->d_count)); 15861da177e4SLinus Torvalds #endif 15871da177e4SLinus Torvalds goto out; 15881da177e4SLinus Torvalds } 158920509f1bSTrond Myklebust } else 159020509f1bSTrond Myklebust new_inode->i_nlink--; 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds go_ahead: 15931da177e4SLinus Torvalds /* 15941da177e4SLinus Torvalds * ... prune child dentries and writebacks if needed. 15951da177e4SLinus Torvalds */ 15961da177e4SLinus Torvalds if (atomic_read(&old_dentry->d_count) > 1) { 15971da177e4SLinus Torvalds nfs_wb_all(old_inode); 15981da177e4SLinus Torvalds shrink_dcache_parent(old_dentry); 15991da177e4SLinus Torvalds } 1600cae7a073STrond Myklebust nfs_inode_return_delegation(old_inode); 16011da177e4SLinus Torvalds 160224174119STrond Myklebust if (new_inode != NULL) { 160324174119STrond Myklebust nfs_inode_return_delegation(new_inode); 16041da177e4SLinus Torvalds d_delete(new_dentry); 160524174119STrond Myklebust } 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds nfs_begin_data_update(old_dir); 16081da177e4SLinus Torvalds nfs_begin_data_update(new_dir); 16091da177e4SLinus Torvalds nfs_begin_data_update(old_inode); 16101da177e4SLinus Torvalds error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 16111da177e4SLinus Torvalds new_dir, &new_dentry->d_name); 16125ba7cc48STrond Myklebust nfs_mark_for_revalidate(old_inode); 16131da177e4SLinus Torvalds nfs_end_data_update(old_inode); 16141da177e4SLinus Torvalds nfs_end_data_update(new_dir); 16151da177e4SLinus Torvalds nfs_end_data_update(old_dir); 16161da177e4SLinus Torvalds out: 16171da177e4SLinus Torvalds if (rehash) 16181da177e4SLinus Torvalds d_rehash(rehash); 16191da177e4SLinus Torvalds if (!error) { 16201da177e4SLinus Torvalds if (!S_ISDIR(old_inode->i_mode)) 16211da177e4SLinus Torvalds d_move(old_dentry, new_dentry); 16221da177e4SLinus Torvalds nfs_renew_times(new_dentry); 16231da177e4SLinus Torvalds nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir)); 16241da177e4SLinus Torvalds } 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds /* new dentry created? */ 16271da177e4SLinus Torvalds if (dentry) 16281da177e4SLinus Torvalds dput(dentry); 16291da177e4SLinus Torvalds unlock_kernel(); 16301da177e4SLinus Torvalds return error; 16311da177e4SLinus Torvalds } 16321da177e4SLinus Torvalds 1633cfcea3e8STrond Myklebust static DEFINE_SPINLOCK(nfs_access_lru_lock); 1634cfcea3e8STrond Myklebust static LIST_HEAD(nfs_access_lru_list); 1635cfcea3e8STrond Myklebust static atomic_long_t nfs_access_nr_entries; 1636cfcea3e8STrond Myklebust 16371c3c07e9STrond Myklebust static void nfs_access_free_entry(struct nfs_access_entry *entry) 16381c3c07e9STrond Myklebust { 16391c3c07e9STrond Myklebust put_rpccred(entry->cred); 16401c3c07e9STrond Myklebust kfree(entry); 1641cfcea3e8STrond Myklebust smp_mb__before_atomic_dec(); 1642cfcea3e8STrond Myklebust atomic_long_dec(&nfs_access_nr_entries); 1643cfcea3e8STrond Myklebust smp_mb__after_atomic_dec(); 16441c3c07e9STrond Myklebust } 16451c3c07e9STrond Myklebust 1646979df72eSTrond Myklebust int nfs_access_cache_shrinker(int nr_to_scan, gfp_t gfp_mask) 1647979df72eSTrond Myklebust { 1648979df72eSTrond Myklebust LIST_HEAD(head); 1649979df72eSTrond Myklebust struct nfs_inode *nfsi; 1650979df72eSTrond Myklebust struct nfs_access_entry *cache; 1651979df72eSTrond Myklebust 1652979df72eSTrond Myklebust spin_lock(&nfs_access_lru_lock); 1653979df72eSTrond Myklebust restart: 1654979df72eSTrond Myklebust list_for_each_entry(nfsi, &nfs_access_lru_list, access_cache_inode_lru) { 1655979df72eSTrond Myklebust struct inode *inode; 1656979df72eSTrond Myklebust 1657979df72eSTrond Myklebust if (nr_to_scan-- == 0) 1658979df72eSTrond Myklebust break; 1659979df72eSTrond Myklebust inode = igrab(&nfsi->vfs_inode); 1660979df72eSTrond Myklebust if (inode == NULL) 1661979df72eSTrond Myklebust continue; 1662979df72eSTrond Myklebust spin_lock(&inode->i_lock); 1663979df72eSTrond Myklebust if (list_empty(&nfsi->access_cache_entry_lru)) 1664979df72eSTrond Myklebust goto remove_lru_entry; 1665979df72eSTrond Myklebust cache = list_entry(nfsi->access_cache_entry_lru.next, 1666979df72eSTrond Myklebust struct nfs_access_entry, lru); 1667979df72eSTrond Myklebust list_move(&cache->lru, &head); 1668979df72eSTrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1669979df72eSTrond Myklebust if (!list_empty(&nfsi->access_cache_entry_lru)) 1670979df72eSTrond Myklebust list_move_tail(&nfsi->access_cache_inode_lru, 1671979df72eSTrond Myklebust &nfs_access_lru_list); 1672979df72eSTrond Myklebust else { 1673979df72eSTrond Myklebust remove_lru_entry: 1674979df72eSTrond Myklebust list_del_init(&nfsi->access_cache_inode_lru); 1675979df72eSTrond Myklebust clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 1676979df72eSTrond Myklebust } 1677979df72eSTrond Myklebust spin_unlock(&inode->i_lock); 1678979df72eSTrond Myklebust iput(inode); 1679979df72eSTrond Myklebust goto restart; 1680979df72eSTrond Myklebust } 1681979df72eSTrond Myklebust spin_unlock(&nfs_access_lru_lock); 1682979df72eSTrond Myklebust while (!list_empty(&head)) { 1683979df72eSTrond Myklebust cache = list_entry(head.next, struct nfs_access_entry, lru); 1684979df72eSTrond Myklebust list_del(&cache->lru); 1685979df72eSTrond Myklebust nfs_access_free_entry(cache); 1686979df72eSTrond Myklebust } 1687979df72eSTrond Myklebust return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 1688979df72eSTrond Myklebust } 1689979df72eSTrond Myklebust 16901c3c07e9STrond Myklebust static void __nfs_access_zap_cache(struct inode *inode) 16911c3c07e9STrond Myklebust { 16921c3c07e9STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 16931c3c07e9STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 16941c3c07e9STrond Myklebust struct rb_node *n, *dispose = NULL; 16951c3c07e9STrond Myklebust struct nfs_access_entry *entry; 16961c3c07e9STrond Myklebust 16971c3c07e9STrond Myklebust /* Unhook entries from the cache */ 16981c3c07e9STrond Myklebust while ((n = rb_first(root_node)) != NULL) { 16991c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 17001c3c07e9STrond Myklebust rb_erase(n, root_node); 1701cfcea3e8STrond Myklebust list_del(&entry->lru); 17021c3c07e9STrond Myklebust n->rb_left = dispose; 17031c3c07e9STrond Myklebust dispose = n; 17041c3c07e9STrond Myklebust } 17051c3c07e9STrond Myklebust nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 17061c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 17071c3c07e9STrond Myklebust 17081c3c07e9STrond Myklebust /* Now kill them all! */ 17091c3c07e9STrond Myklebust while (dispose != NULL) { 17101c3c07e9STrond Myklebust n = dispose; 17111c3c07e9STrond Myklebust dispose = n->rb_left; 17121c3c07e9STrond Myklebust nfs_access_free_entry(rb_entry(n, struct nfs_access_entry, rb_node)); 17131c3c07e9STrond Myklebust } 17141c3c07e9STrond Myklebust } 17151c3c07e9STrond Myklebust 17161c3c07e9STrond Myklebust void nfs_access_zap_cache(struct inode *inode) 17171c3c07e9STrond Myklebust { 1718cfcea3e8STrond Myklebust /* Remove from global LRU init */ 1719cfcea3e8STrond Myklebust if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_FLAGS(inode))) { 1720cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 1721cfcea3e8STrond Myklebust list_del_init(&NFS_I(inode)->access_cache_inode_lru); 1722cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 1723cfcea3e8STrond Myklebust } 1724cfcea3e8STrond Myklebust 17251c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 17261c3c07e9STrond Myklebust /* This will release the spinlock */ 17271c3c07e9STrond Myklebust __nfs_access_zap_cache(inode); 17281c3c07e9STrond Myklebust } 17291c3c07e9STrond Myklebust 17301c3c07e9STrond Myklebust static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 17311c3c07e9STrond Myklebust { 17321c3c07e9STrond Myklebust struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 17331c3c07e9STrond Myklebust struct nfs_access_entry *entry; 17341c3c07e9STrond Myklebust 17351c3c07e9STrond Myklebust while (n != NULL) { 17361c3c07e9STrond Myklebust entry = rb_entry(n, struct nfs_access_entry, rb_node); 17371c3c07e9STrond Myklebust 17381c3c07e9STrond Myklebust if (cred < entry->cred) 17391c3c07e9STrond Myklebust n = n->rb_left; 17401c3c07e9STrond Myklebust else if (cred > entry->cred) 17411c3c07e9STrond Myklebust n = n->rb_right; 17421c3c07e9STrond Myklebust else 17431c3c07e9STrond Myklebust return entry; 17441c3c07e9STrond Myklebust } 17451c3c07e9STrond Myklebust return NULL; 17461c3c07e9STrond Myklebust } 17471c3c07e9STrond Myklebust 17481da177e4SLinus Torvalds int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 17491da177e4SLinus Torvalds { 175055296809SChuck Lever struct nfs_inode *nfsi = NFS_I(inode); 17511c3c07e9STrond Myklebust struct nfs_access_entry *cache; 17521c3c07e9STrond Myklebust int err = -ENOENT; 17531da177e4SLinus Torvalds 17541c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 17551c3c07e9STrond Myklebust if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 17561c3c07e9STrond Myklebust goto out_zap; 17571c3c07e9STrond Myklebust cache = nfs_access_search_rbtree(inode, cred); 17581c3c07e9STrond Myklebust if (cache == NULL) 17591c3c07e9STrond Myklebust goto out; 17601c3c07e9STrond Myklebust if (time_after(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode))) 17611c3c07e9STrond Myklebust goto out_stale; 17621c3c07e9STrond Myklebust res->jiffies = cache->jiffies; 17631c3c07e9STrond Myklebust res->cred = cache->cred; 17641c3c07e9STrond Myklebust res->mask = cache->mask; 1765cfcea3e8STrond Myklebust list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 17661c3c07e9STrond Myklebust err = 0; 17671c3c07e9STrond Myklebust out: 17681c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 17691c3c07e9STrond Myklebust return err; 17701c3c07e9STrond Myklebust out_stale: 17711c3c07e9STrond Myklebust rb_erase(&cache->rb_node, &nfsi->access_cache); 1772cfcea3e8STrond Myklebust list_del(&cache->lru); 17731c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 17741c3c07e9STrond Myklebust nfs_access_free_entry(cache); 17751da177e4SLinus Torvalds return -ENOENT; 17761c3c07e9STrond Myklebust out_zap: 17771c3c07e9STrond Myklebust /* This will release the spinlock */ 17781c3c07e9STrond Myklebust __nfs_access_zap_cache(inode); 17791c3c07e9STrond Myklebust return -ENOENT; 17801c3c07e9STrond Myklebust } 17811c3c07e9STrond Myklebust 17821c3c07e9STrond Myklebust static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 17831c3c07e9STrond Myklebust { 1784cfcea3e8STrond Myklebust struct nfs_inode *nfsi = NFS_I(inode); 1785cfcea3e8STrond Myklebust struct rb_root *root_node = &nfsi->access_cache; 17861c3c07e9STrond Myklebust struct rb_node **p = &root_node->rb_node; 17871c3c07e9STrond Myklebust struct rb_node *parent = NULL; 17881c3c07e9STrond Myklebust struct nfs_access_entry *entry; 17891c3c07e9STrond Myklebust 17901c3c07e9STrond Myklebust spin_lock(&inode->i_lock); 17911c3c07e9STrond Myklebust while (*p != NULL) { 17921c3c07e9STrond Myklebust parent = *p; 17931c3c07e9STrond Myklebust entry = rb_entry(parent, struct nfs_access_entry, rb_node); 17941c3c07e9STrond Myklebust 17951c3c07e9STrond Myklebust if (set->cred < entry->cred) 17961c3c07e9STrond Myklebust p = &parent->rb_left; 17971c3c07e9STrond Myklebust else if (set->cred > entry->cred) 17981c3c07e9STrond Myklebust p = &parent->rb_right; 17991c3c07e9STrond Myklebust else 18001c3c07e9STrond Myklebust goto found; 18011c3c07e9STrond Myklebust } 18021c3c07e9STrond Myklebust rb_link_node(&set->rb_node, parent, p); 18031c3c07e9STrond Myklebust rb_insert_color(&set->rb_node, root_node); 1804cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 18051c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 18061c3c07e9STrond Myklebust return; 18071c3c07e9STrond Myklebust found: 18081c3c07e9STrond Myklebust rb_replace_node(parent, &set->rb_node, root_node); 1809cfcea3e8STrond Myklebust list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 1810cfcea3e8STrond Myklebust list_del(&entry->lru); 18111c3c07e9STrond Myklebust spin_unlock(&inode->i_lock); 18121c3c07e9STrond Myklebust nfs_access_free_entry(entry); 18131da177e4SLinus Torvalds } 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 18161da177e4SLinus Torvalds { 18171c3c07e9STrond Myklebust struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 18181c3c07e9STrond Myklebust if (cache == NULL) 18191c3c07e9STrond Myklebust return; 18201c3c07e9STrond Myklebust RB_CLEAR_NODE(&cache->rb_node); 18211da177e4SLinus Torvalds cache->jiffies = set->jiffies; 18221c3c07e9STrond Myklebust cache->cred = get_rpccred(set->cred); 18231da177e4SLinus Torvalds cache->mask = set->mask; 18241c3c07e9STrond Myklebust 18251c3c07e9STrond Myklebust nfs_access_add_rbtree(inode, cache); 1826cfcea3e8STrond Myklebust 1827cfcea3e8STrond Myklebust /* Update accounting */ 1828cfcea3e8STrond Myklebust smp_mb__before_atomic_inc(); 1829cfcea3e8STrond Myklebust atomic_long_inc(&nfs_access_nr_entries); 1830cfcea3e8STrond Myklebust smp_mb__after_atomic_inc(); 1831cfcea3e8STrond Myklebust 1832cfcea3e8STrond Myklebust /* Add inode to global LRU list */ 1833cfcea3e8STrond Myklebust if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_FLAGS(inode))) { 1834cfcea3e8STrond Myklebust spin_lock(&nfs_access_lru_lock); 1835cfcea3e8STrond Myklebust list_add_tail(&NFS_I(inode)->access_cache_inode_lru, &nfs_access_lru_list); 1836cfcea3e8STrond Myklebust spin_unlock(&nfs_access_lru_lock); 1837cfcea3e8STrond Myklebust } 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 18411da177e4SLinus Torvalds { 18421da177e4SLinus Torvalds struct nfs_access_entry cache; 18431da177e4SLinus Torvalds int status; 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds status = nfs_access_get_cached(inode, cred, &cache); 18461da177e4SLinus Torvalds if (status == 0) 18471da177e4SLinus Torvalds goto out; 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvalds /* Be clever: ask server to check for all possible rights */ 18501da177e4SLinus Torvalds cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 18511da177e4SLinus Torvalds cache.cred = cred; 18521da177e4SLinus Torvalds cache.jiffies = jiffies; 18531da177e4SLinus Torvalds status = NFS_PROTO(inode)->access(inode, &cache); 18541da177e4SLinus Torvalds if (status != 0) 18551da177e4SLinus Torvalds return status; 18561da177e4SLinus Torvalds nfs_access_add_cache(inode, &cache); 18571da177e4SLinus Torvalds out: 18581da177e4SLinus Torvalds if ((cache.mask & mask) == mask) 18591da177e4SLinus Torvalds return 0; 18601da177e4SLinus Torvalds return -EACCES; 18611da177e4SLinus Torvalds } 18621da177e4SLinus Torvalds 18631da177e4SLinus Torvalds int nfs_permission(struct inode *inode, int mask, struct nameidata *nd) 18641da177e4SLinus Torvalds { 18651da177e4SLinus Torvalds struct rpc_cred *cred; 18661da177e4SLinus Torvalds int res = 0; 18671da177e4SLinus Torvalds 186891d5b470SChuck Lever nfs_inc_stats(inode, NFSIOS_VFSACCESS); 186991d5b470SChuck Lever 18701da177e4SLinus Torvalds if (mask == 0) 18711da177e4SLinus Torvalds goto out; 18721da177e4SLinus Torvalds /* Is this sys_access() ? */ 18731da177e4SLinus Torvalds if (nd != NULL && (nd->flags & LOOKUP_ACCESS)) 18741da177e4SLinus Torvalds goto force_lookup; 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds switch (inode->i_mode & S_IFMT) { 18771da177e4SLinus Torvalds case S_IFLNK: 18781da177e4SLinus Torvalds goto out; 18791da177e4SLinus Torvalds case S_IFREG: 18801da177e4SLinus Torvalds /* NFSv4 has atomic_open... */ 18811da177e4SLinus Torvalds if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 18821da177e4SLinus Torvalds && nd != NULL 18831da177e4SLinus Torvalds && (nd->flags & LOOKUP_OPEN)) 18841da177e4SLinus Torvalds goto out; 18851da177e4SLinus Torvalds break; 18861da177e4SLinus Torvalds case S_IFDIR: 18871da177e4SLinus Torvalds /* 18881da177e4SLinus Torvalds * Optimize away all write operations, since the server 18891da177e4SLinus Torvalds * will check permissions when we perform the op. 18901da177e4SLinus Torvalds */ 18911da177e4SLinus Torvalds if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 18921da177e4SLinus Torvalds goto out; 18931da177e4SLinus Torvalds } 18941da177e4SLinus Torvalds 18951da177e4SLinus Torvalds force_lookup: 18961da177e4SLinus Torvalds lock_kernel(); 18971da177e4SLinus Torvalds 18981da177e4SLinus Torvalds if (!NFS_PROTO(inode)->access) 18991da177e4SLinus Torvalds goto out_notsup; 19001da177e4SLinus Torvalds 19011da177e4SLinus Torvalds cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0); 19021da177e4SLinus Torvalds if (!IS_ERR(cred)) { 19031da177e4SLinus Torvalds res = nfs_do_access(inode, cred, mask); 19041da177e4SLinus Torvalds put_rpccred(cred); 19051da177e4SLinus Torvalds } else 19061da177e4SLinus Torvalds res = PTR_ERR(cred); 19071da177e4SLinus Torvalds unlock_kernel(); 19081da177e4SLinus Torvalds out: 19091e7cb3dcSChuck Lever dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 19101e7cb3dcSChuck Lever inode->i_sb->s_id, inode->i_ino, mask, res); 19111da177e4SLinus Torvalds return res; 19121da177e4SLinus Torvalds out_notsup: 19131da177e4SLinus Torvalds res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 19141da177e4SLinus Torvalds if (res == 0) 19151da177e4SLinus Torvalds res = generic_permission(inode, mask, NULL); 19161da177e4SLinus Torvalds unlock_kernel(); 19171e7cb3dcSChuck Lever goto out; 19181da177e4SLinus Torvalds } 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds /* 19211da177e4SLinus Torvalds * Local variables: 19221da177e4SLinus Torvalds * version-control: t 19231da177e4SLinus Torvalds * kept-new-versions: 5 19241da177e4SLinus Torvalds * End: 19251da177e4SLinus Torvalds */ 1926