Commit 96890bc2 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

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

  Features:

   - Multiple patches to add support for fcntl() leases over NFSv4.

   - A sysfs interface to display more information about the various
     transport connections used by the RPC client

   - A sysfs interface to allow a suitably privileged user to offline a
     transport that may no longer point to a valid server

   - A sysfs interface to allow a suitably privileged user to change the
     server IP address used by the RPC client

  Stable fixes:

   - Two sunrpc fixes for deadlocks involving privileged rpc_wait_queues

  Bugfixes:

   - SUNRPC: Avoid a KASAN slab-out-of-bounds bug in xdr_set_page_base()

   - SUNRPC: prevent port reuse on transports which don't request it.

   - NFSv3: Fix memory leak in posix_acl_create()

   - NFS: Various fixes to attribute revalidation timeouts

   - NFSv4: Fix handling of non-atomic change attribute updates

   - NFSv4: If a server is down, don't cause mounts to other servers to
     hang as well

   - pNFS: Fix an Oops in pnfs_mark_request_commit() when doing O_DIRECT

   - NFS: Fix mount failures due to incorrect setting of the
     has_sec_mnt_opts filesystem flag

   - NFS: Ensure nfs_readpage returns promptly when an internal error
     occurs

   - NFS: Fix fscache read from NFS after cache error

   - pNFS: Various bugfixes around the LAYOUTGET operation"

* tag 'nfs-for-5.14-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (46 commits)
  NFSv4/pNFS: Return an error if _nfs4_pnfs_v3_ds_connect can't load NFSv3
  NFSv4/pNFS: Don't call _nfs4_pnfs_v3_ds_connect multiple times
  NFSv4/pnfs: Clean up layout get on open
  NFSv4/pnfs: Fix layoutget behaviour after invalidation
  NFSv4/pnfs: Fix the layout barrier update
  NFS: Fix fscache read from NFS after cache error
  NFS: Ensure nfs_readpage returns promptly when internal error occurs
  sunrpc: remove an offlined xprt using sysfs
  sunrpc: provide showing transport's state info in the sysfs directory
  sunrpc: display xprt's queuelen of assigned tasks via sysfs
  sunrpc: provide multipath info in the sysfs directory
  NFSv4.1 identify and mark RPC tasks that can move between transports
  sunrpc: provide transport info in the sysfs directory
  SUNRPC: take a xprt offline using sysfs
  sunrpc: add dst_attr attributes to the sysfs xprt directory
  SUNRPC for TCP display xprt's source port in sysfs xprt_info
  SUNRPC query transport's source port
  SUNRPC display xprt's main value in sysfs's xprt_info
  SUNRPC mark the first transport
  sunrpc: add add sysfs directory per xprt under each xprt_switch
  ...
parents 227c4d50 878b3dfc

fs/nfs/delegation.c

+73 −21
Original line number Diff line number Diff line
@@ -75,6 +75,13 @@ void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) 
	set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);

}



static void nfs_mark_return_delegation(struct nfs_server *server,

				       struct nfs_delegation *delegation)

{

	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);

	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);

}



static bool

nfs4_is_valid_delegation(const struct nfs_delegation *delegation,

		fmode_t flags)
@@ -293,6 +300,7 @@ nfs_start_delegation_return_locked(struct nfs_inode *nfsi) 
		goto out;

	spin_lock(&delegation->lock);

	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {

		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);

		/* Refcount matched in nfs_end_delegation_return() */

		ret = nfs_get_delegation(delegation);

	}
@@ -314,16 +322,17 @@ nfs_start_delegation_return(struct nfs_inode *nfsi) 
	return delegation;

}



static void

nfs_abort_delegation_return(struct nfs_delegation *delegation,

		struct nfs_client *clp)

static void nfs_abort_delegation_return(struct nfs_delegation *delegation,

					struct nfs_client *clp, int err)

{



	spin_lock(&delegation->lock);

	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);

	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);

	if (err == -EAGAIN) {

		set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);

		set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state);

	}

	spin_unlock(&delegation->lock);

	set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);

}



static struct nfs_delegation *
@@ -521,11 +530,18 @@ int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred, 
static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)

