Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2b2b15c3 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfs-for-3.14-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs 

Pull NFS client updates from Trond Myklebust:
 "Highlights include:

   - stable fix for an infinite loop in RPC state machine
   - stable fix for a use after free situation in the NFSv4 trunking discovery
   - stable fix for error handling in the NFSv4 trunking discovery
   - stable fix for the page write update code
   - stable fix for the NFSv4.1 mount time security negotiation
   - stable fix for the NFSv4 open code.
   - O_DIRECT locking fixes
   - fix an Oops in the pnfs file commit code
   - RPC layer needs finer grained handling of connection errors
   - more RPC GSS upcall fixes"

* tag 'nfs-for-3.14-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (30 commits)
  pnfs: Proper delay for NFS4ERR_RECALLCONFLICT in layout_get_done
  pnfs: fix BUG in filelayout_recover_commit_reqs
  nfs4: fix discover_server_trunking use after free
  NFSv4.1: Handle errors correctly in nfs41_walk_client_list
  nfs: always make sure page is up-to-date before extending a write to cover the entire page
  nfs: page cache invalidation for dio
  nfs: take i_mutex during direct I/O reads
  nfs: merge nfs_direct_write into nfs_file_direct_write
  nfs: merge nfs_direct_read into nfs_file_direct_read
  nfs: increment i_dio_count for reads, too
  nfs: defer inode_dio_done call until size update is done
  nfs: fix size updates for aio writes
  nfs4.1: properly handle ENOTSUP in SECINFO_NO_NAME
  NFSv4.1: Fix a race in nfs4_write_inode
  NFSv4.1: Don't trust attributes if a pNFS LAYOUTCOMMIT is outstanding
  point to the right include file in a comment (left over from a9004abc)
  NFS: dprintk() should not print negative fileids and inode numbers
  nfs: fix dead code of ipv6_addr_scope
  sunrpc: Fix infinite loop in RPC state machine
  SUNRPC: Add tracepoint for socket errors
  ...
parents bf3d846b ed7e5423

fs/nfs/dir.c

+9 −9
Original line number Diff line number Diff line
@@ -1404,7 +1404,7 @@ 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), %pd\n",

	dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",

			dir->i_sb->s_id, dir->i_ino, dentry);



	err = nfs_check_flags(open_flags);
@@ -1594,7 +1594,7 @@ 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), %pd\n",

	dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",

			dir->i_sb->s_id, dir->i_ino, dentry);



	attr.ia_mode = mode;
@@ -1621,7 +1621,7 @@ 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), %pd\n",

	dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",

			dir->i_sb->s_id, dir->i_ino, dentry);



	if (!new_valid_dev(rdev))
@@ -1650,7 +1650,7 @@ int nfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 
	struct iattr attr;

	int error;



	dfprintk(VFS, "NFS: mkdir(%s/%ld), %pd\n",

	dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",

			dir->i_sb->s_id, dir->i_ino, dentry);



	attr.ia_valid = ATTR_MODE;
@@ -1678,7 +1678,7 @@ int nfs_rmdir(struct inode *dir, struct dentry *dentry) 
{

	int error;



	dfprintk(VFS, "NFS: rmdir(%s/%ld), %pd\n",

	dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",

			dir->i_sb->s_id, dir->i_ino, dentry);



	trace_nfs_rmdir_enter(dir, dentry);
@@ -1747,7 +1747,7 @@ int nfs_unlink(struct inode *dir, struct dentry *dentry) 
	int error;

	int need_rehash = 0;



	dfprintk(VFS, "NFS: unlink(%s/%ld, %pd)\n", dir->i_sb->s_id,

	dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,

		dir->i_ino, dentry);



	trace_nfs_unlink_enter(dir, dentry);
@@ -1798,7 +1798,7 @@ 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, %pd, %s)\n", dir->i_sb->s_id,

	dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,

		dir->i_ino, dentry, symname);



	if (pathlen > PAGE_SIZE)
