Lines Matching refs:clp
139 static bool is_client_expired(struct nfs4_client *clp)
141 return clp->cl_time == 0;
144 static __be32 get_client_locked(struct nfs4_client *clp)
146 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
150 if (is_client_expired(clp))
152 atomic_inc(&clp->cl_rpc_users);
158 renew_client_locked(struct nfs4_client *clp)
160 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
162 if (is_client_expired(clp)) {
166 clp->cl_clientid.cl_boot,
167 clp->cl_clientid.cl_id);
171 list_move_tail(&clp->cl_lru, &nn->client_lru);
172 clp->cl_time = ktime_get_boottime_seconds();
175 static void put_client_renew_locked(struct nfs4_client *clp)
177 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
181 if (!atomic_dec_and_test(&clp->cl_rpc_users))
183 if (!is_client_expired(clp))
184 renew_client_locked(clp);
189 static void put_client_renew(struct nfs4_client *clp)
191 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
193 if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock))
195 if (!is_client_expired(clp))
196 renew_client_locked(clp);
217 struct nfs4_client *clp = ses->se_client;
218 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
224 put_client_renew_locked(clp);
229 struct nfs4_client *clp = ses->se_client;
230 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
291 struct nfs4_client *clp = lo->lo_owner.so_client;
292 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
372 struct nfs4_client *clp)
376 lockdep_assert_held(&clp->cl_lock);
378 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
390 struct nfs4_client *clp)
394 spin_lock(&clp->cl_lock);
395 oo = find_openstateowner_str_locked(hashval, open, clp);
396 spin_unlock(&clp->cl_lock);
652 alloc_clnt_odstate(struct nfs4_client *clp)
658 co->co_client = clp;
844 static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
848 stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
939 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
952 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
983 struct nfs4_client *clp = s->sc_client;
985 might_lock(&clp->cl_lock);
987 if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
991 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
992 nfs4_free_cpntf_statelist(clp->net, s);
993 spin_unlock(&clp->cl_lock);
1049 * @clp: a pointer to the nfs4_client we're granting a delegation to
1057 nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp)
1067 if (clp == searchclp) {
1090 struct nfs4_client *clp = dp->dl_stid.sc_client;
1095 if (nfs4_delegation_exists(clp, fp))
1100 list_add(&dp->dl_perclnt, &clp->cl_delegations);
1143 struct nfs4_client *clp = dp->dl_stid.sc_client;
1147 if (clp->cl_minorversion) {
1148 spin_lock(&clp->cl_lock);
1151 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
1152 spin_unlock(&clp->cl_lock);
1332 struct nfs4_client *clp = sop->so_client;
1334 might_lock(&clp->cl_lock);
1336 if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
1339 spin_unlock(&clp->cl_lock);
1401 struct nfs4_client *clp = s->sc_client;
1403 lockdep_assert_held(&clp->cl_lock);
1412 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1429 struct nfs4_client *clp = stp->st_stid.sc_client;
1432 spin_lock(&clp->cl_lock);
1434 spin_unlock(&clp->cl_lock);
1441 struct nfs4_client *clp = lo->lo_owner.so_client;
1443 lockdep_assert_held(&clp->cl_lock);
1510 struct nfs4_client *clp = oo->oo_owner.so_client;
1512 lockdep_assert_held(&clp->cl_lock);
1538 struct nfs4_client *clp = oo->oo_owner.so_client;
1543 spin_lock(&clp->cl_lock);
1551 spin_unlock(&clp->cl_lock);
1605 struct nfs4_client *clp = ses->se_client;
1609 sid->clientid = clp->cl_clientid;
1749 struct nfs4_client *clp = c->cn_session->se_client;
1751 spin_lock(&clp->cl_lock);
1756 nfsd4_probe_callback(clp);
1757 spin_unlock(&clp->cl_lock);
1782 struct nfs4_client *clp = ses->se_client;
1784 spin_lock(&clp->cl_lock);
1786 spin_unlock(&clp->cl_lock);
1820 struct nfs4_client *clp = s->se_client;
1823 spin_lock(&clp->cl_lock);
1827 spin_unlock(&clp->cl_lock);
1832 spin_lock(&clp->cl_lock);
1834 spin_unlock(&clp->cl_lock);
1850 static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
1855 new->se_client = clp;
1867 spin_lock(&clp->cl_lock);
1868 list_add(&new->se_perclnt, &clp->cl_sessions);
1869 spin_unlock(&clp->cl_lock);
1880 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1881 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1931 struct nfs4_client *clp = ses->se_client;
1932 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1964 struct nfs4_client *clp;
1967 clp = kmem_cache_zalloc(client_slab, GFP_KERNEL);
1968 if (clp == NULL)
1970 xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL);
1971 if (clp->cl_name.data == NULL)
1973 clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
1976 if (!clp->cl_ownerstr_hashtbl)
1979 INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
1980 INIT_LIST_HEAD(&clp->cl_sessions);
1981 idr_init(&clp->cl_stateids);
1982 atomic_set(&clp->cl_rpc_users, 0);
1983 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1984 INIT_LIST_HEAD(&clp->cl_idhash);
1985 INIT_LIST_HEAD(&clp->cl_openowners);
1986 INIT_LIST_HEAD(&clp->cl_delegations);
1987 INIT_LIST_HEAD(&clp->cl_lru);
1988 INIT_LIST_HEAD(&clp->cl_revoked);
1990 INIT_LIST_HEAD(&clp->cl_lo_states);
1992 INIT_LIST_HEAD(&clp->async_copies);
1993 spin_lock_init(&clp->async_lock);
1994 spin_lock_init(&clp->cl_lock);
1995 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1996 return clp;
1998 kfree(clp->cl_name.data);
2000 kmem_cache_free(client_slab, clp);
2007 struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs);
2009 free_svc_cred(&clp->cl_cred);
2010 kfree(clp->cl_ownerstr_hashtbl);
2011 kfree(clp->cl_name.data);
2012 kfree(clp->cl_nii_domain.data);
2013 kfree(clp->cl_nii_name.data);
2014 idr_destroy(&clp->cl_stateids);
2015 kmem_cache_free(client_slab, clp);
2018 static void drop_client(struct nfs4_client *clp)
2020 kref_put(&clp->cl_nfsdfs.cl_ref, __free_client);
2024 free_client(struct nfs4_client *clp)
2026 while (!list_empty(&clp->cl_sessions)) {
2028 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
2034 rpc_destroy_wait_queue(&clp->cl_cb_waitq);
2035 if (clp->cl_nfsd_dentry) {
2036 nfsd_client_rmdir(clp->cl_nfsd_dentry);
2037 clp->cl_nfsd_dentry = NULL;
2040 drop_client(clp);
2045 unhash_client_locked(struct nfs4_client *clp)
2047 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2053 clp->cl_time = 0;
2055 if (!list_empty(&clp->cl_idhash)) {
2056 list_del_init(&clp->cl_idhash);
2057 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
2058 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
2060 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2062 list_del_init(&clp->cl_lru);
2063 spin_lock(&clp->cl_lock);
2064 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
2066 spin_unlock(&clp->cl_lock);
2070 unhash_client(struct nfs4_client *clp)
2072 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2075 unhash_client_locked(clp);
2079 static __be32 mark_client_expired_locked(struct nfs4_client *clp)
2081 if (atomic_read(&clp->cl_rpc_users))
2083 unhash_client_locked(clp);
2088 __destroy_client(struct nfs4_client *clp)
2097 while (!list_empty(&clp->cl_delegations)) {
2098 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
2108 while (!list_empty(&clp->cl_revoked)) {
2109 dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
2113 while (!list_empty(&clp->cl_openowners)) {
2114 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
2121 list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
2128 nfsd4_return_all_client_layouts(clp);
2129 nfsd4_shutdown_copy(clp);
2130 nfsd4_shutdown_callback(clp);
2131 if (clp->cl_cb_conn.cb_xprt)
2132 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
2133 free_client(clp);
2138 destroy_client(struct nfs4_client *clp)
2140 unhash_client(clp);
2141 __destroy_client(clp);
2144 static void inc_reclaim_complete(struct nfs4_client *clp)
2146 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2150 if (!nfsd4_find_reclaim_client(clp->cl_name, nn))
2155 clp->net->ns.inum);
2160 static void expire_client(struct nfs4_client *clp)
2162 unhash_client(clp);
2163 nfsd4_client_record_remove(clp);
2164 __destroy_client(clp);
2297 static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
2307 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2310 static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2312 clp->cl_clientid.cl_boot = (u32)nn->boot_time;
2313 clp->cl_clientid.cl_id = nn->clientid_counter++;
2314 gen_confirm(clp, nn);
2364 struct nfs4_client *clp;
2367 clp = get_nfsdfs_clp(inode);
2368 if (!clp)
2370 memcpy(&clid, &clp->cl_clientid, sizeof(clid));
2372 seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr);
2374 seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len);
2375 seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion);
2376 if (clp->cl_nii_domain.data) {
2378 seq_quote_mem(m, clp->cl_nii_domain.data,
2379 clp->cl_nii_domain.len);
2381 seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len);
2383 clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec);
2385 drop_client(clp);
2403 __acquires(&clp->cl_lock)
2405 struct nfs4_client *clp = s->private;
2409 spin_lock(&clp->cl_lock);
2410 ret = idr_get_next_ul(&clp->cl_stateids, &id);
2417 struct nfs4_client *clp = s->private;
2423 ret = idr_get_next_ul(&clp->cl_stateids, &id);
2429 __releases(&clp->cl_lock)
2431 struct nfs4_client *clp = s->private;
2433 spin_unlock(&clp->cl_lock);
2628 struct nfs4_client *clp;
2631 clp = get_nfsdfs_clp(inode);
2632 if (!clp)
2639 s->private = clp;
2646 struct nfs4_client *clp = m->private;
2649 drop_client(clp);
2666 static void force_expire_client(struct nfs4_client *clp)
2668 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2672 clp->cl_time = 0;
2675 wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0);
2677 already_expired = list_empty(&clp->cl_lru);
2679 unhash_client_locked(clp);
2683 expire_client(clp);
2685 wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL);
2692 struct nfs4_client *clp;
2699 clp = get_nfsdfs_clp(file_inode(file));
2700 if (!clp)
2702 force_expire_client(clp);
2703 drop_client(clp);
2722 struct nfs4_client *clp;
2728 clp = alloc_client(name);
2729 if (clp == NULL)
2732 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
2734 free_client(clp);
2737 gen_clid(clp, nn);
2738 kref_init(&clp->cl_nfsdfs.cl_ref);
2739 nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
2740 clp->cl_time = ktime_get_boottime_seconds();
2741 clear_bit(0, &clp->cl_cb_slot_busy);
2742 copy_verf(clp, verf);
2743 memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage));
2744 clp->cl_cb_session = NULL;
2745 clp->net = net;
2746 clp->cl_nfsd_dentry = nfsd_client_mkdir(nn, &clp->cl_nfsdfs,
2747 clp->cl_clientid.cl_id - nn->clientid_base,
2749 if (!clp->cl_nfsd_dentry) {
2750 free_client(clp);
2753 return clp;
2760 struct nfs4_client *clp;
2763 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
2766 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
2781 struct nfs4_client *clp;
2784 clp = rb_entry(node, struct nfs4_client, cl_namenode);
2785 cmp = compare_blob(&clp->cl_name, name);
2791 return clp;
2797 add_to_unconfirmed(struct nfs4_client *clp)
2800 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2804 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2805 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
2806 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2807 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
2808 renew_client_locked(clp);
2812 move_to_confirmed(struct nfs4_client *clp)
2814 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2815 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2819 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
2820 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
2821 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2822 add_clp_to_name_tree(clp, &nn->conf_name_tree);
2823 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2824 renew_client_locked(clp);
2830 struct nfs4_client *clp;
2833 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
2834 if (same_clid(&clp->cl_clientid, clid)) {
2835 if ((bool)clp->cl_minorversion != sessions)
2837 renew_client_locked(clp);
2838 return clp;
2862 static bool clp_used_exchangeid(struct nfs4_client *clp)
2864 return clp->cl_exchange_flags != 0;
2882 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
2884 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
2899 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
2913 trace_nfsd_cb_args(clp, conn);
2918 trace_nfsd_cb_nodelegs(clp);
3039 static bool client_has_openowners(struct nfs4_client *clp)
3043 list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
3050 static bool client_has_state(struct nfs4_client *clp)
3052 return client_has_openowners(clp)
3054 || !list_empty(&clp->cl_lo_states)
3056 || !list_empty(&clp->cl_delegations)
3057 || !list_empty(&clp->cl_sessions)
3058 || !list_empty(&clp->async_copies);
3061 static __be32 copy_impl_id(struct nfs4_client *clp,
3066 xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL);
3067 if (!clp->cl_nii_domain.data)
3069 xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL);
3070 if (!clp->cl_nii_name.data)
3072 clp->cl_nii_time = exid->nii_time;
3539 struct nfs4_client *clp = session->se_client;
3545 spin_lock(&clp->cl_lock);
3559 spin_unlock(&clp->cl_lock);
3664 struct nfs4_client *clp = ses->se_client;
3669 spin_lock(&clp->cl_lock);
3674 if (clp->cl_mach_cred)
3677 spin_unlock(&clp->cl_lock);
3684 spin_unlock(&clp->cl_lock);
3745 struct nfs4_client *clp;
3768 clp = session->se_client;
3801 cstate->clp = clp;
3836 cstate->clp = clp;
3839 switch (clp->cl_cb_state) {
3849 if (!list_empty(&clp->cl_revoked))
3873 } else if (cs->clp)
3874 put_client_renew(cs->clp);
3884 struct nfs4_client *clp = NULL;
3901 clp = conf;
3903 clp = unconf;
3908 if (!nfsd4_mach_creds_match(clp, rqstp)) {
3909 clp = NULL;
3913 unhash_client_locked(clp);
3916 if (clp)
3917 expire_client(clp);
4210 static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
4225 sop->so_client = clp;
4231 static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
4233 lockdep_assert_held(&clp->cl_lock);
4236 &clp->cl_ownerstr_hashtbl[strhashval]);
4237 list_add(&oo->oo_perclient, &clp->cl_openowners);
4331 struct nfs4_client *clp = cstate->clp;
4334 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
4346 spin_lock(&clp->cl_lock);
4347 ret = find_openstateowner_str_locked(strhashval, open, clp);
4349 hash_openowner(oo, clp, strhashval);
4354 spin_unlock(&clp->cl_lock);
4639 struct nfs4_client *clp;
4647 clp = *(rqst->rq_lease_breaker);
4648 return dl->dl_stid.sc_client == clp;
4685 if (cstate->clp) {
4686 found = cstate->clp;
4711 cstate->clp = found;
4720 struct nfs4_client *clp = NULL;
4738 clp = cstate->clp;
4741 oo = find_openstateowner_str(strhashval, open, clp);
4762 open->op_stp = nfs4_alloc_open_stateid(clp);
4768 open->op_odstate = alloc_clnt_odstate(clp);
4965 static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
4967 if (clp->cl_cb_state == NFSD4_CB_UP)
4974 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
4996 nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
5020 if (nfs4_delegation_exists(clp, fp))
5038 dp = alloc_init_deleg(clp, fp, fh, odstate);
5108 struct nfs4_client *clp = stp->st_stid.sc_client;
5128 if (locks_in_grace(clp->net))
5147 dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate);
5320 struct nfs4_client *clp;
5328 clp = cstate->clp;
5330 if (!list_empty(&clp->cl_delegations)
5331 && clp->cl_cb_state != NFSD4_CB_UP)
5399 struct nfs4_client *clp;
5429 clp = list_entry(pos, struct nfs4_client, cl_lru);
5430 if (clp->cl_time > cutoff) {
5431 t = clp->cl_time - cutoff;
5435 if (mark_client_expired_locked(clp)) {
5436 trace_nfsd_clid_expired(&clp->cl_clientid);
5439 list_add(&clp->cl_lru, &reaplist);
5443 clp = list_entry(pos, struct nfs4_client, cl_lru);
5444 trace_nfsd_clid_purged(&clp->cl_clientid);
5445 list_del_init(&clp->cl_lru);
5446 expire_client(clp);
5718 *s = find_stateid_by_type(cstate->clp, stateid, typemask);
5805 struct nfs4_client *clp,
5822 if (!clp)
5831 if (!clp && state)
5855 put_client_renew(cstate.clp);
6222 struct nfs4_client *clp = s->st_stid.sc_client;
6227 spin_lock(&clp->cl_lock);
6230 if (clp->cl_minorversion) {
6233 spin_unlock(&clp->cl_lock);
6235 nfs4_free_cpntf_statelist(clp->net, &stp->st_stid);
6238 spin_unlock(&clp->cl_lock);
6241 move_to_close_lru(s, clp->net);
6440 find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
6445 lockdep_assert_held(&clp->cl_lock);
6447 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
6458 find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
6462 spin_lock(&clp->cl_lock);
6463 lo = find_lockowner_str_locked(clp, owner);
6464 spin_unlock(&clp->cl_lock);
6493 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
6499 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
6507 spin_lock(&clp->cl_lock);
6508 ret = find_lockowner_str_locked(clp, &lock->lk_new_owner);
6511 &clp->cl_ownerstr_hashtbl[strhashval]);
6516 spin_unlock(&clp->cl_lock);
6544 struct nfs4_client *clp = lo->lo_owner.so_client;
6550 spin_lock(&clp->cl_lock);
6569 spin_unlock(&clp->cl_lock);
6572 spin_unlock(&clp->cl_lock);
6581 spin_unlock(&clp->cl_lock);
6594 struct nfs4_client *clp = oo->oo_owner.so_client;
6597 spin_lock(&clp->cl_lock);
6599 spin_unlock(&clp->cl_lock);
6605 ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid);
6976 lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
7124 struct nfs4_client *clp;
7134 clp = cstate->clp;
7136 spin_lock(&clp->cl_lock);
7137 list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval],
7144 spin_unlock(&clp->cl_lock);
7153 spin_unlock(&clp->cl_lock);
7165 spin_unlock(&clp->cl_lock);
7274 if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags))
7277 if (nfsd4_client_record_check(cstate->clp))
7364 struct nfs4_client *clp = NULL;
7369 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
7370 destroy_client(clp);
7378 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
7379 destroy_client(clp);