{

	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;

	unsigned int mode = O_WRONLY | O_RDWR;

	int err = 0;



	if (delegation == NULL)

		return 0;

	do {



	if (!issync)

		mode |= O_NONBLOCK;

	/* Recall of any remaining application leases */

	err = break_lease(inode, mode);



	while (err == 0) {

		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))

			break;

		err = nfs_delegation_claim_opens(inode, &delegation->stateid,
@@ -536,10 +552,10 @@ static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation 
		 * Guard against state recovery

		 */

		err = nfs4_wait_clnt_recover(clp);

	} while (err == 0);

	}



	if (err) {

		nfs_abort_delegation_return(delegation, clp);

		nfs_abort_delegation_return(delegation, clp, err);

		goto out;

	}
@@ -568,6 +584,7 @@ static bool nfs_delegation_need_return(struct nfs_delegation *delegation) 
	if (ret)

		clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);

	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) ||

	    test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) ||

	    test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))

		ret = false;
@@ -647,6 +664,38 @@ static int nfs_server_return_marked_delegations(struct nfs_server *server, 
	return err;

}



static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)

{

	struct nfs_delegation *d;

	bool ret = false;



	list_for_each_entry_rcu (d, &server->delegations, super_list) {

		if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))

			continue;

		nfs_mark_return_delegation(server, d);

		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags);

		ret = true;

	}

	return ret;

}



static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)

{

	struct nfs_server *server;

	bool ret = false;



	if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state))

		goto out;

	rcu_read_lock();

	list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {

		if (nfs_server_clear_delayed_delegations(server))

			ret = true;

	}

	rcu_read_unlock();

out:

	return ret;

}



/**

 * nfs_client_return_marked_delegations - return previously marked delegations

 * @clp: nfs_client to process
@@ -659,8 +708,14 @@ static int nfs_server_return_marked_delegations(struct nfs_server *server, 
 */

int nfs_client_return_marked_delegations(struct nfs_client *clp)

{

	return nfs_client_for_each_server(clp,

			nfs_server_return_marked_delegations, NULL);

	int err = nfs_client_for_each_server(

		clp, nfs_server_return_marked_delegations, NULL);

	if (err)

		return err;

	/* If a return was delayed, sleep to prevent hard looping */

	if (nfs_client_clear_delayed_delegations(clp))

		ssleep(1);

	return 0;

}



/**
@@ -698,13 +753,14 @@ int nfs4_inode_return_delegation(struct inode *inode) 
{

	struct nfs_inode *nfsi = NFS_I(inode);

	struct nfs_delegation *delegation;

	int err = 0;



	nfs_wb_all(inode);

	delegation = nfs_start_delegation_return(nfsi);

	/* Synchronous recall of any application leases */

	break_lease(inode, O_WRONLY | O_RDWR);

	nfs_wb_all(inode);

	if (delegation != NULL)

		err = nfs_end_delegation_return(inode, delegation, 1);

	return err;

		return nfs_end_delegation_return(inode, delegation, 1);

	return 0;

}



/**
@@ -775,13 +831,6 @@ static void nfs_mark_return_if_closed_delegation(struct nfs_server *server, 
	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);

}



static void nfs_mark_return_delegation(struct nfs_server *server,

		struct nfs_delegation *delegation)

{

	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);

	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);

}



static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)

{

	struct nfs_delegation *delegation;
@@ -1010,6 +1059,9 @@ int nfs_async_inode_return_delegation(struct inode *inode, 
	nfs_mark_return_delegation(server, delegation);

	rcu_read_unlock();



	/* If there are any application leases or delegations, recall them */

	break_lease(inode, O_WRONLY | O_RDWR | O_NONBLOCK);



	nfs_delegation_run_state_manager(clp);

	return 0;

out_enoent:

fs/nfs/delegation.h

+1 −0
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ enum { 
	NFS_DELEGATION_REVOKED,

	NFS_DELEGATION_TEST_EXPIRED,

	NFS_DELEGATION_INODE_FREEING,

	NFS_DELEGATION_RETURN_DELAYED,

};



int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,

fs/nfs/direct.c

