Lines Matching defs:clp
143 static void nfsrv_dumpaclient(struct nfsclient *clp,
156 static int nfsrv_getstate(struct nfsclient *clp, nfsv4stateid_t *stateidp,
171 static int nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
173 static int nfsrv_docallback(struct nfsclient *clp, int procnum,
176 static int nfsrv_cbcallargs(struct nfsrv_descript *nd, struct nfsclient *clp,
180 static u_int32_t nfsrv_nextstateindex(struct nfsclient *clp);
181 static void nfsrv_markstable(struct nfsclient *clp);
182 static void nfsrv_markreclaim(struct nfsclient *clp);
183 static int nfsrv_checkstable(struct nfsclient *clp);
184 static int nfsrv_clientconflict(struct nfsclient *clp, int *haslockp, struct
189 struct nfsclient *clp, int *haslockp, NFSPROC_T *p);
191 struct nfsclient *clp);
213 static int nfsv4_setcbsequence(struct nfsrv_descript *nd, struct nfsclient *clp,
215 static int nfsv4_getcbsession(struct nfsclient *clp, struct nfsdsession **sepp);
247 struct nfsclient *clp);
248 static void nfsrv_issuedelegation(struct vnode *vp, struct nfsclient *clp,
296 * If returning a non-error, the clp structure must either be linked into
303 struct nfsclient *clp = NULL, *new_clp = *new_clpp;
355 LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
356 if (new_clp->lc_idlen == clp->lc_idlen &&
357 !NFSBCMP(new_clp->lc_id, clp->lc_id, clp->lc_idlen)) {
367 (clp->lc_flags & (LCL_NEEDSCONFIRM | LCL_ADMINREVOKED))) {
382 LIST_REMOVE(clp, lc_hash);
384 nfsrv_cleanclient(clp, p, true, &old_xprt);
386 nfsrv_cleanclient(clp, p, false, NULL);
387 nfsrv_freedeleglist(&clp->lc_deleg);
388 nfsrv_freedeleglist(&clp->lc_olddeleg);
425 nfsrv_zapclient(clp, p);
434 if (nfsrv_notsamecredname(NFSV4OP_EXCHANGEID, nd, clp)) {
438 if (clp->lc_expiry < NFSD_MONOSEC &&
439 (!LIST_EMPTY(&clp->lc_open) || !LIST_EMPTY(&clp->lc_deleg))) {
441 nfsrv_cleanclient(clp, p, true, &old_xprt);
443 nfsrv_cleanclient(clp, p, false, NULL);
444 nfsrv_freedeleglist(&clp->lc_deleg);
451 if (!LIST_EMPTY(&clp->lc_deleg)) {
453 } else if (LIST_EMPTY(&clp->lc_open)) {
458 LIST_FOREACH(stp, &clp->lc_open, ls_list) {
470 switch (clp->lc_req.nr_nam->sa_family) {
474 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
482 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
496 if (NFSBCMP(new_clp->lc_verf, clp->lc_verf, NFSX_VERF)) {
503 LIST_REMOVE(clp, lc_hash);
505 LIST_NEWHEAD(&old_sess, &clp->lc_session, sess_list);
527 LIST_NEWHEAD(&new_clp->lc_open, &clp->lc_open, ls_list);
530 LIST_NEWHEAD(&new_clp->lc_deleg, &clp->lc_deleg, ls_list);
533 LIST_NEWHEAD(&new_clp->lc_olddeleg, &clp->lc_olddeleg,
539 &clp->lc_stateid[i], ls_hash);
555 * Must wait until any outstanding callback on the old clp
558 while (clp->lc_cbref) {
559 clp->lc_flags |= LCL_WAKEUPWANTED;
560 (void)mtx_sleep(clp, NFSSTATEMUTEXPTR, PZERO - 1,
561 "nfsd clp", 10 * hz);
574 nfsrv_zapclient(clp, p);
581 clientidp->lval[0] = clp->lc_clientid.lval[0];
582 clientidp->lval[1] = clp->lc_clientid.lval[1];
591 LIST_REMOVE(clp, lc_hash);
596 clp->lc_clientid.lval[0];
598 clp->lc_clientid.lval[1];
599 new_clp->lc_delegtime = clp->lc_delegtime;
600 new_clp->lc_stateindex = clp->lc_stateindex;
601 new_clp->lc_statemaxindex = clp->lc_statemaxindex;
603 LIST_NEWHEAD(&new_clp->lc_open, &clp->lc_open, ls_list);
606 LIST_NEWHEAD(&new_clp->lc_deleg, &clp->lc_deleg, ls_list);
609 LIST_NEWHEAD(&new_clp->lc_olddeleg, &clp->lc_olddeleg, ls_list);
614 &clp->lc_stateid[i], ls_hash);
630 * Must wait until any outstanding callback on the old clp
635 while (clp->lc_cbref) {
636 clp->lc_flags |= LCL_WAKEUPWANTED;
637 (void)mtx_sleep(clp, NFSSTATEMUTEXPTR, PZERO - 1,
643 nfsrv_zapclient(clp, p);
665 struct nfsclient *clp;
727 /* For NFSv4.1, the clp is acquired from the associated session. */
730 clp = NULL;
736 clp = sep->sess_clp;
741 LIST_FOREACH(clp, hp, lc_hash) {
742 if (clp->lc_clientid.lval[1] == clientid.lval[1])
746 if (clp == NULL) {
751 } else if (clp->lc_flags & LCL_ADMINREVOKED) {
780 if (clp->lc_confirm.lval[0] + 1 == confirm.lval[0]) {
781 clp->lc_confirm.lval[0] = confirm.lval[0];
782 clp->lc_prevsess = sessid[0];
783 } else if (clp->lc_confirm.lval[0] == confirm.lval[0]) {
784 if (clp->lc_prevsess == 0)
787 sessid[0] = clp->lc_prevsess;
792 clp->lc_confirm.qval != confirm.qval)
795 nd, clp))
799 if ((clp->lc_flags & (LCL_NEEDSCONFIRM | LCL_DONTCLEAN)) ==
807 nfsrv_cleanclient(clp, p, true, &old_xprt);
809 nfsrv_cleanclient(clp, p, false, NULL);
810 nfsrv_freedeleglist(&clp->lc_olddeleg);
811 if (nfsrv_checkgrace(nd, clp, 0)) {
813 nfsrv_freedeleglist(&clp->lc_deleg);
815 LIST_FOREACH(stp, &clp->lc_deleg, ls_list)
817 clp->lc_delegtime = NFSD_MONOSEC +
819 LIST_NEWHEAD(&clp->lc_olddeleg, &clp->lc_deleg,
823 clp->lc_program = cbprogram;
825 clp->lc_flags &= ~(LCL_NEEDSCONFIRM | LCL_DONTCLEAN);
826 if (clp->lc_program)
827 clp->lc_flags |= LCL_NEEDSCBNULL;
833 if (clp->lc_req.nr_client == NULL) {
834 clp->lc_req.nr_client = client;
837 if (clp->lc_req.nr_client != NULL) {
839 CLNT_ACQUIRE(clp->lc_req.nr_client);
840 nd->nd_xprt->xp_p2 = clp->lc_req.nr_client;
857 LIST_INSERT_HEAD(&clp->lc_session, nsep, sess_list);
858 nsep->sess_clp = clp;
865 } else if (clp->lc_flags & LCL_NEEDSCONFIRM) {
873 if (nfsrv_notsamecredname(0, nd, clp)) {
876 LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
887 if (!error && (clp->lc_flags & LCL_CBDOWN))
892 clp->lc_expiry = nfsrv_leaseexpiry();
904 *clpp = clp;
917 struct nfsclient *clp;
935 LIST_FOREACH(clp, hp, lc_hash) {
936 if (clp->lc_clientid.lval[1] == clientid.lval[1])
939 if (clp == NULL) {
946 error = nfsrv_checkmachcred(NFSV4OP_DESTROYCLIENTID, nd, clp);
960 if (!LIST_EMPTY(&clp->lc_stateid[i])) {
965 if (!LIST_EMPTY(&clp->lc_session) || !LIST_EMPTY(&clp->lc_deleg)) {
974 nfsrv_cleanclient(clp, p, true, &old_xprt);
976 nfsrv_cleanclient(clp, p, false, NULL);
977 nfsrv_freedeleglist(&clp->lc_deleg);
978 nfsrv_freedeleglist(&clp->lc_olddeleg);
979 LIST_REMOVE(clp, lc_hash);
983 nfsrv_zapclient(clp, p);
996 struct nfsclient *clp = NULL;
1017 LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
1018 if (revokep->nclid_idlen == clp->lc_idlen &&
1019 !NFSBCMP(revokep->nclid_id, clp->lc_id, clp->lc_idlen)) {
1037 nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
1043 clp->lc_flags &= ~LCL_CALLBACKSON;
1044 clp->lc_flags |= LCL_ADMINREVOKED;
1045 nfsrv_cleanclient(clp, p, false, NULL);
1046 nfsrv_freedeleglist(&clp->lc_deleg);
1047 nfsrv_freedeleglist(&clp->lc_olddeleg);
1064 struct nfsclient *clp;
1079 clp = LIST_FIRST(&NFSD_VNET(nfsclienthash)[i]);
1080 while (clp != LIST_END(&NFSD_VNET(nfsclienthash)[i]) && cnt <
1082 nfsrv_dumpaclient(clp, &dumpp[cnt]);
1084 clp = LIST_NEXT(clp, lc_hash);
1100 nfsrv_dumpaclient(struct nfsclient *clp, struct nfsd_dumpclients *dumpp)
1115 dumpp->ndcl_flags = clp->lc_flags;
1116 dumpp->ndcl_clid.nclid_idlen = clp->lc_idlen;
1117 NFSBCOPY(clp->lc_id, dumpp->ndcl_clid.nclid_id, clp->lc_idlen);
1118 af = clp->lc_req.nr_nam->sa_family;
1123 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
1129 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
1138 LIST_FOREACH(stp, &clp->lc_open, ls_list) {
1154 LIST_FOREACH(stp, &clp->lc_deleg, ls_list) {
1157 LIST_FOREACH(stp, &clp->lc_olddeleg, ls_list) {
1341 struct nfsclient *clp, *nclp;
1388 clp = LIST_FIRST(&NFSD_VNET(nfsclienthash)[i]);
1389 while (clp != LIST_END(&NFSD_VNET(nfsclienthash)[i])) {
1390 nclp = LIST_NEXT(clp, lc_hash);
1391 if (!(clp->lc_flags & LCL_EXPIREIT)) {
1392 if (((clp->lc_expiry + NFSRV_STALELEASE) < NFSD_MONOSEC
1393 && ((LIST_EMPTY(&clp->lc_deleg)
1394 && LIST_EMPTY(&clp->lc_open)) ||
1396 (clp->lc_expiry + NFSRV_MOULDYLEASE) < NFSD_MONOSEC ||
1397 (clp->lc_expiry < NFSD_MONOSEC &&
1419 clp->lc_flags |= LCL_EXPIREIT;
1430 stp = LIST_FIRST(&clp->lc_open);
1431 while (stp != LIST_END(&clp->lc_open)) {
1447 clp = nclp;
1465 nfsrv_cleanclient(struct nfsclient *clp, NFSPROC_T *p, bool locked,
1471 LIST_FOREACH_SAFE(stp, &clp->lc_open, ls_list, nstp) {
1477 if ((clp->lc_flags & LCL_ADMINREVOKED) == 0)
1478 LIST_FOREACH_SAFE(sep, &clp->lc_session, sess_list, nsep)
1490 nfsrv_zapclient(struct nfsclient *clp, NFSPROC_T *p)
1494 if ((clp->lc_flags & (LCL_GSS | LCL_CALLBACKSON)) ==
1496 (clp->lc_hand.nfsh_flag & NFSG_COMPLETE) &&
1497 clp->lc_handlelen > 0) {
1498 clp->lc_hand.nfsh_flag &= ~NFSG_COMPLETE;
1499 clp->lc_hand.nfsh_flag |= NFSG_DESTROYED;
1500 (void) nfsrv_docallback(clp, NFSV4PROC_CBNULL,
1504 newnfs_disconnect(NULL, &clp->lc_req);
1505 free(clp->lc_req.nr_nam, M_SONAME);
1506 NFSFREEMUTEX(&clp->lc_req.nr_mtx);
1507 free(clp->lc_stateid, M_NFSDCLIENT);
1508 free(clp, M_NFSDCLIENT);
1757 nfsrv_getstate(struct nfsclient *clp, nfsv4stateid_t *stateidp, __unused u_int32_t flags,
1765 hp = NFSSTATEHASH(clp, *stateidp);
1831 struct nfsclient *clp = NULL;
1943 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
1956 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
1962 error = nfsrv_getstate(clp, &new_stp->ls_stateid,
2073 error = nfsrv_checkgrace(nd, clp, new_stp->ls_flags);
2075 nfsrv_checkstable(clp))
2081 nfsrv_markstable(clp);
2247 ret = nfsrv_cleandeleg(vp, lfp, clp, &haslock, p);
2291 clp != tstp->ls_clp &&
2295 (clp != tstp->ls_clp ||
2382 (clp != lop->lo_stp->ls_clp ||
2496 clp->lc_clientid.lval[0];
2498 clp->lc_clientid.lval[1];
2500 nfsrv_nextstateindex(clp);
2501 new_stp->ls_clp = clp;
2507 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_stp->ls_stateid),
2551 struct nfsclient *clp;
2588 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
2596 nfsrv_getowner(&clp->lc_open, new_stp, &ownerstp);
2615 error = nfsrv_checkgrace(nd, clp, new_stp->ls_flags);
2617 nfsrv_checkstable(clp))
2764 if ((readonly && stp->ls_clp != clp &&
2766 (!readonly && (stp->ls_clp != clp ||
2809 struct nfsclient *clp;
2857 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
2859 if (!error && (clp->lc_flags & LCL_NEEDSCBNULL) &&
2860 clp->lc_program) {
2867 * Although nfsrv_docallback() will sleep, clp won't
2870 * fields in clp can change, but having multiple
2874 cbret = nfsrv_docallback(clp, NFSV4PROC_CBNULL,
2877 clp->lc_flags &= ~LCL_NEEDSCBNULL;
2879 clp->lc_flags |= LCL_CALLBACKSON;
2887 nfsrv_getowner(&clp->lc_open, new_stp, &ownerstp);
2906 nfsrv_markstable(clp);
2993 if (clp != stp->ls_clp) {
3060 if (stp->ls_clp != clp && (stp->ls_flags & NFSLCK_DELEGREAD))
3062 else if (stp->ls_clp != clp ||
3066 if ((readonly && stp->ls_clp != clp &&
3068 (!readonly && (stp->ls_clp != clp ||
3110 LIST_FOREACH(stp, &clp->lc_olddeleg, ls_list) {
3113 if (stp->ls_clp != clp)
3114 panic("olddeleg clp");
3120 clp->lc_clientid.lval[0];
3122 clp->lc_clientid.lval[1];
3124 nfsrv_nextstateindex(clp);
3126 LIST_INSERT_HEAD(&clp->lc_deleg, stp, ls_list);
3127 LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3133 clp->lc_delegtime = NFSD_MONOSEC +
3140 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3141 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3142 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3152 new_open->ls_clp = clp;
3155 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3170 LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3182 if (stp == LIST_END(&clp->lc_olddeleg))
3192 if (stp->ls_clp == clp)
3206 clp->lc_clientid.lval[0];
3208 clp->lc_clientid.lval[1];
3210 nfsrv_nextstateindex(clp);
3223 new_deleg->ls_clp = clp;
3228 LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3230 LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);
3233 (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) !=
3246 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3247 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3248 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3258 new_open->ls_clp = clp;
3261 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3276 LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3318 nfsrv_issuedelegation(vp, clp, nd, delegate, writedeleg,
3323 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3324 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3325 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3331 new_open->ls_clp = clp;
3335 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3345 nfsrv_issuedelegation(vp, clp, nd, delegate, writedeleg,
3356 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3357 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3358 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3365 new_open->ls_clp = clp;
3373 nfsrv_issuedelegation(vp, clp, nd, delegate, writedeleg,
3383 if (!(clp->lc_flags & LCL_STAMPEDSTABLE)) {
3384 clp->lc_flags |= LCL_STAMPEDSTABLE;
3385 len = clp->lc_idlen;
3386 NFSBCOPY(clp->lc_id, clidp, len);
3397 LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3398 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3449 struct nfsclient *clp;
3467 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3470 error = nfsrv_getstate(clp, &new_stp->ls_stateid,
3538 if (!(clp->lc_flags & LCL_STAMPEDSTABLE)) {
3539 clp->lc_flags |= LCL_STAMPEDSTABLE;
3540 len = clp->lc_idlen;
3541 NFSBCOPY(clp->lc_id, clidp, len);
3600 struct nfsclient *clp;
3627 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3636 error = nfsrv_getstate(clp, stateidp, NFSLCK_DELEGRETURN, &stp);
3670 nfsrv_freedeleglist(&clp->lc_olddeleg);
3688 struct nfsclient *clp;
3703 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3709 LIST_FOREACH(ownstp, &clp->lc_open, ls_list) {
4075 nfsrv_getclientipaddr(struct nfsrv_descript *nd, struct nfsclient *clp)
4100 clp->lc_req.nr_client = NULL;
4101 clp->lc_req.nr_lock = 0;
4111 clp->lc_flags |= LCL_TCPCALLBACK;
4112 clp->lc_req.nr_sotype = SOCK_STREAM;
4113 clp->lc_req.nr_soproto = IPPROTO_TCP;
4116 clp->lc_req.nr_sotype = SOCK_DGRAM;
4117 clp->lc_req.nr_soproto = IPPROTO_UDP;
4124 clp->lc_flags |= LCL_TCPCALLBACK;
4125 clp->lc_req.nr_sotype = SOCK_STREAM;
4126 clp->lc_req.nr_soproto = IPPROTO_TCP;
4129 clp->lc_req.nr_sotype = SOCK_DGRAM;
4130 clp->lc_req.nr_soproto = IPPROTO_UDP;
4147 * The caller has allocated clp->lc_req.nr_nam to be large enough
4159 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
4168 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
4282 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
4292 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
4300 clp->lc_program = 0;
4376 nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
4413 if (nd != NULL && clp != NULL &&
4415 (clp->lc_flags & LCL_RECLAIMCOMPLETE) != 0) {
4441 nfsrv_docallback(struct nfsclient *clp, int procnum, nfsv4stateid_t *stateidp,
4458 if (clp->lc_flags & LCL_NEEDSCONFIRM) {
4462 clp->lc_cbref++;
4468 clp->lc_req.nr_prog = clp->lc_program;
4470 if ((clp->lc_flags & LCL_NFSV41) != 0)
4471 clp->lc_req.nr_vers = NFSV41_CBVERS;
4474 clp->lc_req.nr_vers = NFSV4_CBVERS;
4480 if (clp->lc_flags & LCL_GSS)
4482 if ((clp->lc_flags & LCL_NFSV41) != 0)
4484 if ((clp->lc_flags & LCL_NFSV42) != 0)
4487 cred->cr_uid = clp->lc_uid;
4488 cred->cr_gid = clp->lc_gid;
4489 callback = clp->lc_callback;
4506 error = nfsrv_cbcallargs(nd, clp, callback, NFSV4OP_CBGETATTR,
4516 error = nfsrv_cbcallargs(nd, clp, callback, NFSV4OP_CBRECALL,
4535 error = nfsrv_cbcallargs(nd, clp, callback,
4562 if ((clp->lc_flags & LCL_NFSV41) != 0) {
4563 error = nfsv4_getcbsession(clp, &sep);
4579 if ((clp->lc_flags & LCL_TLSCB) != 0)
4581 (void) newnfs_sndlock(&clp->lc_req.nr_lock);
4582 if (clp->lc_req.nr_client == NULL) {
4583 if ((clp->lc_flags & LCL_NFSV41) != 0) {
4590 error = newnfs_connect(NULL, &clp->lc_req, cred,
4591 NULL, 1, dotls, &clp->lc_req.nr_client);
4593 error = newnfs_connect(NULL, &clp->lc_req, cred,
4594 NULL, 3, dotls, &clp->lc_req.nr_client);
4596 newnfs_sndunlock(&clp->lc_req.nr_lock);
4602 error = newnfs_request(nd, NULL, clp,
4603 &clp->lc_req, NULL, NULL, cred,
4604 clp->lc_program, clp->lc_req.nr_vers, NULL,
4639 error = newnfs_request(nd, NULL, clp, &clp->lc_req,
4640 NULL, NULL, cred, clp->lc_program,
4641 clp->lc_req.nr_vers, NULL, 1, NULL, NULL);
4658 clp->lc_flags |= LCL_CBDOWN;
4668 if (clp->lc_flags & LCL_CBDOWN)
4669 clp->lc_flags &= ~(LCL_CBDOWN | LCL_CALLBACKSON);
4682 clp->lc_cbref--;
4683 if ((clp->lc_flags & LCL_WAKEUPWANTED) && clp->lc_cbref == 0) {
4684 clp->lc_flags &= ~LCL_WAKEUPWANTED;
4685 wakeup(clp);
4698 nfsrv_cbcallargs(struct nfsrv_descript *nd, struct nfsclient *clp,
4716 error = nfsv4_setcbsequence(nd, clp, 1, sepp, slotposp);
4758 nfsrv_nextstateindex(struct nfsclient *clp)
4764 if (!(clp->lc_flags & LCL_INDEXNOTOK)) {
4765 clp->lc_stateindex++;
4766 if (clp->lc_stateindex != clp->lc_statemaxindex)
4767 return (clp->lc_stateindex);
4777 LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
4801 LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
4808 clp->lc_flags |= LCL_INDEXNOTOK;
4815 clp->lc_stateindex = min_index + 1;
4816 clp->lc_statemaxindex = max_index;
4817 clp->lc_flags &= ~LCL_INDEXNOTOK;
4818 return (clp->lc_stateindex);
5105 nfsrv_markstable(struct nfsclient *clp)
5113 if (sp->nst_len == clp->lc_idlen &&
5114 !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5124 sp->nst_clp = clp;
5132 nfsrv_markreclaim(struct nfsclient *clp)
5140 if (sp->nst_len == clp->lc_idlen &&
5141 !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5155 nfsrv_freedeleglist(&clp->lc_olddeleg);
5163 nfsrv_checkstable(struct nfsclient *clp)
5171 if (sp->nst_len == clp->lc_idlen &&
5172 !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5201 nfsrv_clientconflict(struct nfsclient *clp, int *haslockp, vnode_t vp,
5209 if (clp->lc_expiry >= NFSD_MONOSEC ||
5238 nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
5240 nfsrv_cleanclient(clp, p, false, NULL);
5241 nfsrv_freedeleglist(&clp->lc_deleg);
5242 nfsrv_freedeleglist(&clp->lc_olddeleg);
5243 LIST_REMOVE(clp, lc_hash);
5244 nfsrv_zapclient(clp, p);
5271 struct nfsclient *clp = stp->ls_clp;
5283 if (clp->lc_delegtime < NFSD_MONOSEC) {
5312 NFSD_MONOSEC && clp->lc_expiry >= NFSD_MONOSEC &&
5359 error = nfsrv_docallback(clp, NFSV4OP_CBRECALL,
5368 if (clp->lc_expiry >= NFSD_MONOSEC &&
5429 nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
5431 if (clp->lc_expiry < NFSD_MONOSEC) {
5432 nfsrv_cleanclient(clp, p, false, NULL);
5433 nfsrv_freedeleglist(&clp->lc_deleg);
5434 nfsrv_freedeleglist(&clp->lc_olddeleg);
5435 LIST_REMOVE(clp, lc_hash);
5442 nfsrv_zapclient(clp, p);
5458 struct nfsclient *clp;
5464 clp = NULL;
5473 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
5492 error = nfsrv_cleandeleg(vp, lfp, clp, &haslock, p);
5548 struct nfsclient *clp, int *haslockp, NFSPROC_T *p)
5556 if (stp->ls_clp != clp) {
5729 struct nfsclient *clp;
5768 clp = stp->ls_clp;
5771 if (clp->lc_flags & LCL_NEEDSCONFIRM) {
5789 clp->lc_clientid.qval == nd->nd_clientid.qval) ||
5790 nfsaddr2_match(clp->lc_req.nr_nam, nd->nd_nam)) {
5804 if (clp->lc_expiry >= NFSD_MONOSEC) {
5808 error = nfsrv_docallback(clp, NFSV4OP_CBGETATTR, NULL,
5838 struct nfsclient *clp, *nclp;
5848 LIST_FOREACH_SAFE(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash,
5850 LIST_FOREACH_SAFE(stp, &clp->lc_open, ls_list, nstp) {
5870 nfsrv_notsamecredname(int op, struct nfsrv_descript *nd, struct nfsclient *clp)
5874 if (op != 0 && nfsrv_checkmachcred(op, nd, clp) != 0)
5882 if (!(clp->lc_flags & LCL_GSS))
5884 if (clp->lc_flags & LCL_NAME) {
5885 if (nd->nd_princlen != clp->lc_namelen ||
5886 NFSBCMP(nd->nd_principal, clp->lc_name,
5887 clp->lc_namelen))
5892 if (nd->nd_cred->cr_uid == clp->lc_uid)
5896 } else if (clp->lc_flags & LCL_GSS)
5903 if (nd->nd_cred->cr_uid == clp->lc_uid || nd->nd_cred->cr_uid == 0)
6229 struct nfsclient *clp, *nclp;
6237 LIST_FOREACH_SAFE(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash,
6239 nfsrv_cleanclient(clp, p, false, NULL);
6240 nfsrv_freedeleglist(&clp->lc_deleg);
6241 nfsrv_freedeleglist(&clp->lc_olddeleg);
6242 free(clp->lc_stateid, M_NFSDCLIENT);
6243 free(clp, M_NFSDCLIENT);
6483 struct nfsclient *clp;
6494 clp = sep->sess_clp;
6495 error = nfsrv_checkmachcred(NFSV4OP_BINDCONNTOSESS, nd, clp);
6502 if (clp->lc_req.nr_client == NULL) {
6505 clp->lc_req.nr_client = (struct __rpc_client *)
6509 if (clp->lc_req.nr_client != NULL) {
6514 CLNT_ACQUIRE(clp->lc_req.nr_client);
6515 nd->nd_xprt->xp_p2 = clp->lc_req.nr_client;
6520 clp->lc_flags |= LCL_DONEBINDCONN |
6522 clp->lc_flags &= ~LCL_CBDOWN;
6531 clp->lc_flags |= LCL_DONEBINDCONN;
6540 clp->lc_flags |= LCL_DONEBINDCONN;
6623 struct nfsclient *clp;
6631 error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
6635 LIST_FOREACH(stp, &clp->lc_deleg, ls_list) {
6648 error = nfsrv_getstate(clp, stateidp, 0, &stp);
6668 struct nfsclient *clp;
6676 error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
6679 error = nfsrv_getstate(clp, stateidp, 0, &stp);
6691 nfsv4_setcbsequence(struct nfsrv_descript *nd, struct nfsclient *clp,
6700 error = nfsv4_getcbsession(clp, sepp);
6731 nfsv4_getcbsession(struct nfsclient *clp, struct nfsdsession **sepp)
6736 LIST_FOREACH(sep, &clp->lc_session, sess_list) {
6760 struct nfsclient *clp;
6765 LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
6766 LIST_FOREACH(sep, &clp->lc_session, sess_list) {
7180 struct nfsclient *clp;
7184 error = nfsrv_getclient(clid, 0, &clp, NULL, (nfsquad_t)((u_quad_t)0),
7191 if ((clp->lc_flags & LCL_NFSV41) != 0) {
7192 error = nfsrv_docallback(clp, NFSV4OP_CBLAYOUTRECALL,
7212 printf("nfsrv_recalllayout: clp not NFSv4.1\n");
7430 struct nfsclient *clp;
7441 error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
7449 clp->lc_clientid.lval[0];
7451 clp->lc_clientid.lval[1];
7453 nfsrv_nextstateindex(clp);
8915 nfsrv_checkmachcred(int op, struct nfsrv_descript *nd, struct nfsclient *clp)
8918 if ((clp->lc_flags & LCL_MACHCRED) == 0 ||
8919 !NFSISSET_OPBIT(&clp->lc_mustops, op))
8924 nd->nd_princlen == clp->lc_namelen &&
8925 !NFSBCMP(nd->nd_principal, clp->lc_name, nd->nd_princlen))
8934 nfsrv_issuedelegation(struct vnode *vp, struct nfsclient *clp,
8953 (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) !=
8956 if (up_deleg != NULL && up_deleg->ls_clp == clp &&
8978 = clp->lc_clientid.lval[0];
8980 = clp->lc_clientid.lval[1];
8982 = nfsrv_nextstateindex(clp);
8998 new_deleg->ls_clp = clp;
9003 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_deleg->ls_stateid),
9005 LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);