@@ -1821,7 +1821,7 @@ 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, %pd, %s) error %d\n",

		dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",

			dir->i_sb->s_id, dir->i_ino,

			dentry, symname, error);

		d_drop(dentry);
@@ -2304,7 +2304,7 @@ int nfs_permission(struct inode *inode, int mask) 
	if (!res && (mask & MAY_EXEC) && !execute_ok(inode))

		res = -EACCES;



	dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n",

	dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",

		inode->i_sb->s_id, inode->i_ino, mask, res);

	return res;

out_notsup:

fs/nfs/direct.c

+154 −125
Original line number Diff line number Diff line
@@ -222,14 +222,31 @@ static ssize_t nfs_direct_wait(struct nfs_direct_req *dreq) 
 * Synchronous I/O uses a stack-allocated iocb.  Thus we can't trust

 * the iocb is still valid here if this is a synchronous request.

 */

static void nfs_direct_complete(struct nfs_direct_req *dreq)

static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)

{

	struct inode *inode = dreq->inode;



	if (dreq->iocb && write) {

		loff_t pos = dreq->iocb->ki_pos + dreq->count;



		spin_lock(&inode->i_lock);

		if (i_size_read(inode) < pos)

			i_size_write(inode, pos);

		spin_unlock(&inode->i_lock);

	}



	if (write)

		nfs_zap_mapping(inode, inode->i_mapping);



	inode_dio_done(inode);



	if (dreq->iocb) {

		long res = (long) dreq->error;

		if (!res)

			res = (long) dreq->count;

		aio_complete(dreq->iocb, res, 0);

	}



	complete_all(&dreq->completion);



	nfs_direct_req_release(dreq);
@@ -237,9 +254,9 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq) 


static void nfs_direct_readpage_release(struct nfs_page *req)

{

	dprintk("NFS: direct read done (%s/%lld %d@%lld)\n",

	dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",

		req->wb_context->dentry->d_inode->i_sb->s_id,

		(long long)NFS_FILEID(req->wb_context->dentry->d_inode),

		(unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),

		req->wb_bytes,

		(long long)req_offset(req));

	nfs_release_request(req);
@@ -272,7 +289,7 @@ static void nfs_direct_read_completion(struct nfs_pgio_header *hdr) 
	}

out_put:

	if (put_dreq(dreq))

		nfs_direct_complete(dreq);

		nfs_direct_complete(dreq, false);

	hdr->release(hdr);

}
@@ -402,6 +419,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq, 
					      loff_t pos, bool uio)

{

	struct nfs_pageio_descriptor desc;

	struct inode *inode = dreq->inode;

	ssize_t result = -EINVAL;

	size_t requested_bytes = 0;

	unsigned long seg;
@@ -410,6 +428,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq, 
			     &nfs_direct_read_completion_ops);

	get_dreq(dreq);

	desc.pg_dreq = dreq;

	atomic_inc(&inode->i_dio_count);



	for (seg = 0; seg < nr_segs; seg++) {

		const struct iovec *vec = &iov[seg];
@@ -429,26 +448,69 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq, 
	 * generic layer handle the completion.

	 */

	if (requested_bytes == 0) {

		inode_dio_done(inode);

		nfs_direct_req_release(dreq);

		return result < 0 ? result : -EIO;

	}



	if (put_dreq(dreq))

		nfs_direct_complete(dreq);

		nfs_direct_complete(dreq, false);

	return 0;

}



static ssize_t nfs_direct_read(struct kiocb *iocb, const struct iovec *iov,

/**

 * nfs_file_direct_read - file direct read operation for NFS files

 * @iocb: target I/O control block

 * @iov: vector of user buffers into which to read data

 * @nr_segs: size of iov vector

 * @pos: byte offset in file where reading starts

 *

 * We use this function for direct reads instead of calling

 * generic_file_aio_read() in order to avoid gfar's check to see if

 * the request starts before the end of the file.  For that check

 * to work, we must generate a GETATTR before each direct read, and

 * even then there is a window between the GETATTR and the subsequent

 * READ where the file size could change.  Our preference is simply

 * to do all reads the application wants, and the server will take

 * care of managing the end of file boundary.

 *

 * This function also eliminates unnecessarily updating the file's

 * atime locally, as the NFS server sets the file's atime, and this

 * client must read the updated atime from the server back into its

 * cache.

 */

ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,

				unsigned long nr_segs, loff_t pos, bool uio)

