Merge tag 'nfs-for-3.14-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs (2b2b15c3) · Commits · 戴 / test

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 @@ out:
		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 @@ out:
		* 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 @@ out:
		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;

Admin message