1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 #include <sys/param.h> 30 #include <sys/types.h> 31 #include <sys/systm.h> 32 #include <sys/cred.h> 33 #include <sys/vfs.h> 34 #include <sys/vnode.h> 35 #include <sys/pathname.h> 36 #include <sys/sysmacros.h> 37 #include <sys/kmem.h> 38 #include <sys/kstat.h> 39 #include <sys/mkdev.h> 40 #include <sys/mount.h> 41 #include <sys/statvfs.h> 42 #include <sys/errno.h> 43 #include <sys/debug.h> 44 #include <sys/cmn_err.h> 45 #include <sys/utsname.h> 46 #include <sys/bootconf.h> 47 #include <sys/modctl.h> 48 #include <sys/acl.h> 49 #include <sys/flock.h> 50 #include <sys/kstr.h> 51 #include <sys/stropts.h> 52 #include <sys/strsubr.h> 53 #include <sys/atomic.h> 54 #include <sys/disp.h> 55 #include <sys/policy.h> 56 #include <sys/list.h> 57 #include <sys/zone.h> 58 59 #include <rpc/types.h> 60 #include <rpc/auth.h> 61 #include <rpc/rpcsec_gss.h> 62 #include <rpc/clnt.h> 63 #include <rpc/xdr.h> 64 65 #include <nfs/nfs.h> 66 #include <nfs/nfs_clnt.h> 67 #include <nfs/mount.h> 68 #include <nfs/nfs_acl.h> 69 70 #include <fs/fs_subr.h> 71 72 #include <nfs/nfs4.h> 73 #include <nfs/rnode4.h> 74 #include <nfs/nfs4_clnt.h> 75 #include <nfs/nfssys.h> 76 77 #ifdef DEBUG 78 /* 79 * These are "special" state IDs and file handles that 80 * match any delegation state ID or file handled. This 81 * is for testing purposes only. 82 */ 83 84 stateid4 nfs4_deleg_any = { 0x7FFFFFF0 }; 85 char nfs4_deleg_fh[] = "\0377\0376\0375\0374"; 86 nfs_fh4 nfs4_deleg_anyfh = { sizeof (nfs4_deleg_fh)-1, nfs4_deleg_fh }; 87 nfsstat4 cb4_getattr_fail = NFS4_OK; 88 nfsstat4 cb4_recall_fail = NFS4_OK; 89 90 int nfs4_callback_debug; 91 int nfs4_recall_debug; 92 int nfs4_drat_debug; 93 94 #endif 95 96 #define CB_NOTE(x) NFS4_DEBUG(nfs4_callback_debug, (CE_NOTE, x)) 97 #define CB_WARN(x) NFS4_DEBUG(nfs4_callback_debug, (CE_WARN, x)) 98 #define CB_WARN1(x, y) NFS4_DEBUG(nfs4_callback_debug, (CE_WARN, x, y)) 99 100 enum nfs4_delegreturn_policy nfs4_delegreturn_policy = INACTIVE; 101 102 static zone_key_t nfs4_callback_zone_key; 103 104 /* 105 * NFS4_MAPSIZE is the number of bytes we are willing to consume 106 * for the block allocation map when the server grants a NFS_LIMIT_BLOCK 107 * style delegation. 108 */ 109 110 #define NFS4_MAPSIZE 8192 111 #define NFS4_MAPWORDS NFS4_MAPSIZE/sizeof (uint_t) 112 #define NbPW (NBBY*sizeof (uint_t)) 113 114 static int nfs4_num_prognums = 1024; 115 static SVC_CALLOUT_TABLE nfs4_cb_sct; 116 117 struct nfs4_dnode { 118 list_node_t linkage; 119 rnode4_t *rnodep; 120 int flags; /* Flags for nfs4delegreturn_impl() */ 121 }; 122 123 static const struct nfs4_callback_stats nfs4_callback_stats_tmpl = { 124 { "delegations", KSTAT_DATA_UINT64 }, 125 { "cb_getattr", KSTAT_DATA_UINT64 }, 126 { "cb_recall", KSTAT_DATA_UINT64 }, 127 { "cb_null", KSTAT_DATA_UINT64 }, 128 { "cb_dispatch", KSTAT_DATA_UINT64 }, 129 { "delegaccept_r", KSTAT_DATA_UINT64 }, 130 { "delegaccept_rw", KSTAT_DATA_UINT64 }, 131 { "delegreturn", KSTAT_DATA_UINT64 }, 132 { "callbacks", KSTAT_DATA_UINT64 }, 133 { "claim_cur", KSTAT_DATA_UINT64 }, 134 { "claim_cur_ok", KSTAT_DATA_UINT64 }, 135 { "recall_trunc", KSTAT_DATA_UINT64 }, 136 { "recall_failed", KSTAT_DATA_UINT64 }, 137 { "return_limit_write", KSTAT_DATA_UINT64 }, 138 { "return_limit_addmap", KSTAT_DATA_UINT64 }, 139 { "deleg_recover", KSTAT_DATA_UINT64 }, 140 { "cb_illegal", KSTAT_DATA_UINT64 } 141 }; 142 143 struct nfs4_cb_port { 144 list_node_t linkage; /* linkage into per-zone port list */ 145 char netid[KNC_STRSIZE]; 146 char uaddr[KNC_STRSIZE]; 147 char protofmly[KNC_STRSIZE]; 148 char proto[KNC_STRSIZE]; 149 }; 150 151 static int cb_getattr_bytes; 152 153 struct cb_recall_pass { 154 rnode4_t *rp; 155 int flags; /* Flags for nfs4delegreturn_impl() */ 156 bool_t truncate; 157 }; 158 159 static nfs4_open_stream_t *get_next_deleg_stream(rnode4_t *, int); 160 static void nfs4delegreturn_thread(struct cb_recall_pass *); 161 static int deleg_reopen(vnode_t *, bool_t *, struct nfs4_callback_globals *, 162 int); 163 static void nfs4_dlistadd(rnode4_t *, struct nfs4_callback_globals *, int); 164 static void nfs4_dlistclean_impl(struct nfs4_callback_globals *, int); 165 static int nfs4delegreturn_impl(rnode4_t *, int, 166 struct nfs4_callback_globals *); 167 static void nfs4delegreturn_cleanup_impl(rnode4_t *, nfs4_server_t *, 168 struct nfs4_callback_globals *); 169 170 static void 171 cb_getattr(nfs_cb_argop4 *argop, nfs_cb_resop4 *resop, struct svc_req *req, 172 struct compound_state *cs, struct nfs4_callback_globals *ncg) 173 { 174 CB_GETATTR4args *args = &argop->nfs_cb_argop4_u.opcbgetattr; 175 CB_GETATTR4res *resp = &resop->nfs_cb_resop4_u.opcbgetattr; 176 rnode4_t *rp; 177 vnode_t *vp; 178 bool_t found = FALSE; 179 struct nfs4_server *sp; 180 struct fattr4 *fap; 181 rpc_inline_t *fdata; 182 long mapcnt; 183 fattr4_change change; 184 fattr4_size size; 185 uint_t rflag; 186 187 ncg->nfs4_callback_stats.cb_getattr.value.ui64++; 188 189 #ifdef DEBUG 190 /* 191 * error injection hook: set cb_getattr_fail global to 192 * NFS4 pcol error to be returned 193 */ 194 if (cb4_getattr_fail != NFS4_OK) { 195 *cs->statusp = resp->status = cb4_getattr_fail; 196 return; 197 } 198 #endif 199 200 resp->obj_attributes.attrmask = 0; 201 202 mutex_enter(&ncg->nfs4_cb_lock); 203 sp = ncg->nfs4prog2server[req->rq_prog - NFS4_CALLBACK]; 204 mutex_exit(&ncg->nfs4_cb_lock); 205 206 if (nfs4_server_vlock(sp, 0) == FALSE) { 207 208 CB_WARN("cb_getattr: cannot find server\n"); 209 210 *cs->statusp = resp->status = NFS4ERR_BADHANDLE; 211 return; 212 } 213 214 /* 215 * In cb_compound, callback_ident was validated against rq_prog, 216 * but we couldn't verify that it was set to the value we provided 217 * at setclientid time (because we didn't have server struct yet). 218 * Now we have the server struct, but don't have callback_ident 219 * handy. So, validate server struct program number against req 220 * RPC's prog number. At this point, we know the RPC prog num 221 * is valid (else we wouldn't be here); however, we don't know 222 * that it was the prog number we supplied to this server at 223 * setclientid time. If the prog numbers aren't equivalent, then 224 * log the problem and fail the request because either cbserv 225 * and/or cbclient are confused. This will probably never happen. 226 */ 227 if (sp->s_program != req->rq_prog) { 228 #ifdef DEBUG 229 zcmn_err(getzoneid(), CE_WARN, 230 "cb_getattr: wrong server program number srv=%d req=%d\n", 231 sp->s_program, req->rq_prog); 232 #else 233 zcmn_err(getzoneid(), CE_WARN, 234 "cb_getattr: wrong server program number\n"); 235 #endif 236 mutex_exit(&sp->s_lock); 237 nfs4_server_rele(sp); 238 *cs->statusp = resp->status = NFS4ERR_BADHANDLE; 239 return; 240 } 241 242 /* 243 * Search the delegation list for a matching file handle; 244 * mutex on sp prevents the list from changing. 245 */ 246 247 rp = list_head(&sp->s_deleg_list); 248 for (; rp != NULL; rp = list_next(&sp->s_deleg_list, rp)) { 249 nfs4_fhandle_t fhandle; 250 251 sfh4_copyval(rp->r_fh, &fhandle); 252 253 if ((fhandle.fh_len == args->fh.nfs_fh4_len && 254 bcmp(fhandle.fh_buf, args->fh.nfs_fh4_val, 255 fhandle.fh_len) == 0)) { 256 257 found = TRUE; 258 break; 259 } 260 #ifdef DEBUG 261 if (nfs4_deleg_anyfh.nfs_fh4_len == args->fh.nfs_fh4_len && 262 bcmp(nfs4_deleg_anyfh.nfs_fh4_val, args->fh.nfs_fh4_val, 263 args->fh.nfs_fh4_len) == 0) { 264 265 found = TRUE; 266 break; 267 } 268 #endif 269 } 270 271 /* 272 * VN_HOLD the vnode before releasing s_lock to guarantee 273 * we have a valid vnode reference. 274 */ 275 if (found == TRUE) { 276 vp = RTOV4(rp); 277 VN_HOLD(vp); 278 } 279 280 mutex_exit(&sp->s_lock); 281 nfs4_server_rele(sp); 282 283 if (found == FALSE) { 284 285 CB_WARN("cb_getattr: bad fhandle\n"); 286 287 *cs->statusp = resp->status = NFS4ERR_BADHANDLE; 288 return; 289 } 290 291 /* 292 * Figure out which attributes the server wants. We only 293 * offer FATTR4_CHANGE & FATTR4_SIZE; ignore the rest. 294 */ 295 fdata = kmem_alloc(cb_getattr_bytes, KM_SLEEP); 296 297 /* 298 * Don't actually need to create XDR to encode these 299 * simple data structures. 300 * xdrmem_create(&xdr, fdata, cb_getattr_bytes, XDR_ENCODE); 301 */ 302 fap = &resp->obj_attributes; 303 304 fap->attrmask = 0; 305 /* attrlist4_len starts at 0 and increases as attrs are processed */ 306 fap->attrlist4 = (char *)fdata; 307 fap->attrlist4_len = 0; 308 309 /* don't supply attrs if request was zero */ 310 if (args->attr_request != 0) { 311 if (args->attr_request & FATTR4_CHANGE_MASK) { 312 /* 313 * If the file is mmapped, then increment the change 314 * attribute and return it. This will guarantee that 315 * the server will perceive that the file has changed 316 * if there is any chance that the client application 317 * has changed it. Otherwise, just return the change 318 * attribute as it has been updated by nfs4write_deleg. 319 */ 320 321 mutex_enter(&rp->r_statelock); 322 mapcnt = rp->r_mapcnt; 323 rflag = rp->r_flags; 324 mutex_exit(&rp->r_statelock); 325 326 mutex_enter(&rp->r_statev4_lock); 327 /* 328 * If object mapped, then always return new change. 329 * Otherwise, return change if object has dirty 330 * pages. If object doesn't have any dirty pages, 331 * then all changes have been pushed to server, so 332 * reset change to grant change. 333 */ 334 if (mapcnt) 335 rp->r_deleg_change++; 336 else if (! (rflag & R4DIRTY)) 337 rp->r_deleg_change = rp->r_deleg_change_grant; 338 change = rp->r_deleg_change; 339 mutex_exit(&rp->r_statev4_lock); 340 341 /* 342 * Use inline XDR code directly, we know that we 343 * going to a memory buffer and it has enough 344 * space so it cannot fail. 345 */ 346 IXDR_PUT_U_HYPER(fdata, change); 347 fap->attrlist4_len += 2 * BYTES_PER_XDR_UNIT; 348 fap->attrmask |= FATTR4_CHANGE_MASK; 349 } 350 351 if (args->attr_request & FATTR4_SIZE_MASK) { 352 /* 353 * Use an atomic add of 0 to fetch a consistent view 354 * of r_size; this avoids having to take rw_lock 355 * which could cause a deadlock. 356 */ 357 size = atomic_add_64_nv((uint64_t *)&rp->r_size, 0); 358 359 /* 360 * Use inline XDR code directly, we know that we 361 * going to a memory buffer and it has enough 362 * space so it cannot fail. 363 */ 364 IXDR_PUT_U_HYPER(fdata, size); 365 fap->attrlist4_len += 2 * BYTES_PER_XDR_UNIT; 366 fap->attrmask |= FATTR4_SIZE_MASK; 367 } 368 } 369 370 VN_RELE(vp); 371 372 *cs->statusp = resp->status = NFS4_OK; 373 } 374 375 static void 376 cb_getattr_free(nfs_cb_resop4 *resop) 377 { 378 if (resop->nfs_cb_resop4_u.opcbgetattr.obj_attributes.attrlist4) 379 kmem_free(resop->nfs_cb_resop4_u.opcbgetattr. 380 obj_attributes.attrlist4, cb_getattr_bytes); 381 } 382 383 static void 384 cb_recall(nfs_cb_argop4 *argop, nfs_cb_resop4 *resop, struct svc_req *req, 385 struct compound_state *cs, struct nfs4_callback_globals *ncg) 386 { 387 CB_RECALL4args * args = &argop->nfs_cb_argop4_u.opcbrecall; 388 CB_RECALL4res *resp = &resop->nfs_cb_resop4_u.opcbrecall; 389 rnode4_t *rp; 390 vnode_t *vp; 391 struct nfs4_server *sp; 392 bool_t found = FALSE; 393 394 ncg->nfs4_callback_stats.cb_recall.value.ui64++; 395 396 ASSERT(req->rq_prog >= NFS4_CALLBACK); 397 ASSERT(req->rq_prog < NFS4_CALLBACK+nfs4_num_prognums); 398 399 #ifdef DEBUG 400 /* 401 * error injection hook: set cb_recall_fail global to 402 * NFS4 pcol error to be returned 403 */ 404 if (cb4_recall_fail != NFS4_OK) { 405 *cs->statusp = resp->status = cb4_recall_fail; 406 return; 407 } 408 #endif 409 410 mutex_enter(&ncg->nfs4_cb_lock); 411 sp = ncg->nfs4prog2server[req->rq_prog - NFS4_CALLBACK]; 412 mutex_exit(&ncg->nfs4_cb_lock); 413 414 if (nfs4_server_vlock(sp, 0) == FALSE) { 415 416 CB_WARN("cb_recall: cannot find server\n"); 417 418 *cs->statusp = resp->status = NFS4ERR_BADHANDLE; 419 return; 420 } 421 422 /* 423 * Search the delegation list for a matching file handle 424 * AND stateid; mutex on sp prevents the list from changing. 425 */ 426 427 rp = list_head(&sp->s_deleg_list); 428 for (; rp != NULL; rp = list_next(&sp->s_deleg_list, rp)) { 429 mutex_enter(&rp->r_statev4_lock); 430 431 /* check both state id and file handle! */ 432 433 if ((bcmp(&rp->r_deleg_stateid, &args->stateid, 434 sizeof (stateid4)) == 0)) { 435 nfs4_fhandle_t fhandle; 436 437 sfh4_copyval(rp->r_fh, &fhandle); 438 if ((fhandle.fh_len == args->fh.nfs_fh4_len && 439 bcmp(fhandle.fh_buf, args->fh.nfs_fh4_val, 440 fhandle.fh_len) == 0)) { 441 442 found = TRUE; 443 break; 444 } else { 445 #ifdef DEBUG 446 CB_WARN("cb_recall: stateid OK, bad fh"); 447 #endif 448 } 449 } 450 #ifdef DEBUG 451 if (bcmp(&args->stateid, &nfs4_deleg_any, 452 sizeof (stateid4)) == 0) { 453 454 found = TRUE; 455 break; 456 } 457 #endif 458 mutex_exit(&rp->r_statev4_lock); 459 } 460 461 /* 462 * VN_HOLD the vnode before releasing s_lock to guarantee 463 * we have a valid vnode reference. The async thread will 464 * release the hold when it's done. 465 */ 466 if (found == TRUE) { 467 mutex_exit(&rp->r_statev4_lock); 468 vp = RTOV4(rp); 469 VN_HOLD(vp); 470 } 471 mutex_exit(&sp->s_lock); 472 nfs4_server_rele(sp); 473 474 if (found == FALSE) { 475 476 CB_WARN("cb_recall: bad stateid\n"); 477 478 *cs->statusp = resp->status = NFS4ERR_BAD_STATEID; 479 return; 480 } 481 482 /* Fire up a thread to do the delegreturn */ 483 nfs4delegreturn_async(rp, NFS4_DR_RECALL|NFS4_DR_REOPEN, 484 args->truncate); 485 486 *cs->statusp = resp->status = 0; 487 } 488 489 /* ARGSUSED */ 490 static void 491 cb_recall_free(nfs_cb_resop4 *resop) 492 { 493 /* nothing to do here, cb_recall doesn't kmem_alloc */ 494 } 495 496 /* 497 * This function handles the CB_NULL proc call from an NFSv4 Server. 498 * 499 * We take note that the server has sent a CB_NULL for later processing 500 * in the recovery logic. It is noted so we may pause slightly after the 501 * setclientid and before reopening files. The pause is to allow the 502 * NFSv4 Server time to receive the CB_NULL reply and adjust any of 503 * its internal structures such that it has the opportunity to grant 504 * delegations to reopened files. 505 * 506 */ 507 508 /* ARGSUSED */ 509 static void 510 cb_null(CB_COMPOUND4args *args, CB_COMPOUND4res *resp, struct svc_req *req, 511 struct nfs4_callback_globals *ncg) 512 { 513 struct nfs4_server *sp; 514 515 ncg->nfs4_callback_stats.cb_null.value.ui64++; 516 517 ASSERT(req->rq_prog >= NFS4_CALLBACK); 518 ASSERT(req->rq_prog < NFS4_CALLBACK+nfs4_num_prognums); 519 520 mutex_enter(&ncg->nfs4_cb_lock); 521 sp = ncg->nfs4prog2server[req->rq_prog - NFS4_CALLBACK]; 522 mutex_exit(&ncg->nfs4_cb_lock); 523 524 if (nfs4_server_vlock(sp, 0) != FALSE) { 525 sp->s_flags |= N4S_CB_PINGED; 526 cv_broadcast(&sp->wait_cb_null); 527 mutex_exit(&sp->s_lock); 528 nfs4_server_rele(sp); 529 } 530 } 531 532 /* 533 * cb_illegal args: void 534 * res : status (NFS4ERR_OP_CB_ILLEGAL) 535 */ 536 /* ARGSUSED */ 537 static void 538 cb_illegal(nfs_cb_argop4 *argop, nfs_cb_resop4 *resop, struct svc_req *req, 539 struct compound_state *cs, struct nfs4_callback_globals *ncg) 540 { 541 CB_ILLEGAL4res *resp = &resop->nfs_cb_resop4_u.opcbillegal; 542 543 ncg->nfs4_callback_stats.cb_illegal.value.ui64++; 544 resop->resop = OP_CB_ILLEGAL; 545 *cs->statusp = resp->status = NFS4ERR_OP_ILLEGAL; 546 } 547 548 static void 549 cb_compound(CB_COMPOUND4args *args, CB_COMPOUND4res *resp, struct svc_req *req, 550 struct nfs4_callback_globals *ncg) 551 { 552 uint_t i; 553 struct compound_state cs; 554 nfs_cb_argop4 *argop; 555 nfs_cb_resop4 *resop, *new_res; 556 uint_t op; 557 558 bzero(&cs, sizeof (cs)); 559 cs.statusp = &resp->status; 560 cs.cont = TRUE; 561 562 /* 563 * Form a reply tag by copying over the reqeuest tag. 564 */ 565 resp->tag.utf8string_len = args->tag.utf8string_len; 566 resp->tag.utf8string_val = kmem_alloc(resp->tag.utf8string_len, 567 KM_SLEEP); 568 bcopy(args->tag.utf8string_val, resp->tag.utf8string_val, 569 args->tag.utf8string_len); 570 571 /* 572 * XXX for now, minorversion should be zero 573 */ 574 if (args->minorversion != CB4_MINORVERSION) { 575 resp->array_len = 0; 576 resp->array = NULL; 577 resp->status = NFS4ERR_MINOR_VERS_MISMATCH; 578 return; 579 } 580 581 #ifdef DEBUG 582 /* 583 * Verify callback_ident. It doesn't really matter if it's wrong 584 * because we don't really use callback_ident -- we use prog number 585 * of the RPC request instead. In this case, just print a DEBUG 586 * console message to reveal brokenness of cbclient (at bkoff/cthon). 587 */ 588 if (args->callback_ident != req->rq_prog) 589 zcmn_err(getzoneid(), CE_WARN, 590 "cb_compound: cb_client using wrong " 591 "callback_ident(%d), should be %d", 592 args->callback_ident, req->rq_prog); 593 #endif 594 595 resp->array_len = args->array_len; 596 resp->array = kmem_zalloc(args->array_len * sizeof (nfs_cb_resop4), 597 KM_SLEEP); 598 599 for (i = 0; i < args->array_len && cs.cont; i++) { 600 601 argop = &args->array[i]; 602 resop = &resp->array[i]; 603 resop->resop = argop->argop; 604 op = (uint_t)resop->resop; 605 606 switch (op) { 607 608 case OP_CB_GETATTR: 609 610 cb_getattr(argop, resop, req, &cs, ncg); 611 break; 612 613 case OP_CB_RECALL: 614 615 cb_recall(argop, resop, req, &cs, ncg); 616 break; 617 618 case OP_CB_ILLEGAL: 619 620 /* fall through */ 621 622 default: 623 /* 624 * Handle OP_CB_ILLEGAL and any undefined opcode. 625 * Currently, the XDR code will return BADXDR 626 * if cb op doesn't decode to legal value, so 627 * it really only handles OP_CB_ILLEGAL. 628 */ 629 op = OP_CB_ILLEGAL; 630 cb_illegal(argop, resop, req, &cs, ncg); 631 } 632 633 if (*cs.statusp != NFS4_OK) 634 cs.cont = FALSE; 635 636 /* 637 * If not at last op, and if we are to stop, then 638 * compact the results array. 639 */ 640 if ((i + 1) < args->array_len && !cs.cont) { 641 642 new_res = kmem_alloc( 643 (i+1) * sizeof (nfs_cb_resop4), KM_SLEEP); 644 bcopy(resp->array, 645 new_res, (i+1) * sizeof (nfs_cb_resop4)); 646 kmem_free(resp->array, 647 args->array_len * sizeof (nfs_cb_resop4)); 648 649 resp->array_len = i + 1; 650 resp->array = new_res; 651 } 652 } 653 654 } 655 656 static void 657 cb_compound_free(CB_COMPOUND4res *resp) 658 { 659 uint_t i, op; 660 nfs_cb_resop4 *resop; 661 662 if (resp->tag.utf8string_val) { 663 UTF8STRING_FREE(resp->tag) 664 } 665 666 for (i = 0; i < resp->array_len; i++) { 667 668 resop = &resp->array[i]; 669 op = (uint_t)resop->resop; 670 671 switch (op) { 672 673 case OP_CB_GETATTR: 674 675 cb_getattr_free(resop); 676 break; 677 678 case OP_CB_RECALL: 679 680 cb_recall_free(resop); 681 break; 682 683 default: 684 break; 685 } 686 } 687 688 if (resp->array != NULL) { 689 kmem_free(resp->array, 690 resp->array_len * sizeof (nfs_cb_resop4)); 691 } 692 } 693 694 static void 695 cb_dispatch(struct svc_req *req, SVCXPRT *xprt) 696 { 697 CB_COMPOUND4args args; 698 CB_COMPOUND4res res; 699 struct nfs4_callback_globals *ncg; 700 701 bool_t (*xdr_args)(), (*xdr_res)(); 702 void (*proc)(CB_COMPOUND4args *, CB_COMPOUND4res *, struct svc_req *, 703 struct nfs4_callback_globals *); 704 void (*freeproc)(CB_COMPOUND4res *); 705 706 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 707 ASSERT(ncg != NULL); 708 709 ncg->nfs4_callback_stats.cb_dispatch.value.ui64++; 710 711 switch (req->rq_proc) { 712 case CB_NULL: 713 xdr_args = xdr_void; 714 xdr_res = xdr_void; 715 proc = cb_null; 716 freeproc = NULL; 717 break; 718 719 case CB_COMPOUND: 720 xdr_args = xdr_CB_COMPOUND4args_clnt; 721 xdr_res = xdr_CB_COMPOUND4res; 722 proc = cb_compound; 723 freeproc = cb_compound_free; 724 break; 725 726 default: 727 CB_WARN("cb_dispatch: no proc\n"); 728 svcerr_noproc(xprt); 729 return; 730 } 731 732 args.tag.utf8string_val = NULL; 733 args.array = NULL; 734 735 if (!SVC_GETARGS(xprt, xdr_args, (caddr_t)&args)) { 736 737 CB_WARN("cb_dispatch: cannot getargs\n"); 738 svcerr_decode(xprt); 739 return; 740 } 741 742 (*proc)(&args, &res, req, ncg); 743 744 if (svc_sendreply(xprt, xdr_res, (caddr_t)&res) == FALSE) { 745 746 CB_WARN("cb_dispatch: bad sendreply\n"); 747 svcerr_systemerr(xprt); 748 } 749 750 if (freeproc) 751 (*freeproc)(&res); 752 753 if (!SVC_FREEARGS(xprt, xdr_args, (caddr_t)&args)) { 754 755 CB_WARN("cb_dispatch: bad freeargs\n"); 756 } 757 } 758 759 static rpcprog_t 760 nfs4_getnextprogram(struct nfs4_callback_globals *ncg) 761 { 762 int i, j; 763 764 j = ncg->nfs4_program_hint; 765 for (i = 0; i < nfs4_num_prognums; i++, j++) { 766 767 if (j >= nfs4_num_prognums) 768 j = 0; 769 770 if (ncg->nfs4prog2server[j] == NULL) { 771 ncg->nfs4_program_hint = j+1; 772 return (j+NFS4_CALLBACK); 773 } 774 } 775 776 return (0); 777 } 778 779 void 780 nfs4callback_destroy(nfs4_server_t *np) 781 { 782 struct nfs4_callback_globals *ncg; 783 int i; 784 785 if (np->s_program == 0) 786 return; 787 788 ncg = np->zone_globals; 789 i = np->s_program - NFS4_CALLBACK; 790 791 mutex_enter(&ncg->nfs4_cb_lock); 792 793 ASSERT(ncg->nfs4prog2server[i] == np); 794 795 ncg->nfs4prog2server[i] = NULL; 796 797 if (i < ncg->nfs4_program_hint) 798 ncg->nfs4_program_hint = i; 799 800 mutex_exit(&ncg->nfs4_cb_lock); 801 } 802 803 /* 804 * nfs4_setport - This function saves a netid and univeral address for 805 * the callback program. These values will be used during setclientid. 806 */ 807 static void 808 nfs4_setport(char *netid, char *uaddr, char *protofmly, char *proto, 809 struct nfs4_callback_globals *ncg) 810 { 811 struct nfs4_cb_port *p; 812 bool_t found = FALSE; 813 814 ASSERT(MUTEX_HELD(&ncg->nfs4_cb_lock)); 815 816 p = list_head(&ncg->nfs4_cb_ports); 817 for (; p != NULL; p = list_next(&ncg->nfs4_cb_ports, p)) { 818 if (strcmp(p->netid, netid) == 0) { 819 found = TRUE; 820 break; 821 } 822 } 823 if (found == TRUE) 824 (void) strcpy(p->uaddr, uaddr); 825 else { 826 p = kmem_alloc(sizeof (*p), KM_SLEEP); 827 828 (void) strcpy(p->uaddr, uaddr); 829 (void) strcpy(p->netid, netid); 830 (void) strcpy(p->protofmly, protofmly); 831 (void) strcpy(p->proto, proto); 832 list_insert_head(&ncg->nfs4_cb_ports, p); 833 } 834 } 835 836 /* 837 * nfs4_cb_args - This function is used to construct the callback 838 * portion of the arguments needed for setclientid. 839 */ 840 841 void 842 nfs4_cb_args(nfs4_server_t *np, struct knetconfig *knc, SETCLIENTID4args *args) 843 { 844 struct nfs4_cb_port *p; 845 bool_t found = FALSE; 846 rpcprog_t pgm; 847 struct nfs4_callback_globals *ncg = np->zone_globals; 848 849 /* 850 * This server structure may already have a program number 851 * assigned to it. This happens when the client has to 852 * re-issue SETCLIENTID. Just re-use the information. 853 */ 854 if (np->s_program >= NFS4_CALLBACK && 855 np->s_program < NFS4_CALLBACK + nfs4_num_prognums) 856 nfs4callback_destroy(np); 857 858 mutex_enter(&ncg->nfs4_cb_lock); 859 860 p = list_head(&ncg->nfs4_cb_ports); 861 for (; p != NULL; p = list_next(&ncg->nfs4_cb_ports, p)) { 862 if (strcmp(p->protofmly, knc->knc_protofmly) == 0 && 863 strcmp(p->proto, knc->knc_proto) == 0) { 864 found = TRUE; 865 break; 866 } 867 } 868 869 if (found == FALSE) { 870 871 NFS4_DEBUG(nfs4_callback_debug, 872 (CE_WARN, "nfs4_cb_args: could not find netid for %s/%s\n", 873 knc->knc_protofmly, knc->knc_proto)); 874 875 args->callback.cb_program = 0; 876 args->callback.cb_location.r_netid = NULL; 877 args->callback.cb_location.r_addr = NULL; 878 args->callback_ident = 0; 879 mutex_exit(&ncg->nfs4_cb_lock); 880 return; 881 } 882 883 if ((pgm = nfs4_getnextprogram(ncg)) == 0) { 884 CB_WARN("nfs4_cb_args: out of program numbers\n"); 885 886 args->callback.cb_program = 0; 887 args->callback.cb_location.r_netid = NULL; 888 args->callback.cb_location.r_addr = NULL; 889 args->callback_ident = 0; 890 mutex_exit(&ncg->nfs4_cb_lock); 891 return; 892 } 893 894 ncg->nfs4prog2server[pgm-NFS4_CALLBACK] = np; 895 args->callback.cb_program = pgm; 896 args->callback.cb_location.r_netid = p->netid; 897 args->callback.cb_location.r_addr = p->uaddr; 898 args->callback_ident = pgm; 899 900 np->s_program = pgm; 901 902 mutex_exit(&ncg->nfs4_cb_lock); 903 } 904 905 static int 906 nfs4_dquery(struct nfs4_svc_args *arg, model_t model) 907 { 908 file_t *fp; 909 vnode_t *vp; 910 rnode4_t *rp; 911 int error; 912 STRUCT_HANDLE(nfs4_svc_args, uap); 913 914 STRUCT_SET_HANDLE(uap, model, arg); 915 916 if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL) 917 return (EBADF); 918 919 vp = fp->f_vnode; 920 921 if (vp == NULL || vp->v_type != VREG || 922 !vn_matchops(vp, nfs4_vnodeops)) { 923 releasef(STRUCT_FGET(uap, fd)); 924 return (EBADF); 925 } 926 927 rp = VTOR4(vp); 928 929 /* 930 * I can't convince myself that we need locking here. The 931 * rnode cannot disappear and the value returned is instantly 932 * stale anway, so why bother? 933 */ 934 935 error = suword32(STRUCT_FGETP(uap, netid), rp->r_deleg_type); 936 releasef(STRUCT_FGET(uap, fd)); 937 return (error); 938 } 939 940 941 /* 942 * NFS4 client system call. This service does the 943 * necessary initialization for the callback program. 944 * This is fashioned after the server side interaction 945 * between nfsd and the kernel. On the client, the 946 * mount command forks and the child process does the 947 * necessary interaction with the kernel. 948 * 949 * uap->fd is the fd of an open transport provider 950 */ 951 int 952 nfs4_svc(struct nfs4_svc_args *arg, model_t model) 953 { 954 file_t *fp; 955 int error; 956 int readsize; 957 char buf[KNC_STRSIZE], uaddr[KNC_STRSIZE]; 958 char protofmly[KNC_STRSIZE], proto[KNC_STRSIZE]; 959 size_t len; 960 STRUCT_HANDLE(nfs4_svc_args, uap); 961 struct netbuf addrmask; 962 int cmd; 963 SVCMASTERXPRT *cb_xprt; 964 struct nfs4_callback_globals *ncg; 965 966 #ifdef lint 967 model = model; /* STRUCT macros don't always refer to it */ 968 #endif 969 970 STRUCT_SET_HANDLE(uap, model, arg); 971 972 if (STRUCT_FGET(uap, cmd) == NFS4_DQUERY) 973 return (nfs4_dquery(arg, model)); 974 975 if (secpolicy_nfs(CRED()) != 0) 976 return (EPERM); 977 978 if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL) 979 return (EBADF); 980 981 /* 982 * Set read buffer size to rsize 983 * and add room for RPC headers. 984 */ 985 readsize = nfs3tsize() + (RPC_MAXDATASIZE - NFS_MAXDATA); 986 if (readsize < RPC_MAXDATASIZE) 987 readsize = RPC_MAXDATASIZE; 988 989 error = copyinstr((const char *)STRUCT_FGETP(uap, netid), buf, 990 KNC_STRSIZE, &len); 991 if (error) { 992 releasef(STRUCT_FGET(uap, fd)); 993 return (error); 994 } 995 996 cmd = STRUCT_FGET(uap, cmd); 997 998 if (cmd & NFS4_KRPC_START) { 999 addrmask.len = STRUCT_FGET(uap, addrmask.len); 1000 addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen); 1001 addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP); 1002 error = copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf, 1003 addrmask.len); 1004 if (error) { 1005 releasef(STRUCT_FGET(uap, fd)); 1006 kmem_free(addrmask.buf, addrmask.maxlen); 1007 return (error); 1008 } 1009 } 1010 else 1011 addrmask.buf = NULL; 1012 1013 error = copyinstr((const char *)STRUCT_FGETP(uap, addr), uaddr, 1014 sizeof (uaddr), &len); 1015 if (error) { 1016 releasef(STRUCT_FGET(uap, fd)); 1017 if (addrmask.buf) 1018 kmem_free(addrmask.buf, addrmask.maxlen); 1019 return (error); 1020 } 1021 1022 error = copyinstr((const char *)STRUCT_FGETP(uap, protofmly), protofmly, 1023 sizeof (protofmly), &len); 1024 if (error) { 1025 releasef(STRUCT_FGET(uap, fd)); 1026 if (addrmask.buf) 1027 kmem_free(addrmask.buf, addrmask.maxlen); 1028 return (error); 1029 } 1030 1031 error = copyinstr((const char *)STRUCT_FGETP(uap, proto), proto, 1032 sizeof (proto), &len); 1033 if (error) { 1034 releasef(STRUCT_FGET(uap, fd)); 1035 if (addrmask.buf) 1036 kmem_free(addrmask.buf, addrmask.maxlen); 1037 return (error); 1038 } 1039 1040 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 1041 ASSERT(ncg != NULL); 1042 1043 mutex_enter(&ncg->nfs4_cb_lock); 1044 if (cmd & NFS4_SETPORT) 1045 nfs4_setport(buf, uaddr, protofmly, proto, ncg); 1046 1047 if (cmd & NFS4_KRPC_START) { 1048 error = svc_tli_kcreate(fp, readsize, buf, &addrmask, &cb_xprt, 1049 &nfs4_cb_sct, NULL, NFS_CB_SVCPOOL_ID, FALSE); 1050 if (error) { 1051 CB_WARN1("nfs4_svc: svc_tli_kcreate failed %d\n", 1052 error); 1053 kmem_free(addrmask.buf, addrmask.maxlen); 1054 } 1055 } 1056 1057 mutex_exit(&ncg->nfs4_cb_lock); 1058 releasef(STRUCT_FGET(uap, fd)); 1059 return (error); 1060 } 1061 1062 struct nfs4_callback_globals * 1063 nfs4_get_callback_globals(void) 1064 { 1065 return (zone_getspecific(nfs4_callback_zone_key, nfs_zone())); 1066 } 1067 1068 static void * 1069 nfs4_callback_init_zone(zoneid_t zoneid) 1070 { 1071 kstat_t *nfs4_callback_kstat; 1072 struct nfs4_callback_globals *ncg; 1073 1074 ncg = kmem_zalloc(sizeof (*ncg), KM_SLEEP); 1075 1076 ncg->nfs4prog2server = kmem_zalloc(nfs4_num_prognums * 1077 sizeof (struct nfs4_server *), KM_SLEEP); 1078 1079 /* initialize the dlist */ 1080 mutex_init(&ncg->nfs4_dlist_lock, NULL, MUTEX_DEFAULT, NULL); 1081 list_create(&ncg->nfs4_dlist, sizeof (struct nfs4_dnode), 1082 offsetof(struct nfs4_dnode, linkage)); 1083 1084 /* initialize cb_port list */ 1085 mutex_init(&ncg->nfs4_cb_lock, NULL, MUTEX_DEFAULT, NULL); 1086 list_create(&ncg->nfs4_cb_ports, sizeof (struct nfs4_cb_port), 1087 offsetof(struct nfs4_cb_port, linkage)); 1088 1089 /* get our own copy of the kstats */ 1090 bcopy(&nfs4_callback_stats_tmpl, &ncg->nfs4_callback_stats, 1091 sizeof (nfs4_callback_stats_tmpl)); 1092 /* register "nfs:0:nfs4_callback_stats" for this zone */ 1093 if ((nfs4_callback_kstat = 1094 kstat_create_zone("nfs", 0, "nfs4_callback_stats", "misc", 1095 KSTAT_TYPE_NAMED, 1096 sizeof (ncg->nfs4_callback_stats) / sizeof (kstat_named_t), 1097 KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, 1098 zoneid)) != NULL) { 1099 nfs4_callback_kstat->ks_data = &ncg->nfs4_callback_stats; 1100 kstat_install(nfs4_callback_kstat); 1101 } 1102 return (ncg); 1103 } 1104 1105 static void 1106 nfs4_discard_delegations(struct nfs4_callback_globals *ncg) 1107 { 1108 nfs4_server_t *sp; 1109 int i, num_removed; 1110 1111 /* 1112 * It's OK here to just run through the registered "programs", as 1113 * servers without programs won't have any delegations to handle. 1114 */ 1115 for (i = 0; i < nfs4_num_prognums; i++) { 1116 rnode4_t *rp; 1117 1118 mutex_enter(&ncg->nfs4_cb_lock); 1119 sp = ncg->nfs4prog2server[i]; 1120 mutex_exit(&ncg->nfs4_cb_lock); 1121 1122 if (nfs4_server_vlock(sp, 1) == FALSE) 1123 continue; 1124 num_removed = 0; 1125 while ((rp = list_head(&sp->s_deleg_list)) != NULL) { 1126 mutex_enter(&rp->r_statev4_lock); 1127 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 1128 /* 1129 * We need to take matters into our own hands, 1130 * as nfs4delegreturn_cleanup_impl() won't 1131 * remove this from the list. 1132 */ 1133 list_remove(&sp->s_deleg_list, rp); 1134 mutex_exit(&rp->r_statev4_lock); 1135 nfs4_dec_state_ref_count_nolock(sp, 1136 VTOMI4(RTOV4(rp))); 1137 num_removed++; 1138 continue; 1139 } 1140 mutex_exit(&rp->r_statev4_lock); 1141 VN_HOLD(RTOV4(rp)); 1142 mutex_exit(&sp->s_lock); 1143 /* 1144 * The following will remove the node from the list. 1145 */ 1146 nfs4delegreturn_cleanup_impl(rp, sp, ncg); 1147 VN_RELE(RTOV4(rp)); 1148 mutex_enter(&sp->s_lock); 1149 } 1150 mutex_exit(&sp->s_lock); 1151 /* each removed list node reles a reference */ 1152 while (num_removed-- > 0) 1153 nfs4_server_rele(sp); 1154 /* remove our reference for nfs4_server_vlock */ 1155 nfs4_server_rele(sp); 1156 } 1157 } 1158 1159 /* ARGSUSED */ 1160 static void 1161 nfs4_callback_shutdown_zone(zoneid_t zoneid, void *data) 1162 { 1163 struct nfs4_callback_globals *ncg = data; 1164 1165 /* 1166 * Clean pending delegation return list. 1167 */ 1168 nfs4_dlistclean_impl(ncg, NFS4_DR_DISCARD); 1169 1170 /* 1171 * Discard all delegations. 1172 */ 1173 nfs4_discard_delegations(ncg); 1174 } 1175 1176 static void 1177 nfs4_callback_fini_zone(zoneid_t zoneid, void *data) 1178 { 1179 struct nfs4_callback_globals *ncg = data; 1180 struct nfs4_cb_port *p; 1181 nfs4_server_t *sp, *next; 1182 nfs4_server_t freelist; 1183 int i; 1184 1185 kstat_delete_byname_zone("nfs", 0, "nfs4_callback_stats", zoneid); 1186 1187 /* 1188 * Discard all delegations that may have crept in since we did the 1189 * _shutdown. 1190 */ 1191 nfs4_discard_delegations(ncg); 1192 /* 1193 * We're completely done with this zone and all associated 1194 * nfs4_server_t's. Any remaining nfs4_server_ts should only have one 1195 * more reference outstanding -- the reference we didn't release in 1196 * nfs4_renew_lease_thread(). 1197 * 1198 * Here we need to run through the global nfs4_server_lst as we need to 1199 * deal with nfs4_server_ts without programs, as they also have threads 1200 * created for them, and so have outstanding references that we need to 1201 * release. 1202 */ 1203 freelist.forw = &freelist; 1204 freelist.back = &freelist; 1205 mutex_enter(&nfs4_server_lst_lock); 1206 sp = nfs4_server_lst.forw; 1207 while (sp != &nfs4_server_lst) { 1208 next = sp->forw; 1209 if (sp->zoneid == zoneid) { 1210 remque(sp); 1211 insque(sp, &freelist); 1212 } 1213 sp = next; 1214 } 1215 mutex_exit(&nfs4_server_lst_lock); 1216 1217 sp = freelist.forw; 1218 while (sp != &freelist) { 1219 next = sp->forw; 1220 nfs4_server_rele(sp); /* free the list's reference */ 1221 sp = next; 1222 } 1223 1224 #ifdef DEBUG 1225 for (i = 0; i < nfs4_num_prognums; i++) { 1226 ASSERT(ncg->nfs4prog2server[i] == NULL); 1227 } 1228 #endif 1229 kmem_free(ncg->nfs4prog2server, nfs4_num_prognums * 1230 sizeof (struct nfs4_server *)); 1231 1232 mutex_enter(&ncg->nfs4_cb_lock); 1233 while ((p = list_head(&ncg->nfs4_cb_ports)) != NULL) { 1234 list_remove(&ncg->nfs4_cb_ports, p); 1235 kmem_free(p, sizeof (*p)); 1236 } 1237 list_destroy(&ncg->nfs4_cb_ports); 1238 mutex_destroy(&ncg->nfs4_cb_lock); 1239 list_destroy(&ncg->nfs4_dlist); 1240 mutex_destroy(&ncg->nfs4_dlist_lock); 1241 kmem_free(ncg, sizeof (*ncg)); 1242 } 1243 1244 void 1245 nfs4_callback_init(void) 1246 { 1247 int i; 1248 SVC_CALLOUT *nfs4_cb_sc; 1249 1250 /* initialize the callback table */ 1251 nfs4_cb_sc = kmem_alloc(nfs4_num_prognums * 1252 sizeof (SVC_CALLOUT), KM_SLEEP); 1253 1254 for (i = 0; i < nfs4_num_prognums; i++) { 1255 nfs4_cb_sc[i].sc_prog = NFS4_CALLBACK+i; 1256 nfs4_cb_sc[i].sc_versmin = NFS_CB; 1257 nfs4_cb_sc[i].sc_versmax = NFS_CB; 1258 nfs4_cb_sc[i].sc_dispatch = cb_dispatch; 1259 } 1260 1261 nfs4_cb_sct.sct_size = nfs4_num_prognums; 1262 nfs4_cb_sct.sct_free = FALSE; 1263 nfs4_cb_sct.sct_sc = nfs4_cb_sc; 1264 1265 /* 1266 * Compute max bytes required for dyamically allocated parts 1267 * of cb_getattr reply. Only size and change are supported now. 1268 * If CB_GETATTR is changed to reply with additional attrs, 1269 * additional sizes must be added below. 1270 * 1271 * fattr4_change + fattr4_size == uint64_t + uint64_t 1272 */ 1273 cb_getattr_bytes = 2 * BYTES_PER_XDR_UNIT + 2 * BYTES_PER_XDR_UNIT; 1274 1275 zone_key_create(&nfs4_callback_zone_key, nfs4_callback_init_zone, 1276 nfs4_callback_shutdown_zone, nfs4_callback_fini_zone); 1277 } 1278 1279 void 1280 nfs4_callback_fini(void) 1281 { 1282 } 1283 1284 /* 1285 * NB: This function can be called from the *wrong* zone (ie, the zone that 1286 * 'rp' belongs to and the caller's zone may not be the same). This can happen 1287 * if the zone is going away and we get called from nfs4_async_inactive(). In 1288 * this case the globals will be NULL and we won't update the counters, which 1289 * doesn't matter as the zone is going away anyhow. 1290 */ 1291 static void 1292 nfs4delegreturn_cleanup_impl(rnode4_t *rp, nfs4_server_t *np, 1293 struct nfs4_callback_globals *ncg) 1294 { 1295 mntinfo4_t *mi = VTOMI4(RTOV4(rp)); 1296 boolean_t need_rele = B_FALSE; 1297 1298 /* 1299 * Caller must be holding mi_recovlock in read mode 1300 * to call here. This is provided by start_op. 1301 * Delegation management requires to grab s_lock 1302 * first and then r_statev4_lock. 1303 */ 1304 1305 if (np == NULL) { 1306 np = find_nfs4_server_all(mi, 1); 1307 if (np == NULL) 1308 return; 1309 need_rele = B_TRUE; 1310 } else { 1311 mutex_enter(&np->s_lock); 1312 } 1313 1314 mutex_enter(&rp->r_statev4_lock); 1315 1316 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 1317 mutex_exit(&rp->r_statev4_lock); 1318 mutex_exit(&np->s_lock); 1319 if (need_rele) 1320 nfs4_server_rele(np); 1321 return; 1322 } 1323 1324 /* 1325 * Free the cred originally held when 1326 * the delegation was granted. Caller must 1327 * hold this cred if it wants to use it after 1328 * this call. 1329 */ 1330 crfree(rp->r_deleg_cred); 1331 rp->r_deleg_cred = NULL; 1332 rp->r_deleg_type = OPEN_DELEGATE_NONE; 1333 rp->r_deleg_needs_recovery = OPEN_DELEGATE_NONE; 1334 rp->r_deleg_needs_recall = FALSE; 1335 rp->r_deleg_return_pending = FALSE; 1336 1337 /* 1338 * Remove the rnode from the server's list and 1339 * update the ref counts. 1340 */ 1341 list_remove(&np->s_deleg_list, rp); 1342 mutex_exit(&rp->r_statev4_lock); 1343 nfs4_dec_state_ref_count_nolock(np, mi); 1344 mutex_exit(&np->s_lock); 1345 /* removed list node removes a reference */ 1346 nfs4_server_rele(np); 1347 if (need_rele) 1348 nfs4_server_rele(np); 1349 if (ncg != NULL) 1350 ncg->nfs4_callback_stats.delegations.value.ui64--; 1351 } 1352 1353 void 1354 nfs4delegreturn_cleanup(rnode4_t *rp, nfs4_server_t *np) 1355 { 1356 struct nfs4_callback_globals *ncg; 1357 1358 if (np != NULL) { 1359 ncg = np->zone_globals; 1360 } else if (nfs_zone() == VTOMI4(RTOV4(rp))->mi_zone) { 1361 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 1362 ASSERT(ncg != NULL); 1363 } else { 1364 /* 1365 * Request coming from the wrong zone. 1366 */ 1367 ASSERT(getzoneid() == GLOBAL_ZONEID); 1368 ncg = NULL; 1369 } 1370 1371 nfs4delegreturn_cleanup_impl(rp, np, ncg); 1372 } 1373 1374 static void 1375 nfs4delegreturn_save_lost_rqst(int error, nfs4_lost_rqst_t *lost_rqstp, 1376 cred_t *cr, vnode_t *vp) 1377 { 1378 if (error != ETIMEDOUT && error != EINTR && 1379 !NFS4_FRC_UNMT_ERR(error, vp->v_vfsp)) { 1380 lost_rqstp->lr_op = 0; 1381 return; 1382 } 1383 1384 NFS4_DEBUG(nfs4_lost_rqst_debug, (CE_NOTE, 1385 "nfs4close_save_lost_rqst: error %d", error)); 1386 1387 lost_rqstp->lr_op = OP_DELEGRETURN; 1388 /* 1389 * The vp is held and rele'd via the recovery code. 1390 * See nfs4_save_lost_rqst. 1391 */ 1392 lost_rqstp->lr_vp = vp; 1393 lost_rqstp->lr_dvp = NULL; 1394 lost_rqstp->lr_oop = NULL; 1395 lost_rqstp->lr_osp = NULL; 1396 lost_rqstp->lr_lop = NULL; 1397 lost_rqstp->lr_cr = cr; 1398 lost_rqstp->lr_flk = NULL; 1399 lost_rqstp->lr_putfirst = FALSE; 1400 } 1401 1402 static void 1403 nfs4delegreturn_otw(rnode4_t *rp, cred_t *cr, nfs4_error_t *ep) 1404 { 1405 COMPOUND4args_clnt args; 1406 COMPOUND4res_clnt res; 1407 nfs_argop4 argops[3]; 1408 nfs4_ga_res_t *garp = NULL; 1409 hrtime_t t; 1410 int numops; 1411 int doqueue = 1; 1412 1413 args.ctag = TAG_DELEGRETURN; 1414 1415 numops = 3; /* PUTFH, GETATTR, DELEGRETURN */ 1416 1417 args.array = argops; 1418 args.array_len = numops; 1419 1420 argops[0].argop = OP_CPUTFH; 1421 argops[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh; 1422 1423 argops[1].argop = OP_GETATTR; 1424 argops[1].nfs_argop4_u.opgetattr.attr_request = NFS4_VATTR_MASK; 1425 argops[1].nfs_argop4_u.opgetattr.mi = VTOMI4(RTOV4(rp)); 1426 1427 argops[2].argop = OP_DELEGRETURN; 1428 argops[2].nfs_argop4_u.opdelegreturn.deleg_stateid = 1429 rp->r_deleg_stateid; 1430 1431 t = gethrtime(); 1432 rfs4call(VTOMI4(RTOV4(rp)), &args, &res, cr, &doqueue, 0, ep); 1433 1434 if (ep->error) 1435 return; 1436 1437 if (res.status == NFS4_OK) { 1438 garp = &res.array[1].nfs_resop4_u.opgetattr.ga_res; 1439 nfs4_attr_cache(RTOV4(rp), garp, t, cr, TRUE, NULL); 1440 1441 } 1442 (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1443 } 1444 1445 int 1446 nfs4_do_delegreturn(rnode4_t *rp, int flags, cred_t *cr, 1447 struct nfs4_callback_globals *ncg) 1448 { 1449 vnode_t *vp = RTOV4(rp); 1450 mntinfo4_t *mi = VTOMI4(vp); 1451 nfs4_lost_rqst_t lost_rqst; 1452 nfs4_recov_state_t recov_state; 1453 bool_t needrecov = FALSE, recovonly, done = FALSE; 1454 nfs4_error_t e = { 0, NFS4_OK, RPC_SUCCESS }; 1455 1456 ncg->nfs4_callback_stats.delegreturn.value.ui64++; 1457 1458 while (!done) { 1459 e.error = nfs4_start_fop(mi, vp, NULL, OH_DELEGRETURN, 1460 &recov_state, &recovonly); 1461 1462 if (e.error) { 1463 if (flags & NFS4_DR_FORCE) { 1464 (void) nfs_rw_enter_sig(&mi->mi_recovlock, 1465 RW_READER, 0); 1466 nfs4delegreturn_cleanup_impl(rp, NULL, ncg); 1467 nfs_rw_exit(&mi->mi_recovlock); 1468 } 1469 break; 1470 } 1471 1472 /* 1473 * Check to see if the delegation has already been 1474 * returned by the recovery thread. The state of 1475 * the delegation cannot change at this point due 1476 * to start_fop and the r_deleg_recall_lock. 1477 */ 1478 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 1479 e.error = 0; 1480 nfs4_end_op(mi, vp, NULL, &recov_state, needrecov); 1481 break; 1482 } 1483 1484 if (recovonly) { 1485 /* 1486 * Delegation will be returned via the 1487 * recovery framework. Build a lost request 1488 * structure, start recovery and get out. 1489 */ 1490 nfs4_error_init(&e, EINTR); 1491 nfs4delegreturn_save_lost_rqst(e.error, &lost_rqst, 1492 cr, vp); 1493 (void) nfs4_start_recovery(&e, mi, vp, 1494 NULL, &rp->r_deleg_stateid, 1495 lost_rqst.lr_op == OP_DELEGRETURN ? 1496 &lost_rqst : NULL, OP_DELEGRETURN, NULL); 1497 nfs4_end_op(mi, vp, NULL, &recov_state, needrecov); 1498 break; 1499 } 1500 1501 nfs4delegreturn_otw(rp, cr, &e); 1502 1503 /* 1504 * Ignore some errors on delegreturn; no point in marking 1505 * the file dead on a state destroying operation. 1506 */ 1507 if (e.error == 0 && (nfs4_recov_marks_dead(e.stat) || 1508 e.stat == NFS4ERR_BADHANDLE || 1509 e.stat == NFS4ERR_STALE)) 1510 needrecov = FALSE; 1511 else 1512 needrecov = nfs4_needs_recovery(&e, TRUE, vp->v_vfsp); 1513 1514 if (needrecov) { 1515 nfs4delegreturn_save_lost_rqst(e.error, &lost_rqst, 1516 cr, vp); 1517 (void) nfs4_start_recovery(&e, mi, vp, 1518 NULL, &rp->r_deleg_stateid, 1519 lost_rqst.lr_op == OP_DELEGRETURN ? 1520 &lost_rqst : NULL, OP_DELEGRETURN, NULL); 1521 } else { 1522 nfs4delegreturn_cleanup_impl(rp, NULL, ncg); 1523 done = TRUE; 1524 } 1525 1526 nfs4_end_op(mi, vp, NULL, &recov_state, needrecov); 1527 } 1528 return (e.error); 1529 } 1530 1531 /* 1532 * nfs4_resend_delegreturn - used to drive the delegreturn 1533 * operation via the recovery thread. 1534 */ 1535 void 1536 nfs4_resend_delegreturn(nfs4_lost_rqst_t *lorp, nfs4_error_t *ep, 1537 nfs4_server_t *np) 1538 { 1539 rnode4_t *rp = VTOR4(lorp->lr_vp); 1540 1541 /* If the file failed recovery, just quit. */ 1542 mutex_enter(&rp->r_statelock); 1543 if (rp->r_flags & R4RECOVERR) { 1544 ep->error = EIO; 1545 } 1546 mutex_exit(&rp->r_statelock); 1547 1548 if (!ep->error) 1549 nfs4delegreturn_otw(rp, lorp->lr_cr, ep); 1550 1551 /* 1552 * If recovery is now needed, then return the error 1553 * and status and let the recovery thread handle it, 1554 * including re-driving another delegreturn. Otherwise, 1555 * just give up and clean up the delegation. 1556 */ 1557 if (nfs4_needs_recovery(ep, TRUE, lorp->lr_vp->v_vfsp)) 1558 return; 1559 1560 if (rp->r_deleg_type != OPEN_DELEGATE_NONE) 1561 nfs4delegreturn_cleanup(rp, np); 1562 1563 nfs4_error_zinit(ep); 1564 } 1565 1566 /* 1567 * nfs4delegreturn - general function to return a delegation. 1568 * 1569 * NFS4_DR_FORCE - return the delegation even if start_op fails 1570 * NFS4_DR_PUSH - push modified data back to the server via VOP_PUTPAGE 1571 * NFS4_DR_DISCARD - discard the delegation w/o delegreturn 1572 * NFS4_DR_DID_OP - calling function already did nfs4_start_op 1573 * NFS4_DR_RECALL - delegreturned initiated via CB_RECALL 1574 * NFS4_DR_REOPEN - do file reopens, if applicable 1575 */ 1576 static int 1577 nfs4delegreturn_impl(rnode4_t *rp, int flags, struct nfs4_callback_globals *ncg) 1578 { 1579 int error = 0; 1580 cred_t *cr = NULL; 1581 vnode_t *vp; 1582 bool_t needrecov = FALSE; 1583 bool_t rw_entered = FALSE; 1584 bool_t do_reopen; 1585 1586 vp = RTOV4(rp); 1587 1588 /* 1589 * If NFS4_DR_DISCARD is set by itself, take a short-cut and 1590 * discard without doing an otw DELEGRETURN. This may only be used 1591 * by the recovery thread because it bypasses the synchronization 1592 * with r_deleg_recall_lock and mi->mi_recovlock. 1593 */ 1594 if (flags == NFS4_DR_DISCARD) { 1595 nfs4delegreturn_cleanup_impl(rp, NULL, ncg); 1596 return (0); 1597 } 1598 1599 if (flags & NFS4_DR_DID_OP) { 1600 /* 1601 * Caller had already done start_op, which means the 1602 * r_deleg_recall_lock is already held in READ mode 1603 * so we cannot take it in write mode. Return the 1604 * delegation asynchronously. 1605 * 1606 * Remove the NFS4_DR_DID_OP flag so we don't 1607 * get stuck looping through here. 1608 */ 1609 VN_HOLD(vp); 1610 nfs4delegreturn_async(rp, (flags & ~NFS4_DR_DID_OP), FALSE); 1611 return (0); 1612 } 1613 1614 /* 1615 * Verify we still have a delegation and crhold the credential. 1616 */ 1617 mutex_enter(&rp->r_statev4_lock); 1618 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 1619 mutex_exit(&rp->r_statev4_lock); 1620 goto out; 1621 } 1622 cr = rp->r_deleg_cred; 1623 ASSERT(cr != NULL); 1624 crhold(cr); 1625 mutex_exit(&rp->r_statev4_lock); 1626 1627 /* 1628 * Push the modified data back to the server synchronously 1629 * before doing DELEGRETURN. 1630 */ 1631 if (flags & NFS4_DR_PUSH) 1632 (void) VOP_PUTPAGE(vp, 0, 0, 0, cr, NULL); 1633 1634 /* 1635 * Take r_deleg_recall_lock in WRITE mode, this will prevent 1636 * nfs4_is_otw_open_necessary from trying to use the delegation 1637 * while the DELEGRETURN is in progress. 1638 */ 1639 (void) nfs_rw_enter_sig(&rp->r_deleg_recall_lock, RW_WRITER, FALSE); 1640 1641 rw_entered = TRUE; 1642 1643 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) 1644 goto out; 1645 1646 if (flags & NFS4_DR_REOPEN) { 1647 /* 1648 * If R4RECOVERRP is already set, then skip re-opening 1649 * the delegation open streams and go straight to doing 1650 * delegreturn. (XXX if the file has failed recovery, then the 1651 * delegreturn attempt is likely to be futile.) 1652 */ 1653 mutex_enter(&rp->r_statelock); 1654 do_reopen = !(rp->r_flags & R4RECOVERRP); 1655 mutex_exit(&rp->r_statelock); 1656 1657 if (do_reopen) { 1658 error = deleg_reopen(vp, &needrecov, ncg, flags); 1659 if (error != 0) { 1660 if ((flags & (NFS4_DR_FORCE | NFS4_DR_RECALL)) 1661 == 0) 1662 goto out; 1663 } else if (needrecov) { 1664 if ((flags & NFS4_DR_FORCE) == 0) 1665 goto out; 1666 } 1667 } 1668 } 1669 1670 if (flags & NFS4_DR_DISCARD) { 1671 mntinfo4_t *mi = VTOMI4(RTOV4(rp)); 1672 1673 mutex_enter(&rp->r_statelock); 1674 /* 1675 * deleg_return_pending is cleared inside of delegation_accept 1676 * when a delegation is accepted. if this flag has been 1677 * cleared, then a new delegation has overwritten the one we 1678 * were about to throw away. 1679 */ 1680 if (!rp->r_deleg_return_pending) { 1681 mutex_exit(&rp->r_statelock); 1682 goto out; 1683 } 1684 mutex_exit(&rp->r_statelock); 1685 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, FALSE); 1686 nfs4delegreturn_cleanup_impl(rp, NULL, ncg); 1687 nfs_rw_exit(&mi->mi_recovlock); 1688 } else { 1689 error = nfs4_do_delegreturn(rp, flags, cr, ncg); 1690 } 1691 1692 out: 1693 if (cr) 1694 crfree(cr); 1695 if (rw_entered) 1696 nfs_rw_exit(&rp->r_deleg_recall_lock); 1697 return (error); 1698 } 1699 1700 int 1701 nfs4delegreturn(rnode4_t *rp, int flags) 1702 { 1703 struct nfs4_callback_globals *ncg; 1704 1705 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 1706 ASSERT(ncg != NULL); 1707 1708 return (nfs4delegreturn_impl(rp, flags, ncg)); 1709 } 1710 1711 void 1712 nfs4delegreturn_async(rnode4_t *rp, int flags, bool_t trunc) 1713 { 1714 struct cb_recall_pass *pp; 1715 1716 pp = kmem_alloc(sizeof (struct cb_recall_pass), KM_SLEEP); 1717 pp->rp = rp; 1718 pp->flags = flags; 1719 pp->truncate = trunc; 1720 1721 /* 1722 * Fire up a thread to do the actual delegreturn 1723 * Caller must guarantee that the rnode doesn't 1724 * vanish (by calling VN_HOLD). 1725 */ 1726 1727 (void) zthread_create(NULL, 0, nfs4delegreturn_thread, pp, 0, 1728 minclsyspri); 1729 } 1730 1731 static void 1732 delegreturn_all_thread(rpcprog_t *pp) 1733 { 1734 nfs4_server_t *np; 1735 bool_t found = FALSE; 1736 rpcprog_t prog; 1737 rnode4_t *rp; 1738 vnode_t *vp; 1739 zoneid_t zoneid = getzoneid(); 1740 struct nfs4_callback_globals *ncg; 1741 1742 NFS4_DEBUG(nfs4_drat_debug, 1743 (CE_NOTE, "delereturn_all_thread: prog %d\n", *pp)); 1744 1745 prog = *pp; 1746 kmem_free(pp, sizeof (*pp)); 1747 pp = NULL; 1748 1749 mutex_enter(&nfs4_server_lst_lock); 1750 for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) { 1751 if (np->zoneid == zoneid && np->s_program == prog) { 1752 mutex_enter(&np->s_lock); 1753 found = TRUE; 1754 break; 1755 } 1756 } 1757 mutex_exit(&nfs4_server_lst_lock); 1758 1759 /* 1760 * It's possible that the nfs4_server which was using this 1761 * program number has vanished since this thread is async. 1762 * If so, just return. Your work here is finished, my friend. 1763 */ 1764 if (!found) 1765 goto out; 1766 1767 ncg = np->zone_globals; 1768 while ((rp = list_head(&np->s_deleg_list)) != NULL) { 1769 vp = RTOV4(rp); 1770 VN_HOLD(vp); 1771 mutex_exit(&np->s_lock); 1772 (void) nfs4delegreturn_impl(rp, NFS4_DR_PUSH|NFS4_DR_REOPEN, 1773 ncg); 1774 VN_RELE(vp); 1775 1776 /* retake the s_lock for next trip through the loop */ 1777 mutex_enter(&np->s_lock); 1778 } 1779 mutex_exit(&np->s_lock); 1780 out: 1781 NFS4_DEBUG(nfs4_drat_debug, 1782 (CE_NOTE, "delereturn_all_thread: complete\n")); 1783 zthread_exit(); 1784 } 1785 1786 void 1787 nfs4_delegreturn_all(nfs4_server_t *sp) 1788 { 1789 rpcprog_t pro, *pp; 1790 1791 mutex_enter(&sp->s_lock); 1792 1793 /* Check to see if the delegation list is empty */ 1794 1795 if (list_head(&sp->s_deleg_list) == NULL) { 1796 mutex_exit(&sp->s_lock); 1797 return; 1798 } 1799 /* 1800 * Grab the program number; the async thread will use this 1801 * to find the nfs4_server. 1802 */ 1803 pro = sp->s_program; 1804 mutex_exit(&sp->s_lock); 1805 pp = kmem_alloc(sizeof (rpcprog_t), KM_SLEEP); 1806 *pp = pro; 1807 (void) zthread_create(NULL, 0, delegreturn_all_thread, pp, 0, 1808 minclsyspri); 1809 } 1810 1811 1812 /* 1813 * Discard any delegations 1814 * 1815 * Iterate over the servers s_deleg_list and 1816 * for matching mount-point rnodes discard 1817 * the delegation. 1818 */ 1819 void 1820 nfs4_deleg_discard(mntinfo4_t *mi, nfs4_server_t *sp) 1821 { 1822 rnode4_t *rp, *next; 1823 mntinfo4_t *r_mi; 1824 struct nfs4_callback_globals *ncg; 1825 1826 ASSERT(mutex_owned(&sp->s_lock)); 1827 ncg = sp->zone_globals; 1828 1829 for (rp = list_head(&sp->s_deleg_list); rp != NULL; rp = next) { 1830 r_mi = VTOMI4(RTOV4(rp)); 1831 next = list_next(&sp->s_deleg_list, rp); 1832 1833 if (r_mi != mi) { 1834 /* 1835 * Skip if this rnode is in not on the 1836 * same mount-point 1837 */ 1838 continue; 1839 } 1840 1841 ASSERT(rp->r_deleg_type == OPEN_DELEGATE_READ); 1842 1843 #ifdef DEBUG 1844 if (nfs4_client_recov_debug) { 1845 zprintf(getzoneid(), 1846 "nfs4_deleg_discard: matched rnode %p " 1847 "-- discarding delegation\n", (void *)rp); 1848 } 1849 #endif 1850 mutex_enter(&rp->r_statev4_lock); 1851 /* 1852 * Free the cred originally held when the delegation 1853 * was granted. Also need to decrement the refcnt 1854 * on this server for each delegation we discard 1855 */ 1856 if (rp->r_deleg_cred) 1857 crfree(rp->r_deleg_cred); 1858 rp->r_deleg_cred = NULL; 1859 rp->r_deleg_type = OPEN_DELEGATE_NONE; 1860 rp->r_deleg_needs_recovery = OPEN_DELEGATE_NONE; 1861 rp->r_deleg_needs_recall = FALSE; 1862 ASSERT(sp->s_refcnt > 1); 1863 sp->s_refcnt--; 1864 list_remove(&sp->s_deleg_list, rp); 1865 mutex_exit(&rp->r_statev4_lock); 1866 nfs4_dec_state_ref_count_nolock(sp, mi); 1867 ncg->nfs4_callback_stats.delegations.value.ui64--; 1868 } 1869 } 1870 1871 /* 1872 * Reopen any open streams that were covered by the given file's 1873 * delegation. 1874 * Returns zero or an errno value. If there was no error, *recovp 1875 * indicates whether recovery was initiated. 1876 */ 1877 1878 static int 1879 deleg_reopen(vnode_t *vp, bool_t *recovp, struct nfs4_callback_globals *ncg, 1880 int flags) 1881 { 1882 nfs4_open_stream_t *osp; 1883 nfs4_recov_state_t recov_state; 1884 bool_t needrecov = FALSE; 1885 mntinfo4_t *mi; 1886 rnode4_t *rp; 1887 nfs4_error_t e = { 0, NFS4_OK, RPC_SUCCESS }; 1888 int claimnull; 1889 1890 mi = VTOMI4(vp); 1891 rp = VTOR4(vp); 1892 1893 recov_state.rs_flags = 0; 1894 recov_state.rs_num_retry_despite_err = 0; 1895 1896 retry: 1897 if ((e.error = nfs4_start_op(mi, vp, NULL, &recov_state)) != 0) { 1898 return (e.error); 1899 } 1900 1901 /* 1902 * if we mean to discard the delegation, it must be BAD, so don't 1903 * use it when doing the reopen or it will fail too. 1904 */ 1905 claimnull = (flags & NFS4_DR_DISCARD); 1906 /* 1907 * Loop through the open streams for this rnode to find 1908 * all of the ones created using the delegation state ID. 1909 * Each of these needs to be re-opened. 1910 */ 1911 1912 while ((osp = get_next_deleg_stream(rp, claimnull)) != NULL) { 1913 1914 if (claimnull) { 1915 nfs4_reopen(vp, osp, &e, CLAIM_NULL, FALSE, FALSE); 1916 } else { 1917 ncg->nfs4_callback_stats.claim_cur.value.ui64++; 1918 1919 nfs4_reopen(vp, osp, &e, CLAIM_DELEGATE_CUR, FALSE, 1920 FALSE); 1921 if (e.error == 0 && e.stat == NFS4_OK) 1922 ncg->nfs4_callback_stats. 1923 claim_cur_ok.value.ui64++; 1924 } 1925 1926 if (e.error == EAGAIN) { 1927 nfs4_end_op(mi, vp, NULL, &recov_state, TRUE); 1928 goto retry; 1929 } 1930 1931 /* 1932 * if error is EINTR, ETIMEDOUT, or NFS4_FRC_UNMT_ERR, then 1933 * recovery has already been started inside of nfs4_reopen. 1934 */ 1935 if (e.error == EINTR || e.error == ETIMEDOUT || 1936 NFS4_FRC_UNMT_ERR(e.error, vp->v_vfsp)) { 1937 open_stream_rele(osp, rp); 1938 break; 1939 } 1940 1941 needrecov = nfs4_needs_recovery(&e, TRUE, vp->v_vfsp); 1942 1943 if (e.error != 0 && !needrecov) { 1944 /* 1945 * Recovery is not possible, but don't give up yet; 1946 * we'd still like to do delegreturn after 1947 * reopening as many streams as possible. 1948 * Continue processing the open streams. 1949 */ 1950 1951 ncg->nfs4_callback_stats.recall_failed.value.ui64++; 1952 1953 } else if (needrecov) { 1954 /* 1955 * Start recovery and bail out. The recovery 1956 * thread will take it from here. 1957 */ 1958 (void) nfs4_start_recovery(&e, mi, vp, NULL, NULL, 1959 NULL, OP_OPEN, NULL); 1960 open_stream_rele(osp, rp); 1961 *recovp = TRUE; 1962 break; 1963 } 1964 1965 open_stream_rele(osp, rp); 1966 } 1967 1968 nfs4_end_op(mi, vp, NULL, &recov_state, needrecov); 1969 1970 return (e.error); 1971 } 1972 1973 /* 1974 * get_next_deleg_stream - returns the next open stream which 1975 * represents a delegation for this rnode. In order to assure 1976 * forward progress, the caller must guarantee that each open 1977 * stream returned is changed so that a future call won't return 1978 * it again. 1979 * 1980 * There are several ways for the open stream to change. If the open 1981 * stream is !os_delegation, then we aren't interested in it. Also, if 1982 * either os_failed_reopen or !os_valid, then don't return the osp. 1983 * 1984 * If claimnull is false (doing reopen CLAIM_DELEGATE_CUR) then return 1985 * the osp if it is an os_delegation open stream. Also, if the rnode still 1986 * has r_deleg_return_pending, then return the os_delegation osp. Lastly, 1987 * if the rnode's r_deleg_stateid is different from the osp's open_stateid, 1988 * then return the osp. 1989 * 1990 * We have already taken the 'r_deleg_recall_lock' as WRITER, which 1991 * prevents new OPENs from going OTW (as start_fop takes this 1992 * lock in READ mode); thus, no new open streams can be created 1993 * (which inherently means no new delegation open streams are 1994 * being created). 1995 */ 1996 1997 static nfs4_open_stream_t * 1998 get_next_deleg_stream(rnode4_t *rp, int claimnull) 1999 { 2000 nfs4_open_stream_t *osp; 2001 2002 ASSERT(nfs_rw_lock_held(&rp->r_deleg_recall_lock, RW_WRITER)); 2003 2004 /* 2005 * Search through the list of open streams looking for 2006 * one that was created while holding the delegation. 2007 */ 2008 mutex_enter(&rp->r_os_lock); 2009 for (osp = list_head(&rp->r_open_streams); osp != NULL; 2010 osp = list_next(&rp->r_open_streams, osp)) { 2011 mutex_enter(&osp->os_sync_lock); 2012 if (!osp->os_delegation || osp->os_failed_reopen || 2013 !osp->os_valid) { 2014 mutex_exit(&osp->os_sync_lock); 2015 continue; 2016 } 2017 if (!claimnull || rp->r_deleg_return_pending || 2018 !stateid4_cmp(&osp->open_stateid, &rp->r_deleg_stateid)) { 2019 osp->os_ref_count++; 2020 mutex_exit(&osp->os_sync_lock); 2021 mutex_exit(&rp->r_os_lock); 2022 return (osp); 2023 } 2024 mutex_exit(&osp->os_sync_lock); 2025 } 2026 mutex_exit(&rp->r_os_lock); 2027 2028 return (NULL); 2029 } 2030 2031 static void 2032 nfs4delegreturn_thread(struct cb_recall_pass *args) 2033 { 2034 rnode4_t *rp; 2035 vnode_t *vp; 2036 cred_t *cr; 2037 int dtype, error, flags; 2038 bool_t rdirty, rip; 2039 kmutex_t cpr_lock; 2040 callb_cpr_t cpr_info; 2041 struct nfs4_callback_globals *ncg; 2042 2043 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 2044 ASSERT(ncg != NULL); 2045 2046 mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL); 2047 2048 CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, 2049 "nfsv4delegRtn"); 2050 2051 rp = args->rp; 2052 vp = RTOV4(rp); 2053 2054 mutex_enter(&rp->r_statev4_lock); 2055 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 2056 mutex_exit(&rp->r_statev4_lock); 2057 goto out; 2058 } 2059 mutex_exit(&rp->r_statev4_lock); 2060 2061 /* 2062 * Take the read-write lock in read mode to prevent other 2063 * threads from modifying the data during the recall. This 2064 * doesn't affect mmappers. 2065 */ 2066 (void) nfs_rw_enter_sig(&rp->r_rwlock, RW_READER, FALSE); 2067 2068 /* Proceed with delegreturn */ 2069 2070 mutex_enter(&rp->r_statev4_lock); 2071 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) { 2072 mutex_exit(&rp->r_statev4_lock); 2073 nfs_rw_exit(&rp->r_rwlock); 2074 goto out; 2075 } 2076 dtype = rp->r_deleg_type; 2077 cr = rp->r_deleg_cred; 2078 ASSERT(cr != NULL); 2079 crhold(cr); 2080 mutex_exit(&rp->r_statev4_lock); 2081 2082 flags = args->flags; 2083 2084 /* 2085 * If the file is being truncated at the server, then throw 2086 * away all of the pages, it doesn't matter what flavor of 2087 * delegation we have. 2088 */ 2089 2090 if (args->truncate) { 2091 ncg->nfs4_callback_stats.recall_trunc.value.ui64++; 2092 nfs4_invalidate_pages(vp, 0, cr); 2093 } else if (dtype == OPEN_DELEGATE_WRITE) { 2094 2095 mutex_enter(&rp->r_statelock); 2096 rdirty = rp->r_flags & R4DIRTY; 2097 mutex_exit(&rp->r_statelock); 2098 2099 if (rdirty) { 2100 error = VOP_PUTPAGE(vp, 0, 0, 0, cr, NULL); 2101 2102 if (error) 2103 CB_WARN1("nfs4delegreturn_thread:" 2104 " VOP_PUTPAGE: %d\n", error); 2105 } 2106 /* turn off NFS4_DR_PUSH because we just did that above. */ 2107 flags &= ~NFS4_DR_PUSH; 2108 } 2109 2110 mutex_enter(&rp->r_statelock); 2111 rip = rp->r_flags & R4RECOVERRP; 2112 mutex_exit(&rp->r_statelock); 2113 2114 /* If a failed recovery is indicated, discard the pages */ 2115 2116 if (rip) { 2117 2118 error = VOP_PUTPAGE(vp, 0, 0, B_INVAL, cr, NULL); 2119 2120 if (error) 2121 CB_WARN1("nfs4delegreturn_thread: VOP_PUTPAGE: %d\n", 2122 error); 2123 } 2124 2125 /* 2126 * Pass the flags to nfs4delegreturn_impl, but be sure not to pass 2127 * NFS4_DR_DID_OP, which just calls nfs4delegreturn_async again. 2128 */ 2129 flags &= ~NFS4_DR_DID_OP; 2130 2131 (void) nfs4delegreturn_impl(rp, flags, ncg); 2132 2133 nfs_rw_exit(&rp->r_rwlock); 2134 crfree(cr); 2135 out: 2136 kmem_free(args, sizeof (struct cb_recall_pass)); 2137 VN_RELE(vp); 2138 mutex_enter(&cpr_lock); 2139 CALLB_CPR_EXIT(&cpr_info); 2140 mutex_destroy(&cpr_lock); 2141 zthread_exit(); 2142 } 2143 2144 /* 2145 * This function has one assumption that the caller of this function is 2146 * either doing recovery (therefore cannot call nfs4_start_op) or has 2147 * already called nfs4_start_op(). 2148 */ 2149 void 2150 nfs4_delegation_accept(rnode4_t *rp, open_claim_type4 claim, OPEN4res *res, 2151 nfs4_ga_res_t *garp, cred_t *cr) 2152 { 2153 open_read_delegation4 *orp; 2154 open_write_delegation4 *owp; 2155 nfs4_server_t *np; 2156 bool_t already = FALSE; 2157 bool_t recall = FALSE; 2158 bool_t valid_garp = TRUE; 2159 bool_t delegation_granted = FALSE; 2160 bool_t dr_needed = FALSE; 2161 bool_t recov; 2162 int dr_flags = 0; 2163 long mapcnt; 2164 uint_t rflag; 2165 mntinfo4_t *mi; 2166 struct nfs4_callback_globals *ncg; 2167 open_delegation_type4 odt; 2168 2169 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 2170 ASSERT(ncg != NULL); 2171 2172 mi = VTOMI4(RTOV4(rp)); 2173 2174 /* 2175 * Accept a delegation granted to the client via an OPEN. 2176 * Set the delegation fields in the rnode and insert the 2177 * rnode onto the list anchored in the nfs4_server_t. The 2178 * proper locking order requires the nfs4_server_t first, 2179 * even though it may not be needed in all cases. 2180 * 2181 * NB: find_nfs4_server returns with s_lock held. 2182 */ 2183 2184 if ((np = find_nfs4_server(mi)) == NULL) 2185 return; 2186 2187 /* grab the statelock too, for examining r_mapcnt */ 2188 mutex_enter(&rp->r_statelock); 2189 mutex_enter(&rp->r_statev4_lock); 2190 2191 if (rp->r_deleg_type == OPEN_DELEGATE_READ || 2192 rp->r_deleg_type == OPEN_DELEGATE_WRITE) 2193 already = TRUE; 2194 2195 odt = res->delegation.delegation_type; 2196 2197 if (odt == OPEN_DELEGATE_READ) { 2198 2199 rp->r_deleg_type = res->delegation.delegation_type; 2200 orp = &res->delegation.open_delegation4_u.read; 2201 rp->r_deleg_stateid = orp->stateid; 2202 rp->r_deleg_perms = orp->permissions; 2203 if (claim == CLAIM_PREVIOUS) 2204 if ((recall = orp->recall) != 0) 2205 dr_needed = TRUE; 2206 2207 delegation_granted = TRUE; 2208 2209 ncg->nfs4_callback_stats.delegations.value.ui64++; 2210 ncg->nfs4_callback_stats.delegaccept_r.value.ui64++; 2211 2212 } else if (odt == OPEN_DELEGATE_WRITE) { 2213 2214 rp->r_deleg_type = res->delegation.delegation_type; 2215 owp = &res->delegation.open_delegation4_u.write; 2216 rp->r_deleg_stateid = owp->stateid; 2217 rp->r_deleg_perms = owp->permissions; 2218 rp->r_deleg_limit = owp->space_limit; 2219 if (claim == CLAIM_PREVIOUS) 2220 if ((recall = owp->recall) != 0) 2221 dr_needed = TRUE; 2222 2223 delegation_granted = TRUE; 2224 2225 if (garp == NULL || !garp->n4g_change_valid) { 2226 valid_garp = FALSE; 2227 rp->r_deleg_change = 0; 2228 rp->r_deleg_change_grant = 0; 2229 } else { 2230 rp->r_deleg_change = garp->n4g_change; 2231 rp->r_deleg_change_grant = garp->n4g_change; 2232 } 2233 mapcnt = rp->r_mapcnt; 2234 rflag = rp->r_flags; 2235 2236 /* 2237 * Update the delegation change attribute if 2238 * there are mappers for the file is dirty. This 2239 * might be the case during recovery after server 2240 * reboot. 2241 */ 2242 if (mapcnt > 0 || rflag & R4DIRTY) 2243 rp->r_deleg_change++; 2244 2245 NFS4_DEBUG(nfs4_callback_debug, (CE_NOTE, 2246 "nfs4_delegation_accept: r_deleg_change: 0x%x\n", 2247 (int)(rp->r_deleg_change >> 32))); 2248 NFS4_DEBUG(nfs4_callback_debug, (CE_NOTE, 2249 "nfs4_delegation_accept: r_delg_change_grant: 0x%x\n", 2250 (int)(rp->r_deleg_change_grant >> 32))); 2251 2252 2253 ncg->nfs4_callback_stats.delegations.value.ui64++; 2254 ncg->nfs4_callback_stats.delegaccept_rw.value.ui64++; 2255 } else if (already) { 2256 /* 2257 * No delegation granted. If the rnode currently has 2258 * has one, then consider it tainted and return it. 2259 */ 2260 dr_needed = TRUE; 2261 } 2262 2263 if (delegation_granted) { 2264 /* Add the rnode to the list. */ 2265 if (!already) { 2266 crhold(cr); 2267 rp->r_deleg_cred = cr; 2268 2269 ASSERT(mutex_owned(&np->s_lock)); 2270 list_insert_head(&np->s_deleg_list, rp); 2271 /* added list node gets a reference */ 2272 np->s_refcnt++; 2273 nfs4_inc_state_ref_count_nolock(np, mi); 2274 } 2275 rp->r_deleg_needs_recovery = OPEN_DELEGATE_NONE; 2276 } 2277 2278 /* 2279 * We've now safely accepted the delegation, if any. Drop the 2280 * locks and figure out what post-processing is needed. We'd 2281 * like to retain r_statev4_lock, but nfs4_server_rele takes 2282 * s_lock which would be a lock ordering violation. 2283 */ 2284 mutex_exit(&rp->r_statev4_lock); 2285 mutex_exit(&rp->r_statelock); 2286 mutex_exit(&np->s_lock); 2287 nfs4_server_rele(np); 2288 2289 /* 2290 * Check to see if we are in recovery. Remember that 2291 * this function is protected by start_op, so a recovery 2292 * cannot begin until we are out of here. 2293 */ 2294 mutex_enter(&mi->mi_lock); 2295 recov = mi->mi_recovflags & MI4_RECOV_ACTIV; 2296 mutex_exit(&mi->mi_lock); 2297 2298 mutex_enter(&rp->r_statev4_lock); 2299 2300 if (nfs4_delegreturn_policy == IMMEDIATE || !valid_garp) 2301 dr_needed = TRUE; 2302 2303 if (dr_needed && rp->r_deleg_return_pending == FALSE) { 2304 if (recov) { 2305 /* 2306 * We cannot call delegreturn from inside 2307 * of recovery or VOP_PUTPAGE will hang 2308 * due to nfs4_start_fop call in 2309 * nfs4write. Use dlistadd to add the 2310 * rnode to the list of rnodes needing 2311 * cleaning. We do not need to do reopen 2312 * here because recov_openfiles will do it. 2313 * In the non-recall case, just discard the 2314 * delegation as it is no longer valid. 2315 */ 2316 if (recall) 2317 dr_flags = NFS4_DR_PUSH; 2318 else 2319 dr_flags = NFS4_DR_PUSH|NFS4_DR_DISCARD; 2320 2321 nfs4_dlistadd(rp, ncg, dr_flags); 2322 dr_flags = 0; 2323 } else { 2324 /* 2325 * Push the modified data back to the server, 2326 * reopen any delegation open streams, and return 2327 * the delegation. Drop the statev4_lock first! 2328 */ 2329 dr_flags = NFS4_DR_PUSH|NFS4_DR_DID_OP|NFS4_DR_REOPEN; 2330 } 2331 } 2332 mutex_exit(&rp->r_statev4_lock); 2333 if (dr_flags) 2334 (void) nfs4delegreturn_impl(rp, dr_flags, ncg); 2335 } 2336 2337 /* 2338 * nfs4delegabandon - Abandon the delegation on an rnode4. This code 2339 * is called when the client receives EXPIRED, BAD_STATEID, OLD_STATEID 2340 * or BADSEQID and the recovery code is unable to recover. Push any 2341 * dirty data back to the server and return the delegation (if any). 2342 */ 2343 2344 void 2345 nfs4delegabandon(rnode4_t *rp) 2346 { 2347 vnode_t *vp; 2348 struct cb_recall_pass *pp; 2349 open_delegation_type4 dt; 2350 2351 mutex_enter(&rp->r_statev4_lock); 2352 dt = rp->r_deleg_type; 2353 mutex_exit(&rp->r_statev4_lock); 2354 2355 if (dt == OPEN_DELEGATE_NONE) 2356 return; 2357 2358 vp = RTOV4(rp); 2359 VN_HOLD(vp); 2360 2361 pp = kmem_alloc(sizeof (struct cb_recall_pass), KM_SLEEP); 2362 pp->rp = rp; 2363 /* 2364 * Recovery on the file has failed and we want to return 2365 * the delegation. We don't want to reopen files and 2366 * nfs4delegreturn_thread() figures out what to do about 2367 * the data. The only thing to do is attempt to return 2368 * the delegation. 2369 */ 2370 pp->flags = 0; 2371 pp->truncate = FALSE; 2372 2373 /* 2374 * Fire up a thread to do the delegreturn; this is 2375 * necessary because we could be inside a GETPAGE or 2376 * PUTPAGE and we cannot do another one. 2377 */ 2378 2379 (void) zthread_create(NULL, 0, nfs4delegreturn_thread, pp, 0, 2380 minclsyspri); 2381 } 2382 2383 static int 2384 wait_for_recall1(vnode_t *vp, nfs4_op_hint_t op, nfs4_recov_state_t *rsp, 2385 int flg) 2386 { 2387 rnode4_t *rp; 2388 int error = 0; 2389 2390 #ifdef lint 2391 op = op; 2392 #endif 2393 2394 if (vp && vp->v_type == VREG) { 2395 rp = VTOR4(vp); 2396 2397 /* 2398 * Take r_deleg_recall_lock in read mode to synchronize 2399 * with delegreturn. 2400 */ 2401 error = nfs_rw_enter_sig(&rp->r_deleg_recall_lock, 2402 RW_READER, INTR4(vp)); 2403 2404 if (error == 0) 2405 rsp->rs_flags |= flg; 2406 2407 } 2408 return (error); 2409 } 2410 2411 void 2412 nfs4_end_op_recall(vnode_t *vp1, vnode_t *vp2, nfs4_recov_state_t *rsp) 2413 { 2414 NFS4_DEBUG(nfs4_recall_debug, 2415 (CE_NOTE, "nfs4_end_op_recall: 0x%p, 0x%p\n", 2416 (void *)vp1, (void *)vp2)); 2417 2418 if (vp2 && rsp->rs_flags & NFS4_RS_RECALL_HELD2) 2419 nfs_rw_exit(&VTOR4(vp2)->r_deleg_recall_lock); 2420 if (vp1 && rsp->rs_flags & NFS4_RS_RECALL_HELD1) 2421 nfs_rw_exit(&VTOR4(vp1)->r_deleg_recall_lock); 2422 } 2423 2424 int 2425 wait_for_recall(vnode_t *vp1, vnode_t *vp2, nfs4_op_hint_t op, 2426 nfs4_recov_state_t *rsp) 2427 { 2428 int error; 2429 2430 NFS4_DEBUG(nfs4_recall_debug, 2431 (CE_NOTE, "wait_for_recall: 0x%p, 0x%p\n", 2432 (void *)vp1, (void *) vp2)); 2433 2434 rsp->rs_flags &= ~(NFS4_RS_RECALL_HELD1|NFS4_RS_RECALL_HELD2); 2435 2436 if ((error = wait_for_recall1(vp1, op, rsp, NFS4_RS_RECALL_HELD1)) != 0) 2437 return (error); 2438 2439 if ((error = wait_for_recall1(vp2, op, rsp, NFS4_RS_RECALL_HELD2)) 2440 != 0) { 2441 if (rsp->rs_flags & NFS4_RS_RECALL_HELD1) { 2442 nfs_rw_exit(&VTOR4(vp1)->r_deleg_recall_lock); 2443 rsp->rs_flags &= ~NFS4_RS_RECALL_HELD1; 2444 } 2445 2446 return (error); 2447 } 2448 2449 return (0); 2450 } 2451 2452 /* 2453 * nfs4_dlistadd - Add this rnode to a list of rnodes to be 2454 * DELEGRETURN'd at the end of recovery. 2455 */ 2456 2457 static void 2458 nfs4_dlistadd(rnode4_t *rp, struct nfs4_callback_globals *ncg, int flags) 2459 { 2460 struct nfs4_dnode *dp; 2461 2462 ASSERT(mutex_owned(&rp->r_statev4_lock)); 2463 /* 2464 * Mark the delegation as having a return pending. 2465 * This will prevent the use of the delegation stateID 2466 * by read, write, setattr and open. 2467 */ 2468 rp->r_deleg_return_pending = TRUE; 2469 dp = kmem_alloc(sizeof (*dp), KM_SLEEP); 2470 VN_HOLD(RTOV4(rp)); 2471 dp->rnodep = rp; 2472 dp->flags = flags; 2473 mutex_enter(&ncg->nfs4_dlist_lock); 2474 list_insert_head(&ncg->nfs4_dlist, dp); 2475 #ifdef DEBUG 2476 ncg->nfs4_dlistadd_c++; 2477 #endif 2478 mutex_exit(&ncg->nfs4_dlist_lock); 2479 } 2480 2481 /* 2482 * nfs4_dlistclean_impl - Do DELEGRETURN for each rnode on the list. 2483 * of files awaiting cleaning. If the override_flags are non-zero 2484 * then use them rather than the flags that were set when the rnode 2485 * was added to the dlist. 2486 */ 2487 static void 2488 nfs4_dlistclean_impl(struct nfs4_callback_globals *ncg, int override_flags) 2489 { 2490 rnode4_t *rp; 2491 struct nfs4_dnode *dp; 2492 int flags; 2493 2494 ASSERT(override_flags == 0 || override_flags == NFS4_DR_DISCARD); 2495 2496 mutex_enter(&ncg->nfs4_dlist_lock); 2497 while ((dp = list_head(&ncg->nfs4_dlist)) != NULL) { 2498 #ifdef DEBUG 2499 ncg->nfs4_dlistclean_c++; 2500 #endif 2501 list_remove(&ncg->nfs4_dlist, dp); 2502 mutex_exit(&ncg->nfs4_dlist_lock); 2503 rp = dp->rnodep; 2504 flags = (override_flags != 0) ? override_flags : dp->flags; 2505 kmem_free(dp, sizeof (*dp)); 2506 (void) nfs4delegreturn_impl(rp, flags, ncg); 2507 VN_RELE(RTOV4(rp)); 2508 mutex_enter(&ncg->nfs4_dlist_lock); 2509 } 2510 mutex_exit(&ncg->nfs4_dlist_lock); 2511 } 2512 2513 void 2514 nfs4_dlistclean(void) 2515 { 2516 struct nfs4_callback_globals *ncg; 2517 2518 ncg = zone_getspecific(nfs4_callback_zone_key, nfs_zone()); 2519 ASSERT(ncg != NULL); 2520 2521 nfs4_dlistclean_impl(ncg, 0); 2522 } 2523
Indexes created Sat Nov 21 18:40:54 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.