{

	ssize_t result = -ENOMEM;

	struct inode *inode = iocb->ki_filp->f_mapping->host;

	struct file *file = iocb->ki_filp;

	struct address_space *mapping = file->f_mapping;

	struct inode *inode = mapping->host;

	struct nfs_direct_req *dreq;

	struct nfs_lock_context *l_ctx;

	ssize_t result = -EINVAL;

	size_t count;



	count = iov_length(iov, nr_segs);

	nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count);



	dfprintk(FILE, "NFS: direct read(%pD2, %zd@%Ld)\n",

		file, count, (long long) pos);



	result = 0;

	if (!count)

		goto out;



	mutex_lock(&inode->i_mutex);

	result = nfs_sync_mapping(mapping);

	if (result)

		goto out_unlock;



	task_io_account_read(count);



	result = -ENOMEM;

	dreq = nfs_direct_req_alloc();

	if (dreq == NULL)

		goto out;

		goto out_unlock;



	dreq->inode = inode;

	dreq->bytes_left = iov_length(iov, nr_segs);
@@ -464,20 +526,26 @@ static ssize_t nfs_direct_read(struct kiocb *iocb, const struct iovec *iov, 


	NFS_I(inode)->read_io += iov_length(iov, nr_segs);

	result = nfs_direct_read_schedule_iovec(dreq, iov, nr_segs, pos, uio);

	if (!result)



	mutex_unlock(&inode->i_mutex);



	if (!result) {

		result = nfs_direct_wait(dreq);

		if (result > 0)

			iocb->ki_pos = pos + result;

	}



	nfs_direct_req_release(dreq);

	return result;



out_release:

	nfs_direct_req_release(dreq);

out_unlock:

	mutex_unlock(&inode->i_mutex);

out:

	return result;

}



static void nfs_inode_dio_write_done(struct inode *inode)

{

	nfs_zap_mapping(inode, inode->i_mapping);

	inode_dio_done(inode);

}



#if IS_ENABLED(CONFIG_NFS_V3) || IS_ENABLED(CONFIG_NFS_V4)

static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)

{
@@ -593,8 +661,7 @@ static void nfs_direct_write_schedule_work(struct work_struct *work) 
			nfs_direct_write_reschedule(dreq);

			break;

		default:

			nfs_inode_dio_write_done(dreq->inode);

			nfs_direct_complete(dreq);

			nfs_direct_complete(dreq, true);

	}

}
@@ -610,8 +677,7 @@ static void nfs_direct_write_schedule_work(struct work_struct *work) 


static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)

{

	nfs_inode_dio_write_done(inode);

	nfs_direct_complete(dreq);

	nfs_direct_complete(dreq, true);

}

#endif
@@ -842,93 +908,6 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq, 
	return 0;

}



static ssize_t nfs_direct_write(struct kiocb *iocb, const struct iovec *iov,

				unsigned long nr_segs, loff_t pos,

				size_t count, bool uio)

{

	ssize_t result = -ENOMEM;

	struct inode *inode = iocb->ki_filp->f_mapping->host;

	struct nfs_direct_req *dreq;

	struct nfs_lock_context *l_ctx;



	dreq = nfs_direct_req_alloc();

	if (!dreq)

		goto out;



	dreq->inode = inode;

	dreq->bytes_left = count;

	dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));

	l_ctx = nfs_get_lock_context(dreq->ctx);

	if (IS_ERR(l_ctx)) {

		result = PTR_ERR(l_ctx);

		goto out_release;

	}

	dreq->l_ctx = l_ctx;

	if (!is_sync_kiocb(iocb))

		dreq->iocb = iocb;



	result = nfs_direct_write_schedule_iovec(dreq, iov, nr_segs, pos, uio);

	if (!result)

		result = nfs_direct_wait(dreq);

