nfs: use %p[dD] instead of open-coded (and often racy) equivalents (6de1472f) · Commits · e / devices / android_kernel_oneplus_sm8150

fs/nfs/dir.c

+48 −71

Original line number	Diff line number	Diff line
		@@ -98,9 +98,7 @@ nfs_opendir(struct inode inode, struct file filp)
		struct nfs_open_dir_context *ctx;
		struct rpc_cred *cred;

		dfprintk(FILE, "NFS: open dir(%s/%s)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name);
		dfprintk(FILE, "NFS: open dir(%pD2)\n", filp);

		nfs_inc_stats(inode, NFSIOS_VFSOPEN);

		@@ -297,11 +295,10 @@ int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_des
		if (ctx->duped > 0
		&& ctx->dup_cookie == *desc->dir_cookie) {
		if (printk_ratelimit()) {
		pr_notice("NFS: directory %s/%s contains a readdir loop."
		pr_notice("NFS: directory %pD2 contains a readdir loop."
		"Please contact your server vendor. "
		"The file: %s has duplicate cookie %llu\n",
		desc->file->f_dentry->d_parent->d_name.name,
		desc->file->f_dentry->d_name.name,
		desc->file,
		array->array[i].string.name,
		*desc->dir_cookie);
		}
		@@ -822,9 +819,8 @@ static int nfs_readdir(struct file file, struct dir_context ctx)
		struct nfs_open_dir_context *dir_ctx = file->private_data;
		int res = 0;

		dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(long long)ctx->pos);
		dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n",
		file, (long long)ctx->pos);
		nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);

		/*
		@@ -880,22 +876,17 @@ static int nfs_readdir(struct file file, struct dir_context ctx)
		nfs_unblock_sillyrename(dentry);
		if (res > 0)
		res = 0;
		dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		res);
		dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res);
		return res;
		}

		static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
		{
		struct dentry *dentry = filp->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(filp);
		struct nfs_open_dir_context *dir_ctx = filp->private_data;

		dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
		dentry->d_parent->d_name.name,
		dentry->d_name.name,
		offset, whence);
		dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
		filp, offset, whence);

		mutex_lock(&inode->i_mutex);
		switch (whence) {
		@@ -925,15 +916,12 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
		static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
		int datasync)
		{
		struct dentry *dentry = filp->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(filp);

		dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		datasync);
		dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);

		mutex_lock(&inode->i_mutex);
		nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
		nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
		mutex_unlock(&inode->i_mutex);
		return 0;
		}
		@@ -1073,9 +1061,8 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
		}

		if (is_bad_inode(inode)) {
		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
		__func__, dentry);
		goto out_bad;
		}

		@@ -1125,9 +1112,8 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
		nfs_advise_use_readdirplus(dir);
		out_valid_noent:
		dput(parent);
		dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is valid\n",
		__func__, dentry);
		return 1;
		out_zap_parent:
		nfs_zap_caches(dir);
		@@ -1147,18 +1133,16 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
		goto out_valid;

		dput(parent);
		dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
		__func__, dentry);
		return 0;
		out_error:
		nfs_free_fattr(fattr);
		nfs_free_fhandle(fhandle);
		nfs4_label_free(label);
		dput(parent);
		dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name, error);
		dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) lookup returned error %d\n",
		__func__, dentry, error);
		return error;
		}

		@@ -1182,16 +1166,14 @@ static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
		* eventually need to do something more here.
		*/
		if (!inode) {
		dfprintk(LOOKUPCACHE, "%s: %s/%s has negative inode\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n",
		__func__, dentry);
		return 1;
		}

		if (is_bad_inode(inode)) {
		dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
		__func__, dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n",
		__func__, dentry);
		return 0;
		}

		@@ -1206,9 +1188,8 @@ static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
		*/
		static int nfs_dentry_delete(const struct dentry *dentry)
		{
		dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		dentry->d_flags);
		dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n",
		dentry, dentry->d_flags);

		/* Unhash any dentry with a stale inode */
		if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
		@@ -1286,8 +1267,7 @@ struct dentry nfs_lookup(struct inode dir, struct dentry * dentry, unsigned in
		struct nfs4_label *label = NULL;
		int error;

		dfprintk(VFS, "NFS: lookup(%s/%s)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name);
		dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
		nfs_inc_stats(dir, NFSIOS_VFSLOOKUP);

		res = ERR_PTR(-ENAMETOOLONG);
		@@ -1418,8 +1398,8 @@ int nfs_atomic_open(struct inode dir, struct dentry dentry,
		/* Expect a negative dentry */
		BUG_ON(dentry->d_inode);

		dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n",
		dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: atomic_open(%s/%ld), %pd\n",
		dir->i_sb->s_id, dir->i_ino, dentry);

		err = nfs_check_flags(open_flags);
		if (err)
		@@ -1608,8 +1588,8 @@ int nfs_create(struct inode dir, struct dentry dentry,
		int open_flags = excl ? O_CREAT \| O_EXCL : O_CREAT;
		int error;

		dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
		dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: create(%s/%ld), %pd\n",
		dir->i_sb->s_id, dir->i_ino, dentry);

		attr.ia_mode = mode;
		attr.ia_valid = ATTR_MODE;
		@@ -1635,8 +1615,8 @@ nfs_mknod(struct inode dir, struct dentry dentry, umode_t mode, dev_t rdev)
		struct iattr attr;
		int status;

		dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n",
		dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: mknod(%s/%ld), %pd\n",
		dir->i_sb->s_id, dir->i_ino, dentry);

		if (!new_valid_dev(rdev))
		return -EINVAL;
		@@ -1664,8 +1644,8 @@ int nfs_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
		struct iattr attr;
		int error;

		dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n",
		dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: mkdir(%s/%ld), %pd\n",
		dir->i_sb->s_id, dir->i_ino, dentry);

		attr.ia_valid = ATTR_MODE;
		attr.ia_mode = mode \| S_IFDIR;
		@@ -1692,8 +1672,8 @@ int nfs_rmdir(struct inode dir, struct dentry dentry)
		{
		int error;

		dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n",
		dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: rmdir(%s/%ld), %pd\n",
		dir->i_sb->s_id, dir->i_ino, dentry);

		trace_nfs_rmdir_enter(dir, dentry);
		if (dentry->d_inode) {
		@@ -1728,8 +1708,7 @@ static int nfs_safe_remove(struct dentry *dentry)
		struct inode *inode = dentry->d_inode;
		int error = -EBUSY;

		dfprintk(VFS, "NFS: safe_remove(%s/%s)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name);
		dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);

		/* If the dentry was sillyrenamed, we simply call d_delete() */
		if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
		@@ -1762,8 +1741,8 @@ int nfs_unlink(struct inode dir, struct dentry dentry)
		int error;
		int need_rehash = 0;

		dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
		dir->i_ino, dentry->d_name.name);
		dfprintk(VFS, "NFS: unlink(%s/%ld, %pd)\n", dir->i_sb->s_id,
		dir->i_ino, dentry);

		trace_nfs_unlink_enter(dir, dentry);
		spin_lock(&dentry->d_lock);
		@@ -1813,8 +1792,8 @@ int nfs_symlink(struct inode dir, struct dentry dentry, const char *symname)
		unsigned int pathlen = strlen(symname);
		int error;

		dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id,
		dir->i_ino, dentry->d_name.name, symname);
		dfprintk(VFS, "NFS: symlink(%s/%ld, %pd, %s)\n", dir->i_sb->s_id,
		dir->i_ino, dentry, symname);

		if (pathlen > PAGE_SIZE)
		return -ENAMETOOLONG;
		@@ -1836,9 +1815,9 @@ int nfs_symlink(struct inode dir, struct dentry dentry, const char *symname)
		error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr);
		trace_nfs_symlink_exit(dir, dentry, error);
		if (error != 0) {
		dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n",
		dfprintk(VFS, "NFS: symlink(%s/%ld, %pd, %s) error %d\n",
		dir->i_sb->s_id, dir->i_ino,
		dentry->d_name.name, symname, error);
		dentry, symname, error);
		d_drop(dentry);
		__free_page(page);
		return error;
		@@ -1865,9 +1844,8 @@ nfs_link(struct dentry old_dentry, struct inode dir, struct dentry *dentry)
		struct inode *inode = old_dentry->d_inode;
		int error;

		dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n",
		old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
		dentry->d_parent->d_name.name, dentry->d_name.name);
		dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
		old_dentry, dentry);

		trace_nfs_link_enter(inode, dir, dentry);
		NFS_PROTO(inode)->return_delegation(inode);
		@@ -1915,9 +1893,8 @@ int nfs_rename(struct inode old_dir, struct dentry old_dentry,
		struct dentry dentry = NULL, rehash = NULL;
		int error = -EBUSY;

		dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
		old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
		new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
		dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
		old_dentry, new_dentry,
		d_count(new_dentry));

		trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry);

