Lines Matching refs:clp
208 #define NETFAMILY(clp) \
209 (((clp)->nfsc_flags & NFSCLFLAGS_AFINET6) ? AF_INET6 : AF_INET)
220 struct nfsclclient *clp;
246 ret = nfscl_getcl(vp->v_mount, cred, p, false, firstref, &clp);
263 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
283 ohp = &clp->nfsc_owner;
293 nfscl_newopen(clp, dp, &owp, &nowp, &op, &nop, own, nfhp, fhlen,
350 nfscl_newopen(struct nfsclclient *clp, struct nfscldeleg *dp,
369 nowp->nfsow_clp = clp;
378 LIST_INSERT_HEAD(&clp->nfsc_owner, nowp, nfsow_list);
409 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
410 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
415 LIST_INSERT_HEAD(NFSCLOPENHASH(clp, fhp, fhlen),
434 nfscl_deleg(mount_t mp, struct nfsclclient *clp, u_int8_t *nfhp,
454 tdp = nfscl_finddeleg(clp, nfhp, fhlen);
461 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
462 LIST_INSERT_HEAD(NFSCLDELEGHASH(clp, nfhp, fhlen), dp,
476 TAILQ_REMOVE(&clp->nfsc_deleg, tdp, nfsdl_list);
479 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
481 LIST_INSERT_HEAD(NFSCLDELEGHASH(clp, nfhp,
505 nfscl_finddeleg(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
509 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, fhp, fhlen), nfsdl_hash) {
527 struct nfsclclient *clp;
583 clp = nfscl_findcl(nmp);
584 if (clp == NULL) {
592 while ((clp->nfsc_flags & NFSCLFLAGS_RECVRINPROG))
593 (void) nfsmsleep(&clp->nfsc_flags, NFSCLSTATEMUTEXPTR,
599 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
613 TAILQ_REMOVE(&clp->nfsc_deleg, dp,
615 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
640 error = nfscl_getopen(NULL, clp->nfsc_openhash, nfhp, fhlen,
662 oph = NFSCLOPENHASH(clp, nfhp, fhlen);
844 struct nfsclclient *clp;
855 clp = owp->nfsow_clp;
858 nfscl_clrelease(clp);
876 struct nfsclclient *clp;
899 * clp != NULL, this is a harmless optimization.
907 clp = nmp->nm_clp;
908 if (clp == NULL) {
913 clp = newclp;
914 clp->nfsc_idlen = idlen;
915 LIST_INIT(&clp->nfsc_owner);
916 TAILQ_INIT(&clp->nfsc_deleg);
917 TAILQ_INIT(&clp->nfsc_layout);
918 LIST_INIT(&clp->nfsc_devinfo);
920 LIST_INIT(&clp->nfsc_deleghash[i]);
922 LIST_INIT(&clp->nfsc_openhash[i]);
924 LIST_INIT(&clp->nfsc_layouthash[i]);
925 clp->nfsc_flags = NFSCLFLAGS_INITED;
926 clp->nfsc_clientidrev = 1;
927 clp->nfsc_cbident = nfscl_nextcbident();
928 nfscl_fillclid(nmp->nm_clval, uuid, clp->nfsc_id,
929 clp->nfsc_idlen);
930 LIST_INSERT_HEAD(&nfsclhead, clp, nfsc_list);
931 nmp->nm_clp = clp;
932 clp->nfsc_nmp = nmp;
937 while ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0 && !igotlock &&
939 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
951 nfsv4_lock(&clp->nfsc_lock, 0, NULL, NFSCLSTATEMUTEXPTR,
953 nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, mp);
972 if ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0) {
977 nfsv4_unlock(&clp->nfsc_lock, 0);
996 if (clp->nfsc_renew > 0)
997 clidinusedelay = NFSCL_LEASE(clp->nfsc_renew) * 2;
1002 error = nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);
1022 nfsv4_unlock(&clp->nfsc_lock, 0);
1026 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
1030 nfsv4_unlock(&clp->nfsc_lock, 1);
1034 *clpp = clp;
1044 struct nfsclclient *clp;
1046 clp = nmp->nm_clp;
1047 if (clp == NULL || !(clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID))
1049 return (clp);
1056 nfscl_clrelease(struct nfsclclient *clp)
1059 if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
1060 nfsv4_unlock(&clp->nfsc_lock, 0);
1062 nfsv4_relref(&clp->nfsc_lock);
1069 nfscl_clientrelease(struct nfsclclient *clp)
1073 if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
1074 nfsv4_unlock(&clp->nfsc_lock, 0);
1076 nfsv4_relref(&clp->nfsc_lock);
1091 struct nfsclclient *clp;
1132 clp = rclp;
1135 &clp);
1164 ldp = dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
1178 ret = nfscl_getopen(NULL, clp->nfsc_openhash,
1183 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
1184 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
1195 error = nfscl_getopen(NULL, clp->nfsc_openhash,
1202 error = nfscl_localconflict(clp, np->n_fhp->nfh_fh,
1206 nfscl_clrelease(clp);
1258 nfscl_clrelease(clp);
1287 struct nfsclclient *clp, void *id, int flags,
1328 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
1352 LIST_FOREACH(op, NFSCLOPENHASH(clp, np->n_fhp->nfh_fh,
1393 nfscl_releasealllocks(struct nfsclclient *clp, vnode_t vp, NFSPROC_T *p,
1404 LIST_FOREACH(op, NFSCLOPENHASH(clp, np->n_fhp->nfh_fh,
1418 nfscl_clrelease(clp);
1434 struct nfsclclient *clp;
1466 error = nfscl_getcl(vp->v_mount, cred, p, false, true, &clp);
1475 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
1479 nfscl_clrelease(clp);
1495 nfscl_clrelease(clp);
1506 LIST_FOREACH(op, NFSCLOPENHASH(clp, np->n_fhp->nfh_fh,
1522 nfscl_clrelease(clp);
1530 nfscl_clrelease(clp);
1541 struct nfsclclient *clp;
1546 clp = lp->nfsl_open->nfso_own->nfsow_clp;
1552 nfscl_clrelease(clp);
1606 nfscl_expireopen(struct nfsclclient *clp, struct nfsclopen *op,
1639 nfscl_deleg(nmp->nm_mountp, clp, op->nfso_fh,
1768 nfscl_cleanclient(struct nfsclclient *clp)
1775 TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp)
1778 LIST_FOREACH_SAFE(dip, &clp->nfsc_devinfo, nfsdi_list, ndip)
1782 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1794 nfscl_expireclient(struct nfsclclient *clp, struct nfsmount *nmp,
1805 dp = TAILQ_FIRST(&clp->nfsc_deleg);
1815 LIST_FOREACH(towp, &clp->nfsc_owner, nfsow_list) {
1836 LIST_INSERT_HEAD(NFSCLOPENHASH(clp, op->nfso_fh,
1844 owp->nfsow_clp = clp;
1845 LIST_INSERT_HEAD(&clp->nfsc_owner, owp, nfsow_list);
1846 LIST_INSERT_HEAD(NFSCLOPENHASH(clp, op->nfso_fh,
1861 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
1864 if (!TAILQ_EMPTY(&clp->nfsc_deleg))
1870 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1873 ret = nfscl_expireopen(clp, op, nmp, cred, p);
1889 nfscl_cleanup_common(struct nfsclclient *clp, u_int8_t *own)
1896 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
1906 owp = LIST_FIRST(&clp->nfsc_owner);
1931 nfscl_cleanupkext(struct nfsclclient *clp, struct nfscllockownerfhhead *lhp)
1947 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1956 nfscl_cleanup_common(clp, own);
1967 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
1972 nfscl_cleanup_common(clp, own);
2039 struct nfsclclient *clp;
2069 clp = nmp->nm_clp;
2070 if (clp != NULL) {
2071 if ((clp->nfsc_flags & NFSCLFLAGS_INITED) == 0)
2078 clp->nfsc_flags |= NFSCLFLAGS_UMOUNT;
2079 while (clp->nfsc_flags & NFSCLFLAGS_HASTHREAD)
2080 (void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT,
2088 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
2098 LIST_REMOVE(clp, nfsc_list);
2099 nfscl_delegreturnall(clp, p, dhp);
2103 nfsrpc_destroyclient(nmp, clp, cred, p);
2105 nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);
2106 nfscl_cleanclient(clp);
2109 free(clp, M_NFSCLCLIENT);
2121 nfscl_recover(struct nfsclclient *clp, bool *retokp, struct ucred *cred,
2145 clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
2147 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
2152 nmp = clp->nfsc_nmp;
2160 TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp)
2162 TAILQ_INIT(&clp->nfsc_layout);
2164 LIST_INIT(&clp->nfsc_layouthash[i]);
2169 error = nfsrpc_setclient(nmp, clp, 1, retokp, cred, p);
2175 clp->nfsc_flags &= ~(NFSCLFLAGS_RECOVER |
2177 wakeup(&clp->nfsc_flags);
2178 nfsv4_unlock(&clp->nfsc_lock, 0);
2182 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
2183 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
2211 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list)
2221 owp = LIST_FIRST(&clp->nfsc_owner);
2230 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
2262 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
2326 nfscl_expireclient(clp, nmp, tcred, p);
2342 dp = TAILQ_FIRST(&clp->nfsc_deleg);
2356 nowp->nfsow_clp = clp;
2427 nfscl_expireclient(clp, nmp, tcred, p);
2436 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
2478 clp->nfsc_flags &= ~NFSCLFLAGS_RECVRINPROG;
2479 wakeup(&clp->nfsc_flags);
2480 nfsv4_unlock(&clp->nfsc_lock, 0);
2493 nfscl_hasexpired(struct nfsclclient *clp, u_int32_t clidrev, NFSPROC_T *p)
2503 if (clp == NULL || clidrev != clp->nfsc_clientidrev)
2512 clp->nfsc_flags |= NFSCLFLAGS_EXPIREIT;
2514 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
2516 } while (!igotlock && (clp->nfsc_flags & NFSCLFLAGS_EXPIREIT));
2517 if ((clp->nfsc_flags & NFSCLFLAGS_EXPIREIT) == 0) {
2519 nfsv4_unlock(&clp->nfsc_lock, 0);
2523 clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
2526 nmp = clp->nfsc_nmp;
2532 error = nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);
2538 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
2543 nfscl_expireclient(clp, nmp, cred, p);
2545 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
2546 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
2548 clp->nfsc_flags &= ~(NFSCLFLAGS_EXPIREIT | NFSCLFLAGS_RECVRINPROG);
2549 wakeup(&clp->nfsc_flags);
2550 nfsv4_unlock(&clp->nfsc_lock, 0);
2721 nfscl_renewthread(struct nfsclclient *clp, NFSPROC_T *p)
2747 clp->nfsc_flags |= NFSCLFLAGS_HASTHREAD;
2748 mp = clp->nfsc_nmp->nm_mountp;
2753 if (clp->nfsc_flags & NFSCLFLAGS_RECOVER) {
2766 clp->nfsc_renew;
2771 nfscl_recover(clp, &retok, cred, p);
2773 if (clp->nfsc_expire <= NFSD_MONOSEC &&
2774 (clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID)) {
2775 clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
2776 clidrev = clp->nfsc_clientidrev;
2777 error = nfsrpc_renew(clp, NULL, cred, p);
2782 clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
2785 (void) nfscl_hasexpired(clp, clidrev, p);
2789 if (NFSHASNFSV4N(clp->nfsc_nmp)) {
2791 NFSLOCKMNT(clp->nfsc_nmp);
2793 dsp = TAILQ_FIRST(&clp->nfsc_nmp->nm_sess);
2800 clp->nfsc_renew;
2801 NFSUNLOCKMNT(clp->nfsc_nmp);
2802 (void)nfsrpc_renew(clp, dsp, cred, p);
2807 NFSUNLOCKMNT(clp->nfsc_nmp);
2814 nfscl_totalrecall(clp);
2819 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
2832 dp = TAILQ_FIRST(&clp->nfsc_deleg);
2841 nfsv4_unlock(&clp->nfsc_lock, 0);
2854 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
2863 ret = nfscl_recalldeleg(clp, clp->nfsc_nmp, dp,
2867 TAILQ_REMOVE(&clp->nfsc_deleg, dp,
2883 nfsv4_unlock(&clp->nfsc_lock, 0);
2900 dp = TAILQ_LAST(&clp->nfsc_deleg, nfscldeleghead);
2925 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
2935 nfsv4_unlock(&clp->nfsc_lock, 0);
2943 TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp) {
2961 TAILQ_REMOVE(&clp->nfsc_layout, lyp,
2967 if (!NFSHASNOLAYOUTCOMMIT(clp->nfsc_nmp) &&
2972 nfscl_dolayoutcommit(clp->nfsc_nmp, lyp,
2981 lyp = TAILQ_LAST(&clp->nfsc_layout, nfscllayouthead);
3006 LIST_FOREACH_SAFE(dip, &clp->nfsc_devinfo, nfsdi_list, ndip) {
3020 nfscl_layoutreturn(clp->nfsc_nmp, lyp, cred, p);
3035 (void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
3048 nfscl_cleanupkext(clp, &lfh);
3060 (void)nfsrpc_rellockown(clp->nfsc_nmp, lp,
3070 if ((clp->nfsc_flags & NFSCLFLAGS_RECOVER) == 0)
3071 (void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT, "nfscl",
3074 if (clp->nfsc_flags & NFSCLFLAGS_UMOUNT) {
3075 clp->nfsc_flags &= ~NFSCLFLAGS_HASTHREAD;
3078 wakeup((caddr_t)clp);
3090 nfscl_initiate_recovery(struct nfsclclient *clp)
3093 if (clp == NULL)
3096 clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
3098 wakeup((caddr_t)clp);
3108 struct nfsclclient *clp;
3115 clp = nmp->nm_clp;
3116 if (clp == NULL) {
3117 printf("nfscl dumpstate NULL clp\n");
3121 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
3158 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3203 struct nfsclclient *clp;
3208 clp = VFSTONFS(vp->v_mount)->nm_clp;
3209 if (clp == NULL) {
3210 printf("nfscl dupopen NULL clp\n");
3220 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
3221 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3237 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
3239 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3265 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
3269 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3306 * clp returned via clpp.
3311 struct nfsclclient *clp;
3318 error = nfscl_getcl(vp->v_mount, NULL, NULL, false, true, &clp);
3321 *clpp = clp;
3334 dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
3356 LIST_FOREACH(op, NFSCLOPENHASH(clp, nfhp->nfh_fh, nfhp->nfh_len),
3384 struct nfsclclient *clp;
3395 error = nfscl_getcl(vp->v_mount, NULL, NULL, false, true, &clp);
3398 *clpp = clp;
3408 dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
3422 nfscl_retoncloselayout(vp, clp, nfhp->nfh_fh, nfhp->nfh_len, &recallp,
3428 LIST_FOREACH(op, NFSCLOPENHASH(clp, nfhp->nfh_fh, nfhp->nfh_len),
3453 nfscl_clrelease(clp);
3489 nfscl_delegreturnall(struct nfsclclient *clp, NFSPROC_T *p,
3496 TAILQ_FOREACH_SAFE(dp, &clp->nfsc_deleg, nfsdl_list, ndp) {
3498 (void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
3500 nfscl_freedeleg(&clp->nfsc_deleg, dp, false);
3503 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
3514 struct nfsclclient *clp;
3531 clp = nmp->nm_clp;
3532 if (clp != NULL)
3533 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
3537 nfscl_freedeleg(&clp->nfsc_deleg, dp, false);
3540 nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
3555 struct nfsclclient *clp;
3653 &clp);
3666 dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
3717 clp = nfscl_getclnt(cbident);
3719 clp = nfscl_getclntsess(sessionid);
3720 if (clp != NULL) {
3721 dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
3727 wakeup((caddr_t)clp);
3773 clp = nfscl_getclntsess(sessionid);
3774 NFSCL_DEBUG(4, "cbly clp=%p\n", clp);
3775 if (clp != NULL) {
3776 lyp = nfscl_findlayout(clp,
3801 wakeup(clp);
3821 clp = nfscl_getclntsess(sessionid);
3822 if (clp != NULL) {
3823 TAILQ_FOREACH(lyp, &clp->nfsc_layout,
3842 wakeup(clp);
3851 clp = nfscl_getclntsess(sessionid);
3852 if (clp != NULL) {
3853 TAILQ_FOREACH(lyp, &clp->nfsc_layout,
3864 wakeup(clp);
3903 clp = nfscl_getclntsess(sessionid);
3904 if (clp == NULL)
3907 tsep = nfsmnt_mdssession(clp->nfsc_nmp);
3986 clp = nfscl_getclntsess(sessionid);
3987 if (clp != NULL) {
3988 tsep = nfsmnt_mdssession(clp->nfsc_nmp);
4006 struct nfsclclient *clp;
4021 LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
4022 if (clp->nfsc_cbident == nextcbident) {
4042 struct nfsclclient *clp;
4049 LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
4050 tsep = nfsmnt_mdssession(clp->nfsc_nmp);
4052 if (clp->nfsc_cbident == cbident)
4058 if (clp == NULL) {
4062 mp = clp->nfsc_nmp->nm_mountp;
4069 *clpp = clp;
4079 struct nfsclclient *clp;
4081 LIST_FOREACH(clp, &nfsclhead, nfsc_list)
4082 if (clp->nfsc_cbident == cbident)
4084 return (clp);
4093 struct nfsclclient *clp;
4096 LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
4097 tsep = nfsmnt_mdssession(clp->nfsc_nmp);
4102 return (clp);
4111 nfscl_localconflict(struct nfsclclient *clp, u_int8_t *fhp, int fhlen,
4123 LIST_FOREACH(op, NFSCLOPENHASH(clp, fhp, fhlen), nfso_hash) {
4166 nfscl_lockt(vnode_t vp, struct nfsclclient *clp, u_int64_t off,
4187 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4188 error = nfscl_localconflict(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
4216 * The clp must be exclusive locked when this is called.
4219 nfscl_recalldeleg(struct nfsclclient *clp, struct nfsmount *nmp,
4288 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
4292 ret = nfscl_moveopen(vp, clp, nmp, lop,
4315 nfscl_newopen(clp, NULL, &owp, &nowp, &op,
4319 ret = nfscl_moveopen(vp, clp, nmp, lop,
4343 ret = nfscl_relock(vp, clp, nmp, lp, lckp, cred, p);
4362 nfscl_moveopen(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
4391 nfscl_newopen(clp, NULL, &owp, NULL, &op, &nop, owp->nfsow_owner,
4429 nfscl_totalrecall(struct nfsclclient *clp)
4433 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
4443 nfscl_relock(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
4463 clp, 1, NULL, lp->nfsl_lockflags, lp->nfsl_owner,
4648 struct nfsclclient *clp;
4664 clp = nfscl_findcl(nmp);
4665 if (clp == NULL) {
4669 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4688 struct nfsclclient *clp;
4704 clp = nfscl_findcl(nmp);
4705 if (clp == NULL) {
4709 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4727 struct nfsclclient *clp;
4757 clp = nfscl_findcl(nmp);
4758 if (clp == NULL) {
4762 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4770 nfsv4_unlock(&clp->nfsc_lock, 0);
4802 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
4807 nfsv4_unlock(&clp->nfsc_lock, 0);
4819 nfscl_recalldeleg(clp, nmp, dp, vp, cred, p, 0, NULL);
4823 nfsv4_unlock(&clp->nfsc_lock, 0);
4830 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
4833 nfsv4_unlock(&clp->nfsc_lock, 0);
4846 struct nfsclclient *clp;
4877 clp = nfscl_findcl(nmp);
4878 if (clp == NULL) {
4883 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4891 nfsv4_unlock(&clp->nfsc_lock, 0);
4925 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
4930 nfsv4_unlock(&clp->nfsc_lock, 0);
4944 nfscl_recalldeleg(clp, nmp, dp, fvp, cred, p, 0, NULL);
4948 nfsv4_unlock(&clp->nfsc_lock, 0);
4956 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
4959 nfsv4_unlock(&clp->nfsc_lock, 0);
4964 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4998 nfscl_freedeleg(&clp->nfsc_deleg, dp, true);
5013 struct nfsclclient *clp;
5017 clp = nfscl_findcl(nmp);
5018 if (clp == NULL) {
5022 nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, nmp->nm_mountp);
5036 struct nfsclclient *clp;
5039 clp = nfscl_findcl(nmp);
5040 if (clp == NULL) {
5044 nfsv4_relref(&clp->nfsc_lock);
5055 struct nfsclclient *clp;
5064 clp = nfscl_findcl(nmp);
5065 if (clp == NULL) {
5069 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5082 struct nfsclclient *clp;
5091 clp = nfscl_findcl(nmp);
5092 if (clp == NULL) {
5096 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5109 struct nfsclclient *clp;
5124 clp = nfscl_findcl(nmp);
5125 if (clp == NULL) {
5129 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5144 struct nfsclclient *clp;
5159 clp = nfscl_findcl(nmp);
5160 if (clp == NULL) {
5164 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5214 struct nfsclclient *clp;
5232 clp = nmp->nm_clp;
5233 if (clp == NULL) {
5247 lyp = nfscl_findlayout(clp, fhp, fhlen);
5261 lyp->nfsly_clp = clp;
5270 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
5271 LIST_INSERT_HEAD(NFSCLLAYOUTHASH(clp, fhp, fhlen), lyp,
5281 TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
5282 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
5319 nfscl_getlayout(struct nfsclclient *clp, uint8_t *fhp, int fhlen,
5327 mp = clp->nfsc_nmp->nm_mountp;
5331 lyp = nfscl_findlayout(clp, fhp, fhlen);
5334 TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
5335 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
5367 nfscl_retoncloselayout(vnode_t vp, struct nfsclclient *clp, uint8_t *fhp,
5378 lyp = nfscl_findlayout(clp, fhp, fhlen);
5394 wakeup(clp);
5485 nfscl_getdevinfo(struct nfsclclient *clp, uint8_t *deviceid,
5491 dip = nfscl_finddevinfo(clp, deviceid);
5526 nfscl_findlayout(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
5530 LIST_FOREACH(lyp, NFSCLLAYOUTHASH(clp, fhp, fhlen), nfsly_hash)
5541 nfscl_finddevinfo(struct nfsclclient *clp, uint8_t *deviceid)
5545 LIST_FOREACH(dip, &clp->nfsc_devinfo, nfsdi_list)
5585 struct nfsclclient *clp;
5590 clp = nmp->nm_clp;
5591 if (clp == NULL) {
5601 tdip = nfscl_finddevinfo(clp, dev);
5615 LIST_INSERT_HEAD(&clp->nfsc_devinfo, dip, nfsdi_list);
5848 struct nfsclclient *clp;
5859 clp = nmp->nm_clp;
5860 if (clp == NULL) {
5864 lyp = nfscl_findlayout(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5879 nfscl_dolayoutcommit(clp->nfsc_nmp, lyp, NFSPROCCRED(p), p);