Lines Matching defs:clp
203 #define NETFAMILY(clp) \
204 (((clp)->nfsc_flags & NFSCLFLAGS_AFINET6) ? AF_INET6 : AF_INET)
215 struct nfsclclient *clp;
239 ret = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
257 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
272 ohp = &clp->nfsc_owner;
282 nfscl_newopen(clp, dp, &owp, &nowp, &op, &nop, own, nfhp, fhlen,
324 nfscl_newopen(struct nfsclclient *clp, struct nfscldeleg *dp,
343 nowp->nfsow_clp = clp;
352 LIST_INSERT_HEAD(&clp->nfsc_owner, nowp, nfsow_list);
381 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
382 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
404 nfscl_deleg(mount_t mp, struct nfsclclient *clp, u_int8_t *nfhp,
424 tdp = nfscl_finddeleg(clp, nfhp, fhlen);
431 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
432 LIST_INSERT_HEAD(NFSCLDELEGHASH(clp, nfhp, fhlen), dp,
457 nfscl_finddeleg(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
461 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, fhp, fhlen), nfsdl_hash) {
479 struct nfsclclient *clp;
503 clp = nfscl_findcl(VFSTONFS(vnode_mount(vp)));
504 if (clp == NULL) {
512 while ((clp->nfsc_flags & NFSCLFLAGS_RECVRINPROG))
513 (void) nfsmsleep(&clp->nfsc_flags, NFSCLSTATEMUTEXPTR,
519 LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
529 TAILQ_REMOVE(&clp->nfsc_deleg, dp,
531 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
552 error = nfscl_getopen(&clp->nfsc_owner, nfhp, fhlen, own, own,
571 owp = LIST_FIRST(&clp->nfsc_owner);
703 struct nfsclclient *clp;
711 clp = owp->nfsow_clp;
714 nfscl_clrelease(clp);
727 * thread if this creates a new clp.
734 struct nfsclclient *clp;
757 * clp != NULL, this is a harmless optimization.
765 clp = nmp->nm_clp;
766 if (clp == NULL) {
771 clp = newclp;
772 clp->nfsc_idlen = idlen;
773 LIST_INIT(&clp->nfsc_owner);
774 TAILQ_INIT(&clp->nfsc_deleg);
775 TAILQ_INIT(&clp->nfsc_layout);
776 LIST_INIT(&clp->nfsc_devinfo);
778 LIST_INIT(&clp->nfsc_deleghash[i]);
780 LIST_INIT(&clp->nfsc_layouthash[i]);
781 clp->nfsc_flags = NFSCLFLAGS_INITED;
782 clp->nfsc_clientidrev = 1;
783 clp->nfsc_cbident = nfscl_nextcbident();
784 nfscl_fillclid(nmp->nm_clval, uuid, clp->nfsc_id,
785 clp->nfsc_idlen);
786 LIST_INSERT_HEAD(&nfsclhead, clp, nfsc_list);
787 nmp->nm_clp = clp;
788 clp->nfsc_nmp = nmp;
791 nfscl_start_renewthread(clp);
798 while ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0 && !igotlock &&
800 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
803 nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, mp);
821 if ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0) {
826 nfsv4_unlock(&clp->nfsc_lock, 0);
845 if (clp->nfsc_renew > 0)
846 clidinusedelay = NFSCL_LEASE(clp->nfsc_renew) * 2;
851 error = nfsrpc_setclient(nmp, clp, 0, cred, p);
864 nfsv4_unlock(&clp->nfsc_lock, 0);
868 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
872 nfsv4_unlock(&clp->nfsc_lock, 1);
876 *clpp = clp;
886 struct nfsclclient *clp;
888 clp = nmp->nm_clp;
889 if (clp == NULL || !(clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID))
891 return (clp);
898 nfscl_clrelease(struct nfsclclient *clp)
901 if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
902 nfsv4_unlock(&clp->nfsc_lock, 0);
904 nfsv4_relref(&clp->nfsc_lock);
911 nfscl_clientrelease(struct nfsclclient *clp)
915 if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
916 nfsv4_unlock(&clp->nfsc_lock, 0);
918 nfsv4_relref(&clp->nfsc_lock);
933 struct nfsclclient *clp;
974 clp = rclp;
976 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
1002 ldp = dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
1016 ret = nfscl_getopen(&clp->nfsc_owner,
1021 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
1022 TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
1033 error = nfscl_getopen(&clp->nfsc_owner,
1040 error = nfscl_localconflict(clp, np->n_fhp->nfh_fh,
1044 nfscl_clrelease(clp);
1096 nfscl_clrelease(clp);
1125 struct nfsclclient *clp, void *id, int flags,
1167 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
1191 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
1235 nfscl_releasealllocks(struct nfsclclient *clp, vnode_t vp, NFSPROC_T *p,
1247 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
1262 nfscl_clrelease(clp);
1279 struct nfsclclient *clp;
1311 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
1320 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
1334 nfscl_clrelease(clp);
1345 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
1361 nfscl_clrelease(clp);
1370 nfscl_clrelease(clp);
1381 struct nfsclclient *clp;
1386 clp = lp->nfsl_open->nfso_own->nfsow_clp;
1392 nfscl_clrelease(clp);
1433 nfscl_expireopen(struct nfsclclient *clp, struct nfsclopen *op,
1466 nfscl_deleg(nmp->nm_mountp, clp, op->nfso_fh,
1566 nfscl_cleanclient(struct nfsclclient *clp)
1572 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1584 nfscl_expireclient(struct nfsclclient *clp, struct nfsmount *nmp,
1595 dp = TAILQ_FIRST(&clp->nfsc_deleg);
1605 LIST_FOREACH(towp, &clp->nfsc_owner, nfsow_list) {
1632 owp->nfsow_clp = clp;
1633 LIST_INSERT_HEAD(&clp->nfsc_owner, owp, nfsow_list);
1647 nfscl_freedeleg(&clp->nfsc_deleg, dp);
1650 if (!TAILQ_EMPTY(&clp->nfsc_deleg))
1656 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1659 ret = nfscl_expireopen(clp, op, nmp, cred, p);
1675 nfscl_cleanup_common(struct nfsclclient *clp, u_int8_t *own)
1682 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
1691 owp = LIST_FIRST(&clp->nfsc_owner);
1715 nfscl_cleanupkext(struct nfsclclient *clp, struct nfscllockownerfhhead *lhp)
1723 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
1731 nfscl_cleanup_common(clp, owp->nfsow_owner);
1796 struct nfsclclient *clp;
1827 clp = nmp->nm_clp;
1828 if (clp != NULL) {
1829 if ((clp->nfsc_flags & NFSCLFLAGS_INITED) == 0)
1836 clp->nfsc_flags |= NFSCLFLAGS_UMOUNT;
1837 while (clp->nfsc_flags & NFSCLFLAGS_HASTHREAD)
1838 (void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT,
1846 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
1856 LIST_REMOVE(clp, nfsc_list);
1857 nfscl_delegreturnall(clp, p);
1860 (void)nfsrpc_destroysession(nmp, clp, cred, p);
1861 (void)nfsrpc_destroyclient(nmp, clp, cred, p);
1863 (void)nfsrpc_setclient(nmp, clp, 0, cred, p);
1864 nfscl_cleanclient(clp);
1867 free(clp, M_NFSCLCLIENT);
1879 nfscl_recover(struct nfsclclient *clp, struct ucred *cred, NFSPROC_T *p)
1901 clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
1903 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
1908 nmp = clp->nfsc_nmp;
1916 TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp)
1918 TAILQ_INIT(&clp->nfsc_layout);
1920 LIST_INIT(&clp->nfsc_layouthash[i]);
1924 error = nfsrpc_setclient(nmp, clp, 1, cred, p);
1929 nfscl_cleanclient(clp);
1931 clp->nfsc_flags &= ~(NFSCLFLAGS_HASCLIENTID |
1933 wakeup(&clp->nfsc_flags);
1934 nfsv4_unlock(&clp->nfsc_lock, 0);
1938 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
1939 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
1960 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list)
1969 owp = LIST_FIRST(&clp->nfsc_owner);
1978 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
2009 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
2075 dp = TAILQ_FIRST(&clp->nfsc_deleg);
2089 nowp->nfsow_clp = clp;
2152 nfscl_freedeleg(&clp->nfsc_deleg, dp);
2192 clp->nfsc_flags &= ~NFSCLFLAGS_RECVRINPROG;
2193 wakeup(&clp->nfsc_flags);
2194 nfsv4_unlock(&clp->nfsc_lock, 0);
2206 nfscl_hasexpired(struct nfsclclient *clp, u_int32_t clidrev, NFSPROC_T *p)
2216 if (clp == NULL || clidrev != clp->nfsc_clientidrev)
2225 clp->nfsc_flags |= NFSCLFLAGS_EXPIREIT;
2227 igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
2229 } while (!igotlock && (clp->nfsc_flags & NFSCLFLAGS_EXPIREIT));
2230 if ((clp->nfsc_flags & NFSCLFLAGS_EXPIREIT) == 0) {
2232 nfsv4_unlock(&clp->nfsc_lock, 0);
2236 clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
2239 nmp = clp->nfsc_nmp;
2245 error = nfsrpc_setclient(nmp, clp, 0, cred, p);
2253 nfscl_cleanclient(clp);
2255 clp->nfsc_flags &= ~(NFSCLFLAGS_HASCLIENTID |
2261 nfscl_expireclient(clp, nmp, cred, p);
2263 clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
2264 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
2266 clp->nfsc_flags &= ~(NFSCLFLAGS_EXPIREIT | NFSCLFLAGS_RECVRINPROG);
2267 wakeup(&clp->nfsc_flags);
2268 nfsv4_unlock(&clp->nfsc_lock, 0);
2439 nfscl_renewthread(struct nfsclclient *clp, NFSPROC_T *p)
2462 clp->nfsc_flags |= NFSCLFLAGS_HASTHREAD;
2467 if (clp->nfsc_flags & NFSCLFLAGS_RECOVER) {
2474 clp->nfsc_renew;
2475 nfscl_recover(clp, cred, p);
2478 clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
2482 if (clp->nfsc_expire <= NFSD_MONOSEC &&
2483 (clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID)) {
2484 clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
2485 clidrev = clp->nfsc_clientidrev;
2486 error = nfsrpc_renew(clp,
2487 TAILQ_FIRST(&clp->nfsc_nmp->nm_sess), cred, p);
2493 clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
2496 (void) nfscl_hasexpired(clp, clidrev, p);
2501 NFSLOCKMNT(clp->nfsc_nmp);
2503 dsp = TAILQ_FIRST(&clp->nfsc_nmp->nm_sess);
2509 clp->nfsc_renew;
2510 NFSUNLOCKMNT(clp->nfsc_nmp);
2511 (void)nfsrpc_renew(clp, dsp, cred, p);
2516 NFSUNLOCKMNT(clp->nfsc_nmp);
2522 nfscl_totalrecall(clp);
2527 LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
2540 dp = TAILQ_FIRST(&clp->nfsc_deleg);
2549 nfsv4_unlock(&clp->nfsc_lock, 0);
2560 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
2567 ret = nfscl_recalldeleg(clp, clp->nfsc_nmp, dp,
2571 TAILQ_REMOVE(&clp->nfsc_deleg, dp,
2588 dp = TAILQ_LAST(&clp->nfsc_deleg, nfscldeleghead);
2613 TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
2623 nfsv4_unlock(&clp->nfsc_lock, 0);
2631 TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp) {
2647 TAILQ_REMOVE(&clp->nfsc_layout, lyp,
2653 if (!NFSHASNOLAYOUTCOMMIT(clp->nfsc_nmp) &&
2658 nfscl_dolayoutcommit(clp->nfsc_nmp, lyp,
2667 lyp = TAILQ_LAST(&clp->nfsc_layout, nfscllayouthead);
2690 LIST_FOREACH_SAFE(dip, &clp->nfsc_devinfo, nfsdi_list, ndip) {
2704 nfscl_layoutreturn(clp->nfsc_nmp, lyp, cred, p);
2713 (void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
2726 nfscl_cleanupkext(clp, &lfh);
2738 (void)nfsrpc_rellockown(clp->nfsc_nmp, lp,
2748 if ((clp->nfsc_flags & NFSCLFLAGS_RECOVER) == 0)
2749 (void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT, "nfscl",
2751 if (clp->nfsc_flags & NFSCLFLAGS_UMOUNT) {
2752 clp->nfsc_flags &= ~NFSCLFLAGS_HASTHREAD;
2755 wakeup((caddr_t)clp);
2767 nfscl_initiate_recovery(struct nfsclclient *clp)
2770 if (clp == NULL)
2773 clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
2775 wakeup((caddr_t)clp);
2785 struct nfsclclient *clp;
2792 clp = nmp->nm_clp;
2793 if (clp == NULL) {
2794 printf("nfscl dumpstate NULL clp\n");
2798 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
2835 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
2880 struct nfsclclient *clp;
2885 clp = VFSTONFS(vnode_mount(vp))->nm_clp;
2886 if (clp == NULL) {
2887 printf("nfscl dupopen NULL clp\n");
2897 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
2898 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
2914 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
2916 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
2943 LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
2947 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
2984 * clp returned via clpp.
2989 struct nfsclclient *clp;
2996 error = nfscl_getcl(vnode_mount(vp), NULL, NULL, 1, &clp);
2999 *clpp = clp;
3012 dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
3034 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3063 struct nfsclclient *clp;
3070 error = nfscl_getcl(vnode_mount(vp), NULL, NULL, 1, &clp);
3073 *clpp = clp;
3081 dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
3095 nfscl_retoncloselayout(clp, nfhp->nfh_fh, nfhp->nfh_len);
3099 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3126 nfscl_delegreturnall(struct nfsclclient *clp, NFSPROC_T *p)
3132 TAILQ_FOREACH_SAFE(dp, &clp->nfsc_deleg, nfsdl_list, ndp) {
3134 (void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
3135 nfscl_freedeleg(&clp->nfsc_deleg, dp);
3148 struct nfsclclient *clp;
3236 &clp);
3249 dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
3303 clp = nfscl_getclnt(cbident);
3305 clp = nfscl_getclntsess(sessionid);
3306 if (clp != NULL) {
3307 dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
3313 wakeup((caddr_t)clp);
3355 clp = nfscl_getclntsess(sessionid);
3356 NFSCL_DEBUG(4, "cbly clp=%p\n", clp);
3357 if (clp != NULL) {
3358 lyp = nfscl_findlayout(clp,
3376 wakeup(clp);
3394 clp = nfscl_getclntsess(sessionid);
3395 if (clp != NULL) {
3396 TAILQ_FOREACH(lyp, &clp->nfsc_layout,
3414 wakeup(clp);
3423 clp = nfscl_getclntsess(sessionid);
3424 if (clp != NULL) {
3425 TAILQ_FOREACH(lyp, &clp->nfsc_layout,
3436 wakeup(clp);
3472 clp = nfscl_getclntsess(sessionid);
3473 if (clp == NULL)
3480 NFSMNT_MDSSESSION(clp->nfsc_nmp)->
3482 NFSMNT_MDSSESSION(clp->nfsc_nmp)->
3549 clp = nfscl_getclntsess(sessionid);
3550 if (clp != NULL) {
3552 NFSMNT_MDSSESSION(clp->nfsc_nmp)->nfsess_cbslots,
3569 struct nfsclclient *clp;
3584 LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
3585 if (clp->nfsc_cbident == nextcbident) {
3605 struct nfsclclient *clp;
3611 LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
3613 if (clp->nfsc_cbident == cbident)
3615 } else if (!NFSBCMP(NFSMNT_MDSSESSION(clp->nfsc_nmp)->
3619 if (clp == NULL) {
3623 mp = clp->nfsc_nmp->nm_mountp;
3630 *clpp = clp;
3640 struct nfsclclient *clp;
3642 LIST_FOREACH(clp, &nfsclhead, nfsc_list)
3643 if (clp->nfsc_cbident == cbident)
3645 return (clp);
3654 struct nfsclclient *clp;
3656 LIST_FOREACH(clp, &nfsclhead, nfsc_list)
3657 if (!NFSBCMP(NFSMNT_MDSSESSION(clp->nfsc_nmp)->nfsess_sessionid,
3660 return (clp);
3669 nfscl_localconflict(struct nfsclclient *clp, u_int8_t *fhp, int fhlen,
3682 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3727 nfscl_lockt(vnode_t vp, struct nfsclclient *clp, u_int64_t off,
3748 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
3749 error = nfscl_localconflict(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
3777 * The clp must be exclusive locked when this is called.
3780 nfscl_recalldeleg(struct nfsclclient *clp, struct nfsmount *nmp,
3850 LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
3854 ret = nfscl_moveopen(vp, clp, nmp, lop,
3880 nfscl_newopen(clp, NULL, &owp, &nowp, &op,
3884 ret = nfscl_moveopen(vp, clp, nmp, lop,
3911 ret = nfscl_relock(vp, clp, nmp, lp, lckp, cred, p);
3935 nfscl_moveopen(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
3963 nfscl_newopen(clp, NULL, &owp, NULL, &op, &nop, owp->nfsow_owner,
3997 nfscl_totalrecall(struct nfsclclient *clp)
4001 TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
4011 nfscl_relock(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
4024 clp, 1, NULL, lp->nfsl_lockflags, lp->nfsl_owner,
4207 struct nfsclclient *clp;
4217 clp = nfscl_findcl(nmp);
4218 if (clp == NULL) {
4222 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4241 struct nfsclclient *clp;
4251 clp = nfscl_findcl(nmp);
4252 if (clp == NULL) {
4256 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4274 struct nfsclclient *clp;
4294 clp = nfscl_findcl(nmp);
4295 if (clp == NULL) {
4299 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4307 nfsv4_unlock(&clp->nfsc_lock, 0);
4334 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
4344 (void) nfscl_recalldeleg(clp, nmp, dp, vp, cred, p, 0);
4348 nfsv4_unlock(&clp->nfsc_lock, 0);
4355 nfscl_freedeleg(&clp->nfsc_deleg, dp);
4358 nfsv4_unlock(&clp->nfsc_lock, 0);
4371 struct nfsclclient *clp;
4392 clp = nfscl_findcl(nmp);
4393 if (clp == NULL) {
4398 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4406 nfsv4_unlock(&clp->nfsc_lock, 0);
4433 igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
4443 (void) nfscl_recalldeleg(clp, nmp, dp, fvp, cred, p, 0);
4447 nfsv4_unlock(&clp->nfsc_lock, 0);
4455 nfscl_freedeleg(&clp->nfsc_deleg, dp);
4458 nfsv4_unlock(&clp->nfsc_lock, 0);
4463 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
4491 nfscl_freedeleg(&clp->nfsc_deleg, dp);
4506 struct nfsclclient *clp;
4509 clp = nfscl_findcl(nmp);
4510 if (clp == NULL) {
4514 nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, NULL);
4525 struct nfsclclient *clp;
4528 clp = nfscl_findcl(nmp);
4529 if (clp == NULL) {
4533 nfsv4_relref(&clp->nfsc_lock);
4544 struct nfsclclient *clp;
4553 clp = nfscl_findcl(nmp);
4554 if (clp == NULL) {
4558 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4571 struct nfsclclient *clp;
4580 clp = nfscl_findcl(nmp);
4581 if (clp == NULL) {
4585 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4598 struct nfsclclient *clp;
4607 clp = nfscl_findcl(nmp);
4608 if (clp == NULL) {
4612 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4627 struct nfsclclient *clp;
4636 clp = nfscl_findcl(nmp);
4637 if (clp == NULL) {
4641 dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
4691 struct nfsclclient *clp;
4709 clp = nmp->nm_clp;
4710 if (clp == NULL) {
4724 lyp = nfscl_findlayout(clp, fhp, fhlen);
4738 lyp->nfsly_clp = clp;
4743 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
4744 LIST_INSERT_HEAD(NFSCLLAYOUTHASH(clp, fhp, fhlen), lyp,
4751 TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
4752 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
4789 nfscl_getlayout(struct nfsclclient *clp, uint8_t *fhp, int fhlen,
4796 mp = clp->nfsc_nmp->nm_mountp;
4800 lyp = nfscl_findlayout(clp, fhp, fhlen);
4803 TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
4804 TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
4837 nfscl_retoncloselayout(struct nfsclclient *clp, uint8_t *fhp, int fhlen)
4842 lyp = nfscl_findlayout(clp, fhp, fhlen);
4878 nfscl_getdevinfo(struct nfsclclient *clp, uint8_t *deviceid,
4884 dip = nfscl_finddevinfo(clp, deviceid);
4919 nfscl_findlayout(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
4923 LIST_FOREACH(lyp, NFSCLLAYOUTHASH(clp, fhp, fhlen), nfsly_hash)
4934 nfscl_finddevinfo(struct nfsclclient *clp, uint8_t *deviceid)
4938 LIST_FOREACH(dip, &clp->nfsc_devinfo, nfsdi_list)
4978 struct nfsclclient *clp;
4982 clp = nmp->nm_clp;
4983 if (clp == NULL) {
4989 tdip = nfscl_finddevinfo(clp, flp->nfsfl_dev);
5000 LIST_INSERT_HEAD(&clp->nfsc_devinfo, dip, nfsdi_list);
5184 struct nfsclclient *clp;
5195 clp = nmp->nm_clp;
5196 if (clp == NULL) {
5200 lyp = nfscl_findlayout(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
5215 nfscl_dolayoutcommit(clp->nfsc_nmp, lyp, NFSPROCCRED(p), p);
Indexes created Fri Sep 26 20:09:58 GMT 2025