out_release:

	nfs_direct_req_release(dreq);

out:

	return result;

}



/**

 * nfs_file_direct_read - file direct read operation for NFS files

 * @iocb: target I/O control block

 * @iov: vector of user buffers into which to read data

 * @nr_segs: size of iov vector

 * @pos: byte offset in file where reading starts

 *

 * We use this function for direct reads instead of calling

 * generic_file_aio_read() in order to avoid gfar's check to see if

 * the request starts before the end of the file.  For that check

 * to work, we must generate a GETATTR before each direct read, and

 * even then there is a window between the GETATTR and the subsequent

 * READ where the file size could change.  Our preference is simply

 * to do all reads the application wants, and the server will take

 * care of managing the end of file boundary.

 *

 * This function also eliminates unnecessarily updating the file's

 * atime locally, as the NFS server sets the file's atime, and this

 * client must read the updated atime from the server back into its

 * cache.

 */

ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,

				unsigned long nr_segs, loff_t pos, bool uio)

{

	ssize_t retval = -EINVAL;

	struct file *file = iocb->ki_filp;

	struct address_space *mapping = file->f_mapping;

	size_t count;



	count = iov_length(iov, nr_segs);

	nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count);



	dfprintk(FILE, "NFS: direct read(%pD2, %zd@%Ld)\n",

		file, count, (long long) pos);



	retval = 0;

	if (!count)

		goto out;



	retval = nfs_sync_mapping(mapping);

	if (retval)

		goto out;



	task_io_account_read(count);



	retval = nfs_direct_read(iocb, iov, nr_segs, pos, uio);

	if (retval > 0)

		iocb->ki_pos = pos + retval;



out:

	return retval;

}