fs/nfs/direct.c

+6 −11

Original line number	Diff line number	Diff line
		@@ -124,9 +124,8 @@ static inline int put_dreq(struct nfs_direct_req *dreq)
		ssize_t nfs_direct_IO(int rw, struct kiocb iocb, const struct iovec iov, loff_t pos, unsigned long nr_segs)
		{
		#ifndef CONFIG_NFS_SWAP
		dprintk("NFS: nfs_direct_IO (%s) off/no(%Ld/%lu) EINVAL\n",
		iocb->ki_filp->f_path.dentry->d_name.name,
		(long long) pos, nr_segs);
		dprintk("NFS: nfs_direct_IO (%pD) off/no(%Ld/%lu) EINVAL\n",
		iocb->ki_filp, (long long) pos, nr_segs);

		return -EINVAL;
		#else
		@@ -909,10 +908,8 @@ ssize_t nfs_file_direct_read(struct kiocb iocb, const struct iovec iov,
		count = iov_length(iov, nr_segs);
		nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count);

		dfprintk(FILE, "NFS: direct read(%s/%s, %zd@%Ld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		count, (long long) pos);
		dfprintk(FILE, "NFS: direct read(%pD2, %zd@%Ld)\n",
		file, count, (long long) pos);

		retval = 0;
		if (!count)
		@@ -965,10 +962,8 @@ ssize_t nfs_file_direct_write(struct kiocb iocb, const struct iovec iov,
		count = iov_length(iov, nr_segs);
		nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count);

		dfprintk(FILE, "NFS: direct write(%s/%s, %zd@%Ld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		count, (long long) pos);
		dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n",
		file, count, (long long) pos);

		retval = generic_write_checks(file, &pos, &count, 0);
		if (retval)

fs/nfs/file.c

+43 −74

Original line number	Diff line number	Diff line
		@@ -65,9 +65,7 @@ nfs_file_open(struct inode inode, struct file filp)
		{
		int res;

		dprintk("NFS: open file(%s/%s)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name);
		dprintk("NFS: open file(%pD2)\n", filp);

		nfs_inc_stats(inode, NFSIOS_VFSOPEN);
		res = nfs_check_flags(filp->f_flags);
		@@ -81,9 +79,7 @@ nfs_file_open(struct inode inode, struct file filp)
		int
		nfs_file_release(struct inode inode, struct file filp)
		{
		dprintk("NFS: release(%s/%s)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name);
		dprintk("NFS: release(%pD2)\n", filp);

		nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
		return nfs_release(inode, filp);
		@@ -123,10 +119,8 @@ static int nfs_revalidate_file_size(struct inode inode, struct file filp)

		loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
		{
		dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name,
		offset, whence);
		dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
		filp, offset, whence);

		/*
		* whence == SEEK_END \|\| SEEK_DATA \|\| SEEK_HOLE => we must revalidate
		@@ -150,12 +144,9 @@ EXPORT_SYMBOL_GPL(nfs_file_llseek);
		int
		nfs_file_flush(struct file *file, fl_owner_t id)
		{
		struct dentry *dentry = file->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(file);

		dprintk("NFS: flush(%s/%s)\n",
		dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dprintk("NFS: flush(%pD2)\n", file);

		nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
		if ((file->f_mode & FMODE_WRITE) == 0)
		@@ -177,15 +168,14 @@ ssize_t
		nfs_file_read(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct dentry * dentry = iocb->ki_filp->f_path.dentry;
		struct inode * inode = dentry->d_inode;
		struct inode *inode = file_inode(iocb->ki_filp);
		ssize_t result;

		if (iocb->ki_filp->f_flags & O_DIRECT)
		return nfs_file_direct_read(iocb, iov, nr_segs, pos, true);

		dprintk("NFS: read(%s/%s, %lu@%lu)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		dprintk("NFS: read(%pD2, %lu@%lu)\n",
		iocb->ki_filp,
		(unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);

		result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
		@@ -203,13 +193,11 @@ nfs_file_splice_read(struct file filp, loff_t ppos,
		struct pipe_inode_info *pipe, size_t count,
		unsigned int flags)
		{
		struct dentry *dentry = filp->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(filp);
		ssize_t res;

		dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(unsigned long) count, (unsigned long long) *ppos);
		dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n",
		filp, (unsigned long) count, (unsigned long long) *ppos);

		res = nfs_revalidate_mapping(inode, filp->f_mapping);
		if (!res) {
		@@ -224,12 +212,10 @@ EXPORT_SYMBOL_GPL(nfs_file_splice_read);
		int
		nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
		{
		struct dentry *dentry = file->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(file);
		int status;

		dprintk("NFS: mmap(%s/%s)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name);
		dprintk("NFS: mmap(%pD2)\n", file);

		/* Note: generic_file_mmap() returns ENOSYS on nommu systems
		* so we call that before revalidating the mapping
		@@ -258,15 +244,12 @@ EXPORT_SYMBOL_GPL(nfs_file_mmap);
		int
		nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
		{
		struct dentry *dentry = file->f_path.dentry;
		struct nfs_open_context *ctx = nfs_file_open_context(file);
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(file);
		int have_error, do_resend, status;
		int ret = 0;

		dprintk("NFS: fsync file(%s/%s) datasync %d\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		datasync);
		dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync);

		nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
		do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
		@@ -371,10 +354,8 @@ static int nfs_write_begin(struct file file, struct address_space mapping,
		struct page *page;
		int once_thru = 0;

		dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		mapping->host->i_ino, len, (long long) pos);
		dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%ld), %u@%lld)\n",
		file, mapping->host->i_ino, len, (long long) pos);

		start:
		/*
		@@ -414,10 +395,8 @@ static int nfs_write_end(struct file file, struct address_space mapping,
		struct nfs_open_context *ctx = nfs_file_open_context(file);
		int status;

		dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		mapping->host->i_ino, len, (long long) pos);
		dfprintk(PAGECACHE, "NFS: write_end(%pD2(%ld), %u@%lld)\n",
		file, mapping->host->i_ino, len, (long long) pos);

		/*
		* Zero any uninitialised parts of the page, and then mark the page
		@@ -601,22 +580,21 @@ static int nfs_vm_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf)
		{
		struct page *page = vmf->page;
		struct file *filp = vma->vm_file;
		struct dentry *dentry = filp->f_path.dentry;
		struct inode *inode = file_inode(filp);
		unsigned pagelen;
		int ret = VM_FAULT_NOPAGE;
		struct address_space *mapping;

		dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		filp->f_mapping->host->i_ino,
		dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%ld), offset %lld)\n",
		filp, filp->f_mapping->host->i_ino,
		(long long)page_offset(page));

		/* make sure the cache has finished storing the page */
		nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
		nfs_fscache_wait_on_page_write(NFS_I(inode), page);

		lock_page(page);
		mapping = page_file_mapping(page);
		if (mapping != dentry->d_inode->i_mapping)
		if (mapping != inode->i_mapping)
		goto out_unlock;

		wait_on_page_writeback(page);
		@@ -659,22 +637,21 @@ static int nfs_need_sync_write(struct file filp, struct inode inode)
		ssize_t nfs_file_write(struct kiocb iocb, const struct iovec iov,
		unsigned long nr_segs, loff_t pos)
		{
		struct dentry * dentry = iocb->ki_filp->f_path.dentry;
		struct inode * inode = dentry->d_inode;
		struct file *file = iocb->ki_filp;
		struct inode *inode = file_inode(file);
		unsigned long written = 0;
		ssize_t result;
		size_t count = iov_length(iov, nr_segs);

		result = nfs_key_timeout_notify(iocb->ki_filp, inode);
		result = nfs_key_timeout_notify(file, inode);
		if (result)
		return result;

		if (iocb->ki_filp->f_flags & O_DIRECT)
		if (file->f_flags & O_DIRECT)
		return nfs_file_direct_write(iocb, iov, nr_segs, pos, true);

		dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(unsigned long) count, (long long) pos);
		dprintk("NFS: write(%pD2, %lu@%Ld)\n",
		file, (unsigned long) count, (long long) pos);

		result = -EBUSY;
		if (IS_SWAPFILE(inode))
		@@ -682,8 +659,8 @@ ssize_t nfs_file_write(struct kiocb iocb, const struct iovec iov,
		/*
		* O_APPEND implies that we must revalidate the file length.
		*/
		if (iocb->ki_filp->f_flags & O_APPEND) {
		result = nfs_revalidate_file_size(inode, iocb->ki_filp);
		if (file->f_flags & O_APPEND) {
		result = nfs_revalidate_file_size(inode, file);
		if (result)
		goto out;
		}
		@@ -697,8 +674,8 @@ ssize_t nfs_file_write(struct kiocb iocb, const struct iovec iov,
		written = result;

		/* Return error values for O_DSYNC and IS_SYNC() */
		if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
		int err = vfs_fsync(iocb->ki_filp, 0);
		if (result >= 0 && nfs_need_sync_write(file, inode)) {
		int err = vfs_fsync(file, 0);
		if (err < 0)
		result = err;
		}
		@@ -717,14 +694,12 @@ ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
		struct file filp, loff_t ppos,
		size_t count, unsigned int flags)
		{
		struct dentry *dentry = filp->f_path.dentry;
		struct inode *inode = dentry->d_inode;
		struct inode *inode = file_inode(filp);
		unsigned long written = 0;
		ssize_t ret;

		dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(unsigned long) count, (unsigned long long) *ppos);
		dprintk("NFS splice_write(%pD2, %lu@%llu)\n",
		filp, (unsigned long) count, (unsigned long long) *ppos);

		/*
		* The combination of splice and an O_APPEND destination is disallowed.
		@@ -883,10 +858,8 @@ int nfs_lock(struct file filp, int cmd, struct file_lock fl)
		int ret = -ENOLCK;
		int is_local = 0;

		dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name,
		fl->fl_type, fl->fl_flags,
		dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
		filp, fl->fl_type, fl->fl_flags,
		(long long)fl->fl_start, (long long)fl->fl_end);

		nfs_inc_stats(inode, NFSIOS_VFSLOCK);
		@@ -923,10 +896,8 @@ int nfs_flock(struct file filp, int cmd, struct file_lock fl)
		struct inode *inode = filp->f_mapping->host;
		int is_local = 0;

		dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
		filp->f_path.dentry->d_parent->d_name.name,
		filp->f_path.dentry->d_name.name,
		fl->fl_type, fl->fl_flags);
		dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
		filp, fl->fl_type, fl->fl_flags);

		if (!(fl->fl_flags & FL_FLOCK))
		return -ENOLCK;
		@@ -960,9 +931,7 @@ EXPORT_SYMBOL_GPL(nfs_flock);
		*/
		int nfs_setlease(struct file file, long arg, struct file_lock *fl)
		{
		dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name, arg);
		dprintk("NFS: setlease(%pD2, arg=%ld)\n", file, arg);
		return -EINVAL;
		}
		EXPORT_SYMBOL_GPL(nfs_setlease);

fs/nfs/namespace.c

+2 −3

Original line number	Diff line number	Diff line
		@@ -253,9 +253,8 @@ struct vfsmount nfs_do_submount(struct dentry dentry, struct nfs_fh *fh,

		dprintk("--> nfs_do_submount()\n");

		dprintk("%s: submounting on %s/%s\n", __func__,
		dentry->d_parent->d_name.name,
		dentry->d_name.name);
		dprintk("%s: submounting on %pd2\n", __func__,
		dentry);
		if (page == NULL)
		goto out;
		devname = nfs_devname(dentry, page, PAGE_SIZE);

fs/nfs/nfs3proc.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -321,7 +321,7 @@ nfs3_proc_create(struct inode dir, struct dentry dentry, struct iattr *sattr,
		umode_t mode = sattr->ia_mode;
		int status = -ENOMEM;

		dprintk("NFS call create %s\n", dentry->d_name.name);
		dprintk("NFS call create %pd\n", dentry);

		data = nfs3_alloc_createdata();
		if (data == NULL)
		@@ -548,7 +548,7 @@ nfs3_proc_symlink(struct inode dir, struct dentry dentry, struct page *page,
		if (len > NFS3_MAXPATHLEN)
		return -ENAMETOOLONG;

		dprintk("NFS call symlink %s\n", dentry->d_name.name);
		dprintk("NFS call symlink %pd\n", dentry);

		data = nfs3_alloc_createdata();
		if (data == NULL)
		@@ -576,7 +576,7 @@ nfs3_proc_mkdir(struct inode dir, struct dentry dentry, struct iattr *sattr)
		umode_t mode = sattr->ia_mode;
		int status = -ENOMEM;

		dprintk("NFS call mkdir %s\n", dentry->d_name.name);
		dprintk("NFS call mkdir %pd\n", dentry);

		sattr->ia_mode &= ~current_umask();

		@@ -695,7 +695,7 @@ nfs3_proc_mknod(struct inode dir, struct dentry dentry, struct iattr *sattr,
		umode_t mode = sattr->ia_mode;
		int status = -ENOMEM;

		dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
		dprintk("NFS call mknod %pd %u:%u\n", dentry,
		MAJOR(rdev), MINOR(rdev));

		sattr->ia_mode &= ~current_umask();