From e5dde38f606215ae62fabe738aaeb3557de2a13c Mon Sep 17 00:00:00 2001 From: Chuck Lever Date: Sat, 16 Mar 2013 15:54:16 -0400 Subject: [PATCH] --- yaml --- r: 367318 b: refs/heads/master c: 71afa85e798ebc81054164c947b189d163c92b30 h: refs/heads/master v: v3 --- [refs] | 2 +- trunk/fs/lockd/clntlock.c | 3 - trunk/fs/lockd/clntproc.c | 3 + trunk/fs/nfs/callback.c | 3 - trunk/fs/nfs/callback_proc.c | 2 +- trunk/fs/nfs/client.c | 2 - trunk/fs/nfs/delegation.c | 121 +++++--------- trunk/fs/nfs/delegation.h | 5 +- trunk/fs/nfs/file.c | 9 -- trunk/fs/nfs/inode.c | 1 - trunk/fs/nfs/internal.h | 7 - trunk/fs/nfs/nfs4_fs.h | 1 - trunk/fs/nfs/nfs4client.c | 2 - trunk/fs/nfs/nfs4proc.c | 225 ++++++++++++++------------- trunk/fs/nfs/nfs4state.c | 10 +- trunk/fs/nfs/nfs4xdr.c | 43 ++--- trunk/fs/nfs/pagelist.c | 51 ------ trunk/include/linux/nfs_fs.h | 7 - trunk/include/linux/nfs_fs_sb.h | 1 - trunk/include/linux/nfs_xdr.h | 1 - trunk/include/linux/sunrpc/clnt.h | 1 - trunk/include/linux/sunrpc/xprt.h | 5 - trunk/net/sunrpc/Kconfig | 1 + trunk/net/sunrpc/auth_gss/auth_gss.c | 1 + trunk/net/sunrpc/clnt.c | 19 +-- trunk/net/sunrpc/xprt.c | 61 +------- trunk/net/sunrpc/xprtsock.c | 6 +- 27 files changed, 192 insertions(+), 401 deletions(-) diff --git a/[refs] b/[refs] index d808f0aa1e91..c6652945be7c 100644 --- a/[refs] +++ b/[refs] @@ -1,2 +1,2 @@ --- -refs/heads/master: bdeca1b76cd56cd10a029f0ad2fd9ab6dd7e313d +refs/heads/master: 71afa85e798ebc81054164c947b189d163c92b30 diff --git a/trunk/fs/lockd/clntlock.c b/trunk/fs/lockd/clntlock.c index 01bfe7662751..0796c45d0d4d 100644 --- a/trunk/fs/lockd/clntlock.c +++ b/trunk/fs/lockd/clntlock.c @@ -144,9 +144,6 @@ int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout) timeout); if (ret < 0) return -ERESTARTSYS; - /* Reset the lock status after a server reboot so we resend */ - if (block->b_status == nlm_lck_denied_grace_period) - block->b_status = nlm_lck_blocked; req->a_res.status = block->b_status; return 0; } diff --git a/trunk/fs/lockd/clntproc.c b/trunk/fs/lockd/clntproc.c index 9760ecb9b60f..7e529c3c45c0 100644 --- a/trunk/fs/lockd/clntproc.c +++ b/trunk/fs/lockd/clntproc.c @@ -550,6 +550,9 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT); if (status < 0) break; + /* Resend the blocking lock request after a server reboot */ + if (resp->status == nlm_lck_denied_grace_period) + continue; if (resp->status != nlm_lck_blocked) break; } diff --git a/trunk/fs/nfs/callback.c b/trunk/fs/nfs/callback.c index cff089a412c7..5088b57b078a 100644 --- a/trunk/fs/nfs/callback.c +++ b/trunk/fs/nfs/callback.c @@ -125,9 +125,6 @@ nfs41_callback_svc(void *vrqstp) set_freezable(); while (!kthread_should_stop()) { - if (try_to_freeze()) - continue; - prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE); spin_lock_bh(&serv->sv_cb_lock); if (!list_empty(&serv->sv_cb_list)) { diff --git a/trunk/fs/nfs/callback_proc.c b/trunk/fs/nfs/callback_proc.c index a13d26ede254..2960512792c2 100644 --- a/trunk/fs/nfs/callback_proc.c +++ b/trunk/fs/nfs/callback_proc.c @@ -500,7 +500,7 @@ __be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy, &args->craa_type_mask)) pnfs_recall_all_layouts(cps->clp); if (flags) - nfs_expire_unused_delegation_types(cps->clp, flags); + nfs_expire_all_delegation_types(cps->clp, flags); out: dprintk("%s: exit with status = %d\n", __func__, ntohl(status)); return status; diff --git a/trunk/fs/nfs/client.c b/trunk/fs/nfs/client.c index c513b0cc835f..84d8eae203a7 100644 --- a/trunk/fs/nfs/client.c +++ b/trunk/fs/nfs/client.c @@ -593,8 +593,6 @@ int nfs_create_rpc_client(struct nfs_client *clp, args.flags |= RPC_CLNT_CREATE_DISCRTRY; if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags)) args.flags |= RPC_CLNT_CREATE_NONPRIVPORT; - if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags)) - args.flags |= RPC_CLNT_CREATE_INFINITE_SLOTS; if (!IS_ERR(clp->cl_rpcclient)) return 0; diff --git a/trunk/fs/nfs/delegation.c b/trunk/fs/nfs/delegation.c index 57db3244f4d9..6390a4b5fee7 100644 --- a/trunk/fs/nfs/delegation.c +++ b/trunk/fs/nfs/delegation.c @@ -64,15 +64,17 @@ int nfs4_have_delegation(struct inode *inode, fmode_t flags) return ret; } -static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) +static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state) { struct inode *inode = state->inode; struct file_lock *fl; int status = 0; if (inode->i_flock == NULL) - goto out; + return 0; + if (inode->i_flock == NULL) + goto out; /* Protect inode->i_flock using the file locks lock */ lock_flocks(); for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) { @@ -81,7 +83,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_ if (nfs_file_open_context(fl->fl_file) != ctx) continue; unlock_flocks(); - status = nfs4_lock_delegation_recall(fl, state, stateid); + status = nfs4_lock_delegation_recall(state, fl); if (status < 0) goto out; lock_flocks(); @@ -118,7 +120,7 @@ static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *s seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); err = nfs4_open_delegation_recall(ctx, state, stateid); if (!err) - err = nfs_delegation_claim_locks(ctx, state, stateid); + err = nfs_delegation_claim_locks(ctx, state); if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) err = -EAGAIN; mutex_unlock(&sp->so_delegreturn_mutex); @@ -387,24 +389,6 @@ static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation return err; } -static bool nfs_delegation_need_return(struct nfs_delegation *delegation) -{ - bool ret = false; - - if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags)) - ret = true; - if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) { - struct inode *inode; - - spin_lock(&delegation->lock); - inode = delegation->inode; - if (inode && list_empty(&NFS_I(inode)->open_files)) - ret = true; - spin_unlock(&delegation->lock); - } - return ret; -} - /** * nfs_client_return_marked_delegations - return previously marked delegations * @clp: nfs_client to process @@ -427,7 +411,8 @@ int nfs_client_return_marked_delegations(struct nfs_client *clp) list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { list_for_each_entry_rcu(delegation, &server->delegations, super_list) { - if (!nfs_delegation_need_return(delegation)) + if (!test_and_clear_bit(NFS_DELEGATION_RETURN, + &delegation->flags)) continue; inode = nfs_delegation_grab_inode(delegation); if (inode == NULL) @@ -486,13 +471,6 @@ int nfs4_inode_return_delegation(struct inode *inode) return err; } -static void nfs_mark_return_if_closed_delegation(struct nfs_server *server, - struct nfs_delegation *delegation) -{ - set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); - set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); -} - static void nfs_mark_return_delegation(struct nfs_server *server, struct nfs_delegation *delegation) { @@ -500,45 +478,6 @@ static void nfs_mark_return_delegation(struct nfs_server *server, 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; - bool ret = false; - - list_for_each_entry_rcu(delegation, &server->delegations, super_list) { - nfs_mark_return_delegation(server, delegation); - ret = true; - } - return ret; -} - -static void nfs_client_mark_return_all_delegations(struct nfs_client *clp) -{ - struct nfs_server *server; - - rcu_read_lock(); - list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) - nfs_server_mark_return_all_delegations(server); - rcu_read_unlock(); -} - -static void nfs_delegation_run_state_manager(struct nfs_client *clp) -{ - if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) - nfs4_schedule_state_manager(clp); -} - -/** - * nfs_expire_all_delegations - * @clp: client to process - * - */ -void nfs_expire_all_delegations(struct nfs_client *clp) -{ - nfs_client_mark_return_all_delegations(clp); - nfs_delegation_run_state_manager(clp); -} - /** * nfs_super_return_all_delegations - return delegations for one superblock * @sb: sb to process @@ -547,22 +486,24 @@ void nfs_expire_all_delegations(struct nfs_client *clp) void nfs_server_return_all_delegations(struct nfs_server *server) { struct nfs_client *clp = server->nfs_client; - bool need_wait; + struct nfs_delegation *delegation; if (clp == NULL) return; rcu_read_lock(); - need_wait = nfs_server_mark_return_all_delegations(server); + list_for_each_entry_rcu(delegation, &server->delegations, super_list) { + spin_lock(&delegation->lock); + set_bit(NFS_DELEGATION_RETURN, &delegation->flags); + spin_unlock(&delegation->lock); + } rcu_read_unlock(); - if (need_wait) { + if (nfs_client_return_marked_delegations(clp) != 0) nfs4_schedule_state_manager(clp); - nfs4_wait_clnt_recover(clp); - } } -static void nfs_mark_return_unused_delegation_types(struct nfs_server *server, +static void nfs_mark_return_all_delegation_types(struct nfs_server *server, fmode_t flags) { struct nfs_delegation *delegation; @@ -571,21 +512,27 @@ static void nfs_mark_return_unused_delegation_types(struct nfs_server *server, if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE)) continue; if (delegation->type & flags) - nfs_mark_return_if_closed_delegation(server, delegation); + nfs_mark_return_delegation(server, delegation); } } -static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp, +static void nfs_client_mark_return_all_delegation_types(struct nfs_client *clp, fmode_t flags) { struct nfs_server *server; rcu_read_lock(); list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) - nfs_mark_return_unused_delegation_types(server, flags); + nfs_mark_return_all_delegation_types(server, flags); rcu_read_unlock(); } +static void nfs_delegation_run_state_manager(struct nfs_client *clp) +{ + if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) + nfs4_schedule_state_manager(clp); +} + void nfs_remove_bad_delegation(struct inode *inode) { struct nfs_delegation *delegation; @@ -599,17 +546,27 @@ void nfs_remove_bad_delegation(struct inode *inode) EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation); /** - * nfs_expire_unused_delegation_types + * nfs_expire_all_delegation_types * @clp: client to process * @flags: delegation types to expire * */ -void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags) +void nfs_expire_all_delegation_types(struct nfs_client *clp, fmode_t flags) { - nfs_client_mark_return_unused_delegation_types(clp, flags); + nfs_client_mark_return_all_delegation_types(clp, flags); nfs_delegation_run_state_manager(clp); } +/** + * nfs_expire_all_delegations + * @clp: client to process + * + */ +void nfs_expire_all_delegations(struct nfs_client *clp) +{ + nfs_expire_all_delegation_types(clp, FMODE_READ|FMODE_WRITE); +} + static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server) { struct nfs_delegation *delegation; @@ -617,7 +574,7 @@ static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server) list_for_each_entry_rcu(delegation, &server->delegations, super_list) { if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags)) continue; - nfs_mark_return_if_closed_delegation(server, delegation); + nfs_mark_return_delegation(server, delegation); } } diff --git a/trunk/fs/nfs/delegation.h b/trunk/fs/nfs/delegation.h index 9a79c7a99d6d..d54d4fca6793 100644 --- a/trunk/fs/nfs/delegation.h +++ b/trunk/fs/nfs/delegation.h @@ -28,7 +28,6 @@ struct nfs_delegation { enum { NFS_DELEGATION_NEED_RECLAIM = 0, NFS_DELEGATION_RETURN, - NFS_DELEGATION_RETURN_IF_CLOSED, NFS_DELEGATION_REFERENCED, NFS_DELEGATION_RETURNING, }; @@ -42,7 +41,7 @@ void nfs_inode_return_delegation_noreclaim(struct inode *inode); struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs_fh *fhandle); void nfs_server_return_all_delegations(struct nfs_server *); void nfs_expire_all_delegations(struct nfs_client *clp); -void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags); +void nfs_expire_all_delegation_types(struct nfs_client *clp, fmode_t flags); void nfs_expire_unreferenced_delegations(struct nfs_client *clp); int nfs_client_return_marked_delegations(struct nfs_client *clp); int nfs_delegations_present(struct nfs_client *clp); @@ -54,7 +53,7 @@ void nfs_delegation_reap_unclaimed(struct nfs_client *clp); /* NFSv4 delegation-related procedures */ int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync); int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid); -int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid); +int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl); bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode, fmode_t flags); void nfs_mark_delegation_referenced(struct nfs_delegation *delegation); diff --git a/trunk/fs/nfs/file.c b/trunk/fs/nfs/file.c index a87a44f84113..29f4a48a0ee6 100644 --- a/trunk/fs/nfs/file.c +++ b/trunk/fs/nfs/file.c @@ -744,7 +744,6 @@ static int do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) { struct inode *inode = filp->f_mapping->host; - struct nfs_lock_context *l_ctx; int status; /* @@ -753,14 +752,6 @@ do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local) */ nfs_sync_mapping(filp->f_mapping); - l_ctx = nfs_get_lock_context(nfs_file_open_context(filp)); - if (!IS_ERR(l_ctx)) { - status = nfs_iocounter_wait(&l_ctx->io_count); - nfs_put_lock_context(l_ctx); - if (status < 0) - return status; - } - /* NOTE: special case * If we're signalled while cleaning up locks on process exit, we * still need to complete the unlock. diff --git a/trunk/fs/nfs/inode.c b/trunk/fs/nfs/inode.c index c1c7a9d78722..55b840f05ab2 100644 --- a/trunk/fs/nfs/inode.c +++ b/trunk/fs/nfs/inode.c @@ -561,7 +561,6 @@ static void nfs_init_lock_context(struct nfs_lock_context *l_ctx) l_ctx->lockowner.l_owner = current->files; l_ctx->lockowner.l_pid = current->tgid; INIT_LIST_HEAD(&l_ctx->list); - nfs_iocounter_init(&l_ctx->io_count); } static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx) diff --git a/trunk/fs/nfs/internal.h b/trunk/fs/nfs/internal.h index 91e59a39fc08..541c9ebdbc5a 100644 --- a/trunk/fs/nfs/internal.h +++ b/trunk/fs/nfs/internal.h @@ -229,13 +229,6 @@ extern void nfs_pgheader_init(struct nfs_pageio_descriptor *desc, struct nfs_pgio_header *hdr, void (*release)(struct nfs_pgio_header *hdr)); void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos); -int nfs_iocounter_wait(struct nfs_io_counter *c); - -static inline void nfs_iocounter_init(struct nfs_io_counter *c) -{ - c->flags = 0; - atomic_set(&c->io_count, 0); -} /* nfs2xdr.c */ extern struct rpc_procinfo nfs_procedures[]; diff --git a/trunk/fs/nfs/nfs4_fs.h b/trunk/fs/nfs/nfs4_fs.h index 553a83cc4106..7ef19ce6d832 100644 --- a/trunk/fs/nfs/nfs4_fs.h +++ b/trunk/fs/nfs/nfs4_fs.h @@ -144,7 +144,6 @@ struct nfs4_lock_state { enum { LK_STATE_IN_USE, NFS_DELEGATED_STATE, /* Current stateid is delegation */ - NFS_OPEN_STATE, /* OPEN stateid is set */ NFS_O_RDONLY_STATE, /* OPEN stateid has read-only state */ NFS_O_WRONLY_STATE, /* OPEN stateid has write-only state */ NFS_O_RDWR_STATE, /* OPEN stateid has read/write state */ diff --git a/trunk/fs/nfs/nfs4client.c b/trunk/fs/nfs/nfs4client.c index f4d4d4ec6bf7..17b34b2da2df 100644 --- a/trunk/fs/nfs/nfs4client.c +++ b/trunk/fs/nfs/nfs4client.c @@ -198,8 +198,6 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp, /* Check NFS protocol revision and initialize RPC op vector */ clp->rpc_ops = &nfs_v4_clientops; - if (clp->cl_minorversion != 0) - __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); error = nfs_create_rpc_client(clp, timeparms, authflavour); if (error < 0) diff --git a/trunk/fs/nfs/nfs4proc.c b/trunk/fs/nfs/nfs4proc.c index e18b3b46c001..81343944e096 100644 --- a/trunk/fs/nfs/nfs4proc.c +++ b/trunk/fs/nfs/nfs4proc.c @@ -304,13 +304,9 @@ static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struc case -NFS4ERR_DELEG_REVOKED: case -NFS4ERR_ADMIN_REVOKED: case -NFS4ERR_BAD_STATEID: - if (inode != NULL && nfs4_have_delegation(inode, FMODE_READ)) { - nfs_remove_bad_delegation(inode); - exception->retry = 1; - break; - } if (state == NULL) break; + nfs_remove_bad_delegation(state->inode); ret = nfs4_schedule_stateid_recovery(server, state); if (ret < 0) break; @@ -769,7 +765,6 @@ struct nfs4_opendata { struct iattr attrs; unsigned long timestamp; unsigned int rpc_done : 1; - unsigned int is_recover : 1; int rpc_status; int cancelled; }; @@ -979,7 +974,6 @@ static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid * if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) nfs4_stateid_copy(&state->stateid, stateid); nfs4_stateid_copy(&state->open_stateid, stateid); - set_bit(NFS_OPEN_STATE, &state->flags); switch (fmode) { case FMODE_READ: set_bit(NFS_O_RDONLY_STATE, &state->flags); @@ -1102,11 +1096,9 @@ static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata) /* Save the delegation */ nfs4_stateid_copy(&stateid, &delegation->stateid); rcu_read_unlock(); - if (!opendata->is_recover) { - ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); - if (ret != 0) - goto out; - } + ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); + if (ret != 0) + goto out; ret = -EAGAIN; /* Try to update the stateid using the delegation */ @@ -1293,7 +1285,6 @@ static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state * /* memory barrier prior to reading state->n_* */ clear_bit(NFS_DELEGATED_STATE, &state->flags); - clear_bit(NFS_OPEN_STATE, &state->flags); smp_rmb(); if (state->n_rdwr != 0) { clear_bit(NFS_O_RDWR_STATE, &state->flags); @@ -1388,66 +1379,65 @@ static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *sta return ret; } -static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err) -{ - switch (err) { - default: - printk(KERN_ERR "NFS: %s: unhandled error " - "%d.\n", __func__, err); - case 0: - case -ENOENT: - case -ESTALE: - break; - case -NFS4ERR_BADSESSION: - case -NFS4ERR_BADSLOT: - case -NFS4ERR_BAD_HIGH_SLOT: - case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: - case -NFS4ERR_DEADSESSION: - set_bit(NFS_DELEGATED_STATE, &state->flags); - nfs4_schedule_session_recovery(server->nfs_client->cl_session, err); - return -EAGAIN; - case -NFS4ERR_STALE_CLIENTID: - case -NFS4ERR_STALE_STATEID: - set_bit(NFS_DELEGATED_STATE, &state->flags); - case -NFS4ERR_EXPIRED: - /* Don't recall a delegation if it was lost */ - nfs4_schedule_lease_recovery(server->nfs_client); - return -EAGAIN; - case -NFS4ERR_DELEG_REVOKED: - case -NFS4ERR_ADMIN_REVOKED: - case -NFS4ERR_BAD_STATEID: - case -NFS4ERR_OPENMODE: - nfs_inode_find_state_and_recover(state->inode, - stateid); - nfs4_schedule_stateid_recovery(server, state); - return 0; - case -NFS4ERR_DELAY: - case -NFS4ERR_GRACE: - set_bit(NFS_DELEGATED_STATE, &state->flags); - ssleep(1); - return -EAGAIN; - case -ENOMEM: - case -NFS4ERR_DENIED: - /* kill_proc(fl->fl_pid, SIGLOST, 1); */ - return 0; - } - return err; -} - -int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) +static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) { - struct nfs_server *server = NFS_SERVER(state->inode); struct nfs4_opendata *opendata; - int err; + int ret; opendata = nfs4_open_recoverdata_alloc(ctx, state, NFS4_OPEN_CLAIM_DELEG_CUR_FH); if (IS_ERR(opendata)) return PTR_ERR(opendata); nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid); - err = nfs4_open_recover(opendata, state); + ret = nfs4_open_recover(opendata, state); nfs4_opendata_put(opendata); - return nfs4_handle_delegation_recall_error(server, state, stateid, err); + return ret; +} + +int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid) +{ + struct nfs4_exception exception = { }; + struct nfs_server *server = NFS_SERVER(state->inode); + int err; + do { + err = _nfs4_open_delegation_recall(ctx, state, stateid); + switch (err) { + case 0: + case -ENOENT: + case -ESTALE: + goto out; + case -NFS4ERR_BADSESSION: + case -NFS4ERR_BADSLOT: + case -NFS4ERR_BAD_HIGH_SLOT: + case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: + case -NFS4ERR_DEADSESSION: + set_bit(NFS_DELEGATED_STATE, &state->flags); + nfs4_schedule_session_recovery(server->nfs_client->cl_session, err); + err = -EAGAIN; + goto out; + case -NFS4ERR_STALE_CLIENTID: + case -NFS4ERR_STALE_STATEID: + set_bit(NFS_DELEGATED_STATE, &state->flags); + case -NFS4ERR_EXPIRED: + /* Don't recall a delegation if it was lost */ + nfs4_schedule_lease_recovery(server->nfs_client); + err = -EAGAIN; + goto out; + case -NFS4ERR_DELEG_REVOKED: + case -NFS4ERR_ADMIN_REVOKED: + case -NFS4ERR_BAD_STATEID: + nfs_inode_find_state_and_recover(state->inode, + stateid); + nfs4_schedule_stateid_recovery(server, state); + case -ENOMEM: + err = 0; + goto out; + } + set_bit(NFS_DELEGATED_STATE, &state->flags); + err = nfs4_handle_exception(server, err, &exception); + } while (exception.retry); +out: + return err; } static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata) @@ -1530,7 +1520,6 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata) { struct nfs4_opendata *data = calldata; struct nfs4_state_owner *sp = data->owner; - struct nfs_client *clp = sp->so_server->nfs_client; if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) goto out_wait; @@ -1546,20 +1535,15 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata) rcu_read_lock(); delegation = rcu_dereference(NFS_I(data->state->inode)->delegation); if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR && - data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH && can_open_delegated(delegation, data->o_arg.fmode)) goto unlock_no_action; rcu_read_unlock(); } /* Update client id. */ - data->o_arg.clientid = clp->cl_clientid; - switch (data->o_arg.claim) { - case NFS4_OPEN_CLAIM_PREVIOUS: - case NFS4_OPEN_CLAIM_DELEG_CUR_FH: - case NFS4_OPEN_CLAIM_DELEG_PREV_FH: - data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; - case NFS4_OPEN_CLAIM_FH: + data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid; + if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; + data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; nfs_copy_fh(&data->o_res.fh, data->o_arg.fh); } data->timestamp = jiffies; @@ -1568,16 +1552,6 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata) &data->o_res.seq_res, task) != 0) nfs_release_seqid(data->o_arg.seqid); - - /* Set the create mode (note dependency on the session type) */ - data->o_arg.createmode = NFS4_CREATE_UNCHECKED; - if (data->o_arg.open_flags & O_EXCL) { - data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE; - if (nfs4_has_persistent_session(clp)) - data->o_arg.createmode = NFS4_CREATE_GUARDED; - else if (clp->cl_mvops->minor_version > 0) - data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1; - } return; unlock_no_action: rcu_read_unlock(); @@ -1673,11 +1647,8 @@ static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) data->rpc_done = 0; data->rpc_status = 0; data->cancelled = 0; - data->is_recover = 0; - if (isrecover) { + if (isrecover) nfs4_set_sequence_privileged(&o_arg->seq_args); - data->is_recover = 1; - } task = rpc_run_task(&task_setup_data); if (IS_ERR(task)) return PTR_ERR(task); @@ -1905,7 +1876,6 @@ static int nfs41_check_open_stateid(struct nfs4_state *state) clear_bit(NFS_O_RDONLY_STATE, &state->flags); clear_bit(NFS_O_WRONLY_STATE, &state->flags); clear_bit(NFS_O_RDWR_STATE, &state->flags); - clear_bit(NFS_OPEN_STATE, &state->flags); } return status; } @@ -2025,8 +1995,7 @@ static int _nfs4_do_open(struct inode *dir, if (status != 0) goto err_opendata_put; - if ((opendata->o_arg.open_flags & O_EXCL) && - (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) { + if (opendata->o_arg.open_flags & O_EXCL) { nfs4_exclusive_attrset(opendata, sattr); nfs_fattr_init(opendata->o_res.f_attr); @@ -2221,19 +2190,11 @@ static void nfs4_close_clear_stateid_flags(struct nfs4_state *state, fmode_t fmode) { spin_lock(&state->owner->so_lock); - clear_bit(NFS_O_RDWR_STATE, &state->flags); - switch (fmode & (FMODE_READ|FMODE_WRITE)) { - case FMODE_WRITE: + if (!(fmode & FMODE_READ)) clear_bit(NFS_O_RDONLY_STATE, &state->flags); - break; - case FMODE_READ: + if (!(fmode & FMODE_WRITE)) clear_bit(NFS_O_WRONLY_STATE, &state->flags); - break; - case 0: - clear_bit(NFS_O_RDONLY_STATE, &state->flags); - clear_bit(NFS_O_WRONLY_STATE, &state->flags); - clear_bit(NFS_OPEN_STATE, &state->flags); - } + clear_bit(NFS_O_RDWR_STATE, &state->flags); spin_unlock(&state->owner->so_lock); } @@ -2313,10 +2274,8 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data) if (calldata->arg.fmode == 0) { task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; if (calldata->roc && - pnfs_roc_drain(inode, &calldata->roc_barrier, task)) { - nfs_release_seqid(calldata->arg.seqid); + pnfs_roc_drain(inode, &calldata->roc_barrier, task)) goto out_wait; - } } nfs_fattr_init(calldata->res.fattr); @@ -3837,7 +3796,7 @@ static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, return -ENOMEM; data->client = clp; data->timestamp = jiffies; - return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, + return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT, &nfs4_renew_ops, data); } @@ -3851,7 +3810,7 @@ static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred) unsigned long now = jiffies; int status; - status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); + status = rpc_call_sync(clp->cl_rpcclient, &msg, 0); if (status < 0) return status; do_renew_lease(clp, now); @@ -4814,7 +4773,7 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) { goto out_release_lock_seqid; } - data->arg.open_stateid = &state->open_stateid; + data->arg.open_stateid = &state->stateid; data->arg.new_lock_owner = 1; data->res.open_seqid = data->arg.open_seqid; } else @@ -5176,16 +5135,58 @@ nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request) return status; } -int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid) +int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl) { struct nfs_server *server = NFS_SERVER(state->inode); + struct nfs4_exception exception = { }; int err; err = nfs4_set_lock_state(state, fl); if (err != 0) - return err; - err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); - return nfs4_handle_delegation_recall_error(server, state, stateid, err); + goto out; + do { + err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); + switch (err) { + default: + printk(KERN_ERR "NFS: %s: unhandled error " + "%d.\n", __func__, err); + case 0: + case -ESTALE: + goto out; + case -NFS4ERR_STALE_CLIENTID: + case -NFS4ERR_STALE_STATEID: + set_bit(NFS_DELEGATED_STATE, &state->flags); + case -NFS4ERR_EXPIRED: + nfs4_schedule_lease_recovery(server->nfs_client); + err = -EAGAIN; + goto out; + case -NFS4ERR_BADSESSION: + case -NFS4ERR_BADSLOT: + case -NFS4ERR_BAD_HIGH_SLOT: + case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: + case -NFS4ERR_DEADSESSION: + set_bit(NFS_DELEGATED_STATE, &state->flags); + nfs4_schedule_session_recovery(server->nfs_client->cl_session, err); + err = -EAGAIN; + goto out; + case -NFS4ERR_DELEG_REVOKED: + case -NFS4ERR_ADMIN_REVOKED: + case -NFS4ERR_BAD_STATEID: + case -NFS4ERR_OPENMODE: + nfs4_schedule_stateid_recovery(server, state); + err = 0; + goto out; + case -ENOMEM: + case -NFS4ERR_DENIED: + /* kill_proc(fl->fl_pid, SIGLOST, 1); */ + err = 0; + goto out; + } + set_bit(NFS_DELEGATED_STATE, &state->flags); + err = nfs4_handle_exception(server, err, &exception); + } while (exception.retry); +out: + return err; } struct nfs_release_lockowner_data { @@ -5999,7 +6000,7 @@ static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, .rpc_client = clp->cl_rpcclient, .rpc_message = &msg, .callback_ops = &nfs41_sequence_ops, - .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT, + .flags = RPC_TASK_ASYNC | RPC_TASK_SOFT, }; if (!atomic_inc_not_zero(&clp->cl_count)) diff --git a/trunk/fs/nfs/nfs4state.c b/trunk/fs/nfs/nfs4state.c index b7796950eceb..b924bdd69494 100644 --- a/trunk/fs/nfs/nfs4state.c +++ b/trunk/fs/nfs/nfs4state.c @@ -1024,16 +1024,12 @@ static int nfs4_copy_lock_stateid(nfs4_stateid *dst, static int nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state) { - const nfs4_stateid *src; int ret; int seq; do { - src = &zero_stateid; seq = read_seqbegin(&state->seqlock); - if (test_bit(NFS_OPEN_STATE, &state->flags)) - src = &state->open_stateid; - nfs4_stateid_copy(dst, src); + nfs4_stateid_copy(dst, &state->stateid); ret = 0; smp_rmb(); if (!list_empty(&state->owner->so_seqid.list)) @@ -1743,10 +1739,6 @@ static int nfs4_check_lease(struct nfs_client *clp) } status = ops->renew_lease(clp, cred); put_rpccred(cred); - if (status == -ETIMEDOUT) { - set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); - return 0; - } out: return nfs4_recovery_handle_error(clp, status); } diff --git a/trunk/fs/nfs/nfs4xdr.c b/trunk/fs/nfs/nfs4xdr.c index c2cbf0d90a31..0b744895b9e1 100644 --- a/trunk/fs/nfs/nfs4xdr.c +++ b/trunk/fs/nfs/nfs4xdr.c @@ -1058,7 +1058,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const if (iap->ia_valid & ATTR_ATIME_SET) { bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); - p = xdr_encode_hyper(p, (s64)iap->ia_atime.tv_sec); + *p++ = cpu_to_be32(0); + *p++ = cpu_to_be32(iap->ia_atime.tv_sec); *p++ = cpu_to_be32(iap->ia_atime.tv_nsec); } else if (iap->ia_valid & ATTR_ATIME) { @@ -1068,7 +1069,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const if (iap->ia_valid & ATTR_MTIME_SET) { bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET; *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME); - p = xdr_encode_hyper(p, (s64)iap->ia_mtime.tv_sec); + *p++ = cpu_to_be32(0); + *p++ = cpu_to_be32(iap->ia_mtime.tv_sec); *p++ = cpu_to_be32(iap->ia_mtime.tv_nsec); } else if (iap->ia_valid & ATTR_MTIME) { @@ -1364,28 +1366,33 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg) { - struct iattr dummy; __be32 *p; + struct nfs_client *clp; p = reserve_space(xdr, 4); - switch(arg->createmode) { - case NFS4_CREATE_UNCHECKED: + switch(arg->open_flags & O_EXCL) { + case 0: *p = cpu_to_be32(NFS4_CREATE_UNCHECKED); encode_attrs(xdr, arg->u.attrs, arg->server); break; - case NFS4_CREATE_GUARDED: - *p = cpu_to_be32(NFS4_CREATE_GUARDED); - encode_attrs(xdr, arg->u.attrs, arg->server); - break; - case NFS4_CREATE_EXCLUSIVE: - *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE); - encode_nfs4_verifier(xdr, &arg->u.verifier); - break; - case NFS4_CREATE_EXCLUSIVE4_1: - *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1); - encode_nfs4_verifier(xdr, &arg->u.verifier); - dummy.ia_valid = 0; - encode_attrs(xdr, &dummy, arg->server); + default: + clp = arg->server->nfs_client; + if (clp->cl_mvops->minor_version > 0) { + if (nfs4_has_persistent_session(clp)) { + *p = cpu_to_be32(NFS4_CREATE_GUARDED); + encode_attrs(xdr, arg->u.attrs, arg->server); + } else { + struct iattr dummy; + + *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1); + encode_nfs4_verifier(xdr, &arg->u.verifier); + dummy.ia_valid = 0; + encode_attrs(xdr, &dummy, arg->server); + } + } else { + *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE); + encode_nfs4_verifier(xdr, &arg->u.verifier); + } } } diff --git a/trunk/fs/nfs/pagelist.c b/trunk/fs/nfs/pagelist.c index 29cfb7ade121..7f0933086b36 100644 --- a/trunk/fs/nfs/pagelist.c +++ b/trunk/fs/nfs/pagelist.c @@ -84,55 +84,6 @@ nfs_page_free(struct nfs_page *p) kmem_cache_free(nfs_page_cachep, p); } -static void -nfs_iocounter_inc(struct nfs_io_counter *c) -{ - atomic_inc(&c->io_count); -} - -static void -nfs_iocounter_dec(struct nfs_io_counter *c) -{ - if (atomic_dec_and_test(&c->io_count)) { - clear_bit(NFS_IO_INPROGRESS, &c->flags); - smp_mb__after_clear_bit(); - wake_up_bit(&c->flags, NFS_IO_INPROGRESS); - } -} - -static int -__nfs_iocounter_wait(struct nfs_io_counter *c) -{ - wait_queue_head_t *wq = bit_waitqueue(&c->flags, NFS_IO_INPROGRESS); - DEFINE_WAIT_BIT(q, &c->flags, NFS_IO_INPROGRESS); - int ret = 0; - - do { - prepare_to_wait(wq, &q.wait, TASK_KILLABLE); - set_bit(NFS_IO_INPROGRESS, &c->flags); - if (atomic_read(&c->io_count) == 0) - break; - ret = nfs_wait_bit_killable(&c->flags); - } while (atomic_read(&c->io_count) != 0); - finish_wait(wq, &q.wait); - return ret; -} - -/** - * nfs_iocounter_wait - wait for i/o to complete - * @c: nfs_io_counter to use - * - * returns -ERESTARTSYS if interrupted by a fatal signal. - * Otherwise returns 0 once the io_count hits 0. - */ -int -nfs_iocounter_wait(struct nfs_io_counter *c) -{ - if (atomic_read(&c->io_count) == 0) - return 0; - return __nfs_iocounter_wait(c); -} - /** * nfs_create_request - Create an NFS read/write request. * @ctx: open context to use @@ -167,7 +118,6 @@ nfs_create_request(struct nfs_open_context *ctx, struct inode *inode, return ERR_CAST(l_ctx); } req->wb_lock_context = l_ctx; - nfs_iocounter_inc(&l_ctx->io_count); /* Initialize the request struct. Initially, we assume a * long write-back delay. This will be adjusted in @@ -227,7 +177,6 @@ static void nfs_clear_request(struct nfs_page *req) req->wb_page = NULL; } if (l_ctx != NULL) { - nfs_iocounter_dec(&l_ctx->io_count); nfs_put_lock_context(l_ctx); req->wb_lock_context = NULL; } diff --git a/trunk/include/linux/nfs_fs.h b/trunk/include/linux/nfs_fs.h index fc01d5cb4cf1..f6b1956f3c86 100644 --- a/trunk/include/linux/nfs_fs.h +++ b/trunk/include/linux/nfs_fs.h @@ -59,18 +59,11 @@ struct nfs_lockowner { pid_t l_pid; }; -#define NFS_IO_INPROGRESS 0 -struct nfs_io_counter { - unsigned long flags; - atomic_t io_count; -}; - struct nfs_lock_context { atomic_t count; struct list_head list; struct nfs_open_context *open_context; struct nfs_lockowner lockowner; - struct nfs_io_counter io_count; }; struct nfs4_state; diff --git a/trunk/include/linux/nfs_fs_sb.h b/trunk/include/linux/nfs_fs_sb.h index 3b7fa2abecca..d8fdfdc7a8fe 100644 --- a/trunk/include/linux/nfs_fs_sb.h +++ b/trunk/include/linux/nfs_fs_sb.h @@ -40,7 +40,6 @@ struct nfs_client { #define NFS_CS_NORESVPORT 0 /* - use ephemeral src port */ #define NFS_CS_DISCRTRY 1 /* - disconnect on RPC retry */ #define NFS_CS_MIGRATION 2 /* - transparent state migr */ -#define NFS_CS_INFINITE_SLOTS 3 /* - don't limit TCP slots */ struct sockaddr_storage cl_addr; /* server identifier */ size_t cl_addrlen; char * cl_hostname; /* hostname of server */ diff --git a/trunk/include/linux/nfs_xdr.h b/trunk/include/linux/nfs_xdr.h index bdc100f66dfb..90a4aa190b43 100644 --- a/trunk/include/linux/nfs_xdr.h +++ b/trunk/include/linux/nfs_xdr.h @@ -349,7 +349,6 @@ struct nfs_openargs { const u32 * bitmask; const u32 * open_bitmap; __u32 claim; - enum createmode4 createmode; }; struct nfs_openres { diff --git a/trunk/include/linux/sunrpc/clnt.h b/trunk/include/linux/sunrpc/clnt.h index e7d492ce7c18..2cf4ffaa3cd4 100644 --- a/trunk/include/linux/sunrpc/clnt.h +++ b/trunk/include/linux/sunrpc/clnt.h @@ -124,7 +124,6 @@ struct rpc_create_args { #define RPC_CLNT_CREATE_NOPING (1UL << 4) #define RPC_CLNT_CREATE_DISCRTRY (1UL << 5) #define RPC_CLNT_CREATE_QUIET (1UL << 6) -#define RPC_CLNT_CREATE_INFINITE_SLOTS (1UL << 7) struct rpc_clnt *rpc_create(struct rpc_create_args *args); struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *, diff --git a/trunk/include/linux/sunrpc/xprt.h b/trunk/include/linux/sunrpc/xprt.h index ff5392421cb2..30834be03011 100644 --- a/trunk/include/linux/sunrpc/xprt.h +++ b/trunk/include/linux/sunrpc/xprt.h @@ -255,8 +255,6 @@ static inline int bc_prealloc(struct rpc_rqst *req) } #endif /* CONFIG_SUNRPC_BACKCHANNEL */ -#define XPRT_CREATE_INFINITE_SLOTS (1U) - struct xprt_create { int ident; /* XPRT_TRANSPORT identifier */ struct net * net; @@ -265,7 +263,6 @@ struct xprt_create { size_t addrlen; const char *servername; struct svc_xprt *bc_xprt; /* NFSv4.1 backchannel */ - unsigned int flags; }; struct xprt_class { @@ -282,7 +279,6 @@ struct xprt_class { struct rpc_xprt *xprt_create_transport(struct xprt_create *args); void xprt_connect(struct rpc_task *task); void xprt_reserve(struct rpc_task *task); -void xprt_retry_reserve(struct rpc_task *task); int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task); int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task); void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task); @@ -338,7 +334,6 @@ int xs_swapper(struct rpc_xprt *xprt, int enable); #define XPRT_CLOSING (6) #define XPRT_CONNECTION_ABORT (7) #define XPRT_CONNECTION_CLOSE (8) -#define XPRT_CONGESTED (9) static inline void xprt_set_connected(struct rpc_xprt *xprt) { diff --git a/trunk/net/sunrpc/Kconfig b/trunk/net/sunrpc/Kconfig index 262caf03bd5f..516fe2caac2c 100644 --- a/trunk/net/sunrpc/Kconfig +++ b/trunk/net/sunrpc/Kconfig @@ -24,6 +24,7 @@ config SUNRPC_XPRT_RDMA config SUNRPC_SWAP bool depends on SUNRPC + select NETVM config RPCSEC_GSS_KRB5 tristate "Secure RPC: Kerberos V mechanism" diff --git a/trunk/net/sunrpc/auth_gss/auth_gss.c b/trunk/net/sunrpc/auth_gss/auth_gss.c index 5257d2982ba5..282dfb14db05 100644 --- a/trunk/net/sunrpc/auth_gss/auth_gss.c +++ b/trunk/net/sunrpc/auth_gss/auth_gss.c @@ -1733,6 +1733,7 @@ static void __exit exit_rpcsec_gss(void) rcu_barrier(); /* Wait for completion of call_rcu()'s */ } +MODULE_ALIAS("rpc-auth-6"); MODULE_LICENSE("GPL"); module_param_named(expired_cred_retry_delay, gss_expired_cred_retry_delay, diff --git a/trunk/net/sunrpc/clnt.c b/trunk/net/sunrpc/clnt.c index 651245aa829a..b95a0a2d5eea 100644 --- a/trunk/net/sunrpc/clnt.c +++ b/trunk/net/sunrpc/clnt.c @@ -414,8 +414,6 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args) }; char servername[48]; - if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS) - xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS; /* * If the caller chooses not to specify a hostname, whip * up a string representation of the passed-in address. @@ -1308,8 +1306,6 @@ call_reserve(struct rpc_task *task) xprt_reserve(task); } -static void call_retry_reserve(struct rpc_task *task); - /* * 1b. Grok the result of xprt_reserve() */ @@ -1351,7 +1347,7 @@ call_reserveresult(struct rpc_task *task) case -ENOMEM: rpc_delay(task, HZ >> 2); case -EAGAIN: /* woken up; retry */ - task->tk_action = call_retry_reserve; + task->tk_action = call_reserve; return; case -EIO: /* probably a shutdown */ break; @@ -1363,19 +1359,6 @@ call_reserveresult(struct rpc_task *task) rpc_exit(task, status); } -/* - * 1c. Retry reserving an RPC call slot - */ -static void -call_retry_reserve(struct rpc_task *task) -{ - dprint_status(task); - - task->tk_status = 0; - task->tk_action = call_reserveresult; - xprt_retry_reserve(task); -} - /* * 2. Bind and/or refresh the credentials */ diff --git a/trunk/net/sunrpc/xprt.c b/trunk/net/sunrpc/xprt.c index 745fca3cfd36..b7478d5e7ffd 100644 --- a/trunk/net/sunrpc/xprt.c +++ b/trunk/net/sunrpc/xprt.c @@ -948,34 +948,6 @@ void xprt_transmit(struct rpc_task *task) spin_unlock_bh(&xprt->transport_lock); } -static void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task) -{ - set_bit(XPRT_CONGESTED, &xprt->state); - rpc_sleep_on(&xprt->backlog, task, NULL); -} - -static void xprt_wake_up_backlog(struct rpc_xprt *xprt) -{ - if (rpc_wake_up_next(&xprt->backlog) == NULL) - clear_bit(XPRT_CONGESTED, &xprt->state); -} - -static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task) -{ - bool ret = false; - - if (!test_bit(XPRT_CONGESTED, &xprt->state)) - goto out; - spin_lock(&xprt->reserve_lock); - if (test_bit(XPRT_CONGESTED, &xprt->state)) { - rpc_sleep_on(&xprt->backlog, task, NULL); - ret = true; - } - spin_unlock(&xprt->reserve_lock); -out: - return ret; -} - static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt, gfp_t gfp_flags) { struct rpc_rqst *req = ERR_PTR(-EAGAIN); @@ -1020,7 +992,7 @@ void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task) task->tk_status = -ENOMEM; break; case -EAGAIN: - xprt_add_backlog(xprt, task); + rpc_sleep_on(&xprt->backlog, task, NULL); dprintk("RPC: waiting for request slot\n"); default: task->tk_status = -EAGAIN; @@ -1056,7 +1028,7 @@ static void xprt_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req) memset(req, 0, sizeof(*req)); /* mark unused */ list_add(&req->rq_list, &xprt->free); } - xprt_wake_up_backlog(xprt); + rpc_wake_up_next(&xprt->backlog); spin_unlock(&xprt->reserve_lock); } @@ -1120,37 +1092,10 @@ EXPORT_SYMBOL_GPL(xprt_free); * xprt_reserve - allocate an RPC request slot * @task: RPC task requesting a slot allocation * - * If the transport is marked as being congested, or if no more - * slots are available, place the task on the transport's - * backlog queue. - */ -void xprt_reserve(struct rpc_task *task) -{ - struct rpc_xprt *xprt; - - task->tk_status = 0; - if (task->tk_rqstp != NULL) - return; - - task->tk_timeout = 0; - task->tk_status = -EAGAIN; - rcu_read_lock(); - xprt = rcu_dereference(task->tk_client->cl_xprt); - if (!xprt_throttle_congested(xprt, task)) - xprt->ops->alloc_slot(xprt, task); - rcu_read_unlock(); -} - -/** - * xprt_retry_reserve - allocate an RPC request slot - * @task: RPC task requesting a slot allocation - * * If no more slots are available, place the task on the transport's * backlog queue. - * Note that the only difference with xprt_reserve is that we now - * ignore the value of the XPRT_CONGESTED flag. */ -void xprt_retry_reserve(struct rpc_task *task) +void xprt_reserve(struct rpc_task *task) { struct rpc_xprt *xprt; diff --git a/trunk/net/sunrpc/xprtsock.c b/trunk/net/sunrpc/xprtsock.c index 726e702b7a29..3081620cb02c 100644 --- a/trunk/net/sunrpc/xprtsock.c +++ b/trunk/net/sunrpc/xprtsock.c @@ -2762,13 +2762,9 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args) struct rpc_xprt *xprt; struct sock_xprt *transport; struct rpc_xprt *ret; - unsigned int max_slot_table_size = xprt_max_tcp_slot_table_entries; - - if (args->flags & XPRT_CREATE_INFINITE_SLOTS) - max_slot_table_size = RPC_MAX_SLOT_TABLE_LIMIT; xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries, - max_slot_table_size); + xprt_max_tcp_slot_table_entries); if (IS_ERR(xprt)) return xprt; transport = container_of(xprt, struct sock_xprt, xprt);