/**

 * nfs_file_direct_write - file direct write operation for NFS files

 * @iocb: target I/O control block
@@ -954,46 +933,96 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov, 
ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,

				unsigned long nr_segs, loff_t pos, bool uio)

{

	ssize_t retval = -EINVAL;

	ssize_t result = -EINVAL;

	struct file *file = iocb->ki_filp;

	struct address_space *mapping = file->f_mapping;

	struct inode *inode = mapping->host;

	struct nfs_direct_req *dreq;

	struct nfs_lock_context *l_ctx;

	loff_t end;

	size_t count;



	count = iov_length(iov, nr_segs);

	end = (pos + count - 1) >> PAGE_CACHE_SHIFT;



	nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count);



	dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n",

		file, count, (long long) pos);



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

	if (retval)

	result = generic_write_checks(file, &pos, &count, 0);

	if (result)

		goto out;



	retval = -EINVAL;

	result = -EINVAL;

	if ((ssize_t) count < 0)

		goto out;

	retval = 0;

	result = 0;

	if (!count)

		goto out;



	retval = nfs_sync_mapping(mapping);

	if (retval)

		goto out;

	mutex_lock(&inode->i_mutex);



	result = nfs_sync_mapping(mapping);

	if (result)

		goto out_unlock;



	if (mapping->nrpages) {

		result = invalidate_inode_pages2_range(mapping,

					pos >> PAGE_CACHE_SHIFT, end);

		if (result)

			goto out_unlock;

	}



	task_io_account_write(count);



	retval = nfs_direct_write(iocb, iov, nr_segs, pos, count, uio);

	if (retval > 0) {

	result = -ENOMEM;

	dreq = nfs_direct_req_alloc();

	if (!dreq)

		goto out_unlock;



	dreq->inode = inode;

	dreq->bytes_left = count;

	dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));

	l_ctx = nfs_get_lock_context(dreq->ctx);

	if (IS_ERR(l_ctx)) {

		result = PTR_ERR(l_ctx);

		goto out_release;

	}

	dreq->l_ctx = l_ctx;

	if (!is_sync_kiocb(iocb))

		dreq->iocb = iocb;



	result = nfs_direct_write_schedule_iovec(dreq, iov, nr_segs, pos, uio);



	if (mapping->nrpages) {

		invalidate_inode_pages2_range(mapping,

					      pos >> PAGE_CACHE_SHIFT, end);

	}



	mutex_unlock(&inode->i_mutex);



	if (!result) {

		result = nfs_direct_wait(dreq);

		if (result > 0) {

			struct inode *inode = mapping->host;



		iocb->ki_pos = pos + retval;

			iocb->ki_pos = pos + result;

			spin_lock(&inode->i_lock);

			if (i_size_read(inode) < iocb->ki_pos)

				i_size_write(inode, iocb->ki_pos);

			spin_unlock(&inode->i_lock);

		}

	}

	nfs_direct_req_release(dreq);

	return result;



out_release:

	nfs_direct_req_release(dreq);

out_unlock:

	mutex_unlock(&inode->i_mutex);

out:

	return retval;

	return result;

}



/**

fs/nfs/file.c

+3 −3
Original line number Diff line number Diff line
@@ -354,7 +354,7 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping, 
	struct page *page;

	int once_thru = 0;



	dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%ld), %u@%lld)\n",

	dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",

		file, mapping->host->i_ino, len, (long long) pos);



start:
@@ -395,7 +395,7 @@ 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(%pD2(%ld), %u@%lld)\n",

	dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",

		file, mapping->host->i_ino, len, (long long) pos);



	/*
@@ -585,7 +585,7 @@ static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
	int ret = VM_FAULT_NOPAGE;

	struct address_space *mapping;



	dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%ld), offset %lld)\n",

	dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",

		filp, filp->f_mapping->host->i_ino,

		(long long)page_offset(page));

fs/nfs/inode.c

+32 −16
Original line number Diff line number Diff line
@@ -458,9 +458,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st 
		unlock_new_inode(inode);

	} else

		nfs_refresh_inode(inode, fattr);

	dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",

	dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",

		inode->i_sb->s_id,

		(long long)NFS_FILEID(inode),

		(unsigned long long)NFS_FILEID(inode),

		nfs_display_fhandle_hash(fh),

		atomic_read(&inode->i_count));
@@ -870,8 +870,8 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 
	struct nfs_fattr *fattr = NULL;

	struct nfs_inode *nfsi = NFS_I(inode);



	dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",

		inode->i_sb->s_id, (long long)NFS_FILEID(inode));

	dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",

		inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));



	trace_nfs_revalidate_inode_enter(inode);
@@ -895,9 +895,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 


	status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);

	if (status != 0) {

		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",

		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",

			 inode->i_sb->s_id,

			 (long long)NFS_FILEID(inode), status);

			 (unsigned long long)NFS_FILEID(inode), status);

		if (status == -ESTALE) {

			nfs_zap_caches(inode);

			if (!S_ISDIR(inode->i_mode))
@@ -908,9 +908,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 


	status = nfs_refresh_inode(inode, fattr);

	if (status) {

		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",

		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",

			 inode->i_sb->s_id,

			 (long long)NFS_FILEID(inode), status);

			 (unsigned long long)NFS_FILEID(inode), status);

		goto err_out;

	}
@@ -919,9 +919,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode) 


	nfs_setsecurity(inode, fattr, label);



	dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",

	dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",

		inode->i_sb->s_id,

		(long long)NFS_FILEID(inode));

		(unsigned long long)NFS_FILEID(inode));



err_out:

	nfs4_label_free(label);
@@ -985,8 +985,9 @@ static int nfs_invalidate_mapping(struct inode *inode, struct address_space *map 
	nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);

	nfs_fscache_wait_on_invalidate(inode);



	dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",

			inode->i_sb->s_id, (long long)NFS_FILEID(inode));

	dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",

			inode->i_sb->s_id,

			(unsigned long long)NFS_FILEID(inode));

	return 0;

}
@@ -1282,12 +1283,28 @@ static int nfs_inode_attrs_need_update(const struct inode *inode, const struct n 
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);

}



/*

 * Don't trust the change_attribute, mtime, ctime or size if

 * a pnfs LAYOUTCOMMIT is outstanding

 */

