clp 984 drivers/atm/fore200e.c rpd->atm_header.clp; clp 1635 drivers/atm/fore200e.c tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP); clp 1643 drivers/atm/fore200e.c tpd->atm_header.clp = 0; clp 91 drivers/atm/fore200e.h u32 clp : 1, /* cell loss priority */ clp 2542 drivers/atm/he.c int clp, pti; clp 2545 drivers/atm/he.c clp = (*pti_clp & ATM_HDR_CLP); clp 2547 drivers/atm/he.c if (clp) clp 237 drivers/atm/nicstar.h #define ns_tbd_mkword_4(gfc, vpi, vci, pt, clp) \ clp 238 drivers/atm/nicstar.h (cpu_to_le32((gfc) << 28 | (vpi) << 20 | (vci) << 4 | (pt) << 1 | (clp))) clp 492 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c struct pvr2_sysfs_class *clp; clp 493 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp = container_of(class,struct pvr2_sysfs_class,class); clp 494 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c pvr2_sysfs_trace("Destroying pvr2_sysfs_class id=%p",clp); clp 495 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c kfree(clp); clp 774 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c struct pvr2_sysfs_class *clp; clp 775 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp = kzalloc(sizeof(*clp),GFP_KERNEL); clp 776 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c if (!clp) return clp; clp 778 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp); clp 779 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp->class.name = "pvrusb2"; clp 780 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp->class.class_release = pvr2_sysfs_class_release; clp 781 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp->class.dev_release = pvr2_sysfs_release; clp 782 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c if (class_register(&clp->class)) { clp 784 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c "Registration failed for pvr2_sysfs_class id=%p",clp); clp 785 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c kfree(clp); clp 786 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c clp = NULL; clp 788 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c return clp; clp 792 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c void pvr2_sysfs_class_destroy(struct pvr2_sysfs_class *clp) clp 794 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c pvr2_sysfs_trace("Unregistering pvr2_sysfs_class id=%p", clp); clp 795 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c if (clp) clp 796 drivers/media/usb/pvrusb2/pvrusb2-sysfs.c class_unregister(&clp->class); clp 382 fs/nfs/callback.c check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp) clp 390 fs/nfs/callback.c if (clp->cl_minorversion != 0) clp 403 fs/nfs/callback.c if (clp->cl_acceptor) clp 404 fs/nfs/callback.c return !strcmp(p, clp->cl_acceptor); clp 416 fs/nfs/callback.c if (strcmp(p, clp->cl_hostname) != 0) clp 44 fs/nfs/callback.h struct nfs_client *clp; clp 33 fs/nfs/callback_proc.c if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */ clp 40 fs/nfs/callback_proc.c rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR)); clp 42 fs/nfs/callback_proc.c inode = nfs_delegation_find_inode(cps->clp, &args->fh); clp 46 fs/nfs/callback_proc.c trace_nfs4_cb_getattr(cps->clp, &args->fh, NULL, clp 68 fs/nfs/callback_proc.c trace_nfs4_cb_getattr(cps->clp, &args->fh, inode, -ntohl(res->status)); clp 83 fs/nfs/callback_proc.c if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */ clp 87 fs/nfs/callback_proc.c rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR)); clp 90 fs/nfs/callback_proc.c inode = nfs_delegation_find_inode(cps->clp, &args->fh); clp 94 fs/nfs/callback_proc.c trace_nfs4_cb_recall(cps->clp, &args->fh, NULL, clp 109 fs/nfs/callback_proc.c trace_nfs4_cb_recall(cps->clp, &args->fh, inode, clp 124 fs/nfs/callback_proc.c static struct inode *nfs_layout_find_inode_by_stateid(struct nfs_client *clp, clp 131 fs/nfs/callback_proc.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 143 fs/nfs/callback_proc.c spin_unlock(&clp->cl_lock); clp 145 fs/nfs/callback_proc.c spin_lock(&clp->cl_lock); clp 162 fs/nfs/callback_proc.c static struct inode *nfs_layout_find_inode_by_fh(struct nfs_client *clp, clp 170 fs/nfs/callback_proc.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 182 fs/nfs/callback_proc.c spin_unlock(&clp->cl_lock); clp 184 fs/nfs/callback_proc.c spin_lock(&clp->cl_lock); clp 195 fs/nfs/callback_proc.c static struct inode *nfs_layout_find_inode(struct nfs_client *clp, clp 201 fs/nfs/callback_proc.c spin_lock(&clp->cl_lock); clp 203 fs/nfs/callback_proc.c inode = nfs_layout_find_inode_by_stateid(clp, stateid); clp 205 fs/nfs/callback_proc.c inode = nfs_layout_find_inode_by_fh(clp, fh); clp 207 fs/nfs/callback_proc.c spin_unlock(&clp->cl_lock); clp 250 fs/nfs/callback_proc.c static u32 initiate_file_draining(struct nfs_client *clp, clp 258 fs/nfs/callback_proc.c ino = nfs_layout_find_inode(clp, &args->cbl_fh, &args->cbl_stateid); clp 314 fs/nfs/callback_proc.c trace_nfs4_cb_layoutrecall_file(clp, &args->cbl_fh, ino, clp 319 fs/nfs/callback_proc.c static u32 initiate_bulk_draining(struct nfs_client *clp, clp 325 fs/nfs/callback_proc.c stat = pnfs_destroy_layouts_byfsid(clp, &args->cbl_fsid, true); clp 327 fs/nfs/callback_proc.c stat = pnfs_destroy_layouts_byclid(clp, true); clp 333 fs/nfs/callback_proc.c static u32 do_callback_layoutrecall(struct nfs_client *clp, clp 337 fs/nfs/callback_proc.c return initiate_file_draining(clp, args); clp 338 fs/nfs/callback_proc.c return initiate_bulk_draining(clp, args); clp 347 fs/nfs/callback_proc.c if (cps->clp) clp 348 fs/nfs/callback_proc.c res = do_callback_layoutrecall(cps->clp, args); clp 352 fs/nfs/callback_proc.c static void pnfs_recall_all_layouts(struct nfs_client *clp) clp 360 fs/nfs/callback_proc.c do_callback_layoutrecall(clp, &args); clp 369 fs/nfs/callback_proc.c struct nfs_client *clp = cps->clp; clp 372 fs/nfs/callback_proc.c if (!clp) { clp 383 fs/nfs/callback_proc.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 394 fs/nfs/callback_proc.c nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id); clp 459 fs/nfs/callback_proc.c static int referring_call_exists(struct nfs_client *clp, clp 477 fs/nfs/callback_proc.c session = clp->cl_session; clp 509 fs/nfs/callback_proc.c struct nfs_client *clp; clp 513 fs/nfs/callback_proc.c clp = nfs4_find_client_sessionid(cps->net, args->csa_addr, clp 515 fs/nfs/callback_proc.c if (clp == NULL) clp 518 fs/nfs/callback_proc.c if (!(clp->cl_session->flags & SESSION4_BACK_CHAN)) clp 521 fs/nfs/callback_proc.c tbl = &clp->cl_session->bc_slot_table; clp 536 fs/nfs/callback_proc.c if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) clp 569 fs/nfs/callback_proc.c if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists, clp 585 fs/nfs/callback_proc.c cps->clp = clp; /* put in nfs4_callback_compound */ clp 614 fs/nfs/callback_proc.c if (!cps->clp) /* set in cb_sequence */ clp 618 fs/nfs/callback_proc.c rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR)); clp 630 fs/nfs/callback_proc.c nfs_expire_unused_delegation_types(cps->clp, flags); clp 633 fs/nfs/callback_proc.c pnfs_recall_all_layouts(cps->clp); clp 648 fs/nfs/callback_proc.c if (!cps->clp) /* set in cb_sequence */ clp 652 fs/nfs/callback_proc.c rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR), clp 655 fs/nfs/callback_proc.c fc_tbl = &cps->clp->cl_session->fc_slot_table; clp 660 fs/nfs/callback_proc.c nfs41_notify_server(cps->clp); clp 671 fs/nfs/callback_proc.c if (!cps->clp) /* set in cb_sequence */ clp 675 fs/nfs/callback_proc.c rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR)); clp 679 fs/nfs/callback_proc.c __wake_up(&cps->clp->cl_lock_waitq, TASK_NORMAL, 0, args); clp 710 fs/nfs/callback_proc.c spin_lock(&cps->clp->cl_lock); clp 712 fs/nfs/callback_proc.c list_for_each_entry_rcu(server, &cps->clp->cl_superblocks, clp 730 fs/nfs/callback_proc.c list_add_tail(©->copies, &cps->clp->pending_cb_stateids); clp 733 fs/nfs/callback_proc.c spin_unlock(&cps->clp->cl_lock); clp 809 fs/nfs/callback_xdr.c nfs4_callback_free_slot(cps->clp->cl_session, cps->slot); clp 932 fs/nfs/callback_xdr.c .clp = NULL, clp 948 fs/nfs/callback_xdr.c cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident); clp 949 fs/nfs/callback_xdr.c if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp)) { clp 950 fs/nfs/callback_xdr.c if (cps.clp) clp 951 fs/nfs/callback_xdr.c nfs_put_client(cps.clp); clp 960 fs/nfs/callback_xdr.c if (cps.clp) clp 961 fs/nfs/callback_xdr.c nfs_put_client(cps.clp); clp 981 fs/nfs/callback_xdr.c nfs_put_client(cps.clp); clp 150 fs/nfs/client.c struct nfs_client *clp; clp 153 fs/nfs/client.c if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL) clp 156 fs/nfs/client.c clp->cl_minorversion = cl_init->minorversion; clp 157 fs/nfs/client.c clp->cl_nfs_mod = cl_init->nfs_mod; clp 158 fs/nfs/client.c if (!try_module_get(clp->cl_nfs_mod->owner)) clp 161 fs/nfs/client.c clp->rpc_ops = clp->cl_nfs_mod->rpc_ops; clp 163 fs/nfs/client.c refcount_set(&clp->cl_count, 1); clp 164 fs/nfs/client.c clp->cl_cons_state = NFS_CS_INITING; clp 166 fs/nfs/client.c memcpy(&clp->cl_addr, cl_init->addr, cl_init->addrlen); clp 167 fs/nfs/client.c clp->cl_addrlen = cl_init->addrlen; clp 171 fs/nfs/client.c clp->cl_hostname = kstrdup(cl_init->hostname, GFP_KERNEL); clp 172 fs/nfs/client.c if (!clp->cl_hostname) clp 176 fs/nfs/client.c INIT_LIST_HEAD(&clp->cl_superblocks); clp 177 fs/nfs/client.c clp->cl_rpcclient = ERR_PTR(-EINVAL); clp 179 fs/nfs/client.c clp->cl_proto = cl_init->proto; clp 180 fs/nfs/client.c clp->cl_nconnect = cl_init->nconnect; clp 181 fs/nfs/client.c clp->cl_net = get_net(cl_init->net); clp 183 fs/nfs/client.c clp->cl_principal = "*"; clp 184 fs/nfs/client.c nfs_fscache_get_client_cookie(clp); clp 186 fs/nfs/client.c return clp; clp 189 fs/nfs/client.c put_nfs_version(clp->cl_nfs_mod); clp 191 fs/nfs/client.c kfree(clp); clp 206 fs/nfs/client.c static void nfs_cb_idr_remove_locked(struct nfs_client *clp) clp 208 fs/nfs/client.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 210 fs/nfs/client.c if (clp->cl_cb_ident) clp 211 fs/nfs/client.c idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident); clp 224 fs/nfs/client.c static void nfs_cb_idr_remove_locked(struct nfs_client *clp) clp 237 fs/nfs/client.c void nfs_free_client(struct nfs_client *clp) clp 239 fs/nfs/client.c nfs_fscache_release_client_cookie(clp); clp 242 fs/nfs/client.c if (!IS_ERR(clp->cl_rpcclient)) clp 243 fs/nfs/client.c rpc_shutdown_client(clp->cl_rpcclient); clp 245 fs/nfs/client.c put_net(clp->cl_net); clp 246 fs/nfs/client.c put_nfs_version(clp->cl_nfs_mod); clp 247 fs/nfs/client.c kfree(clp->cl_hostname); clp 248 fs/nfs/client.c kfree(clp->cl_acceptor); clp 249 fs/nfs/client.c kfree(clp); clp 256 fs/nfs/client.c void nfs_put_client(struct nfs_client *clp) clp 260 fs/nfs/client.c if (!clp) clp 263 fs/nfs/client.c nn = net_generic(clp->cl_net, nfs_net_id); clp 265 fs/nfs/client.c if (refcount_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) { clp 266 fs/nfs/client.c list_del(&clp->cl_share_link); clp 267 fs/nfs/client.c nfs_cb_idr_remove_locked(clp); clp 270 fs/nfs/client.c WARN_ON_ONCE(!list_empty(&clp->cl_superblocks)); clp 272 fs/nfs/client.c clp->rpc_ops->free_client(clp); clp 283 fs/nfs/client.c struct nfs_client *clp; clp 289 fs/nfs/client.c list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { clp 290 fs/nfs/client.c const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr; clp 292 fs/nfs/client.c if (clp->cl_cons_state < 0) clp 296 fs/nfs/client.c if (clp->cl_cons_state > NFS_CS_READY) { clp 297 fs/nfs/client.c refcount_inc(&clp->cl_count); clp 299 fs/nfs/client.c error = nfs_wait_client_init_complete(clp); clp 300 fs/nfs/client.c nfs_put_client(clp); clp 308 fs/nfs/client.c if (clp->rpc_ops != data->nfs_mod->rpc_ops) clp 311 fs/nfs/client.c if (clp->cl_proto != data->proto) clp 314 fs/nfs/client.c if (clp->cl_minorversion != data->minorversion) clp 319 fs/nfs/client.c if (IS_ERR(clp->cl_rpcclient) || clp 320 fs/nfs/client.c !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient, clp 324 fs/nfs/client.c refcount_inc(&clp->cl_count); clp 325 fs/nfs/client.c return clp; clp 335 fs/nfs/client.c bool nfs_client_init_is_complete(const struct nfs_client *clp) clp 337 fs/nfs/client.c return clp->cl_cons_state <= NFS_CS_READY; clp 347 fs/nfs/client.c int nfs_client_init_status(const struct nfs_client *clp) clp 350 fs/nfs/client.c if (clp->cl_cons_state > NFS_CS_READY) { clp 354 fs/nfs/client.c return clp->cl_cons_state; clp 358 fs/nfs/client.c int nfs_wait_client_init_complete(const struct nfs_client *clp) clp 361 fs/nfs/client.c nfs_client_init_is_complete(clp)); clp 370 fs/nfs/client.c struct nfs_client *clp) clp 374 fs/nfs/client.c error = nfs_wait_client_init_complete(clp); clp 376 fs/nfs/client.c nfs_put_client(clp); clp 380 fs/nfs/client.c if (clp->cl_cons_state < NFS_CS_READY) { clp 381 fs/nfs/client.c error = clp->cl_cons_state; clp 382 fs/nfs/client.c nfs_put_client(clp); clp 387 fs/nfs/client.c return clp; clp 396 fs/nfs/client.c struct nfs_client *clp, *new = NULL; clp 409 fs/nfs/client.c clp = nfs_match_client(cl_init); clp 410 fs/nfs/client.c if (clp) { clp 414 fs/nfs/client.c if (IS_ERR(clp)) clp 415 fs/nfs/client.c return clp; clp 416 fs/nfs/client.c return nfs_found_client(cl_init, clp); clp 438 fs/nfs/client.c void nfs_mark_client_ready(struct nfs_client *clp, int state) clp 441 fs/nfs/client.c clp->cl_cons_state = state; clp 491 fs/nfs/client.c int nfs_create_rpc_client(struct nfs_client *clp, clp 497 fs/nfs/client.c .net = clp->cl_net, clp 498 fs/nfs/client.c .protocol = clp->cl_proto, clp 499 fs/nfs/client.c .nconnect = clp->cl_nconnect, clp 500 fs/nfs/client.c .address = (struct sockaddr *)&clp->cl_addr, clp 501 fs/nfs/client.c .addrsize = clp->cl_addrlen, clp 503 fs/nfs/client.c .servername = clp->cl_hostname, clp 506 fs/nfs/client.c .version = clp->rpc_ops->version, clp 511 fs/nfs/client.c if (test_bit(NFS_CS_DISCRTRY, &clp->cl_flags)) clp 513 fs/nfs/client.c if (test_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags)) clp 515 fs/nfs/client.c if (test_bit(NFS_CS_NORESVPORT, &clp->cl_flags)) clp 517 fs/nfs/client.c if (test_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags)) clp 520 fs/nfs/client.c if (!IS_ERR(clp->cl_rpcclient)) clp 530 fs/nfs/client.c clnt->cl_principal = clp->cl_principal; clp 531 fs/nfs/client.c clp->cl_rpcclient = clnt; clp 551 fs/nfs/client.c struct nfs_client *clp = server->nfs_client; clp 553 fs/nfs/client.c .hostname = clp->cl_hostname, clp 554 fs/nfs/client.c .address = (struct sockaddr *)&clp->cl_addr, clp 555 fs/nfs/client.c .addrlen = clp->cl_addrlen, clp 556 fs/nfs/client.c .nfs_version = clp->rpc_ops->version, clp 559 fs/nfs/client.c .net = clp->cl_net, clp 560 fs/nfs/client.c .nlmclnt_ops = clp->cl_nfs_mod->rpc_ops->nlmclnt_ops, clp 570 fs/nfs/client.c switch (clp->cl_proto) { clp 594 fs/nfs/client.c struct nfs_client *clp = server->nfs_client; clp 596 fs/nfs/client.c server->client = rpc_clone_client_set_auth(clp->cl_rpcclient, clp 625 fs/nfs/client.c struct nfs_client *nfs_init_client(struct nfs_client *clp, clp 631 fs/nfs/client.c if (clp->cl_cons_state == NFS_CS_READY) clp 632 fs/nfs/client.c return clp; clp 638 fs/nfs/client.c error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); clp 639 fs/nfs/client.c nfs_mark_client_ready(clp, error == 0 ? NFS_CS_READY : error); clp 641 fs/nfs/client.c nfs_put_client(clp); clp 642 fs/nfs/client.c clp = ERR_PTR(error); clp 644 fs/nfs/client.c return clp; clp 667 fs/nfs/client.c struct nfs_client *clp; clp 676 fs/nfs/client.c clp = nfs_get_client(&cl_init); clp 677 fs/nfs/client.c if (IS_ERR(clp)) clp 678 fs/nfs/client.c return PTR_ERR(clp); clp 680 fs/nfs/client.c server->nfs_client = clp; clp 727 fs/nfs/client.c nfs_put_client(clp); clp 791 fs/nfs/client.c struct nfs_client *clp = server->nfs_client; clp 794 fs/nfs/client.c if (clp->rpc_ops->set_capabilities != NULL) { clp 795 fs/nfs/client.c error = clp->rpc_ops->set_capabilities(server, mntfh); clp 803 fs/nfs/client.c error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo); clp 816 fs/nfs/client.c if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0) clp 845 fs/nfs/client.c struct nfs_client *clp = server->nfs_client; clp 846 fs/nfs/client.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 849 fs/nfs/client.c list_add_tail_rcu(&server->client_link, &clp->cl_superblocks); clp 851 fs/nfs/client.c clear_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state); clp 859 fs/nfs/client.c struct nfs_client *clp = server->nfs_client; clp 862 fs/nfs/client.c if (clp == NULL) clp 864 fs/nfs/client.c nn = net_generic(clp->cl_net, nfs_net_id); clp 867 fs/nfs/client.c if (list_empty(&clp->cl_superblocks)) clp 868 fs/nfs/client.c set_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state); clp 1158 fs/nfs/client.c struct nfs_client *clp; clp 1168 fs/nfs/client.c clp = list_entry(v, struct nfs_client, cl_share_link); clp 1171 fs/nfs/client.c if (clp->cl_cons_state != NFS_CS_READY) clp 1176 fs/nfs/client.c clp->rpc_ops->version, clp 1177 fs/nfs/client.c rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR), clp 1178 fs/nfs/client.c rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT), clp 1179 fs/nfs/client.c refcount_read(&clp->cl_count), clp 1180 fs/nfs/client.c clp->cl_hostname); clp 1226 fs/nfs/client.c struct nfs_client *clp; clp 1239 fs/nfs/client.c clp = server->nfs_client; clp 1250 fs/nfs/client.c clp->rpc_ops->version, clp 1251 fs/nfs/client.c rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR), clp 1252 fs/nfs/client.c rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT), clp 278 fs/nfs/delegation.c struct nfs_client *clp) clp 285 fs/nfs/delegation.c set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); clp 291 fs/nfs/delegation.c struct nfs_client *clp) clp 295 fs/nfs/delegation.c lockdep_is_held(&clp->cl_lock)); clp 313 fs/nfs/delegation.c struct nfs_client *clp = server->nfs_client; clp 315 fs/nfs/delegation.c spin_lock(&clp->cl_lock); clp 316 fs/nfs/delegation.c delegation = nfs_detach_delegation_locked(nfsi, delegation, clp); clp 317 fs/nfs/delegation.c spin_unlock(&clp->cl_lock); clp 361 fs/nfs/delegation.c struct nfs_client *clp = server->nfs_client; clp 379 fs/nfs/delegation.c spin_lock(&clp->cl_lock); clp 381 fs/nfs/delegation.c lockdep_is_held(&clp->cl_lock)); clp 398 fs/nfs/delegation.c __func__, clp->cl_hostname); clp 409 fs/nfs/delegation.c old_delegation, clp); clp 424 fs/nfs/delegation.c spin_unlock(&clp->cl_lock); clp 437 fs/nfs/delegation.c struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; clp 453 fs/nfs/delegation.c err = nfs4_wait_clnt_recover(clp); clp 457 fs/nfs/delegation.c nfs_abort_delegation_return(delegation, clp); clp 499 fs/nfs/delegation.c int nfs_client_return_marked_delegations(struct nfs_client *clp) clp 525 fs/nfs/delegation.c server = list_entry_rcu(clp->cl_superblocks.next, clp 527 fs/nfs/delegation.c list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) { clp 575 fs/nfs/delegation.c set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); clp 668 fs/nfs/delegation.c static void nfs_client_mark_return_all_delegations(struct nfs_client *clp) clp 673 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 678 fs/nfs/delegation.c static void nfs_delegation_run_state_manager(struct nfs_client *clp) clp 680 fs/nfs/delegation.c if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) clp 681 fs/nfs/delegation.c nfs4_schedule_state_manager(clp); clp 689 fs/nfs/delegation.c void nfs_expire_all_delegations(struct nfs_client *clp) clp 691 fs/nfs/delegation.c nfs_client_mark_return_all_delegations(clp); clp 692 fs/nfs/delegation.c nfs_delegation_run_state_manager(clp); clp 702 fs/nfs/delegation.c struct nfs_client *clp = server->nfs_client; clp 705 fs/nfs/delegation.c if (clp == NULL) clp 713 fs/nfs/delegation.c nfs4_schedule_state_manager(clp); clp 714 fs/nfs/delegation.c nfs4_wait_clnt_recover(clp); clp 731 fs/nfs/delegation.c static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp, clp 737 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 794 fs/nfs/delegation.c void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags) clp 796 fs/nfs/delegation.c nfs_client_mark_return_unused_delegation_types(clp, flags); clp 797 fs/nfs/delegation.c nfs_delegation_run_state_manager(clp); clp 816 fs/nfs/delegation.c void nfs_expire_unreferenced_delegations(struct nfs_client *clp) clp 821 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 825 fs/nfs/delegation.c nfs_delegation_run_state_manager(clp); clp 839 fs/nfs/delegation.c struct nfs_client *clp = server->nfs_client; clp 847 fs/nfs/delegation.c !clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) clp 852 fs/nfs/delegation.c nfs_delegation_run_state_manager(clp); clp 896 fs/nfs/delegation.c struct inode *nfs_delegation_find_inode(struct nfs_client *clp, clp 903 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 934 fs/nfs/delegation.c void nfs_delegation_mark_reclaim(struct nfs_client *clp) clp 939 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 949 fs/nfs/delegation.c void nfs_delegation_reap_unclaimed(struct nfs_client *clp) clp 957 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 992 fs/nfs/delegation.c static inline bool nfs4_server_rebooted(const struct nfs_client *clp) clp 994 fs/nfs/delegation.c return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) | clp 1037 fs/nfs/delegation.c void nfs_mark_test_expired_all_delegations(struct nfs_client *clp) clp 1042 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 1053 fs/nfs/delegation.c void nfs_test_expired_all_delegations(struct nfs_client *clp) clp 1055 fs/nfs/delegation.c nfs_mark_test_expired_all_delegations(clp); clp 1056 fs/nfs/delegation.c nfs4_schedule_state_manager(clp); clp 1084 fs/nfs/delegation.c void nfs_reap_expired_delegations(struct nfs_client *clp) clp 1094 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 1118 fs/nfs/delegation.c if (nfs4_server_rebooted(clp)) { clp 1136 fs/nfs/delegation.c struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; clp 1149 fs/nfs/delegation.c nfs4_schedule_state_manager(clp); clp 1159 fs/nfs/delegation.c int nfs_delegations_present(struct nfs_client *clp) clp 1165 fs/nfs/delegation.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 48 fs/nfs/delegation.h struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs_fh *fhandle); clp 50 fs/nfs/delegation.h void nfs_expire_all_delegations(struct nfs_client *clp); clp 51 fs/nfs/delegation.h void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags); clp 52 fs/nfs/delegation.h void nfs_expire_unreferenced_delegations(struct nfs_client *clp); clp 53 fs/nfs/delegation.h int nfs_client_return_marked_delegations(struct nfs_client *clp); clp 54 fs/nfs/delegation.h int nfs_delegations_present(struct nfs_client *clp); clp 57 fs/nfs/delegation.h void nfs_delegation_mark_reclaim(struct nfs_client *clp); clp 58 fs/nfs/delegation.h void nfs_delegation_reap_unclaimed(struct nfs_client *clp); clp 60 fs/nfs/delegation.h void nfs_mark_test_expired_all_delegations(struct nfs_client *clp); clp 61 fs/nfs/delegation.h void nfs_test_expired_all_delegations(struct nfs_client *clp); clp 62 fs/nfs/delegation.h void nfs_reap_expired_delegations(struct nfs_client *clp); clp 124 fs/nfs/filelayout/filelayout.c struct nfs_client *clp, clp 130 fs/nfs/filelayout/filelayout.c struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table; clp 146 fs/nfs/filelayout/filelayout.c clp->cl_exchange_flags); clp 147 fs/nfs/filelayout/filelayout.c nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); clp 1130 fs/nfs/flexfilelayout/flexfilelayout.c struct nfs_client *clp, clp 1137 fs/nfs/flexfilelayout/flexfilelayout.c struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table; clp 1149 fs/nfs/flexfilelayout/flexfilelayout.c clp->cl_exchange_flags); clp 1150 fs/nfs/flexfilelayout/flexfilelayout.c nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); clp 1239 fs/nfs/flexfilelayout/flexfilelayout.c struct nfs_client *clp, clp 1243 fs/nfs/flexfilelayout/flexfilelayout.c int vers = clp->cl_nfs_mod->rpc_vers->number; clp 1258 fs/nfs/flexfilelayout/flexfilelayout.c return ff_layout_async_handle_error_v4(task, state, clp, clp 50 fs/nfs/fscache.c void nfs_fscache_get_client_cookie(struct nfs_client *clp) clp 52 fs/nfs/fscache.c const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr; clp 53 fs/nfs/fscache.c const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr; clp 58 fs/nfs/fscache.c key.hdr.nfsversion = clp->rpc_ops->version; clp 59 fs/nfs/fscache.c key.hdr.minorversion = clp->cl_minorversion; clp 60 fs/nfs/fscache.c key.hdr.family = clp->cl_addr.ss_family; clp 62 fs/nfs/fscache.c switch (clp->cl_addr.ss_family) { clp 77 fs/nfs/fscache.c clp->cl_addr.ss_family); clp 78 fs/nfs/fscache.c clp->fscache = NULL; clp 83 fs/nfs/fscache.c clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index, clp 87 fs/nfs/fscache.c clp, 0, true); clp 89 fs/nfs/fscache.c clp, clp->fscache); clp 95 fs/nfs/fscache.c void nfs_fscache_release_client_cookie(struct nfs_client *clp) clp 98 fs/nfs/fscache.c clp, clp->fscache); clp 100 fs/nfs/fscache.c fscache_relinquish_cookie(clp->fscache, NULL, false); clp 101 fs/nfs/fscache.c clp->fscache = NULL; clp 196 fs/nfs/fscache.h static inline void nfs_fscache_get_client_cookie(struct nfs_client *clp) {} clp 197 fs/nfs/fscache.h static inline void nfs_fscache_release_client_cookie(struct nfs_client *clp) {} clp 188 fs/nfs/internal.h extern bool nfs_client_init_is_complete(const struct nfs_client *clp); clp 189 fs/nfs/internal.h extern int nfs_client_init_status(const struct nfs_client *clp); clp 190 fs/nfs/internal.h extern int nfs_wait_client_init_complete(const struct nfs_client *clp); clp 191 fs/nfs/internal.h extern void nfs_mark_client_ready(struct nfs_client *clp, int state); clp 343 fs/nfs/internal.h extern struct nfs_client *nfs_init_client(struct nfs_client *clp, clp 558 fs/nfs/internal.h extern struct nfs_client *nfs4_init_client(struct nfs_client *clp, clp 560 fs/nfs/internal.h extern int nfs40_walk_client_list(struct nfs_client *clp, clp 563 fs/nfs/internal.h extern int nfs41_walk_client_list(struct nfs_client *clp, clp 97 fs/nfs/nfs3client.c struct nfs_client *clp; clp 113 fs/nfs/nfs3client.c clp = nfs_get_client(&cl_init); clp 115 fs/nfs/nfs3client.c return clp; clp 249 fs/nfs/nfs4_fs.h struct nfs_client *clp; clp 295 fs/nfs/nfs4_fs.h extern int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred); clp 296 fs/nfs/nfs4_fs.h extern int nfs4_destroy_clientid(struct nfs_client *clp); clp 315 fs/nfs/nfs4_fs.h extern int nfs4_proc_get_lease_time(struct nfs_client *clp, clp 323 fs/nfs/nfs4_fs.h extern int nfs4_detect_session_trunking(struct nfs_client *clp, clp 327 fs/nfs/nfs4_fs.h is_ds_only_client(struct nfs_client *clp) clp 329 fs/nfs/nfs4_fs.h return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) == clp 334 fs/nfs/nfs4_fs.h is_ds_client(struct nfs_client *clp) clp 336 fs/nfs/nfs4_fs.h return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS; clp 340 fs/nfs/nfs4_fs.h _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode, clp 356 fs/nfs/nfs4_fs.h if (test_bit(sp4_mode, &clp->cl_sp4_flags)) { clp 359 fs/nfs/nfs4_fs.h flavor = clp->cl_rpcclient->cl_auth->au_flavor; clp 362 fs/nfs/nfs4_fs.h *clntp = clp->cl_rpcclient; clp 376 fs/nfs/nfs4_fs.h nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode, clp 379 fs/nfs/nfs4_fs.h _nfs4_state_protect(clp, sp4_mode, clntp, msg); clp 388 fs/nfs/nfs4_fs.h nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp, clp 391 fs/nfs/nfs4_fs.h if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) && clp 392 fs/nfs/nfs4_fs.h !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags)) clp 397 fs/nfs/nfs4_fs.h is_ds_only_client(struct nfs_client *clp) clp 403 fs/nfs/nfs4_fs.h is_ds_client(struct nfs_client *clp) clp 409 fs/nfs/nfs4_fs.h nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags, clp 415 fs/nfs/nfs4_fs.h nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp, clp 442 fs/nfs/nfs4_fs.h extern void nfs4_set_lease_period(struct nfs_client *clp, unsigned long lease); clp 446 fs/nfs/nfs4_fs.h const struct cred *nfs4_get_clid_cred(struct nfs_client *clp); clp 447 fs/nfs/nfs4_fs.h const struct cred *nfs4_get_machine_cred(struct nfs_client *clp); clp 448 fs/nfs/nfs4_fs.h const struct cred *nfs4_get_renew_cred(struct nfs_client *clp); clp 449 fs/nfs/nfs4_fs.h int nfs4_discover_server_trunking(struct nfs_client *clp, clp 451 fs/nfs/nfs4_fs.h int nfs40_discover_server_trunking(struct nfs_client *clp, clp 454 fs/nfs/nfs4_fs.h int nfs41_discover_server_trunking(struct nfs_client *clp, clp 477 fs/nfs/nfs4_fs.h extern int nfs4_wait_clnt_recover(struct nfs_client *clp); clp 478 fs/nfs/nfs4_fs.h extern int nfs4_client_recover_expired_lease(struct nfs_client *clp); clp 480 fs/nfs/nfs4_fs.h extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp); clp 484 fs/nfs/nfs4_fs.h extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, bool); clp 28 fs/nfs/nfs4client.c static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion) clp 31 fs/nfs/nfs4client.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 33 fs/nfs/nfs4client.c if (clp->rpc_ops->version != 4 || minorversion != 0) clp 37 fs/nfs/nfs4client.c ret = idr_alloc(&nn->cb_ident_idr, clp, 1, 0, GFP_NOWAIT); clp 39 fs/nfs/nfs4client.c clp->cl_cb_ident = ret; clp 152 fs/nfs/nfs4client.c nfs4_shutdown_ds_clients(struct nfs_client *clp) clp 156 fs/nfs/nfs4client.c while (!list_empty(&clp->cl_ds_clients)) { clp 157 fs/nfs/nfs4client.c dss = list_entry(clp->cl_ds_clients.next, clp 166 fs/nfs/nfs4client.c nfs4_cleanup_callback(struct nfs_client *clp) clp 170 fs/nfs/nfs4client.c while (!list_empty(&clp->pending_cb_stateids)) { clp 171 fs/nfs/nfs4client.c cp_state = list_entry(clp->pending_cb_stateids.next, clp 178 fs/nfs/nfs4client.c void nfs41_shutdown_client(struct nfs_client *clp) clp 180 fs/nfs/nfs4client.c if (nfs4_has_session(clp)) { clp 181 fs/nfs/nfs4client.c nfs4_cleanup_callback(clp); clp 182 fs/nfs/nfs4client.c nfs4_shutdown_ds_clients(clp); clp 183 fs/nfs/nfs4client.c nfs4_destroy_session(clp->cl_session); clp 184 fs/nfs/nfs4client.c nfs4_destroy_clientid(clp); clp 190 fs/nfs/nfs4client.c void nfs40_shutdown_client(struct nfs_client *clp) clp 192 fs/nfs/nfs4client.c if (clp->cl_slot_tbl) { clp 193 fs/nfs/nfs4client.c nfs4_shutdown_slot_table(clp->cl_slot_tbl); clp 194 fs/nfs/nfs4client.c kfree(clp->cl_slot_tbl); clp 201 fs/nfs/nfs4client.c struct nfs_client *clp = nfs_alloc_client(cl_init); clp 202 fs/nfs/nfs4client.c if (IS_ERR(clp)) clp 203 fs/nfs/nfs4client.c return clp; clp 205 fs/nfs/nfs4client.c err = nfs_get_cb_ident_idr(clp, cl_init->minorversion); clp 214 fs/nfs/nfs4client.c spin_lock_init(&clp->cl_lock); clp 215 fs/nfs/nfs4client.c INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state); clp 216 fs/nfs/nfs4client.c INIT_LIST_HEAD(&clp->cl_ds_clients); clp 217 fs/nfs/nfs4client.c rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client"); clp 218 fs/nfs/nfs4client.c clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED; clp 219 fs/nfs/nfs4client.c clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion]; clp 220 fs/nfs/nfs4client.c clp->cl_mig_gen = 1; clp 222 fs/nfs/nfs4client.c init_waitqueue_head(&clp->cl_lock_waitq); clp 224 fs/nfs/nfs4client.c INIT_LIST_HEAD(&clp->pending_cb_stateids); clp 225 fs/nfs/nfs4client.c return clp; clp 228 fs/nfs/nfs4client.c nfs_free_client(clp); clp 235 fs/nfs/nfs4client.c static void nfs4_destroy_callback(struct nfs_client *clp) clp 237 fs/nfs/nfs4client.c if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state)) clp 238 fs/nfs/nfs4client.c nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net); clp 241 fs/nfs/nfs4client.c static void nfs4_shutdown_client(struct nfs_client *clp) clp 243 fs/nfs/nfs4client.c if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state)) clp 244 fs/nfs/nfs4client.c nfs4_kill_renewd(clp); clp 245 fs/nfs/nfs4client.c clp->cl_mvops->shutdown_client(clp); clp 246 fs/nfs/nfs4client.c nfs4_destroy_callback(clp); clp 247 fs/nfs/nfs4client.c if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state)) clp 248 fs/nfs/nfs4client.c nfs_idmap_delete(clp); clp 250 fs/nfs/nfs4client.c rpc_destroy_wait_queue(&clp->cl_rpcwaitq); clp 251 fs/nfs/nfs4client.c kfree(clp->cl_serverowner); clp 252 fs/nfs/nfs4client.c kfree(clp->cl_serverscope); clp 253 fs/nfs/nfs4client.c kfree(clp->cl_implid); clp 254 fs/nfs/nfs4client.c kfree(clp->cl_owner_id); clp 257 fs/nfs/nfs4client.c void nfs4_free_client(struct nfs_client *clp) clp 259 fs/nfs/nfs4client.c nfs4_shutdown_client(clp); clp 260 fs/nfs/nfs4client.c nfs_free_client(clp); clp 266 fs/nfs/nfs4client.c static int nfs4_init_callback(struct nfs_client *clp) clp 271 fs/nfs/nfs4client.c xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt); clp 273 fs/nfs/nfs4client.c if (nfs4_has_session(clp)) { clp 279 fs/nfs/nfs4client.c error = nfs_callback_up(clp->cl_mvops->minor_version, xprt); clp 285 fs/nfs/nfs4client.c __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state); clp 296 fs/nfs/nfs4client.c int nfs40_init_client(struct nfs_client *clp) clp 312 fs/nfs/nfs4client.c clp->cl_slot_tbl = tbl; clp 324 fs/nfs/nfs4client.c int nfs41_init_client(struct nfs_client *clp) clp 333 fs/nfs/nfs4client.c session = nfs4_alloc_session(clp); clp 337 fs/nfs/nfs4client.c clp->cl_session = session; clp 345 fs/nfs/nfs4client.c nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING); clp 354 fs/nfs/nfs4client.c static int nfs4_init_client_minor_version(struct nfs_client *clp) clp 358 fs/nfs/nfs4client.c ret = clp->cl_mvops->init_client(clp); clp 361 fs/nfs/nfs4client.c return nfs4_init_callback(clp); clp 372 fs/nfs/nfs4client.c struct nfs_client *nfs4_init_client(struct nfs_client *clp, clp 380 fs/nfs/nfs4client.c if (clp->cl_cons_state == NFS_CS_READY) clp 382 fs/nfs/nfs4client.c return clp; clp 385 fs/nfs/nfs4client.c clp->rpc_ops = &nfs_v4_clientops; clp 387 fs/nfs/nfs4client.c if (clp->cl_minorversion != 0) clp 388 fs/nfs/nfs4client.c __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); clp 389 fs/nfs/nfs4client.c __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); clp 390 fs/nfs/nfs4client.c __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); clp 392 fs/nfs/nfs4client.c error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); clp 394 fs/nfs/nfs4client.c error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); clp 403 fs/nfs/nfs4client.c error = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); clp 411 fs/nfs/nfs4client.c strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); clp 413 fs/nfs/nfs4client.c error = nfs_idmap_new(clp); clp 419 fs/nfs/nfs4client.c __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); clp 421 fs/nfs/nfs4client.c error = nfs4_init_client_minor_version(clp); clp 425 fs/nfs/nfs4client.c error = nfs4_discover_server_trunking(clp, &old); clp 429 fs/nfs/nfs4client.c if (clp != old) { clp 430 fs/nfs/nfs4client.c clp->cl_preserve_clid = true; clp 436 fs/nfs/nfs4client.c nfs_mark_client_ready(clp, -EPERM); clp 438 fs/nfs/nfs4client.c nfs_put_client(clp); clp 439 fs/nfs/nfs4client.c clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags); clp 443 fs/nfs/nfs4client.c nfs_mark_client_ready(clp, error); clp 444 fs/nfs/nfs4client.c nfs_put_client(clp); clp 669 fs/nfs/nfs4client.c int nfs4_detect_session_trunking(struct nfs_client *clp, clp 674 fs/nfs/nfs4client.c if (clp->cl_clientid != res->clientid) clp 678 fs/nfs/nfs4client.c if (!nfs4_check_serverowner_major_id(clp->cl_serverowner, clp 683 fs/nfs/nfs4client.c if (clp->cl_serverowner->minor_id != res->server_owner->minor_id) clp 687 fs/nfs/nfs4client.c if (!nfs4_check_server_scope(clp->cl_serverscope, res->server_scope)) clp 691 fs/nfs/nfs4client.c clp->cl_hostname, clp 696 fs/nfs/nfs4client.c pr_info("NFS: %s: Session trunking failed for %s\n", clp->cl_hostname, clp 776 fs/nfs/nfs4client.c struct nfs_client *clp; clp 780 fs/nfs/nfs4client.c clp = idr_find(&nn->cb_ident_idr, cb_ident); clp 781 fs/nfs/nfs4client.c if (clp) clp 782 fs/nfs/nfs4client.c refcount_inc(&clp->cl_count); clp 784 fs/nfs/nfs4client.c return clp; clp 790 fs/nfs/nfs4client.c struct nfs_client *clp, u32 minorversion) clp 792 fs/nfs/nfs4client.c struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr; clp 795 fs/nfs/nfs4client.c if (!(clp->cl_cons_state == NFS_CS_READY || clp 796 fs/nfs/nfs4client.c clp->cl_cons_state == NFS_CS_SESSION_INITING)) clp 802 fs/nfs/nfs4client.c if (clp->rpc_ops->version != 4 || clp 803 fs/nfs/nfs4client.c clp->cl_minorversion != minorversion) clp 821 fs/nfs/nfs4client.c struct nfs_client *clp; clp 825 fs/nfs/nfs4client.c list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { clp 826 fs/nfs/nfs4client.c if (!nfs4_cb_match_client(addr, clp, minorversion)) clp 829 fs/nfs/nfs4client.c if (!nfs4_has_session(clp)) clp 833 fs/nfs/nfs4client.c if (memcmp(clp->cl_session->sess_id.data, clp 837 fs/nfs/nfs4client.c refcount_inc(&clp->cl_count); clp 839 fs/nfs/nfs4client.c return clp; clp 879 fs/nfs/nfs4client.c struct nfs_client *clp; clp 892 fs/nfs/nfs4client.c clp = nfs_get_client(&cl_init); clp 893 fs/nfs/nfs4client.c if (IS_ERR(clp)) clp 894 fs/nfs/nfs4client.c return PTR_ERR(clp); clp 896 fs/nfs/nfs4client.c if (server->nfs_client == clp) { clp 897 fs/nfs/nfs4client.c nfs_put_client(clp); clp 908 fs/nfs/nfs4client.c set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state); clp 910 fs/nfs/nfs4client.c server->nfs_client = clp; clp 1256 fs/nfs/nfs4client.c struct nfs_client *clp = server->nfs_client; clp 1259 fs/nfs/nfs4client.c .ident = clp->cl_proto, clp 1284 fs/nfs/nfs4client.c clp->cl_proto, clnt->cl_timeout, clp 1285 fs/nfs/nfs4client.c clp->cl_minorversion, clp 1286 fs/nfs/nfs4client.c clp->cl_nconnect, net); clp 1292 fs/nfs/nfs4client.c nfs_put_client(clp); clp 454 fs/nfs/nfs4idmap.c nfs_idmap_new(struct nfs_client *clp) clp 465 fs/nfs/nfs4idmap.c idmap->cred = get_cred(clp->cl_rpcclient->cl_cred); clp 478 fs/nfs/nfs4idmap.c error = rpc_add_pipe_dir_object(clp->cl_net, clp 479 fs/nfs/nfs4idmap.c &clp->cl_rpcclient->cl_pipedir_objects, clp 484 fs/nfs/nfs4idmap.c clp->cl_idmap = idmap; clp 495 fs/nfs/nfs4idmap.c nfs_idmap_delete(struct nfs_client *clp) clp 497 fs/nfs/nfs4idmap.c struct idmap *idmap = clp->cl_idmap; clp 501 fs/nfs/nfs4idmap.c clp->cl_idmap = NULL; clp 502 fs/nfs/nfs4idmap.c rpc_remove_pipe_dir_object(clp->cl_net, clp 503 fs/nfs/nfs4idmap.c &clp->cl_rpcclient->cl_pipedir_objects, clp 101 fs/nfs/nfs4proc.c static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, clp 453 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 506 fs/nfs/nfs4proc.c nfs4_schedule_lease_recovery(clp); clp 514 fs/nfs/nfs4proc.c nfs4_schedule_lease_moved_recovery(clp); clp 574 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 584 fs/nfs/nfs4proc.c ret = nfs4_wait_clnt_recover(clp); clp 600 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 609 fs/nfs/nfs4proc.c rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); clp 610 fs/nfs/nfs4proc.c if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) clp 611 fs/nfs/nfs4proc.c rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); clp 656 fs/nfs/nfs4proc.c static bool _nfs4_is_integrity_protected(struct nfs_client *clp) clp 658 fs/nfs/nfs4proc.c rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor; clp 662 fs/nfs/nfs4proc.c static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp) clp 664 fs/nfs/nfs4proc.c spin_lock(&clp->cl_lock); clp 665 fs/nfs/nfs4proc.c if (time_before(clp->cl_last_renewal,timestamp)) clp 666 fs/nfs/nfs4proc.c clp->cl_last_renewal = timestamp; clp 667 fs/nfs/nfs4proc.c spin_unlock(&clp->cl_lock); clp 672 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 674 fs/nfs/nfs4proc.c if (!nfs4_has_session(clp)) clp 675 fs/nfs/nfs4proc.c do_renew_lease(clp, timestamp); clp 753 fs/nfs/nfs4proc.c nfs41_notify_server(session->clp); clp 782 fs/nfs/nfs4proc.c struct nfs_client *clp; clp 807 fs/nfs/nfs4proc.c clp = session->clp; clp 808 fs/nfs/nfs4proc.c do_renew_lease(clp, res->sr_timestamp); clp 810 fs/nfs/nfs4proc.c nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags, clp 1106 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 1115 fs/nfs/nfs4proc.c .callback_ops = clp->cl_mvops->call_sync_ops, clp 1517 fs/nfs/nfs4proc.c struct nfs_client *clp = state->owner->so_server->nfs_client; clp 1527 fs/nfs/nfs4proc.c nfs4_state_mark_reclaim_nograce(clp, state); clp 1735 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 1777 fs/nfs/nfs4proc.c nfs4_schedule_state_manager(clp); clp 1867 fs/nfs/nfs4proc.c struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client; clp 1884 fs/nfs/nfs4proc.c clp->cl_hostname); clp 2364 fs/nfs/nfs4proc.c struct nfs_client *clp = sp->so_server->nfs_client; clp 2386 fs/nfs/nfs4proc.c data->o_arg.clientid = clp->cl_clientid; clp 2409 fs/nfs/nfs4proc.c if (nfs4_has_persistent_session(clp)) clp 2411 fs/nfs/nfs4proc.c else if (clp->cl_mvops->minor_version > 0) clp 5401 fs/nfs/nfs4proc.c struct nfs_client *clp = data->client; clp 5403 fs/nfs/nfs4proc.c if (refcount_read(&clp->cl_count) > 1) clp 5404 fs/nfs/nfs4proc.c nfs4_schedule_state_renewal(clp); clp 5405 fs/nfs/nfs4proc.c nfs_put_client(clp); clp 5412 fs/nfs/nfs4proc.c struct nfs_client *clp = data->client; clp 5415 fs/nfs/nfs4proc.c trace_nfs4_renew_async(clp, task->tk_status); clp 5420 fs/nfs/nfs4proc.c nfs4_schedule_lease_moved_recovery(clp); clp 5424 fs/nfs/nfs4proc.c if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0) clp 5427 fs/nfs/nfs4proc.c nfs4_schedule_lease_recovery(clp); clp 5430 fs/nfs/nfs4proc.c nfs4_schedule_path_down_recovery(clp); clp 5432 fs/nfs/nfs4proc.c do_renew_lease(clp, timestamp); clp 5440 fs/nfs/nfs4proc.c static int nfs4_proc_async_renew(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags) clp 5444 fs/nfs/nfs4proc.c .rpc_argp = clp, clp 5451 fs/nfs/nfs4proc.c if (!refcount_inc_not_zero(&clp->cl_count)) clp 5455 fs/nfs/nfs4proc.c nfs_put_client(clp); clp 5458 fs/nfs/nfs4proc.c data->client = clp; clp 5460 fs/nfs/nfs4proc.c return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, clp 5464 fs/nfs/nfs4proc.c static int nfs4_proc_renew(struct nfs_client *clp, const struct cred *cred) clp 5468 fs/nfs/nfs4proc.c .rpc_argp = clp, clp 5474 fs/nfs/nfs4proc.c status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); clp 5477 fs/nfs/nfs4proc.c do_renew_lease(clp, now); clp 5912 fs/nfs/nfs4proc.c static void nfs4_init_boot_verifier(const struct nfs_client *clp, clp 5917 fs/nfs/nfs4proc.c if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { clp 5923 fs/nfs/nfs4proc.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 5933 fs/nfs/nfs4proc.c nfs4_init_nonuniform_client_string(struct nfs_client *clp) clp 5938 fs/nfs/nfs4proc.c if (clp->cl_owner_id != NULL) clp 5943 fs/nfs/nfs4proc.c strlen(clp->cl_rpcclient->cl_nodename) + clp 5945 fs/nfs/nfs4proc.c strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) + clp 5965 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_nodename, clp 5967 fs/nfs/nfs4proc.c rpc_peeraddr2str(clp->cl_rpcclient, clp 5971 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_nodename, clp 5972 fs/nfs/nfs4proc.c rpc_peeraddr2str(clp->cl_rpcclient, clp 5976 fs/nfs/nfs4proc.c clp->cl_owner_id = str; clp 5981 fs/nfs/nfs4proc.c nfs4_init_uniquifier_client_string(struct nfs_client *clp) clp 5988 fs/nfs/nfs4proc.c strlen(clp->cl_rpcclient->cl_nodename) + 1; clp 6003 fs/nfs/nfs4proc.c clp->rpc_ops->version, clp->cl_minorversion, clp 6005 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_nodename); clp 6006 fs/nfs/nfs4proc.c clp->cl_owner_id = str; clp 6011 fs/nfs/nfs4proc.c nfs4_init_uniform_client_string(struct nfs_client *clp) clp 6016 fs/nfs/nfs4proc.c if (clp->cl_owner_id != NULL) clp 6020 fs/nfs/nfs4proc.c return nfs4_init_uniquifier_client_string(clp); clp 6023 fs/nfs/nfs4proc.c strlen(clp->cl_rpcclient->cl_nodename) + 1; clp 6038 fs/nfs/nfs4proc.c clp->rpc_ops->version, clp->cl_minorversion, clp 6039 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_nodename); clp 6040 fs/nfs/nfs4proc.c clp->cl_owner_id = str; clp 6050 fs/nfs/nfs4proc.c nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len) clp 6052 fs/nfs/nfs4proc.c if (strchr(clp->cl_ipaddr, ':') != NULL) clp 6080 fs/nfs/nfs4proc.c int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, clp 6088 fs/nfs/nfs4proc.c .sc_clnt = clp, clp 6097 fs/nfs/nfs4proc.c .rpc_client = clp->cl_rpcclient, clp 6107 fs/nfs/nfs4proc.c nfs4_init_boot_verifier(clp, &sc_verifier); clp 6109 fs/nfs/nfs4proc.c if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags)) clp 6110 fs/nfs/nfs4proc.c status = nfs4_init_uniform_client_string(clp); clp 6112 fs/nfs/nfs4proc.c status = nfs4_init_nonuniform_client_string(clp); clp 6119 fs/nfs/nfs4proc.c nfs4_init_callback_netid(clp, clp 6124 fs/nfs/nfs4proc.c clp->cl_ipaddr, port >> 8, port & 255); clp 6127 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_auth->au_ops->au_name, clp 6128 fs/nfs/nfs4proc.c clp->cl_owner_id); clp 6132 fs/nfs/nfs4proc.c kfree(clp->cl_acceptor); clp 6133 fs/nfs/nfs4proc.c clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred); clp 6138 fs/nfs/nfs4proc.c do_renew_lease(clp, now); clp 6140 fs/nfs/nfs4proc.c trace_nfs4_setclientid(clp, status); clp 6153 fs/nfs/nfs4proc.c int nfs4_proc_setclientid_confirm(struct nfs_client *clp, clp 6165 fs/nfs/nfs4proc.c clp->cl_rpcclient->cl_auth->au_ops->au_name, clp 6166 fs/nfs/nfs4proc.c clp->cl_clientid); clp 6167 fs/nfs/nfs4proc.c status = rpc_call_sync(clp->cl_rpcclient, &msg, clp 6169 fs/nfs/nfs4proc.c trace_nfs4_setclientid_confirm(clp, status); clp 6388 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 6405 fs/nfs/nfs4proc.c arg.lock_owner.clientid = clp->cl_clientid; clp 7116 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 7117 fs/nfs/nfs4proc.c wait_queue_head_t *q = &clp->cl_lock_waitq; clp 7118 fs/nfs/nfs4proc.c struct nfs_lowner owner = { .clientid = clp->cl_clientid, clp 7585 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 7587 fs/nfs/nfs4proc.c clp->cl_mvops->mig_recovery_ops; clp 7596 fs/nfs/nfs4proc.c clp->cl_hostname); clp 7618 fs/nfs/nfs4proc.c struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; clp 7622 fs/nfs/nfs4proc.c .clientid = clp->cl_clientid, clp 7648 fs/nfs/nfs4proc.c do_renew_lease(clp, now); clp 7711 fs/nfs/nfs4proc.c struct nfs_client *clp = server->nfs_client; clp 7713 fs/nfs/nfs4proc.c clp->cl_mvops->mig_recovery_ops; clp 7722 fs/nfs/nfs4proc.c clp->cl_hostname); clp 7745 fs/nfs/nfs4proc.c struct nfs_client *clp = NFS_SERVER(dir)->nfs_client; clp 7766 fs/nfs/nfs4proc.c .callback_ops = clp->cl_mvops->call_sync_ops, clp 7773 fs/nfs/nfs4proc.c clnt = clp->cl_rpcclient; clp 7776 fs/nfs/nfs4proc.c cred = nfs4_get_clid_cred(clp); clp 7782 fs/nfs/nfs4proc.c nfs4_state_protect(clp, NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg); clp 7856 fs/nfs/nfs4proc.c struct nfs_client *clp = args->client; clp 7861 fs/nfs/nfs4proc.c nfs4_schedule_session_recovery(clp->cl_session, clp 7885 fs/nfs/nfs4proc.c struct nfs_client *clp, clp 7890 fs/nfs/nfs4proc.c .client = clp, clp 7911 fs/nfs/nfs4proc.c nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id); clp 7912 fs/nfs/nfs4proc.c if (!(clp->cl_session->flags & SESSION4_BACK_CHAN)) clp 7925 fs/nfs/nfs4proc.c trace_nfs4_bind_conn_to_session(clp, status); clp 7928 fs/nfs/nfs4proc.c clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) { clp 7948 fs/nfs/nfs4proc.c struct nfs_client *clp; clp 7959 fs/nfs/nfs4proc.c return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred); clp 7962 fs/nfs/nfs4proc.c int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, const struct cred *cred) clp 7965 fs/nfs/nfs4proc.c .clp = clp, clp 7968 fs/nfs/nfs4proc.c return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient, clp 8006 fs/nfs/nfs4proc.c static int nfs4_sp4_select_mode(struct nfs_client *clp, clp 8097 fs/nfs/nfs4proc.c clp->cl_sp4_flags = flags; clp 8128 fs/nfs/nfs4proc.c nfs4_run_exchange_id(struct nfs_client *clp, const struct cred *cred, clp 8136 fs/nfs/nfs4proc.c .rpc_client = clp->cl_rpcclient, clp 8144 fs/nfs/nfs4proc.c if (!refcount_inc_not_zero(&clp->cl_count)) clp 8152 fs/nfs/nfs4proc.c nfs4_init_boot_verifier(clp, &calldata->args.verifier); clp 8154 fs/nfs/nfs4proc.c status = nfs4_init_uniform_client_string(clp); clp 8191 fs/nfs/nfs4proc.c memcpy(calldata->args.verifier.data, clp->cl_confirm.data, clp 8194 fs/nfs/nfs4proc.c calldata->args.client = clp; clp 8215 fs/nfs/nfs4proc.c nfs_put_client(clp); clp 8224 fs/nfs/nfs4proc.c static int _nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred, clp 8233 fs/nfs/nfs4proc.c task = nfs4_run_exchange_id(clp, cred, sp4_how, NULL); clp 8247 fs/nfs/nfs4proc.c status = nfs4_sp4_select_mode(clp, &resp->state_protect); clp 8251 fs/nfs/nfs4proc.c do_renew_lease(clp, now); clp 8253 fs/nfs/nfs4proc.c clp->cl_clientid = resp->clientid; clp 8254 fs/nfs/nfs4proc.c clp->cl_exchange_flags = resp->flags; clp 8255 fs/nfs/nfs4proc.c clp->cl_seqid = resp->seqid; clp 8259 fs/nfs/nfs4proc.c &clp->cl_session->session_state); clp 8261 fs/nfs/nfs4proc.c if (clp->cl_serverscope != NULL && clp 8262 fs/nfs/nfs4proc.c !nfs41_same_server_scope(clp->cl_serverscope, clp 8266 fs/nfs/nfs4proc.c set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); clp 8269 fs/nfs/nfs4proc.c swap(clp->cl_serverowner, resp->server_owner); clp 8270 fs/nfs/nfs4proc.c swap(clp->cl_serverscope, resp->server_scope); clp 8271 fs/nfs/nfs4proc.c swap(clp->cl_implid, resp->impl_id); clp 8274 fs/nfs/nfs4proc.c memcpy(clp->cl_confirm.data, argp->verifier.data, clp 8275 fs/nfs/nfs4proc.c sizeof(clp->cl_confirm.data)); clp 8277 fs/nfs/nfs4proc.c trace_nfs4_exchange_id(clp, status); clp 8294 fs/nfs/nfs4proc.c int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred) clp 8296 fs/nfs/nfs4proc.c rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; clp 8302 fs/nfs/nfs4proc.c status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED); clp 8308 fs/nfs/nfs4proc.c return _nfs4_proc_exchange_id(clp, cred, SP4_NONE); clp 8338 fs/nfs/nfs4proc.c sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED); clp 8341 fs/nfs/nfs4proc.c task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt); clp 8347 fs/nfs/nfs4proc.c status = nfs4_detect_session_trunking(adata->clp, clp 8357 fs/nfs/nfs4proc.c static int _nfs4_proc_destroy_clientid(struct nfs_client *clp, clp 8362 fs/nfs/nfs4proc.c .rpc_argp = clp, clp 8367 fs/nfs/nfs4proc.c status = rpc_call_sync(clp->cl_rpcclient, &msg, clp 8369 fs/nfs/nfs4proc.c trace_nfs4_destroy_clientid(clp, status); clp 8372 fs/nfs/nfs4proc.c "DESTROY_CLIENTID.", status, clp->cl_hostname); clp 8376 fs/nfs/nfs4proc.c static int nfs4_proc_destroy_clientid(struct nfs_client *clp, clp 8383 fs/nfs/nfs4proc.c ret = _nfs4_proc_destroy_clientid(clp, cred); clp 8396 fs/nfs/nfs4proc.c int nfs4_destroy_clientid(struct nfs_client *clp) clp 8401 fs/nfs/nfs4proc.c if (clp->cl_mvops->minor_version < 1) clp 8403 fs/nfs/nfs4proc.c if (clp->cl_exchange_flags == 0) clp 8405 fs/nfs/nfs4proc.c if (clp->cl_preserve_clid) clp 8407 fs/nfs/nfs4proc.c cred = nfs4_get_clid_cred(clp); clp 8408 fs/nfs/nfs4proc.c ret = nfs4_proc_destroy_clientid(clp, cred); clp 8413 fs/nfs/nfs4proc.c clp->cl_exchange_flags = 0; clp 8424 fs/nfs/nfs4proc.c struct nfs_client *clp; clp 8436 fs/nfs/nfs4proc.c nfs4_setup_sequence(data->clp, clp 8474 fs/nfs/nfs4proc.c int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo) clp 8483 fs/nfs/nfs4proc.c .clp = clp, clp 8491 fs/nfs/nfs4proc.c .rpc_client = clp->cl_rpcclient, clp 8613 fs/nfs/nfs4proc.c session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R; clp 8622 fs/nfs/nfs4proc.c static int _nfs4_proc_create_session(struct nfs_client *clp, clp 8625 fs/nfs/nfs4proc.c struct nfs4_session *session = clp->cl_session; clp 8627 fs/nfs/nfs4proc.c .client = clp, clp 8628 fs/nfs/nfs4proc.c .clientid = clp->cl_clientid, clp 8629 fs/nfs/nfs4proc.c .seqid = clp->cl_seqid, clp 8642 fs/nfs/nfs4proc.c nfs4_init_channel_attrs(&args, clp->cl_rpcclient); clp 8645 fs/nfs/nfs4proc.c status = rpc_call_sync(session->clp->cl_rpcclient, &msg, clp 8647 fs/nfs/nfs4proc.c trace_nfs4_create_session(clp, status); clp 8658 fs/nfs/nfs4proc.c clp->cl_seqid++; clp 8676 fs/nfs/nfs4proc.c int nfs4_proc_create_session(struct nfs_client *clp, const struct cred *cred) clp 8680 fs/nfs/nfs4proc.c struct nfs4_session *session = clp->cl_session; clp 8682 fs/nfs/nfs4proc.c dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); clp 8684 fs/nfs/nfs4proc.c status = _nfs4_proc_create_session(clp, cred); clp 8696 fs/nfs/nfs4proc.c clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); clp 8722 fs/nfs/nfs4proc.c status = rpc_call_sync(session->clp->cl_rpcclient, &msg, clp 8724 fs/nfs/nfs4proc.c trace_nfs4_destroy_session(session->clp, status); clp 8738 fs/nfs/nfs4proc.c struct nfs_client *clp; clp 8746 fs/nfs/nfs4proc.c struct nfs_client *clp = calldata->clp; clp 8748 fs/nfs/nfs4proc.c if (refcount_read(&clp->cl_count) > 1) clp 8749 fs/nfs/nfs4proc.c nfs4_schedule_state_renewal(clp); clp 8750 fs/nfs/nfs4proc.c nfs_put_client(clp); clp 8754 fs/nfs/nfs4proc.c static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp) clp 8761 fs/nfs/nfs4proc.c nfs4_schedule_lease_recovery(clp); clp 8769 fs/nfs/nfs4proc.c struct nfs_client *clp = calldata->clp; clp 8774 fs/nfs/nfs4proc.c trace_nfs4_sequence(clp, task->tk_status); clp 8777 fs/nfs/nfs4proc.c if (refcount_read(&clp->cl_count) == 1) clp 8780 fs/nfs/nfs4proc.c if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { clp 8793 fs/nfs/nfs4proc.c struct nfs_client *clp = calldata->clp; clp 8800 fs/nfs/nfs4proc.c nfs4_setup_sequence(clp, args, res, task); clp 8809 fs/nfs/nfs4proc.c static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp, clp 8820 fs/nfs/nfs4proc.c .rpc_client = clp->cl_rpcclient, clp 8828 fs/nfs/nfs4proc.c if (!refcount_inc_not_zero(&clp->cl_count)) clp 8839 fs/nfs/nfs4proc.c calldata->clp = clp; clp 8847 fs/nfs/nfs4proc.c nfs_put_client(clp); clp 8853 fs/nfs/nfs4proc.c static int nfs41_proc_async_sequence(struct nfs_client *clp, const struct cred *cred, unsigned renew_flags) clp 8860 fs/nfs/nfs4proc.c task = _nfs41_proc_sequence(clp, cred, NULL, false); clp 8869 fs/nfs/nfs4proc.c static int nfs4_proc_sequence(struct nfs_client *clp, const struct cred *cred) clp 8874 fs/nfs/nfs4proc.c task = _nfs41_proc_sequence(clp, cred, NULL, true); clp 8889 fs/nfs/nfs4proc.c struct nfs_client *clp; clp 8898 fs/nfs/nfs4proc.c nfs4_setup_sequence(calldata->clp, clp 8904 fs/nfs/nfs4proc.c static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp) clp 8908 fs/nfs/nfs4proc.c wake_up_all(&clp->cl_lock_waitq); clp 8923 fs/nfs/nfs4proc.c nfs4_schedule_lease_recovery(clp); clp 8931 fs/nfs/nfs4proc.c struct nfs_client *clp = calldata->clp; clp 8938 fs/nfs/nfs4proc.c trace_nfs4_reclaim_complete(clp, task->tk_status); clp 8939 fs/nfs/nfs4proc.c if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { clp 8962 fs/nfs/nfs4proc.c static int nfs41_proc_reclaim_complete(struct nfs_client *clp, clp 8971 fs/nfs/nfs4proc.c .rpc_client = clp->cl_rpcclient, clp 8982 fs/nfs/nfs4proc.c calldata->clp = clp; clp 9197 fs/nfs/nfs4proc.c nfs4_setup_sequence(lrp->clp, clp 58 fs/nfs/nfs4renewd.c struct nfs_client *clp = clp 65 fs/nfs/nfs4renewd.c ops = clp->cl_mvops->state_renewal_ops; clp 68 fs/nfs/nfs4renewd.c if (test_bit(NFS_CS_STOP_RENEW, &clp->cl_res_state)) clp 71 fs/nfs/nfs4renewd.c lease = clp->cl_lease_time; clp 72 fs/nfs/nfs4renewd.c last = clp->cl_last_renewal; clp 77 fs/nfs/nfs4renewd.c if (nfs_delegations_present(clp)) clp 81 fs/nfs/nfs4renewd.c cred = ops->get_state_renewal_cred(clp); clp 84 fs/nfs/nfs4renewd.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 87 fs/nfs/nfs4renewd.c nfs_expire_all_delegations(clp); clp 92 fs/nfs/nfs4renewd.c ret = ops->sched_state_renewal(clp, cred, renew_flags); clp 106 fs/nfs/nfs4renewd.c nfs4_schedule_state_renewal(clp); clp 108 fs/nfs/nfs4renewd.c nfs_expire_unreferenced_delegations(clp); clp 114 fs/nfs/nfs4renewd.c nfs4_schedule_state_renewal(struct nfs_client *clp) clp 118 fs/nfs/nfs4renewd.c spin_lock(&clp->cl_lock); clp 119 fs/nfs/nfs4renewd.c timeout = (2 * clp->cl_lease_time) / 3 + (long)clp->cl_last_renewal clp 125 fs/nfs/nfs4renewd.c mod_delayed_work(system_wq, &clp->cl_renewd, timeout); clp 126 fs/nfs/nfs4renewd.c set_bit(NFS_CS_RENEWD, &clp->cl_res_state); clp 127 fs/nfs/nfs4renewd.c spin_unlock(&clp->cl_lock); clp 131 fs/nfs/nfs4renewd.c nfs4_kill_renewd(struct nfs_client *clp) clp 133 fs/nfs/nfs4renewd.c cancel_delayed_work_sync(&clp->cl_renewd); clp 142 fs/nfs/nfs4renewd.c void nfs4_set_lease_period(struct nfs_client *clp, clp 145 fs/nfs/nfs4renewd.c spin_lock(&clp->cl_lock); clp 146 fs/nfs/nfs4renewd.c clp->cl_lease_time = lease; clp 147 fs/nfs/nfs4renewd.c spin_unlock(&clp->cl_lock); clp 150 fs/nfs/nfs4renewd.c rpc_set_connect_timeout(clp->cl_rpcclient, lease, lease >> 1); clp 555 fs/nfs/nfs4session.c struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) clp 567 fs/nfs/nfs4session.c session->clp = clp; clp 582 fs/nfs/nfs4session.c cred = nfs4_get_clid_cred(session->clp); clp 587 fs/nfs/nfs4session.c xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt); clp 603 fs/nfs/nfs4session.c static int nfs41_check_session_ready(struct nfs_client *clp) clp 607 fs/nfs/nfs4session.c if (clp->cl_cons_state == NFS_CS_SESSION_INITING) { clp 608 fs/nfs/nfs4session.c ret = nfs4_client_recover_expired_lease(clp); clp 612 fs/nfs/nfs4session.c if (clp->cl_cons_state < NFS_CS_READY) clp 618 fs/nfs/nfs4session.c int nfs4_init_session(struct nfs_client *clp) clp 620 fs/nfs/nfs4session.c if (!nfs4_has_session(clp)) clp 623 fs/nfs/nfs4session.c clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state); clp 624 fs/nfs/nfs4session.c return nfs41_check_session_ready(clp); clp 627 fs/nfs/nfs4session.c int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time) clp 629 fs/nfs/nfs4session.c struct nfs4_session *session = clp->cl_session; clp 632 fs/nfs/nfs4session.c spin_lock(&clp->cl_lock); clp 638 fs/nfs/nfs4session.c clp->cl_lease_time = lease_time; clp 639 fs/nfs/nfs4session.c clp->cl_last_renewal = jiffies; clp 641 fs/nfs/nfs4session.c spin_unlock(&clp->cl_lock); clp 643 fs/nfs/nfs4session.c ret = nfs41_check_session_ready(clp); clp 647 fs/nfs/nfs4session.c if (!is_ds_client(clp)) clp 74 fs/nfs/nfs4session.h struct nfs_client *clp; clp 108 fs/nfs/nfs4session.h static inline struct nfs4_session *nfs4_get_session(const struct nfs_client *clp) clp 110 fs/nfs/nfs4session.h return clp->cl_session; clp 122 fs/nfs/nfs4session.h extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp); clp 124 fs/nfs/nfs4session.h extern int nfs4_init_session(struct nfs_client *clp); clp 130 fs/nfs/nfs4session.h static inline int nfs4_has_session(const struct nfs_client *clp) clp 132 fs/nfs/nfs4session.h if (clp->cl_session) clp 137 fs/nfs/nfs4session.h static inline int nfs4_has_persistent_session(const struct nfs_client *clp) clp 139 fs/nfs/nfs4session.h if (nfs4_has_session(clp)) clp 140 fs/nfs/nfs4session.h return (clp->cl_session->flags & SESSION4_PERSIST); clp 162 fs/nfs/nfs4session.h static inline int nfs4_init_session(struct nfs_client *clp) clp 170 fs/nfs/nfs4session.h static inline int nfs4_has_session(const struct nfs_client *clp) clp 175 fs/nfs/nfs4session.h static inline int nfs4_has_persistent_session(const struct nfs_client *clp) clp 90 fs/nfs/nfs4state.c static int nfs4_setup_state_renewal(struct nfs_client *clp) clp 95 fs/nfs/nfs4state.c if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) { clp 96 fs/nfs/nfs4state.c nfs4_schedule_state_renewal(clp); clp 100 fs/nfs/nfs4state.c status = nfs4_proc_get_lease_time(clp, &fsinfo); clp 102 fs/nfs/nfs4state.c nfs4_set_lease_period(clp, fsinfo.lease_time * HZ); clp 103 fs/nfs/nfs4state.c nfs4_schedule_state_renewal(clp); clp 109 fs/nfs/nfs4state.c int nfs4_init_clientid(struct nfs_client *clp, const struct cred *cred) clp 112 fs/nfs/nfs4state.c .clientid = clp->cl_clientid, clp 113 fs/nfs/nfs4state.c .confirm = clp->cl_confirm, clp 117 fs/nfs/nfs4state.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 119 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state)) clp 122 fs/nfs/nfs4state.c if (clp->cl_addr.ss_family == AF_INET6) clp 125 fs/nfs/nfs4state.c status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid); clp 128 fs/nfs/nfs4state.c clp->cl_clientid = clid.clientid; clp 129 fs/nfs/nfs4state.c clp->cl_confirm = clid.confirm; clp 130 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 132 fs/nfs/nfs4state.c status = nfs4_proc_setclientid_confirm(clp, &clid, cred); clp 135 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 136 fs/nfs/nfs4state.c nfs4_setup_state_renewal(clp); clp 154 fs/nfs/nfs4state.c int nfs40_discover_server_trunking(struct nfs_client *clp, clp 159 fs/nfs/nfs4state.c .clientid = clp->cl_clientid, clp 160 fs/nfs/nfs4state.c .confirm = clp->cl_confirm, clp 162 fs/nfs/nfs4state.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 167 fs/nfs/nfs4state.c if (clp->cl_addr.ss_family == AF_INET6) clp 170 fs/nfs/nfs4state.c status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid); clp 173 fs/nfs/nfs4state.c clp->cl_clientid = clid.clientid; clp 174 fs/nfs/nfs4state.c clp->cl_confirm = clid.confirm; clp 176 fs/nfs/nfs4state.c status = nfs40_walk_client_list(clp, result, cred); clp 183 fs/nfs/nfs4state.c if (clp->cl_state) clp 184 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 190 fs/nfs/nfs4state.c const struct cred *nfs4_get_machine_cred(struct nfs_client *clp) clp 195 fs/nfs/nfs4state.c static void nfs4_root_machine_cred(struct nfs_client *clp) clp 199 fs/nfs/nfs4state.c clp->cl_principal = NULL; clp 200 fs/nfs/nfs4state.c clp->cl_rpcclient->cl_principal = NULL; clp 229 fs/nfs/nfs4state.c const struct cred *nfs4_get_renew_cred(struct nfs_client *clp) clp 235 fs/nfs/nfs4state.c cred = nfs4_get_machine_cred(clp); clp 239 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 241 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 247 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 262 fs/nfs/nfs4state.c static void nfs4_end_drain_session(struct nfs_client *clp) clp 264 fs/nfs/nfs4state.c struct nfs4_session *ses = clp->cl_session; clp 266 fs/nfs/nfs4state.c if (clp->cl_slot_tbl) { clp 267 fs/nfs/nfs4state.c nfs4_end_drain_slot_table(clp->cl_slot_tbl); clp 290 fs/nfs/nfs4state.c static int nfs4_begin_drain_session(struct nfs_client *clp) clp 292 fs/nfs/nfs4state.c struct nfs4_session *ses = clp->cl_session; clp 295 fs/nfs/nfs4state.c if (clp->cl_slot_tbl) clp 296 fs/nfs/nfs4state.c return nfs4_drain_slot_tbl(clp->cl_slot_tbl); clp 308 fs/nfs/nfs4state.c static void nfs41_finish_session_reset(struct nfs_client *clp) clp 310 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 311 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); clp 313 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clp 314 fs/nfs/nfs4state.c nfs4_setup_state_renewal(clp); clp 317 fs/nfs/nfs4state.c int nfs41_init_clientid(struct nfs_client *clp, const struct cred *cred) clp 321 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state)) clp 323 fs/nfs/nfs4state.c status = nfs4_proc_exchange_id(clp, cred); clp 326 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 328 fs/nfs/nfs4state.c status = nfs4_proc_create_session(clp, cred); clp 331 fs/nfs/nfs4state.c nfs41_finish_session_reset(clp); clp 332 fs/nfs/nfs4state.c nfs_mark_client_ready(clp, NFS_CS_READY); clp 350 fs/nfs/nfs4state.c int nfs41_discover_server_trunking(struct nfs_client *clp, clp 356 fs/nfs/nfs4state.c status = nfs4_proc_exchange_id(clp, cred); clp 360 fs/nfs/nfs4state.c status = nfs41_walk_client_list(clp, result, cred); clp 363 fs/nfs/nfs4state.c if (clp != *result) clp 371 fs/nfs/nfs4state.c if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R) { clp 372 fs/nfs/nfs4state.c if (!test_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags)) clp 373 fs/nfs/nfs4state.c set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); clp 375 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 377 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 378 fs/nfs/nfs4state.c status = nfs_wait_client_init_complete(clp); clp 380 fs/nfs/nfs4state.c nfs_put_client(clp); clp 392 fs/nfs/nfs4state.c const struct cred *nfs4_get_clid_cred(struct nfs_client *clp) clp 396 fs/nfs/nfs4state.c cred = nfs4_get_machine_cred(clp); clp 541 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 546 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 548 fs/nfs/nfs4state.c time_min = (long)time_max - (long)clp->cl_lease_time; clp 556 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 576 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 579 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 581 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 587 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 589 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 612 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 614 fs/nfs/nfs4state.c if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock)) clp 619 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 635 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 638 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 643 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 946 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 948 fs/nfs/nfs4state.c clp->cl_mvops->free_lock_state(server, lsp); clp 1192 fs/nfs/nfs4state.c static void nfs4_clear_state_manager_bit(struct nfs_client *clp) clp 1195 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); clp 1197 fs/nfs/nfs4state.c wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING); clp 1198 fs/nfs/nfs4state.c rpc_wake_up(&clp->cl_rpcwaitq); clp 1204 fs/nfs/nfs4state.c void nfs4_schedule_state_manager(struct nfs_client *clp) clp 1209 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); clp 1210 fs/nfs/nfs4state.c if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) clp 1213 fs/nfs/nfs4state.c refcount_inc(&clp->cl_count); clp 1220 fs/nfs/nfs4state.c rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)); clp 1222 fs/nfs/nfs4state.c task = kthread_run(nfs4_run_state_manager, clp, "%s", buf); clp 1226 fs/nfs/nfs4state.c nfs4_clear_state_manager_bit(clp); clp 1227 fs/nfs/nfs4state.c nfs_put_client(clp); clp 1235 fs/nfs/nfs4state.c void nfs4_schedule_lease_recovery(struct nfs_client *clp) clp 1237 fs/nfs/nfs4state.c if (!clp) clp 1239 fs/nfs/nfs4state.c if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) clp 1240 fs/nfs/nfs4state.c set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); clp 1242 fs/nfs/nfs4state.c clp->cl_hostname); clp 1243 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1257 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 1261 fs/nfs/nfs4state.c clp->cl_hostname); clp 1272 fs/nfs/nfs4state.c clp->cl_hostname); clp 1276 fs/nfs/nfs4state.c set_bit(NFS4CLNT_MOVED, &clp->cl_state); clp 1278 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1289 fs/nfs/nfs4state.c void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp) clp 1292 fs/nfs/nfs4state.c __func__, clp->cl_clientid, clp->cl_hostname); clp 1294 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state); clp 1295 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1299 fs/nfs/nfs4state.c int nfs4_wait_clnt_recover(struct nfs_client *clp) clp 1305 fs/nfs/nfs4state.c refcount_inc(&clp->cl_count); clp 1306 fs/nfs/nfs4state.c res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING, clp 1310 fs/nfs/nfs4state.c if (clp->cl_cons_state < 0) clp 1311 fs/nfs/nfs4state.c res = clp->cl_cons_state; clp 1313 fs/nfs/nfs4state.c nfs_put_client(clp); clp 1317 fs/nfs/nfs4state.c int nfs4_client_recover_expired_lease(struct nfs_client *clp) clp 1323 fs/nfs/nfs4state.c ret = nfs4_wait_clnt_recover(clp); clp 1326 fs/nfs/nfs4state.c if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) && clp 1327 fs/nfs/nfs4state.c !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state)) clp 1329 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1343 fs/nfs/nfs4state.c static void nfs40_handle_cb_pathdown(struct nfs_client *clp) clp 1345 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 1346 fs/nfs/nfs4state.c nfs_expire_all_delegations(clp); clp 1348 fs/nfs/nfs4state.c clp->cl_hostname); clp 1351 fs/nfs/nfs4state.c void nfs4_schedule_path_down_recovery(struct nfs_client *clp) clp 1353 fs/nfs/nfs4state.c nfs40_handle_cb_pathdown(clp); clp 1354 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1357 fs/nfs/nfs4state.c static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state) clp 1369 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); clp 1373 fs/nfs/nfs4state.c int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state) clp 1380 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); clp 1386 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 1388 fs/nfs/nfs4state.c if (!nfs4_state_mark_reclaim_nograce(clp, state)) clp 1393 fs/nfs/nfs4state.c clp->cl_hostname); clp 1394 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1431 fs/nfs/nfs4state.c struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; clp 1443 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_nograce(clp, state)) { clp 1448 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_nograce(clp, state)) { clp 1453 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_nograce(clp, state)) clp 1460 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 1709 fs/nfs/nfs4state.c int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) clp 1711 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 1716 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 1724 fs/nfs/nfs4state.c if (mark_reclaim(clp, state)) clp 1729 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 1732 fs/nfs/nfs4state.c static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, clp 1733 fs/nfs/nfs4state.c int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state)) clp 1738 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 1743 fs/nfs/nfs4state.c static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp) clp 1746 fs/nfs/nfs4state.c nfs_delegation_mark_reclaim(clp); clp 1747 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot); clp 1750 fs/nfs/nfs4state.c static int nfs4_reclaim_complete(struct nfs_client *clp, clp 1756 fs/nfs/nfs4state.c return ops->reclaim_complete(clp, cred); clp 1762 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 1767 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 1777 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_nograce(clp, state); clp 1781 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 1784 fs/nfs/nfs4state.c static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp) clp 1788 fs/nfs/nfs4state.c if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) clp 1792 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) clp 1796 fs/nfs/nfs4state.c nfs_delegation_reap_unclaimed(clp); clp 1800 fs/nfs/nfs4state.c static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp) clp 1806 fs/nfs/nfs4state.c if (!nfs4_state_clear_reclaim_reboot(clp)) clp 1808 fs/nfs/nfs4state.c ops = clp->cl_mvops->reboot_recovery_ops; clp 1809 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 1810 fs/nfs/nfs4state.c err = nfs4_reclaim_complete(clp, ops, cred); clp 1813 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); clp 1816 fs/nfs/nfs4state.c static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp) clp 1818 fs/nfs/nfs4state.c nfs_mark_test_expired_all_delegations(clp); clp 1819 fs/nfs/nfs4state.c nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce); clp 1822 fs/nfs/nfs4state.c static int nfs4_recovery_handle_error(struct nfs_client *clp, int error) clp 1828 fs/nfs/nfs4state.c nfs40_handle_cb_pathdown(clp); clp 1831 fs/nfs/nfs4state.c nfs4_state_end_reclaim_reboot(clp); clp 1834 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 1835 fs/nfs/nfs4state.c nfs4_state_start_reclaim_reboot(clp); clp 1838 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 1839 fs/nfs/nfs4state.c nfs4_state_start_reclaim_nograce(clp); clp 1847 fs/nfs/nfs4state.c set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); clp 1851 fs/nfs/nfs4state.c set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clp 1855 fs/nfs/nfs4state.c __func__, error, clp->cl_hostname); clp 1859 fs/nfs/nfs4state.c clp->cl_hostname); clp 1863 fs/nfs/nfs4state.c static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops) clp 1873 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 1875 fs/nfs/nfs4state.c spin_lock(&clp->cl_lock); clp 1886 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 1893 fs/nfs/nfs4state.c status = nfs4_recovery_handle_error(clp, status); clp 1900 fs/nfs/nfs4state.c spin_unlock(&clp->cl_lock); clp 1907 fs/nfs/nfs4state.c static int nfs4_check_lease(struct nfs_client *clp) clp 1911 fs/nfs/nfs4state.c clp->cl_mvops->state_renewal_ops; clp 1915 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) clp 1917 fs/nfs/nfs4state.c cred = ops->get_state_renewal_cred(clp); clp 1919 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 1924 fs/nfs/nfs4state.c status = ops->renew_lease(clp, cred); clp 1927 fs/nfs/nfs4state.c set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); clp 1931 fs/nfs/nfs4state.c return nfs4_recovery_handle_error(clp, status); clp 1937 fs/nfs/nfs4state.c static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status) clp 1941 fs/nfs/nfs4state.c if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) clp 1945 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 1948 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 1949 fs/nfs/nfs4state.c nfs4_state_start_reclaim_reboot(clp); clp 1953 fs/nfs/nfs4state.c clp->cl_hostname); clp 1954 fs/nfs/nfs4state.c nfs_mark_client_ready(clp, -EPERM); clp 1955 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 1964 fs/nfs/nfs4state.c if (clp->cl_cons_state == NFS_CS_SESSION_INITING) clp 1965 fs/nfs/nfs4state.c nfs_mark_client_ready(clp, -EPROTONOSUPPORT); clp 1967 fs/nfs/nfs4state.c __func__, -EPROTONOSUPPORT, clp->cl_hostname); clp 1973 fs/nfs/nfs4state.c status, clp->cl_hostname); clp 1976 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 1978 fs/nfs/nfs4state.c clp->cl_hostname); clp 1982 fs/nfs/nfs4state.c static int nfs4_establish_lease(struct nfs_client *clp) clp 1986 fs/nfs/nfs4state.c clp->cl_mvops->reboot_recovery_ops; clp 1989 fs/nfs/nfs4state.c status = nfs4_begin_drain_session(clp); clp 1992 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 1995 fs/nfs/nfs4state.c status = ops->establish_clid(clp, cred); clp 1999 fs/nfs/nfs4state.c pnfs_destroy_all_layouts(clp); clp 2007 fs/nfs/nfs4state.c static int nfs4_reclaim_lease(struct nfs_client *clp) clp 2011 fs/nfs/nfs4state.c status = nfs4_establish_lease(clp); clp 2013 fs/nfs/nfs4state.c return nfs4_handle_reclaim_lease_error(clp, status); clp 2014 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state)) clp 2015 fs/nfs/nfs4state.c nfs4_state_start_reclaim_nograce(clp); clp 2016 fs/nfs/nfs4state.c if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) clp 2017 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state); clp 2018 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); clp 2019 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 2023 fs/nfs/nfs4state.c static int nfs4_purge_lease(struct nfs_client *clp) clp 2027 fs/nfs/nfs4state.c status = nfs4_establish_lease(clp); clp 2029 fs/nfs/nfs4state.c return nfs4_handle_reclaim_lease_error(clp, status); clp 2030 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); clp 2031 fs/nfs/nfs4state.c set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state); clp 2032 fs/nfs/nfs4state.c nfs4_state_start_reclaim_nograce(clp); clp 2045 fs/nfs/nfs4state.c struct nfs_client *clp = server->nfs_client; clp 2054 fs/nfs/nfs4state.c clp->cl_hostname); clp 2079 fs/nfs/nfs4state.c status = nfs4_begin_drain_session(clp); clp 2101 fs/nfs/nfs4state.c clp->cl_hostname); clp 2110 fs/nfs/nfs4state.c static int nfs4_handle_migration(struct nfs_client *clp) clp 2113 fs/nfs/nfs4state.c clp->cl_mvops->state_renewal_ops; clp 2118 fs/nfs/nfs4state.c clp->cl_hostname); clp 2120 fs/nfs/nfs4state.c cred = ops->get_state_renewal_cred(clp); clp 2124 fs/nfs/nfs4state.c clp->cl_mig_gen++; clp 2127 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 2130 fs/nfs/nfs4state.c if (server->mig_gen == clp->cl_mig_gen) clp 2132 fs/nfs/nfs4state.c server->mig_gen = clp->cl_mig_gen; clp 2156 fs/nfs/nfs4state.c static int nfs4_handle_lease_moved(struct nfs_client *clp) clp 2159 fs/nfs/nfs4state.c clp->cl_mvops->state_renewal_ops; clp 2164 fs/nfs/nfs4state.c clp->cl_hostname); clp 2166 fs/nfs/nfs4state.c cred = ops->get_state_renewal_cred(clp); clp 2170 fs/nfs/nfs4state.c clp->cl_mig_gen++; clp 2173 fs/nfs/nfs4state.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 2177 fs/nfs/nfs4state.c if (server->mig_gen == clp->cl_mig_gen) clp 2179 fs/nfs/nfs4state.c server->mig_gen = clp->cl_mig_gen; clp 2211 fs/nfs/nfs4state.c int nfs4_discover_server_trunking(struct nfs_client *clp, clp 2215 fs/nfs/nfs4state.c clp->cl_mvops->reboot_recovery_ops; clp 2220 fs/nfs/nfs4state.c dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname); clp 2222 fs/nfs/nfs4state.c clnt = clp->cl_rpcclient; clp 2228 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 2232 fs/nfs/nfs4state.c status = ops->detect_trunking(clp, result, cred); clp 2253 fs/nfs/nfs4state.c nfs4_root_machine_cred(clp); clp 2275 fs/nfs/nfs4state.c clnt = xchg(&clp->cl_rpcclient, clnt); clp 2277 fs/nfs/nfs4state.c clnt = clp->cl_rpcclient; clp 2304 fs/nfs/nfs4state.c struct nfs_client *clp = session->clp; clp 2308 fs/nfs/nfs4state.c set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); clp 2311 fs/nfs/nfs4state.c set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clp 2313 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2317 fs/nfs/nfs4state.c void nfs41_notify_server(struct nfs_client *clp) clp 2320 fs/nfs/nfs4state.c set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state); clp 2321 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2324 fs/nfs/nfs4state.c static void nfs4_reset_all_state(struct nfs_client *clp) clp 2326 fs/nfs/nfs4state.c if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { clp 2327 fs/nfs/nfs4state.c set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state); clp 2328 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state); clp 2329 fs/nfs/nfs4state.c nfs4_state_start_reclaim_nograce(clp); clp 2331 fs/nfs/nfs4state.c __func__, clp->cl_hostname); clp 2332 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2336 fs/nfs/nfs4state.c static void nfs41_handle_server_reboot(struct nfs_client *clp) clp 2338 fs/nfs/nfs4state.c if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) { clp 2339 fs/nfs/nfs4state.c nfs4_state_start_reclaim_reboot(clp); clp 2341 fs/nfs/nfs4state.c clp->cl_hostname); clp 2342 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2346 fs/nfs/nfs4state.c static void nfs41_handle_all_state_revoked(struct nfs_client *clp) clp 2348 fs/nfs/nfs4state.c nfs4_reset_all_state(clp); clp 2349 fs/nfs/nfs4state.c dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); clp 2352 fs/nfs/nfs4state.c static void nfs41_handle_some_state_revoked(struct nfs_client *clp) clp 2354 fs/nfs/nfs4state.c nfs4_state_start_reclaim_nograce(clp); clp 2355 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2357 fs/nfs/nfs4state.c dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname); clp 2360 fs/nfs/nfs4state.c static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp) clp 2363 fs/nfs/nfs4state.c pnfs_destroy_all_layouts(clp); clp 2364 fs/nfs/nfs4state.c nfs_test_expired_all_delegations(clp); clp 2366 fs/nfs/nfs4state.c clp->cl_hostname); clp 2369 fs/nfs/nfs4state.c static void nfs41_handle_backchannel_fault(struct nfs_client *clp) clp 2371 fs/nfs/nfs4state.c set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); clp 2372 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2375 fs/nfs/nfs4state.c clp->cl_hostname); clp 2378 fs/nfs/nfs4state.c static void nfs41_handle_cb_path_down(struct nfs_client *clp) clp 2381 fs/nfs/nfs4state.c &clp->cl_state) == 0) clp 2382 fs/nfs/nfs4state.c nfs4_schedule_state_manager(clp); clp 2385 fs/nfs/nfs4state.c void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, clp 2392 fs/nfs/nfs4state.c __func__, clp->cl_hostname, clp->cl_clientid, flags); clp 2403 fs/nfs/nfs4state.c nfs41_handle_server_reboot(clp); clp 2405 fs/nfs/nfs4state.c nfs41_handle_all_state_revoked(clp); clp 2408 fs/nfs/nfs4state.c nfs41_handle_some_state_revoked(clp); clp 2410 fs/nfs/nfs4state.c nfs4_schedule_lease_moved_recovery(clp); clp 2412 fs/nfs/nfs4state.c nfs41_handle_recallable_state_revoked(clp); clp 2415 fs/nfs/nfs4state.c nfs41_handle_backchannel_fault(clp); clp 2418 fs/nfs/nfs4state.c nfs41_handle_cb_path_down(clp); clp 2421 fs/nfs/nfs4state.c static int nfs4_reset_session(struct nfs_client *clp) clp 2426 fs/nfs/nfs4state.c if (!nfs4_has_session(clp)) clp 2428 fs/nfs/nfs4state.c status = nfs4_begin_drain_session(clp); clp 2431 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 2432 fs/nfs/nfs4state.c status = nfs4_proc_destroy_session(clp->cl_session, cred); clp 2440 fs/nfs/nfs4state.c set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); clp 2445 fs/nfs/nfs4state.c status = nfs4_recovery_handle_error(clp, status); clp 2449 fs/nfs/nfs4state.c memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN); clp 2450 fs/nfs/nfs4state.c status = nfs4_proc_create_session(clp, cred); clp 2453 fs/nfs/nfs4state.c __func__, status, clp->cl_hostname); clp 2454 fs/nfs/nfs4state.c status = nfs4_handle_reclaim_lease_error(clp, status); clp 2457 fs/nfs/nfs4state.c nfs41_finish_session_reset(clp); clp 2459 fs/nfs/nfs4state.c __func__, clp->cl_hostname); clp 2465 fs/nfs/nfs4state.c static int nfs4_bind_conn_to_session(struct nfs_client *clp) clp 2470 fs/nfs/nfs4state.c if (!nfs4_has_session(clp)) clp 2472 fs/nfs/nfs4state.c ret = nfs4_begin_drain_session(clp); clp 2475 fs/nfs/nfs4state.c cred = nfs4_get_clid_cred(clp); clp 2476 fs/nfs/nfs4state.c ret = nfs4_proc_bind_conn_to_session(clp, cred); clp 2478 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clp 2482 fs/nfs/nfs4state.c __func__, clp->cl_hostname); clp 2486 fs/nfs/nfs4state.c set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state); clp 2489 fs/nfs/nfs4state.c return nfs4_recovery_handle_error(clp, ret); clp 2494 fs/nfs/nfs4state.c static int nfs4_reset_session(struct nfs_client *clp) { return 0; } clp 2496 fs/nfs/nfs4state.c static int nfs4_bind_conn_to_session(struct nfs_client *clp) clp 2502 fs/nfs/nfs4state.c static void nfs4_state_manager(struct nfs_client *clp) clp 2509 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); clp 2510 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { clp 2512 fs/nfs/nfs4state.c status = nfs4_purge_lease(clp); clp 2518 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) { clp 2521 fs/nfs/nfs4state.c status = nfs4_reclaim_lease(clp); clp 2528 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) { clp 2530 fs/nfs/nfs4state.c status = nfs4_reset_session(clp); clp 2531 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) clp 2539 fs/nfs/nfs4state.c &clp->cl_state)) { clp 2541 fs/nfs/nfs4state.c status = nfs4_bind_conn_to_session(clp); clp 2547 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) { clp 2549 fs/nfs/nfs4state.c status = nfs4_check_lease(clp); clp 2555 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) { clp 2557 fs/nfs/nfs4state.c status = nfs4_handle_migration(clp); clp 2562 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) { clp 2564 fs/nfs/nfs4state.c status = nfs4_handle_lease_moved(clp); clp 2570 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) { clp 2572 fs/nfs/nfs4state.c status = nfs4_do_reclaim(clp, clp 2573 fs/nfs/nfs4state.c clp->cl_mvops->reboot_recovery_ops); clp 2578 fs/nfs/nfs4state.c nfs4_state_end_reclaim_reboot(clp); clp 2582 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) { clp 2584 fs/nfs/nfs4state.c nfs_reap_expired_delegations(clp); clp 2589 fs/nfs/nfs4state.c if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) { clp 2591 fs/nfs/nfs4state.c status = nfs4_do_reclaim(clp, clp 2592 fs/nfs/nfs4state.c clp->cl_mvops->nograce_recovery_ops); clp 2597 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state); clp 2600 fs/nfs/nfs4state.c nfs4_end_drain_session(clp); clp 2601 fs/nfs/nfs4state.c nfs4_clear_state_manager_bit(clp); clp 2603 fs/nfs/nfs4state.c if (!test_and_set_bit(NFS4CLNT_DELEGRETURN_RUNNING, &clp->cl_state)) { clp 2604 fs/nfs/nfs4state.c if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) { clp 2605 fs/nfs/nfs4state.c nfs_client_return_marked_delegations(clp); clp 2606 fs/nfs/nfs4state.c set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); clp 2608 fs/nfs/nfs4state.c clear_bit(NFS4CLNT_DELEGRETURN_RUNNING, &clp->cl_state); clp 2612 fs/nfs/nfs4state.c if (!test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state)) clp 2614 fs/nfs/nfs4state.c if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) clp 2616 fs/nfs/nfs4state.c } while (refcount_read(&clp->cl_count) > 1 && !signalled()); clp 2624 fs/nfs/nfs4state.c clp->cl_hostname, -status); clp 2627 fs/nfs/nfs4state.c nfs4_end_drain_session(clp); clp 2628 fs/nfs/nfs4state.c nfs4_clear_state_manager_bit(clp); clp 2633 fs/nfs/nfs4state.c struct nfs_client *clp = ptr; clp 2636 fs/nfs/nfs4state.c nfs4_state_manager(clp); clp 2637 fs/nfs/nfs4state.c nfs_put_client(clp); clp 343 fs/nfs/nfs4trace.h const struct nfs_client *clp, clp 347 fs/nfs/nfs4trace.h TP_ARGS(clp, error), clp 350 fs/nfs/nfs4trace.h __string(dstaddr, clp->cl_hostname) clp 356 fs/nfs/nfs4trace.h __assign_str(dstaddr, clp->cl_hostname); clp 369 fs/nfs/nfs4trace.h const struct nfs_client *clp, \ clp 372 fs/nfs/nfs4trace.h TP_ARGS(clp, error)) clp 1348 fs/nfs/nfs4trace.h const struct nfs_client *clp, clp 1354 fs/nfs/nfs4trace.h TP_ARGS(clp, fhandle, inode, error), clp 1361 fs/nfs/nfs4trace.h __string(dstaddr, clp ? clp->cl_hostname : "unknown") clp 1374 fs/nfs/nfs4trace.h __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") clp 1392 fs/nfs/nfs4trace.h const struct nfs_client *clp, \ clp 1397 fs/nfs/nfs4trace.h TP_ARGS(clp, fhandle, inode, error)) clp 1402 fs/nfs/nfs4trace.h const struct nfs_client *clp, clp 1409 fs/nfs/nfs4trace.h TP_ARGS(clp, fhandle, inode, stateid, error), clp 1416 fs/nfs/nfs4trace.h __string(dstaddr, clp ? clp->cl_hostname : "unknown") clp 1431 fs/nfs/nfs4trace.h __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") clp 1454 fs/nfs/nfs4trace.h const struct nfs_client *clp, \ clp 1460 fs/nfs/nfs4trace.h TP_ARGS(clp, fhandle, inode, stateid, error)) clp 1838 fs/nfs/nfs4xdr.c struct nfs_client *clp = args->client; clp 1839 fs/nfs/nfs4xdr.c struct rpc_clnt *clnt = clp->cl_rpcclient; clp 1840 fs/nfs/nfs4xdr.c struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); clp 2109 fs/nfs/nfs4xdr.c return session->clp->cl_mvops->minor_version; clp 2720 fs/nfs/nfs4xdr.c const struct nfs_client *clp = data; clp 2726 fs/nfs/nfs4xdr.c encode_renew(xdr, clp->cl_clientid, &hdr); clp 2921 fs/nfs/nfs4xdr.c .minorversion = session->clp->cl_mvops->minor_version, clp 2936 fs/nfs/nfs4xdr.c const struct nfs_client *clp = data; clp 2938 fs/nfs/nfs4xdr.c .minorversion = clp->cl_mvops->minor_version, clp 2942 fs/nfs/nfs4xdr.c encode_destroy_clientid(xdr, clp->cl_clientid, &hdr); clp 272 fs/nfs/pnfs.c struct nfs_client *clp = server->nfs_client; clp 274 fs/nfs/pnfs.c spin_lock(&clp->cl_lock); clp 276 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 768 fs/nfs/pnfs.c pnfs_layout_bulk_destroy_byserver_locked(struct nfs_client *clp, clp 771 fs/nfs/pnfs.c __must_hold(&clp->cl_lock) clp 792 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 796 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 800 fs/nfs/pnfs.c spin_lock(&clp->cl_lock); clp 843 fs/nfs/pnfs.c pnfs_destroy_layouts_byfsid(struct nfs_client *clp, clp 850 fs/nfs/pnfs.c spin_lock(&clp->cl_lock); clp 853 fs/nfs/pnfs.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 856 fs/nfs/pnfs.c if (pnfs_layout_bulk_destroy_byserver_locked(clp, clp 862 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 870 fs/nfs/pnfs.c pnfs_destroy_layouts_byclid(struct nfs_client *clp, clp 876 fs/nfs/pnfs.c spin_lock(&clp->cl_lock); clp 879 fs/nfs/pnfs.c list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { clp 880 fs/nfs/pnfs.c if (pnfs_layout_bulk_destroy_byserver_locked(clp, clp 886 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 898 fs/nfs/pnfs.c pnfs_destroy_all_layouts(struct nfs_client *clp) clp 900 fs/nfs/pnfs.c nfs4_deviceid_mark_client_invalid(clp); clp 901 fs/nfs/pnfs.c nfs4_deviceid_purge_client(clp); clp 903 fs/nfs/pnfs.c pnfs_destroy_layouts_byclid(clp, false); clp 1190 fs/nfs/pnfs.c lrp->clp = NFS_SERVER(ino)->nfs_client; clp 1863 fs/nfs/pnfs.c struct nfs_client *clp = server->nfs_client; clp 1868 fs/nfs/pnfs.c spin_lock(&clp->cl_lock); clp 1871 fs/nfs/pnfs.c spin_unlock(&clp->cl_lock); clp 1895 fs/nfs/pnfs.c struct nfs_client *clp = server->nfs_client; clp 1901 fs/nfs/pnfs.c unsigned long giveup = jiffies + (clp->cl_lease_time << 1); clp 1917 fs/nfs/pnfs.c lseg = ERR_PTR(nfs4_client_recover_expired_lease(clp)); clp 259 fs/nfs/pnfs.h int pnfs_destroy_layouts_byfsid(struct nfs_client *clp, clp 262 fs/nfs/pnfs.h int pnfs_destroy_layouts_byclid(struct nfs_client *clp, clp 323 fs/nfs/pnfs.h void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp); clp 646 fs/nfs/pnfs.h static inline void pnfs_destroy_all_layouts(struct nfs_client *clp) clp 78 fs/nfs/pnfs_dev.c const struct nfs_client *clp, const struct nfs4_deviceid *id, clp 84 fs/nfs/pnfs_dev.c if (d->ld == ld && d->nfs_client == clp && clp 226 fs/nfs/pnfs_dev.c const struct nfs_client *clp, const struct nfs4_deviceid *id) clp 232 fs/nfs/pnfs_dev.c d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id)); clp 324 fs/nfs/pnfs_dev.c _deviceid_purge_client(const struct nfs_client *clp, long hash) clp 332 fs/nfs/pnfs_dev.c if (d->nfs_client == clp && atomic_read(&d->ref)) { clp 351 fs/nfs/pnfs_dev.c nfs4_deviceid_purge_client(const struct nfs_client *clp) clp 355 fs/nfs/pnfs_dev.c if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS)) clp 358 fs/nfs/pnfs_dev.c _deviceid_purge_client(clp, h); clp 365 fs/nfs/pnfs_dev.c nfs4_deviceid_mark_client_invalid(struct nfs_client *clp) clp 373 fs/nfs/pnfs_dev.c if (d->nfs_client == clp) clp 605 fs/nfs/pnfs_nfs.c struct nfs_client *clp = ERR_PTR(-EIO); clp 618 fs/nfs/pnfs_nfs.c if (!IS_ERR(clp)) { clp 621 fs/nfs/pnfs_nfs.c .net = clp->cl_net, clp 624 fs/nfs/pnfs_nfs.c .servername = clp->cl_hostname, clp 627 fs/nfs/pnfs_nfs.c rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args, clp 631 fs/nfs/pnfs_nfs.c clp = get_v3_ds_connect(mds_srv, clp 635 fs/nfs/pnfs_nfs.c if (IS_ERR(clp)) clp 637 fs/nfs/pnfs_nfs.c clp->cl_rpcclient->cl_softerr = 0; clp 638 fs/nfs/pnfs_nfs.c clp->cl_rpcclient->cl_softrtry = 0; clp 641 fs/nfs/pnfs_nfs.c if (IS_ERR(clp)) { clp 642 fs/nfs/pnfs_nfs.c status = PTR_ERR(clp); clp 647 fs/nfs/pnfs_nfs.c ds->ds_clp = clp; clp 659 fs/nfs/pnfs_nfs.c struct nfs_client *clp = ERR_PTR(-EIO); clp 669 fs/nfs/pnfs_nfs.c if (!IS_ERR(clp) && clp->cl_mvops->session_trunk) { clp 672 fs/nfs/pnfs_nfs.c .net = clp->cl_net, clp 675 fs/nfs/pnfs_nfs.c .servername = clp->cl_hostname, clp 678 fs/nfs/pnfs_nfs.c .clp = clp, clp 679 fs/nfs/pnfs_nfs.c .cred = nfs4_get_clid_cred(clp), clp 682 fs/nfs/pnfs_nfs.c .add_xprt_test = clp->cl_mvops->session_trunk, clp 690 fs/nfs/pnfs_nfs.c rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args, clp 696 fs/nfs/pnfs_nfs.c clp = nfs4_set_ds_client(mds_srv, clp 700 fs/nfs/pnfs_nfs.c if (IS_ERR(clp)) clp 703 fs/nfs/pnfs_nfs.c status = nfs4_init_ds_session(clp, clp 706 fs/nfs/pnfs_nfs.c nfs_put_client(clp); clp 707 fs/nfs/pnfs_nfs.c clp = ERR_PTR(-EIO); clp 714 fs/nfs/pnfs_nfs.c if (IS_ERR(clp)) { clp 715 fs/nfs/pnfs_nfs.c status = PTR_ERR(clp); clp 720 fs/nfs/pnfs_nfs.c ds->ds_clp = clp; clp 605 fs/nfs/super.c struct nfs_client *clp = nfss->nfs_client; clp 607 fs/nfs/super.c seq_printf(m, ",clientaddr=%s", clp->cl_ipaddr); clp 649 fs/nfs/super.c struct nfs_client *clp = nfss->nfs_client; clp 650 fs/nfs/super.c u32 version = clp->rpc_ops->version; clp 653 fs/nfs/super.c nfs_show_nfs_version(m, version, clp->cl_minorversion); clp 679 fs/nfs/super.c if (clp->cl_nconnect > 0) clp 680 fs/nfs/super.c seq_printf(m, ",nconnect=%u", clp->cl_nconnect); clp 745 fs/nfs/super.c struct nfs_client *clp = server->nfs_client; clp 748 fs/nfs/super.c seq_printf(m, ",lease_time=%ld", clp->cl_lease_time / HZ); clp 749 fs/nfs/super.c expire = clp->cl_last_renewal + clp->cl_lease_time; clp 168 fs/nfs/sysfs.c struct nfs_netns_client *clp; clp 170 fs/nfs/sysfs.c clp = nfs_netns_client_alloc(nfs_client_kobj, net); clp 171 fs/nfs/sysfs.c if (clp) { clp 172 fs/nfs/sysfs.c netns->nfs_client = clp; clp 173 fs/nfs/sysfs.c kobject_uevent(&clp->kobject, KOBJ_ADD); clp 179 fs/nfs/sysfs.c struct nfs_netns_client *clp = netns->nfs_client; clp 181 fs/nfs/sysfs.c if (clp) { clp 182 fs/nfs/sysfs.c kobject_uevent(&clp->kobject, KOBJ_REMOVE); clp 183 fs/nfs/sysfs.c kobject_del(&clp->kobject); clp 184 fs/nfs/sysfs.c kobject_put(&clp->kobject); clp 170 fs/nfsd/blocklayout.c struct nfs4_client *clp, clp 323 fs/nfsd/blocklayout.c static u64 nfsd4_scsi_pr_key(struct nfs4_client *clp) clp 325 fs/nfsd/blocklayout.c return ((u64)clp->cl_clientid.cl_boot << 32) | clp->cl_clientid.cl_id; clp 330 fs/nfsd/blocklayout.c struct nfs4_client *clp, clp 348 fs/nfsd/blocklayout.c b->scsi.pr_key = nfsd4_scsi_pr_key(clp); clp 382 fs/nfsd/blocklayout.c struct nfs4_client *clp, clp 387 fs/nfsd/blocklayout.c return nfserrno(nfsd4_block_get_device_info_scsi(sb, clp, gdp)); clp 407 fs/nfsd/blocklayout.c struct nfs4_client *clp = ls->ls_stid.sc_client; clp 411 fs/nfsd/blocklayout.c nfsd4_scsi_pr_key(clp), 0, true); clp 818 fs/nfsd/export.c exp_find_key(struct cache_detail *cd, struct auth_domain *clp, int fsid_type, clp 824 fs/nfsd/export.c if (!clp) clp 827 fs/nfsd/export.c key.ek_client = clp; clp 841 fs/nfsd/export.c exp_get_by_name(struct cache_detail *cd, struct auth_domain *clp, clp 847 fs/nfsd/export.c if (!clp) clp 850 fs/nfsd/export.c key.ex_client = clp; clp 867 fs/nfsd/export.c exp_parent(struct cache_detail *cd, struct auth_domain *clp, struct path *path) clp 870 fs/nfsd/export.c struct svc_export *exp = exp_get_by_name(cd, clp, path, NULL); clp 876 fs/nfsd/export.c exp = exp_get_by_name(cd, clp, path, NULL); clp 891 fs/nfsd/export.c exp_rootfh(struct net *net, struct auth_domain *clp, char *name, clp 911 fs/nfsd/export.c name, path.dentry, clp->name, clp 913 fs/nfsd/export.c exp = exp_parent(cd, clp, &path); clp 936 fs/nfsd/export.c struct auth_domain *clp, int fsid_type, clp 941 fs/nfsd/export.c struct svc_expkey *ek = exp_find_key(nn->svc_expkey_cache, clp, fsid_type, fsidv, reqp); clp 945 fs/nfsd/export.c exp = exp_get_by_name(cd, clp, &ek->ek_path, reqp); clp 81 fs/nfsd/flexfilelayout.c struct nfs4_client *clp, struct nfsd4_getdeviceinfo *gdp) clp 829 fs/nfsd/nfs4callback.c static const struct cred *get_backchannel_cred(struct nfs4_client *clp, struct rpc_clnt *client, struct nfsd4_session *ses) clp 831 fs/nfsd/nfs4callback.c if (clp->cl_minorversion == 0) { clp 832 fs/nfsd/nfs4callback.c client->cl_principal = clp->cl_cred.cr_targ_princ ? clp 833 fs/nfsd/nfs4callback.c clp->cl_cred.cr_targ_princ : "nfs"; clp 849 fs/nfsd/nfs4callback.c static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses) clp 851 fs/nfsd/nfs4callback.c int maxtime = max_cb_time(clp->net); clp 858 fs/nfsd/nfs4callback.c .net = clp->net, clp 871 fs/nfsd/nfs4callback.c if (clp->cl_minorversion == 0) { clp 872 fs/nfsd/nfs4callback.c if (!clp->cl_cred.cr_principal && clp 873 fs/nfsd/nfs4callback.c (clp->cl_cred.cr_flavor >= RPC_AUTH_GSS_KRB5)) clp 875 fs/nfsd/nfs4callback.c args.client_name = clp->cl_cred.cr_principal; clp 878 fs/nfsd/nfs4callback.c args.authflavor = clp->cl_cred.cr_flavor; clp 879 fs/nfsd/nfs4callback.c clp->cl_cb_ident = conn->cb_ident; clp 883 fs/nfsd/nfs4callback.c clp->cl_cb_conn.cb_xprt = conn->cb_xprt; clp 884 fs/nfsd/nfs4callback.c clp->cl_cb_session = ses; clp 886 fs/nfsd/nfs4callback.c args.prognumber = clp->cl_cb_session->se_cb_prog; clp 898 fs/nfsd/nfs4callback.c cred = get_backchannel_cred(clp, client, ses); clp 903 fs/nfsd/nfs4callback.c clp->cl_cb_client = client; clp 904 fs/nfsd/nfs4callback.c clp->cl_cb_cred = cred; clp 908 fs/nfsd/nfs4callback.c static void warn_no_callback_path(struct nfs4_client *clp, int reason) clp 911 fs/nfsd/nfs4callback.c (int)clp->cl_name.len, clp->cl_name.data, reason); clp 914 fs/nfsd/nfs4callback.c static void nfsd4_mark_cb_down(struct nfs4_client *clp, int reason) clp 916 fs/nfsd/nfs4callback.c if (test_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags)) clp 918 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_DOWN; clp 919 fs/nfsd/nfs4callback.c warn_no_callback_path(clp, reason); clp 922 fs/nfsd/nfs4callback.c static void nfsd4_mark_cb_fault(struct nfs4_client *clp, int reason) clp 924 fs/nfsd/nfs4callback.c if (test_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags)) clp 926 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_FAULT; clp 927 fs/nfsd/nfs4callback.c warn_no_callback_path(clp, reason); clp 932 fs/nfsd/nfs4callback.c struct nfs4_client *clp = container_of(calldata, struct nfs4_client, cl_cb_null); clp 935 fs/nfsd/nfs4callback.c nfsd4_mark_cb_down(clp, task->tk_status); clp 937 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_UP; clp 952 fs/nfsd/nfs4callback.c void nfsd4_probe_callback(struct nfs4_client *clp) clp 954 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_UNKNOWN; clp 955 fs/nfsd/nfs4callback.c set_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags); clp 956 fs/nfsd/nfs4callback.c nfsd4_run_cb(&clp->cl_cb_null); clp 959 fs/nfsd/nfs4callback.c void nfsd4_probe_callback_sync(struct nfs4_client *clp) clp 961 fs/nfsd/nfs4callback.c nfsd4_probe_callback(clp); clp 965 fs/nfsd/nfs4callback.c void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *conn) clp 967 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_UNKNOWN; clp 968 fs/nfsd/nfs4callback.c spin_lock(&clp->cl_lock); clp 969 fs/nfsd/nfs4callback.c memcpy(&clp->cl_cb_conn, conn, sizeof(struct nfs4_cb_conn)); clp 970 fs/nfsd/nfs4callback.c spin_unlock(&clp->cl_lock); clp 978 fs/nfsd/nfs4callback.c static bool nfsd41_cb_get_slot(struct nfs4_client *clp, struct rpc_task *task) clp 980 fs/nfsd/nfs4callback.c if (test_and_set_bit(0, &clp->cl_cb_slot_busy) != 0) { clp 981 fs/nfsd/nfs4callback.c rpc_sleep_on(&clp->cl_cb_waitq, task, NULL); clp 983 fs/nfsd/nfs4callback.c if (test_and_set_bit(0, &clp->cl_cb_slot_busy) != 0) { clp 987 fs/nfsd/nfs4callback.c rpc_wake_up_queued_task(&clp->cl_cb_waitq, task); clp 999 fs/nfsd/nfs4callback.c struct nfs4_client *clp = cb->cb_clp; clp 1000 fs/nfsd/nfs4callback.c u32 minorversion = clp->cl_minorversion; clp 1009 fs/nfsd/nfs4callback.c if (!cb->cb_holds_slot && !nfsd41_cb_get_slot(clp, task)) clp 1018 fs/nfsd/nfs4callback.c struct nfs4_client *clp = cb->cb_clp; clp 1019 fs/nfsd/nfs4callback.c struct nfsd4_session *session = clp->cl_cb_session; clp 1022 fs/nfsd/nfs4callback.c if (!clp->cl_minorversion) { clp 1080 fs/nfsd/nfs4callback.c clear_bit(0, &clp->cl_cb_slot_busy); clp 1081 fs/nfsd/nfs4callback.c rpc_wake_up_next(&clp->cl_cb_waitq); clp 1083 fs/nfsd/nfs4callback.c clp->cl_cb_session->se_cb_seq_nr); clp 1102 fs/nfsd/nfs4callback.c struct nfs4_client *clp = cb->cb_clp; clp 1105 fs/nfsd/nfs4callback.c clp->cl_minorversion); clp 1124 fs/nfsd/nfs4callback.c nfsd4_mark_cb_down(clp, task->tk_status); clp 1163 fs/nfsd/nfs4callback.c void nfsd4_shutdown_callback(struct nfs4_client *clp) clp 1165 fs/nfsd/nfs4callback.c set_bit(NFSD4_CLIENT_CB_KILL, &clp->cl_flags); clp 1171 fs/nfsd/nfs4callback.c nfsd4_run_cb(&clp->cl_cb_null); clp 1176 fs/nfsd/nfs4callback.c static struct nfsd4_conn * __nfsd4_find_backchannel(struct nfs4_client *clp) clp 1181 fs/nfsd/nfs4callback.c list_for_each_entry(s, &clp->cl_sessions, se_perclnt) { clp 1193 fs/nfsd/nfs4callback.c struct nfs4_client *clp = cb->cb_clp; clp 1202 fs/nfsd/nfs4callback.c if (clp->cl_cb_client) { clp 1203 fs/nfsd/nfs4callback.c rpc_shutdown_client(clp->cl_cb_client); clp 1204 fs/nfsd/nfs4callback.c clp->cl_cb_client = NULL; clp 1205 fs/nfsd/nfs4callback.c put_cred(clp->cl_cb_cred); clp 1206 fs/nfsd/nfs4callback.c clp->cl_cb_cred = NULL; clp 1208 fs/nfsd/nfs4callback.c if (clp->cl_cb_conn.cb_xprt) { clp 1209 fs/nfsd/nfs4callback.c svc_xprt_put(clp->cl_cb_conn.cb_xprt); clp 1210 fs/nfsd/nfs4callback.c clp->cl_cb_conn.cb_xprt = NULL; clp 1212 fs/nfsd/nfs4callback.c if (test_bit(NFSD4_CLIENT_CB_KILL, &clp->cl_flags)) clp 1214 fs/nfsd/nfs4callback.c spin_lock(&clp->cl_lock); clp 1219 fs/nfsd/nfs4callback.c BUG_ON(!(clp->cl_flags & NFSD4_CLIENT_CB_FLAG_MASK)); clp 1220 fs/nfsd/nfs4callback.c clear_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_flags); clp 1222 fs/nfsd/nfs4callback.c c = __nfsd4_find_backchannel(clp); clp 1228 fs/nfsd/nfs4callback.c spin_unlock(&clp->cl_lock); clp 1230 fs/nfsd/nfs4callback.c err = setup_callback_client(clp, &conn, ses); clp 1232 fs/nfsd/nfs4callback.c nfsd4_mark_cb_down(clp, err); clp 1242 fs/nfsd/nfs4callback.c struct nfs4_client *clp = cb->cb_clp; clp 1253 fs/nfsd/nfs4callback.c if (clp->cl_flags & NFSD4_CLIENT_CB_FLAG_MASK) clp 1256 fs/nfsd/nfs4callback.c clnt = clp->cl_cb_client; clp 1267 fs/nfsd/nfs4callback.c if (!cb->cb_ops && clp->cl_minorversion) { clp 1268 fs/nfsd/nfs4callback.c clp->cl_cb_state = NFSD4_CB_UP; clp 1272 fs/nfsd/nfs4callback.c cb->cb_msg.rpc_cred = clp->cl_cb_cred; clp 1273 fs/nfsd/nfs4callback.c flags = clp->cl_minorversion ? RPC_TASK_NOCONNECT : RPC_TASK_SOFTCONN; clp 1278 fs/nfsd/nfs4callback.c void nfsd4_init_cb(struct nfsd4_callback *cb, struct nfs4_client *clp, clp 1281 fs/nfsd/nfs4callback.c cb->cb_clp = clp; clp 517 fs/nfsd/nfs4idmap.c struct auth_domain *clp; clp 519 fs/nfsd/nfs4idmap.c clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client; clp 520 fs/nfsd/nfs4idmap.c return clp->name; clp 158 fs/nfsd/nfs4layouts.c struct nfs4_client *clp = ls->ls_stid.sc_client; clp 163 fs/nfsd/nfs4layouts.c spin_lock(&clp->cl_lock); clp 165 fs/nfsd/nfs4layouts.c spin_unlock(&clp->cl_lock); clp 215 fs/nfsd/nfs4layouts.c struct nfs4_client *clp = cstate->clp; clp 220 fs/nfsd/nfs4layouts.c stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache, clp 235 fs/nfsd/nfs4layouts.c nfsd4_init_cb(&ls->ls_recall, clp, &nfsd4_cb_layout_ops, clp 251 fs/nfsd/nfs4layouts.c spin_lock(&clp->cl_lock); clp 253 fs/nfsd/nfs4layouts.c list_add(&ls->ls_perclnt, &clp->cl_lo_states); clp 254 fs/nfsd/nfs4layouts.c spin_unlock(&clp->cl_lock); clp 537 fs/nfsd/nfs4layouts.c struct nfs4_client *clp = cstate->clp; clp 543 fs/nfsd/nfs4layouts.c spin_lock(&clp->cl_lock); clp 544 fs/nfsd/nfs4layouts.c list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt) { clp 561 fs/nfsd/nfs4layouts.c spin_unlock(&clp->cl_lock); clp 577 fs/nfsd/nfs4layouts.c nfsd4_return_all_client_layouts(struct nfs4_client *clp) clp 582 fs/nfsd/nfs4layouts.c spin_lock(&clp->cl_lock); clp 583 fs/nfsd/nfs4layouts.c list_for_each_entry_safe(ls, n, &clp->cl_lo_states, ls_perclnt) clp 585 fs/nfsd/nfs4layouts.c spin_unlock(&clp->cl_lock); clp 591 fs/nfsd/nfs4layouts.c nfsd4_return_all_file_layouts(struct nfs4_client *clp, struct nfs4_file *fp) clp 598 fs/nfsd/nfs4layouts.c if (ls->ls_stid.sc_client == clp) clp 609 fs/nfsd/nfs4layouts.c struct nfs4_client *clp = ls->ls_stid.sc_client; clp 621 fs/nfsd/nfs4layouts.c rpc_ntop((struct sockaddr *)&clp->cl_addr, addr_str, sizeof(addr_str)); clp 1117 fs/nfsd/nfs4proc.c static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp) clp 1121 fs/nfsd/nfs4proc.c spin_lock(&clp->async_lock); clp 1122 fs/nfsd/nfs4proc.c if (!list_empty(&clp->async_copies)) { clp 1123 fs/nfsd/nfs4proc.c copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, clp 1127 fs/nfsd/nfs4proc.c spin_unlock(&clp->async_lock); clp 1131 fs/nfsd/nfs4proc.c void nfsd4_shutdown_copy(struct nfs4_client *clp) clp 1135 fs/nfsd/nfs4proc.c while ((copy = nfsd4_get_copy(clp)) != NULL) clp 1268 fs/nfsd/nfs4proc.c copy->cp_clp = cstate->clp; clp 1307 fs/nfsd/nfs4proc.c find_async_copy(struct nfs4_client *clp, stateid_t *stateid) clp 1311 fs/nfsd/nfs4proc.c spin_lock(&clp->async_lock); clp 1312 fs/nfsd/nfs4proc.c list_for_each_entry(copy, &clp->async_copies, copies) { clp 1316 fs/nfsd/nfs4proc.c spin_unlock(&clp->async_lock); clp 1319 fs/nfsd/nfs4proc.c spin_unlock(&clp->async_lock); clp 1331 fs/nfsd/nfs4proc.c struct nfs4_client *clp = cstate->clp; clp 1333 fs/nfsd/nfs4proc.c copy = find_async_copy(clp, &os->stateid); clp 1372 fs/nfsd/nfs4proc.c struct nfs4_client *clp = cstate->clp; clp 1374 fs/nfsd/nfs4proc.c copy = find_async_copy(clp, &os->stateid); clp 2737 fs/nfsd/nfs4proc.c struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; clp 2750 fs/nfsd/nfs4proc.c cstate->clp->cl_mach_cred && clp 2751 fs/nfsd/nfs4proc.c nfsd4_mach_creds_match(cstate->clp, rqstp)) { clp 159 fs/nfsd/nfs4recover.c legacy_recdir_name_error(struct nfs4_client *clp, int error) clp 172 fs/nfsd/nfs4recover.c nfsd4_client_tracking_exit(clp->net); clp 177 fs/nfsd/nfs4recover.c __nfsd4_create_reclaim_record_grace(struct nfs4_client *clp, clp 196 fs/nfsd/nfs4recover.c crp->cr_clp = clp; clp 200 fs/nfsd/nfs4recover.c nfsd4_create_clid_dir(struct nfs4_client *clp) clp 206 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 208 fs/nfsd/nfs4recover.c if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 213 fs/nfsd/nfs4recover.c status = nfs4_make_rec_clidname(dname, &clp->cl_name); clp 215 fs/nfsd/nfs4recover.c return legacy_recdir_name_error(clp, status); clp 251 fs/nfsd/nfs4recover.c __nfsd4_create_reclaim_record_grace(clp, dname, clp 393 fs/nfsd/nfs4recover.c nfsd4_remove_clid_dir(struct nfs4_client *clp) clp 398 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 400 fs/nfsd/nfs4recover.c if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 403 fs/nfsd/nfs4recover.c status = nfs4_make_rec_clidname(dname, &clp->cl_name); clp 405 fs/nfsd/nfs4recover.c return legacy_recdir_name_error(clp, status); clp 410 fs/nfsd/nfs4recover.c clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 683 fs/nfsd/nfs4recover.c nfsd4_check_legacy_client(struct nfs4_client *clp) clp 688 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 692 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 695 fs/nfsd/nfs4recover.c status = nfs4_make_rec_clidname(dname, &clp->cl_name); clp 697 fs/nfsd/nfs4recover.c legacy_recdir_name_error(clp, status); clp 712 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 713 fs/nfsd/nfs4recover.c crp->cr_clp = clp; clp 1104 fs/nfsd/nfs4recover.c nfsd4_cld_create(struct nfs4_client *clp) clp 1108 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1112 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1122 fs/nfsd/nfs4recover.c cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; clp 1123 fs/nfsd/nfs4recover.c memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, clp 1124 fs/nfsd/nfs4recover.c clp->cl_name.len); clp 1129 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1141 fs/nfsd/nfs4recover.c nfsd4_cld_create_v2(struct nfs4_client *clp) clp 1145 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1154 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1165 fs/nfsd/nfs4recover.c cmsg->cm_u.cm_clntinfo.cc_name.cn_len = clp->cl_name.len; clp 1166 fs/nfsd/nfs4recover.c memcpy(cmsg->cm_u.cm_clntinfo.cc_name.cn_id, clp->cl_name.data, clp 1167 fs/nfsd/nfs4recover.c clp->cl_name.len); clp 1168 fs/nfsd/nfs4recover.c if (clp->cl_cred.cr_raw_principal) clp 1169 fs/nfsd/nfs4recover.c principal = clp->cl_cred.cr_raw_principal; clp 1170 fs/nfsd/nfs4recover.c else if (clp->cl_cred.cr_principal) clp 1171 fs/nfsd/nfs4recover.c principal = clp->cl_cred.cr_principal; clp 1197 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1210 fs/nfsd/nfs4recover.c nfsd4_cld_remove(struct nfs4_client *clp) clp 1214 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1218 fs/nfsd/nfs4recover.c if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1228 fs/nfsd/nfs4recover.c cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; clp 1229 fs/nfsd/nfs4recover.c memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, clp 1230 fs/nfsd/nfs4recover.c clp->cl_name.len); clp 1235 fs/nfsd/nfs4recover.c clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1252 fs/nfsd/nfs4recover.c nfsd4_cld_check_v0(struct nfs4_client *clp) clp 1256 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1260 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1271 fs/nfsd/nfs4recover.c cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; clp 1272 fs/nfsd/nfs4recover.c memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, clp 1273 fs/nfsd/nfs4recover.c clp->cl_name.len); clp 1278 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1292 fs/nfsd/nfs4recover.c nfsd4_cld_check(struct nfs4_client *clp) clp 1295 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1302 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1306 fs/nfsd/nfs4recover.c crp = nfsd4_find_reclaim_client(clp->cl_name, nn); clp 1311 fs/nfsd/nfs4recover.c status = nfs4_make_rec_clidname(dname, &clp->cl_name); clp 1330 fs/nfsd/nfs4recover.c crp->cr_clp = clp; clp 1335 fs/nfsd/nfs4recover.c nfsd4_cld_check_v2(struct nfs4_client *clp) clp 1338 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1349 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1353 fs/nfsd/nfs4recover.c crp = nfsd4_find_reclaim_client(clp->cl_name, nn); clp 1358 fs/nfsd/nfs4recover.c status = nfs4_make_rec_clidname(dname, &clp->cl_name); clp 1378 fs/nfsd/nfs4recover.c if (clp->cl_cred.cr_raw_principal) clp 1379 fs/nfsd/nfs4recover.c principal = clp->cl_cred.cr_raw_principal; clp 1380 fs/nfsd/nfs4recover.c else if (clp->cl_cred.cr_principal) clp 1381 fs/nfsd/nfs4recover.c principal = clp->cl_cred.cr_principal; clp 1403 fs/nfsd/nfs4recover.c crp->cr_clp = clp; clp 1760 fs/nfsd/nfs4recover.c nfsd4_cltrack_client_has_session(struct nfs4_client *clp) clp 1774 fs/nfsd/nfs4recover.c clp->cl_minorversion ? 'Y' : 'N'); clp 1893 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_lock(struct nfs4_client *clp) clp 1895 fs/nfsd/nfs4recover.c wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK, clp 1900 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp) clp 1903 fs/nfsd/nfs4recover.c clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags); clp 1905 fs/nfsd/nfs4recover.c wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK); clp 1909 fs/nfsd/nfs4recover.c nfsd4_umh_cltrack_create(struct nfs4_client *clp) clp 1912 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1926 fs/nfsd/nfs4recover.c if (clp->cl_minorversion == 0 && clp 1927 fs/nfsd/nfs4recover.c test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1930 fs/nfsd/nfs4recover.c hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); clp 1936 fs/nfsd/nfs4recover.c has_session = nfsd4_cltrack_client_has_session(clp); clp 1939 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_lock(clp); clp 1941 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1942 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_unlock(clp); clp 1950 fs/nfsd/nfs4recover.c nfsd4_umh_cltrack_remove(struct nfs4_client *clp) clp 1954 fs/nfsd/nfs4recover.c if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1957 fs/nfsd/nfs4recover.c hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); clp 1963 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_lock(clp); clp 1964 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) && clp 1966 fs/nfsd/nfs4recover.c clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1967 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_unlock(clp); clp 1973 fs/nfsd/nfs4recover.c nfsd4_umh_cltrack_check(struct nfs4_client *clp) clp 1978 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) clp 1981 fs/nfsd/nfs4recover.c hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); clp 1987 fs/nfsd/nfs4recover.c has_session = nfsd4_cltrack_client_has_session(clp); clp 1988 fs/nfsd/nfs4recover.c legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name); clp 1990 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_lock(clp); clp 1991 fs/nfsd/nfs4recover.c if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) { clp 1996 fs/nfsd/nfs4recover.c set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); clp 1998 fs/nfsd/nfs4recover.c nfsd4_cltrack_upcall_unlock(clp); clp 2099 fs/nfsd/nfs4recover.c nfsd4_client_record_create(struct nfs4_client *clp) clp 2101 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2104 fs/nfsd/nfs4recover.c nn->client_tracking_ops->create(clp); clp 2108 fs/nfsd/nfs4recover.c nfsd4_client_record_remove(struct nfs4_client *clp) clp 2110 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2113 fs/nfsd/nfs4recover.c nn->client_tracking_ops->remove(clp); clp 2117 fs/nfsd/nfs4recover.c nfsd4_client_record_check(struct nfs4_client *clp) clp 2119 fs/nfsd/nfs4recover.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2122 fs/nfsd/nfs4recover.c return nn->client_tracking_ops->check(clp); clp 137 fs/nfsd/nfs4state.c static bool is_client_expired(struct nfs4_client *clp) clp 139 fs/nfsd/nfs4state.c return clp->cl_time == 0; clp 142 fs/nfsd/nfs4state.c static __be32 get_client_locked(struct nfs4_client *clp) clp 144 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 148 fs/nfsd/nfs4state.c if (is_client_expired(clp)) clp 150 fs/nfsd/nfs4state.c atomic_inc(&clp->cl_rpc_users); clp 156 fs/nfsd/nfs4state.c renew_client_locked(struct nfs4_client *clp) clp 158 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 160 fs/nfsd/nfs4state.c if (is_client_expired(clp)) { clp 164 fs/nfsd/nfs4state.c clp->cl_clientid.cl_boot, clp 165 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id); clp 170 fs/nfsd/nfs4state.c clp->cl_clientid.cl_boot, clp 171 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id); clp 172 fs/nfsd/nfs4state.c list_move_tail(&clp->cl_lru, &nn->client_lru); clp 173 fs/nfsd/nfs4state.c clp->cl_time = get_seconds(); clp 176 fs/nfsd/nfs4state.c static void put_client_renew_locked(struct nfs4_client *clp) clp 178 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 182 fs/nfsd/nfs4state.c if (!atomic_dec_and_test(&clp->cl_rpc_users)) clp 184 fs/nfsd/nfs4state.c if (!is_client_expired(clp)) clp 185 fs/nfsd/nfs4state.c renew_client_locked(clp); clp 190 fs/nfsd/nfs4state.c static void put_client_renew(struct nfs4_client *clp) clp 192 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 194 fs/nfsd/nfs4state.c if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock)) clp 196 fs/nfsd/nfs4state.c if (!is_client_expired(clp)) clp 197 fs/nfsd/nfs4state.c renew_client_locked(clp); clp 218 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 219 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 225 fs/nfsd/nfs4state.c put_client_renew_locked(clp); clp 230 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 231 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 292 fs/nfsd/nfs4state.c struct nfs4_client *clp = lo->lo_owner.so_client; clp 293 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 373 fs/nfsd/nfs4state.c struct nfs4_client *clp) clp 377 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 379 fs/nfsd/nfs4state.c list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval], clp 391 fs/nfsd/nfs4state.c struct nfs4_client *clp) clp 395 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 396 fs/nfsd/nfs4state.c oo = find_openstateowner_str_locked(hashval, open, clp); clp 397 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 629 fs/nfsd/nfs4state.c alloc_clnt_odstate(struct nfs4_client *clp) clp 635 fs/nfsd/nfs4state.c co->co_client = clp; clp 773 fs/nfsd/nfs4state.c static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp) clp 777 fs/nfsd/nfs4state.c stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid); clp 867 fs/nfsd/nfs4state.c alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp, clp 880 fs/nfsd/nfs4state.c dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg)); clp 911 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->sc_client; clp 913 fs/nfsd/nfs4state.c might_lock(&clp->cl_lock); clp 915 fs/nfsd/nfs4state.c if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) { clp 919 fs/nfsd/nfs4state.c idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); clp 920 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 984 fs/nfsd/nfs4state.c nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp) clp 994 fs/nfsd/nfs4state.c if (clp == searchclp) { clp 1017 fs/nfsd/nfs4state.c struct nfs4_client *clp = dp->dl_stid.sc_client; clp 1022 fs/nfsd/nfs4state.c if (nfs4_delegation_exists(clp, fp)) clp 1027 fs/nfsd/nfs4state.c list_add(&dp->dl_perclnt, &clp->cl_delegations); clp 1065 fs/nfsd/nfs4state.c struct nfs4_client *clp = dp->dl_stid.sc_client; clp 1069 fs/nfsd/nfs4state.c if (clp->cl_minorversion) { clp 1072 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1073 fs/nfsd/nfs4state.c list_add(&dp->dl_recall_lru, &clp->cl_revoked); clp 1074 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1254 fs/nfsd/nfs4state.c struct nfs4_client *clp = sop->so_client; clp 1256 fs/nfsd/nfs4state.c might_lock(&clp->cl_lock); clp 1258 fs/nfsd/nfs4state.c if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock)) clp 1261 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1316 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->sc_client; clp 1318 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 1327 fs/nfsd/nfs4state.c idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id); clp 1342 fs/nfsd/nfs4state.c struct nfs4_client *clp = stp->st_stid.sc_client; clp 1345 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1347 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1354 fs/nfsd/nfs4state.c struct nfs4_client *clp = lo->lo_owner.so_client; clp 1356 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 1424 fs/nfsd/nfs4state.c struct nfs4_client *clp = oo->oo_owner.so_client; clp 1426 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 1452 fs/nfsd/nfs4state.c struct nfs4_client *clp = oo->oo_owner.so_client; clp 1457 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1465 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1519 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 1523 fs/nfsd/nfs4state.c sid->clientid = clp->cl_clientid; clp 1663 fs/nfsd/nfs4state.c struct nfs4_client *clp = c->cn_session->se_client; clp 1665 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1670 fs/nfsd/nfs4state.c nfsd4_probe_callback(clp); clp 1671 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1696 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 1698 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1700 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1734 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->se_client; clp 1737 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1741 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1746 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1748 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1764 fs/nfsd/nfs4state.c static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses) clp 1769 fs/nfsd/nfs4state.c new->se_client = clp; clp 1781 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1782 fs/nfsd/nfs4state.c list_add(&new->se_perclnt, &clp->cl_sessions); clp 1783 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1794 fs/nfsd/nfs4state.c rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa); clp 1795 fs/nfsd/nfs4state.c clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa); clp 1845 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 1846 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1879 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 1882 fs/nfsd/nfs4state.c clp = kmem_cache_zalloc(client_slab, GFP_KERNEL); clp 1883 fs/nfsd/nfs4state.c if (clp == NULL) clp 1885 fs/nfsd/nfs4state.c xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL); clp 1886 fs/nfsd/nfs4state.c if (clp->cl_name.data == NULL) clp 1888 fs/nfsd/nfs4state.c clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE, clp 1891 fs/nfsd/nfs4state.c if (!clp->cl_ownerstr_hashtbl) clp 1894 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]); clp 1895 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_sessions); clp 1896 fs/nfsd/nfs4state.c idr_init(&clp->cl_stateids); clp 1897 fs/nfsd/nfs4state.c atomic_set(&clp->cl_rpc_users, 0); clp 1898 fs/nfsd/nfs4state.c clp->cl_cb_state = NFSD4_CB_UNKNOWN; clp 1899 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_idhash); clp 1900 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_openowners); clp 1901 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_delegations); clp 1902 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_lru); clp 1903 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_revoked); clp 1905 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->cl_lo_states); clp 1907 fs/nfsd/nfs4state.c INIT_LIST_HEAD(&clp->async_copies); clp 1908 fs/nfsd/nfs4state.c spin_lock_init(&clp->async_lock); clp 1909 fs/nfsd/nfs4state.c spin_lock_init(&clp->cl_lock); clp 1910 fs/nfsd/nfs4state.c rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table"); clp 1911 fs/nfsd/nfs4state.c return clp; clp 1913 fs/nfsd/nfs4state.c kfree(clp->cl_name.data); clp 1915 fs/nfsd/nfs4state.c kmem_cache_free(client_slab, clp); clp 1922 fs/nfsd/nfs4state.c struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs); clp 1924 fs/nfsd/nfs4state.c free_svc_cred(&clp->cl_cred); clp 1925 fs/nfsd/nfs4state.c kfree(clp->cl_ownerstr_hashtbl); clp 1926 fs/nfsd/nfs4state.c kfree(clp->cl_name.data); clp 1927 fs/nfsd/nfs4state.c kfree(clp->cl_nii_domain.data); clp 1928 fs/nfsd/nfs4state.c kfree(clp->cl_nii_name.data); clp 1929 fs/nfsd/nfs4state.c idr_destroy(&clp->cl_stateids); clp 1930 fs/nfsd/nfs4state.c kmem_cache_free(client_slab, clp); clp 1933 fs/nfsd/nfs4state.c static void drop_client(struct nfs4_client *clp) clp 1935 fs/nfsd/nfs4state.c kref_put(&clp->cl_nfsdfs.cl_ref, __free_client); clp 1939 fs/nfsd/nfs4state.c free_client(struct nfs4_client *clp) clp 1941 fs/nfsd/nfs4state.c while (!list_empty(&clp->cl_sessions)) { clp 1943 fs/nfsd/nfs4state.c ses = list_entry(clp->cl_sessions.next, struct nfsd4_session, clp 1949 fs/nfsd/nfs4state.c rpc_destroy_wait_queue(&clp->cl_cb_waitq); clp 1950 fs/nfsd/nfs4state.c if (clp->cl_nfsd_dentry) { clp 1951 fs/nfsd/nfs4state.c nfsd_client_rmdir(clp->cl_nfsd_dentry); clp 1952 fs/nfsd/nfs4state.c clp->cl_nfsd_dentry = NULL; clp 1955 fs/nfsd/nfs4state.c drop_client(clp); clp 1960 fs/nfsd/nfs4state.c unhash_client_locked(struct nfs4_client *clp) clp 1962 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1968 fs/nfsd/nfs4state.c clp->cl_time = 0; clp 1970 fs/nfsd/nfs4state.c if (!list_empty(&clp->cl_idhash)) { clp 1971 fs/nfsd/nfs4state.c list_del_init(&clp->cl_idhash); clp 1972 fs/nfsd/nfs4state.c if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags)) clp 1973 fs/nfsd/nfs4state.c rb_erase(&clp->cl_namenode, &nn->conf_name_tree); clp 1975 fs/nfsd/nfs4state.c rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); clp 1977 fs/nfsd/nfs4state.c list_del_init(&clp->cl_lru); clp 1978 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 1979 fs/nfsd/nfs4state.c list_for_each_entry(ses, &clp->cl_sessions, se_perclnt) clp 1981 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 1985 fs/nfsd/nfs4state.c unhash_client(struct nfs4_client *clp) clp 1987 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 1990 fs/nfsd/nfs4state.c unhash_client_locked(clp); clp 1994 fs/nfsd/nfs4state.c static __be32 mark_client_expired_locked(struct nfs4_client *clp) clp 1996 fs/nfsd/nfs4state.c if (atomic_read(&clp->cl_rpc_users)) clp 1998 fs/nfsd/nfs4state.c unhash_client_locked(clp); clp 2003 fs/nfsd/nfs4state.c __destroy_client(struct nfs4_client *clp) clp 2012 fs/nfsd/nfs4state.c while (!list_empty(&clp->cl_delegations)) { clp 2013 fs/nfsd/nfs4state.c dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt); clp 2023 fs/nfsd/nfs4state.c while (!list_empty(&clp->cl_revoked)) { clp 2024 fs/nfsd/nfs4state.c dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru); clp 2028 fs/nfsd/nfs4state.c while (!list_empty(&clp->cl_openowners)) { clp 2029 fs/nfsd/nfs4state.c oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient); clp 2036 fs/nfsd/nfs4state.c list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i], clp 2043 fs/nfsd/nfs4state.c nfsd4_return_all_client_layouts(clp); clp 2044 fs/nfsd/nfs4state.c nfsd4_shutdown_copy(clp); clp 2045 fs/nfsd/nfs4state.c nfsd4_shutdown_callback(clp); clp 2046 fs/nfsd/nfs4state.c if (clp->cl_cb_conn.cb_xprt) clp 2047 fs/nfsd/nfs4state.c svc_xprt_put(clp->cl_cb_conn.cb_xprt); clp 2048 fs/nfsd/nfs4state.c free_client(clp); clp 2053 fs/nfsd/nfs4state.c destroy_client(struct nfs4_client *clp) clp 2055 fs/nfsd/nfs4state.c unhash_client(clp); clp 2056 fs/nfsd/nfs4state.c __destroy_client(clp); clp 2059 fs/nfsd/nfs4state.c static void inc_reclaim_complete(struct nfs4_client *clp) clp 2061 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2065 fs/nfsd/nfs4state.c if (!nfsd4_find_reclaim_client(clp->cl_name, nn)) clp 2070 fs/nfsd/nfs4state.c clp->net->ns.inum); clp 2075 fs/nfsd/nfs4state.c static void expire_client(struct nfs4_client *clp) clp 2077 fs/nfsd/nfs4state.c unhash_client(clp); clp 2078 fs/nfsd/nfs4state.c nfsd4_client_record_remove(clp); clp 2079 fs/nfsd/nfs4state.c __destroy_client(clp); clp 2212 fs/nfsd/nfs4state.c static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn) clp 2222 fs/nfsd/nfs4state.c memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data)); clp 2225 fs/nfsd/nfs4state.c static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn) clp 2227 fs/nfsd/nfs4state.c clp->cl_clientid.cl_boot = nn->boot_time; clp 2228 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id = nn->clientid_counter++; clp 2229 fs/nfsd/nfs4state.c gen_confirm(clp, nn); clp 2279 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2282 fs/nfsd/nfs4state.c clp = get_nfsdfs_clp(inode); clp 2283 fs/nfsd/nfs4state.c if (!clp) clp 2285 fs/nfsd/nfs4state.c memcpy(&clid, &clp->cl_clientid, sizeof(clid)); clp 2287 fs/nfsd/nfs4state.c seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr); clp 2289 fs/nfsd/nfs4state.c seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len); clp 2290 fs/nfsd/nfs4state.c seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion); clp 2291 fs/nfsd/nfs4state.c if (clp->cl_nii_domain.data) { clp 2293 fs/nfsd/nfs4state.c seq_quote_mem(m, clp->cl_nii_domain.data, clp 2294 fs/nfsd/nfs4state.c clp->cl_nii_domain.len); clp 2296 fs/nfsd/nfs4state.c seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len); clp 2298 fs/nfsd/nfs4state.c clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec); clp 2300 fs/nfsd/nfs4state.c drop_client(clp); clp 2318 fs/nfsd/nfs4state.c __acquires(&clp->cl_lock) clp 2320 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->private; clp 2324 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 2325 fs/nfsd/nfs4state.c ret = idr_get_next_ul(&clp->cl_stateids, &id); clp 2332 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->private; clp 2338 fs/nfsd/nfs4state.c ret = idr_get_next_ul(&clp->cl_stateids, &id); clp 2344 fs/nfsd/nfs4state.c __releases(&clp->cl_lock) clp 2346 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->private; clp 2348 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 2505 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2508 fs/nfsd/nfs4state.c clp = get_nfsdfs_clp(inode); clp 2509 fs/nfsd/nfs4state.c if (!clp) clp 2516 fs/nfsd/nfs4state.c s->private = clp; clp 2523 fs/nfsd/nfs4state.c struct nfs4_client *clp = m->private; clp 2526 fs/nfsd/nfs4state.c drop_client(clp); clp 2543 fs/nfsd/nfs4state.c static void force_expire_client(struct nfs4_client *clp) clp 2545 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2548 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 2549 fs/nfsd/nfs4state.c clp->cl_time = 0; clp 2550 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 2552 fs/nfsd/nfs4state.c wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0); clp 2554 fs/nfsd/nfs4state.c already_expired = list_empty(&clp->cl_lru); clp 2556 fs/nfsd/nfs4state.c unhash_client_locked(clp); clp 2560 fs/nfsd/nfs4state.c expire_client(clp); clp 2562 fs/nfsd/nfs4state.c wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL); clp 2569 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2576 fs/nfsd/nfs4state.c clp = get_nfsdfs_clp(file_inode(file)); clp 2577 fs/nfsd/nfs4state.c if (!clp) clp 2579 fs/nfsd/nfs4state.c force_expire_client(clp); clp 2580 fs/nfsd/nfs4state.c drop_client(clp); clp 2599 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2605 fs/nfsd/nfs4state.c clp = alloc_client(name); clp 2606 fs/nfsd/nfs4state.c if (clp == NULL) clp 2609 fs/nfsd/nfs4state.c ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred); clp 2611 fs/nfsd/nfs4state.c free_client(clp); clp 2614 fs/nfsd/nfs4state.c gen_clid(clp, nn); clp 2615 fs/nfsd/nfs4state.c kref_init(&clp->cl_nfsdfs.cl_ref); clp 2616 fs/nfsd/nfs4state.c nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL); clp 2617 fs/nfsd/nfs4state.c clp->cl_time = get_seconds(); clp 2618 fs/nfsd/nfs4state.c clear_bit(0, &clp->cl_cb_slot_busy); clp 2619 fs/nfsd/nfs4state.c copy_verf(clp, verf); clp 2620 fs/nfsd/nfs4state.c memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage)); clp 2621 fs/nfsd/nfs4state.c clp->cl_cb_session = NULL; clp 2622 fs/nfsd/nfs4state.c clp->net = net; clp 2623 fs/nfsd/nfs4state.c clp->cl_nfsd_dentry = nfsd_client_mkdir(nn, &clp->cl_nfsdfs, clp 2624 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id - nn->clientid_base, clp 2626 fs/nfsd/nfs4state.c if (!clp->cl_nfsd_dentry) { clp 2627 fs/nfsd/nfs4state.c free_client(clp); clp 2630 fs/nfsd/nfs4state.c return clp; clp 2637 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2640 fs/nfsd/nfs4state.c clp = rb_entry(*new, struct nfs4_client, cl_namenode); clp 2643 fs/nfsd/nfs4state.c if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0) clp 2658 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2661 fs/nfsd/nfs4state.c clp = rb_entry(node, struct nfs4_client, cl_namenode); clp 2662 fs/nfsd/nfs4state.c cmp = compare_blob(&clp->cl_name, name); clp 2668 fs/nfsd/nfs4state.c return clp; clp 2674 fs/nfsd/nfs4state.c add_to_unconfirmed(struct nfs4_client *clp) clp 2677 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2681 fs/nfsd/nfs4state.c clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); clp 2682 fs/nfsd/nfs4state.c add_clp_to_name_tree(clp, &nn->unconf_name_tree); clp 2683 fs/nfsd/nfs4state.c idhashval = clientid_hashval(clp->cl_clientid.cl_id); clp 2684 fs/nfsd/nfs4state.c list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]); clp 2685 fs/nfsd/nfs4state.c renew_client_locked(clp); clp 2689 fs/nfsd/nfs4state.c move_to_confirmed(struct nfs4_client *clp) clp 2691 fs/nfsd/nfs4state.c unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id); clp 2692 fs/nfsd/nfs4state.c struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); clp 2696 fs/nfsd/nfs4state.c dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp); clp 2697 fs/nfsd/nfs4state.c list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]); clp 2698 fs/nfsd/nfs4state.c rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); clp 2699 fs/nfsd/nfs4state.c add_clp_to_name_tree(clp, &nn->conf_name_tree); clp 2700 fs/nfsd/nfs4state.c set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags); clp 2701 fs/nfsd/nfs4state.c renew_client_locked(clp); clp 2707 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 2710 fs/nfsd/nfs4state.c list_for_each_entry(clp, &tbl[idhashval], cl_idhash) { clp 2711 fs/nfsd/nfs4state.c if (same_clid(&clp->cl_clientid, clid)) { clp 2712 fs/nfsd/nfs4state.c if ((bool)clp->cl_minorversion != sessions) clp 2714 fs/nfsd/nfs4state.c renew_client_locked(clp); clp 2715 fs/nfsd/nfs4state.c return clp; clp 2739 fs/nfsd/nfs4state.c static bool clp_used_exchangeid(struct nfs4_client *clp) clp 2741 fs/nfsd/nfs4state.c return clp->cl_exchange_flags != 0; clp 2759 fs/nfsd/nfs4state.c gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp) clp 2761 fs/nfsd/nfs4state.c struct nfs4_cb_conn *conn = &clp->cl_cb_conn; clp 2776 fs/nfsd/nfs4state.c conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val, clp 2796 fs/nfsd/nfs4state.c clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id); clp 2918 fs/nfsd/nfs4state.c static bool client_has_openowners(struct nfs4_client *clp) clp 2922 fs/nfsd/nfs4state.c list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) { clp 2929 fs/nfsd/nfs4state.c static bool client_has_state(struct nfs4_client *clp) clp 2931 fs/nfsd/nfs4state.c return client_has_openowners(clp) clp 2933 fs/nfsd/nfs4state.c || !list_empty(&clp->cl_lo_states) clp 2935 fs/nfsd/nfs4state.c || !list_empty(&clp->cl_delegations) clp 2936 fs/nfsd/nfs4state.c || !list_empty(&clp->cl_sessions) clp 2937 fs/nfsd/nfs4state.c || !list_empty(&clp->async_copies); clp 2940 fs/nfsd/nfs4state.c static __be32 copy_impl_id(struct nfs4_client *clp, clp 2945 fs/nfsd/nfs4state.c xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL); clp 2946 fs/nfsd/nfs4state.c if (!clp->cl_nii_domain.data) clp 2948 fs/nfsd/nfs4state.c xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL); clp 2949 fs/nfsd/nfs4state.c if (!clp->cl_nii_name.data) clp 2951 fs/nfsd/nfs4state.c clp->cl_nii_time.tv_sec = exid->nii_time.tv_sec; clp 2952 fs/nfsd/nfs4state.c clp->cl_nii_time.tv_nsec = exid->nii_time.tv_nsec; clp 3504 fs/nfsd/nfs4state.c struct nfs4_client *clp = ses->se_client; clp 3509 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 3514 fs/nfsd/nfs4state.c if (clp->cl_mach_cred) clp 3517 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 3524 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 3585 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 3608 fs/nfsd/nfs4state.c clp = session->se_client; clp 3641 fs/nfsd/nfs4state.c cstate->clp = clp; clp 3676 fs/nfsd/nfs4state.c cstate->clp = clp; clp 3679 fs/nfsd/nfs4state.c switch (clp->cl_cb_state) { clp 3689 fs/nfsd/nfs4state.c if (!list_empty(&clp->cl_revoked)) clp 3713 fs/nfsd/nfs4state.c } else if (cs->clp) clp 3714 fs/nfsd/nfs4state.c put_client_renew(cs->clp); clp 3724 fs/nfsd/nfs4state.c struct nfs4_client *clp = NULL; clp 3741 fs/nfsd/nfs4state.c clp = conf; clp 3743 fs/nfsd/nfs4state.c clp = unconf; clp 3748 fs/nfsd/nfs4state.c if (!nfsd4_mach_creds_match(clp, rqstp)) { clp 3749 fs/nfsd/nfs4state.c clp = NULL; clp 3753 fs/nfsd/nfs4state.c unhash_client_locked(clp); clp 3756 fs/nfsd/nfs4state.c if (clp) clp 3757 fs/nfsd/nfs4state.c expire_client(clp); clp 4054 fs/nfsd/nfs4state.c static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp) clp 4069 fs/nfsd/nfs4state.c sop->so_client = clp; clp 4075 fs/nfsd/nfs4state.c static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval) clp 4077 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 4080 fs/nfsd/nfs4state.c &clp->cl_ownerstr_hashtbl[strhashval]); clp 4081 fs/nfsd/nfs4state.c list_add(&oo->oo_perclient, &clp->cl_openowners); clp 4175 fs/nfsd/nfs4state.c struct nfs4_client *clp = cstate->clp; clp 4178 fs/nfsd/nfs4state.c oo = alloc_stateowner(openowner_slab, &open->op_owner, clp); clp 4190 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 4191 fs/nfsd/nfs4state.c ret = find_openstateowner_str_locked(strhashval, open, clp); clp 4193 fs/nfsd/nfs4state.c hash_openowner(oo, clp, strhashval); clp 4198 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 4499 fs/nfsd/nfs4state.c if (cstate->clp) { clp 4500 fs/nfsd/nfs4state.c found = cstate->clp; clp 4525 fs/nfsd/nfs4state.c cstate->clp = found; clp 4534 fs/nfsd/nfs4state.c struct nfs4_client *clp = NULL; clp 4552 fs/nfsd/nfs4state.c clp = cstate->clp; clp 4555 fs/nfsd/nfs4state.c oo = find_openstateowner_str(strhashval, open, clp); clp 4576 fs/nfsd/nfs4state.c open->op_stp = nfs4_alloc_open_stateid(clp); clp 4582 fs/nfsd/nfs4state.c open->op_odstate = alloc_clnt_odstate(clp); clp 4774 fs/nfsd/nfs4state.c static bool nfsd4_cb_channel_good(struct nfs4_client *clp) clp 4776 fs/nfsd/nfs4state.c if (clp->cl_cb_state == NFSD4_CB_UP) clp 4783 fs/nfsd/nfs4state.c return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN; clp 4805 fs/nfsd/nfs4state.c nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh, clp 4829 fs/nfsd/nfs4state.c if (nfs4_delegation_exists(clp, fp)) clp 4847 fs/nfsd/nfs4state.c dp = alloc_init_deleg(clp, fp, fh, odstate); clp 4917 fs/nfsd/nfs4state.c struct nfs4_client *clp = stp->st_stid.sc_client; clp 4937 fs/nfsd/nfs4state.c if (locks_in_grace(clp->net)) clp 4956 fs/nfsd/nfs4state.c dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate); clp 5132 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 5141 fs/nfsd/nfs4state.c clp = cstate->clp; clp 5143 fs/nfsd/nfs4state.c if (!list_empty(&clp->cl_delegations) clp 5144 fs/nfsd/nfs4state.c && clp->cl_cb_state != NFSD4_CB_UP) clp 5212 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 5232 fs/nfsd/nfs4state.c clp = list_entry(pos, struct nfs4_client, cl_lru); clp 5233 fs/nfsd/nfs4state.c if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) { clp 5234 fs/nfsd/nfs4state.c t = clp->cl_time - cutoff; clp 5238 fs/nfsd/nfs4state.c if (mark_client_expired_locked(clp)) { clp 5240 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id); clp 5243 fs/nfsd/nfs4state.c list_add(&clp->cl_lru, &reaplist); clp 5247 fs/nfsd/nfs4state.c clp = list_entry(pos, struct nfs4_client, cl_lru); clp 5249 fs/nfsd/nfs4state.c clp->cl_clientid.cl_id); clp 5250 fs/nfsd/nfs4state.c list_del_init(&clp->cl_lru); clp 5251 fs/nfsd/nfs4state.c expire_client(clp); clp 5534 fs/nfsd/nfs4state.c *s = find_stateid_by_type(cstate->clp, stateid, typemask); clp 5956 fs/nfsd/nfs4state.c struct nfs4_client *clp = s->st_stid.sc_client; clp 5960 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 5963 fs/nfsd/nfs4state.c if (clp->cl_minorversion) { clp 5966 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 5969 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 5972 fs/nfsd/nfs4state.c move_to_close_lru(s, clp->net); clp 6171 fs/nfsd/nfs4state.c find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner) clp 6176 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 6178 fs/nfsd/nfs4state.c list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval], clp 6189 fs/nfsd/nfs4state.c find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner) clp 6193 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 6194 fs/nfsd/nfs4state.c lo = find_lockowner_str_locked(clp, owner); clp 6195 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6224 fs/nfsd/nfs4state.c alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, clp 6230 fs/nfsd/nfs4state.c lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp); clp 6238 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 6239 fs/nfsd/nfs4state.c ret = find_lockowner_str_locked(clp, &lock->lk_new_owner); clp 6242 fs/nfsd/nfs4state.c &clp->cl_ownerstr_hashtbl[strhashval]); clp 6247 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6255 fs/nfsd/nfs4state.c struct nfs4_client *clp = lo->lo_owner.so_client; clp 6257 fs/nfsd/nfs4state.c lockdep_assert_held(&clp->cl_lock); clp 6275 fs/nfsd/nfs4state.c struct nfs4_client *clp = lo->lo_owner.so_client; clp 6281 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 6300 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6321 fs/nfsd/nfs4state.c struct nfs4_client *clp = oo->oo_owner.so_client; clp 6324 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 6326 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6332 fs/nfsd/nfs4state.c ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid); clp 6692 fs/nfsd/nfs4state.c lo = find_lockowner_str(cstate->clp, &lockt->lt_owner); clp 6840 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 6850 fs/nfsd/nfs4state.c clp = cstate->clp; clp 6852 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 6853 fs/nfsd/nfs4state.c list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval], clp 6864 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6873 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6885 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 6997 fs/nfsd/nfs4state.c if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags)) clp 7000 fs/nfsd/nfs4state.c if (nfsd4_client_record_check(cstate->clp)) clp 7008 fs/nfsd/nfs4state.c put_client(struct nfs4_client *clp) clp 7010 fs/nfsd/nfs4state.c atomic_dec(&clp->cl_rpc_users); clp 7016 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7023 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) { clp 7024 fs/nfsd/nfs4state.c if (memcmp(&clp->cl_addr, addr, addr_size) == 0) clp 7025 fs/nfsd/nfs4state.c return clp; clp 7033 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7043 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) { clp 7044 fs/nfsd/nfs4state.c rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf)); clp 7057 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7065 fs/nfsd/nfs4state.c clp = nfsd_find_client(addr, addr_size); clp 7066 fs/nfsd/nfs4state.c if (clp) { clp 7067 fs/nfsd/nfs4state.c if (mark_client_expired_locked(clp) == nfs_ok) clp 7070 fs/nfsd/nfs4state.c clp = NULL; clp 7074 fs/nfsd/nfs4state.c if (clp) clp 7075 fs/nfsd/nfs4state.c expire_client(clp); clp 7084 fs/nfsd/nfs4state.c struct nfs4_client *clp, *next; clp 7093 fs/nfsd/nfs4state.c list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { clp 7094 fs/nfsd/nfs4state.c if (mark_client_expired_locked(clp) == nfs_ok) { clp 7095 fs/nfsd/nfs4state.c list_add(&clp->cl_lru, &reaplist); clp 7102 fs/nfsd/nfs4state.c list_for_each_entry_safe(clp, next, &reaplist, cl_lru) clp 7103 fs/nfsd/nfs4state.c expire_client(clp); clp 7108 fs/nfsd/nfs4state.c static void nfsd_print_count(struct nfs4_client *clp, unsigned int count, clp 7112 fs/nfsd/nfs4state.c rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf)); clp 7120 fs/nfsd/nfs4state.c struct nfs4_client *clp = lst->st_stid.sc_client; clp 7128 fs/nfsd/nfs4state.c atomic_inc(&clp->cl_rpc_users); clp 7132 fs/nfsd/nfs4state.c static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, clp 7141 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 7142 fs/nfsd/nfs4state.c list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) { clp 7167 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 7173 fs/nfsd/nfs4state.c nfsd_collect_client_locks(struct nfs4_client *clp, struct list_head *collect, clp 7176 fs/nfsd/nfs4state.c return nfsd_foreach_client_lock(clp, max, collect, unhash_lock_stateid); clp 7180 fs/nfsd/nfs4state.c nfsd_print_client_locks(struct nfs4_client *clp) clp 7182 fs/nfsd/nfs4state.c u64 count = nfsd_foreach_client_lock(clp, 0, NULL, NULL); clp 7183 fs/nfsd/nfs4state.c nfsd_print_count(clp, count, "locked files"); clp 7190 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7199 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) clp 7200 fs/nfsd/nfs4state.c count += nfsd_print_client_locks(clp); clp 7209 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7214 fs/nfsd/nfs4state.c clp = stp->st_stid.sc_client; clp 7216 fs/nfsd/nfs4state.c put_client(clp); clp 7224 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7233 fs/nfsd/nfs4state.c clp = nfsd_find_client(addr, addr_size); clp 7234 fs/nfsd/nfs4state.c if (clp) clp 7235 fs/nfsd/nfs4state.c count = nfsd_collect_client_locks(clp, &reaplist, 0); clp 7245 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7254 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) { clp 7255 fs/nfsd/nfs4state.c count += nfsd_collect_client_locks(clp, &reaplist, max - count); clp 7265 fs/nfsd/nfs4state.c nfsd_foreach_client_openowner(struct nfs4_client *clp, u64 max, clp 7276 fs/nfsd/nfs4state.c spin_lock(&clp->cl_lock); clp 7277 fs/nfsd/nfs4state.c list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) { clp 7281 fs/nfsd/nfs4state.c atomic_inc(&clp->cl_rpc_users); clp 7296 fs/nfsd/nfs4state.c spin_unlock(&clp->cl_lock); clp 7302 fs/nfsd/nfs4state.c nfsd_print_client_openowners(struct nfs4_client *clp) clp 7304 fs/nfsd/nfs4state.c u64 count = nfsd_foreach_client_openowner(clp, 0, NULL, NULL); clp 7306 fs/nfsd/nfs4state.c nfsd_print_count(clp, count, "openowners"); clp 7311 fs/nfsd/nfs4state.c nfsd_collect_client_openowners(struct nfs4_client *clp, clp 7314 fs/nfsd/nfs4state.c return nfsd_foreach_client_openowner(clp, max, collect, clp 7321 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7330 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) clp 7331 fs/nfsd/nfs4state.c count += nfsd_print_client_openowners(clp); clp 7340 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7345 fs/nfsd/nfs4state.c clp = oop->oo_owner.so_client; clp 7347 fs/nfsd/nfs4state.c put_client(clp); clp 7356 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7365 fs/nfsd/nfs4state.c clp = nfsd_find_client(addr, addr_size); clp 7366 fs/nfsd/nfs4state.c if (clp) clp 7367 fs/nfsd/nfs4state.c count = nfsd_collect_client_openowners(clp, &reaplist, 0); clp 7377 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7386 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) { clp 7387 fs/nfsd/nfs4state.c count += nfsd_collect_client_openowners(clp, &reaplist, clp 7397 fs/nfsd/nfs4state.c static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max, clp 7408 fs/nfsd/nfs4state.c list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) { clp 7419 fs/nfsd/nfs4state.c atomic_inc(&clp->cl_rpc_users); clp 7439 fs/nfsd/nfs4state.c nfsd_print_client_delegations(struct nfs4_client *clp) clp 7441 fs/nfsd/nfs4state.c u64 count = nfsd_find_all_delegations(clp, 0, NULL); clp 7443 fs/nfsd/nfs4state.c nfsd_print_count(clp, count, "delegations"); clp 7450 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7459 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) clp 7460 fs/nfsd/nfs4state.c count += nfsd_print_client_delegations(clp); clp 7469 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7474 fs/nfsd/nfs4state.c clp = dp->dl_stid.sc_client; clp 7476 fs/nfsd/nfs4state.c put_client(clp); clp 7485 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7494 fs/nfsd/nfs4state.c clp = nfsd_find_client(addr, addr_size); clp 7495 fs/nfsd/nfs4state.c if (clp) clp 7496 fs/nfsd/nfs4state.c count = nfsd_find_all_delegations(clp, 0, &reaplist); clp 7507 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7516 fs/nfsd/nfs4state.c list_for_each_entry(clp, &nn->client_lru, cl_lru) { clp 7517 fs/nfsd/nfs4state.c count += nfsd_find_all_delegations(clp, max - count, &reaplist); clp 7529 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7534 fs/nfsd/nfs4state.c clp = dp->dl_stid.sc_client; clp 7545 fs/nfsd/nfs4state.c put_client(clp); clp 7554 fs/nfsd/nfs4state.c struct nfs4_client *clp; clp 7563 fs/nfsd/nfs4state.c clp = nfsd_find_client(addr, addr_size); clp 7564 fs/nfsd/nfs4state.c if (clp) clp 7565 fs/nfsd/nfs4state.c count = nfsd_find_all_delegations(clp, 0, &reaplist); clp 7576 fs/nfsd/nfs4state.c struct nfs4_client *clp, *next; clp 7585 fs/nfsd/nfs4state.c list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { clp 7586 fs/nfsd/nfs4state.c count += nfsd_find_all_delegations(clp, max - count, &reaplist); clp 7677 fs/nfsd/nfs4state.c struct nfs4_client *clp = NULL; clp 7682 fs/nfsd/nfs4state.c clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); clp 7683 fs/nfsd/nfs4state.c destroy_client(clp); clp 7691 fs/nfsd/nfs4state.c clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); clp 7692 fs/nfsd/nfs4state.c destroy_client(clp); clp 27 fs/nfsd/pnfs.h struct nfs4_client *clp, clp 73 fs/nfsd/pnfs.h void nfsd4_return_all_file_layouts(struct nfs4_client *clp, clp 85 fs/nfsd/pnfs.h static inline void nfsd4_return_all_client_layouts(struct nfs4_client *clp) clp 88 fs/nfsd/pnfs.h static inline void nfsd4_return_all_file_layouts(struct nfs4_client *clp, clp 637 fs/nfsd/state.h extern void nfsd4_probe_callback(struct nfs4_client *clp); clp 638 fs/nfsd/state.h extern void nfsd4_probe_callback_sync(struct nfs4_client *clp); clp 639 fs/nfsd/state.h extern void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *); clp 640 fs/nfsd/state.h extern void nfsd4_init_cb(struct nfsd4_callback *cb, struct nfs4_client *clp, clp 646 fs/nfsd/state.h extern void nfsd4_shutdown_copy(struct nfs4_client *clp); clp 656 fs/nfsd/state.h find_async_copy(struct nfs4_client *clp, stateid_t *staetid); clp 669 fs/nfsd/state.h extern void nfsd4_client_record_create(struct nfs4_client *clp); clp 670 fs/nfsd/state.h extern void nfsd4_client_record_remove(struct nfs4_client *clp); clp 671 fs/nfsd/state.h extern int nfsd4_client_record_check(struct nfs4_client *clp); clp 57 fs/nfsd/xdr4.h struct nfs4_client *clp; clp 338 include/linux/nfs_xdr.h struct nfs_client *clp; clp 139 include/net/pkt_cls.h __cls_set_class(unsigned long *clp, unsigned long cl) clp 141 include/net/pkt_cls.h return xchg(clp, cl); clp 980 net/sched/sch_cbq.c struct cbq_class *cl, **clp; clp 986 net/sched/sch_cbq.c clp = &this->sibling; clp 987 net/sched/sch_cbq.c cl = *clp; clp 990 net/sched/sch_cbq.c *clp = cl->sibling; clp 993 net/sched/sch_cbq.c clp = &cl->sibling; clp 994 net/sched/sch_cbq.c } while ((cl = *clp) != this->sibling); clp 805 net/sched/sch_htb.c struct htb_prio *clp; clp 810 net/sched/sch_htb.c clp = &cl->inner.clprio[prio]; clp 811 net/sched/sch_htb.c (++sp)->root = clp->feed.rb_node; clp 812 net/sched/sch_htb.c sp->pptr = &clp->ptr; clp 813 net/sched/sch_htb.c sp->pid = &clp->last_ptr_id;