+7 −10
Original line number Diff line number Diff line
@@ -700,8 +700,8 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) 
{

	struct nfs_direct_req *dreq = hdr->dreq;

	struct nfs_commit_info cinfo;

	bool request_commit = false;

	struct nfs_page *req = nfs_list_entry(hdr->pages.next);

	int flags = NFS_ODIRECT_DONE;



	nfs_init_cinfo_from_dreq(&cinfo, dreq);
@@ -713,15 +713,9 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) 


	nfs_direct_count_bytes(dreq, hdr);

	if (hdr->good_bytes != 0 && nfs_write_need_commit(hdr)) {

		switch (dreq->flags) {

		case 0:

		if (!dreq->flags)

			dreq->flags = NFS_ODIRECT_DO_COMMIT;

			request_commit = true;

			break;

		case NFS_ODIRECT_RESCHED_WRITES:

		case NFS_ODIRECT_DO_COMMIT:

			request_commit = true;

		}

		flags = dreq->flags;

	}

	spin_unlock(&dreq->lock);
@@ -729,12 +723,15 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) 


		req = nfs_list_entry(hdr->pages.next);

		nfs_list_remove_request(req);

		if (request_commit) {

		if (flags == NFS_ODIRECT_DO_COMMIT) {

			kref_get(&req->wb_kref);

			memcpy(&req->wb_verf, &hdr->verf.verifier,

			       sizeof(req->wb_verf));

			nfs_mark_request_commit(req, hdr->lseg, &cinfo,

				hdr->ds_commit_idx);

		} else if (flags == NFS_ODIRECT_RESCHED_WRITES) {

			kref_get(&req->wb_kref);

			nfs_mark_request_commit(req, NULL, &cinfo, 0);

		}

		nfs_unlock_and_release_request(req);

	}

fs/nfs/fscache.c

+13 −5
Original line number Diff line number Diff line
@@ -385,13 +385,16 @@ static void nfs_readpage_from_fscache_complete(struct page *page, 
		 "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n",

		 page, context, error);



	/* if the read completes with an error, we just unlock the page and let

	 * the VM reissue the readpage */

	if (!error) {

	/*

	 * If the read completes with an error, mark the page with PG_checked,

	 * unlock the page, and let the VM reissue the readpage.

	 */

	if (!error)

		SetPageUptodate(page);

	else

		SetPageChecked(page);

	unlock_page(page);

}

}



/*

 * Retrieve a page from fscache
@@ -405,6 +408,11 @@ int __nfs_readpage_from_fscache(struct nfs_open_context *ctx, 
		 "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n",

		 nfs_i_fscache(inode), page, page->index, page->flags, inode);



	if (PageChecked(page)) {

		ClearPageChecked(page);

		return 1;

	}



	ret = fscache_read_or_alloc_page(nfs_i_fscache(inode),

					 page,

					 nfs_readpage_from_fscache_complete,

fs/nfs/getroot.c

+8 −4
Original line number Diff line number Diff line
@@ -67,7 +67,7 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i 
int nfs_get_root(struct super_block *s, struct fs_context *fc)

{

	struct nfs_fs_context *ctx = nfs_fc2context(fc);

	struct nfs_server *server = NFS_SB(s);

	struct nfs_server *server = NFS_SB(s), *clone_server;

	struct nfs_fsinfo fsinfo;

	struct dentry *root;

	struct inode *inode;
@@ -127,7 +127,7 @@ int nfs_get_root(struct super_block *s, struct fs_context *fc) 
	}

	spin_unlock(&root->d_lock);

	fc->root = root;

	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)

	if (server->caps & NFS_CAP_SECURITY_LABEL)

		kflags |= SECURITY_LSM_NATIVE_LABELS;

	if (ctx->clone_data.sb) {

		if (d_inode(fc->root)->i_fop != &nfs_dir_operations) {
@@ -137,15 +137,19 @@ int nfs_get_root(struct super_block *s, struct fs_context *fc) 
		/* clone lsm security options from the parent to the new sb */

		error = security_sb_clone_mnt_opts(ctx->clone_data.sb,

						   s, kflags, &kflags_out);

		if (error)

			goto error_splat_root;

		clone_server = NFS_SB(ctx->clone_data.sb);

		server->has_sec_mnt_opts = clone_server->has_sec_mnt_opts;

	} else {

		error = security_sb_set_mnt_opts(s, fc->security,

							kflags, &kflags_out);

	}

	if (error)

		goto error_splat_root;

	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&

	if (server->caps & NFS_CAP_SECURITY_LABEL &&

		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))

		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;

		server->caps &= ~NFS_CAP_SECURITY_LABEL;



	nfs_setsecurity(inode, fsinfo.fattr, fsinfo.fattr->label);

	error = 0;