static void nfs_inode_attrs_handle_layoutcommit(struct inode *inode,

		struct nfs_fattr *fattr)

{

	if (pnfs_layoutcommit_outstanding(inode))

		fattr->valid &= ~(NFS_ATTR_FATTR_CHANGE |

				NFS_ATTR_FATTR_MTIME |

				NFS_ATTR_FATTR_CTIME |

				NFS_ATTR_FATTR_SIZE);

}



static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)

{

	int ret;



	trace_nfs_refresh_inode_enter(inode);



	nfs_inode_attrs_handle_layoutcommit(inode, fattr);



	if (nfs_inode_attrs_need_update(inode, fattr))

		ret = nfs_update_inode(inode, fattr);

	else
@@ -1434,7 +1451,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
	unsigned long now = jiffies;

	unsigned long save_cache_validity;



	dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n",

	dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",

			__func__, inode->i_sb->s_id, inode->i_ino,

			nfs_display_fhandle_hash(NFS_FH(inode)),

			atomic_read(&inode->i_count), fattr->valid);
@@ -1455,7 +1472,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		/*

		* Big trouble! The inode has become a different object.

		*/

		printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",

		printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",

				__func__, inode->i_ino, inode->i_mode, fattr->mode);

		goto out_err;

	}
@@ -1517,8 +1534,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		if (new_isize != cur_isize) {

			/* Do we perhaps have any outstanding writes, or has

			 * the file grown beyond our last write? */

			if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||

			     new_isize > cur_isize) {

			if ((nfsi->npages == 0) || new_isize > cur_isize) {

				i_size_write(inode, new_isize);

				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;

			}

fs/nfs/nfs4client.c

+15 −10
Original line number Diff line number Diff line
@@ -10,6 +10,7 @@ 
#include <linux/sunrpc/auth.h>

#include <linux/sunrpc/xprt.h>

#include <linux/sunrpc/bc_xprt.h>

#include <linux/sunrpc/rpc_pipe_fs.h>

#include "internal.h"

#include "callback.h"

#include "delegation.h"
@@ -370,7 +371,11 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp, 
		__set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags);

	__set_bit(NFS_CS_DISCRTRY, &clp->cl_flags);

	__set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags);

	error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_GSS_KRB5I);



	error = -EINVAL;

	if (gssd_running(clp->cl_net))

		error = nfs_create_rpc_client(clp, timeparms,

					      RPC_AUTH_GSS_KRB5I);

	if (error == -EINVAL)

		error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX);

	if (error < 0)
@@ -409,13 +414,11 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp, 
	error = nfs4_discover_server_trunking(clp, &old);

	if (error < 0)

		goto error;

	nfs_put_client(clp);

	if (clp != old) {

		clp->cl_preserve_clid = true;

		clp = old;

	}



	return clp;

	if (clp != old)

		clp->cl_preserve_clid = true;

	nfs_put_client(clp);

	return old;



error:

	nfs_mark_client_ready(clp, error);
@@ -493,9 +496,10 @@ int nfs40_walk_client_list(struct nfs_client *new, 
			prev = pos;



			status = nfs_wait_client_init_complete(pos);

			spin_lock(&nn->nfs_client_lock);

			if (status < 0)

				continue;

				goto out;

			status = -NFS4ERR_STALE_CLIENTID;

			spin_lock(&nn->nfs_client_lock);

		}

		if (pos->cl_cons_state != NFS_CS_READY)

			continue;
@@ -633,7 +637,8 @@ int nfs41_walk_client_list(struct nfs_client *new, 
			}

			spin_lock(&nn->nfs_client_lock);

			if (status < 0)

				continue;

				break;

			status = -NFS4ERR_STALE_CLIENTID;

		}

		if (pos->cl_cons_state != NFS_CS_READY)

			continue;