Lines Matching refs:rp
496 rnode4_t *rp, cred_t *cr, bitmap4 supp, int *error,
514 ASSERT(rp != NULL);
515 mi = VTOMI4(RTOV4(rp));
518 nfs4_get_stateid(cr, rp, curproc->p_pidp->pid_id, mi,
577 nfs4args_write(nfs_argop4 *argop, stable_how4 stable, rnode4_t *rp, cred_t *cr,
581 mntinfo4_t *mi = VTOMI4(RTOV4(rp));
585 wargs->stateid = nfs4_get_w_stateid(cr, rp, curproc->p_pidp->pid_id,
621 rnode4_t *rp, *drp;
629 rp = VTOR4(*vpp);
665 mutex_enter(&rp->r_statev4_lock);
666 if (rp->created_v4) {
667 rp->created_v4 = 0;
668 mutex_exit(&rp->r_statev4_lock);
674 mutex_exit(&rp->r_statev4_lock);
698 if (error == 0 && IS_SHADOW(*vpp, rp))
770 rnode4_t *rp;
1135 * Also we specify NULL rp since we're only
1169 "nfs4open_otw: %s call, nm %s, rp %s",
1239 * to server2:/drp/rp.
1441 rp = VTOR4(vp);
1443 mutex_enter(&rp->r_statev4_lock);
1445 rp->created_v4 = 1;
1446 mutex_exit(&rp->r_statev4_lock);
1458 osp = find_or_create_open_stream(oop, rp, &created_osp);
1503 " clearing os_failed_reopen for osp %p, cr %p, rp %s",
1504 (void *)osp, (void *)cr, rnode4info(rp)));
1521 open_stream_rele(osp, rp);
1524 nfs4_delegation_accept(rp, CLAIM_NULL, op_res, garp, cred_otw);
1683 rnode4_t *rp = VTOR4(vp);
1747 mutex_enter(&rp->r_statev4_lock);
1748 if (rp->r_deleg_type != OPEN_DELEGATE_NONE &&
1749 !rp->r_deleg_return_pending &&
1750 (rp->r_deleg_needs_recovery == OPEN_DELEGATE_NONE) &&
1751 !rp->r_deleg_needs_recall &&
1753 !(rp->r_flags & R4RECOVERR)) {
1756 osp->open_stateid = rp->r_deleg_stateid;
1758 mutex_exit(&rp->r_statev4_lock);
1761 mutex_exit(&rp->r_statev4_lock);
1767 mutex_enter(&rp->r_statelock);
1768 if (rp->r_flags & R4RECOVERR) {
1769 mutex_exit(&rp->r_statelock);
1773 mutex_exit(&rp->r_statelock);
1800 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
1835 mutex_enter(&rp->r_statev4_lock);
1838 rp->r_deleg_type :
1839 rp->r_deleg_needs_recovery;
1840 mutex_exit(&rp->r_statev4_lock);
1854 mutex_enter(&rp->r_statev4_lock);
1856 rp->r_deleg_stateid;
1857 mutex_exit(&rp->r_statev4_lock);
1872 NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, "nfs4_reopen: osp %p rp "
1875 (void *)osp, (void *)rp, osp->os_share_acc_read,
1941 mutex_enter(&rp->r_statelock);
1942 rp->r_delay_interval = 0;
1943 mutex_exit(&rp->r_statelock);
2072 fh_different = (nfs4cmpfh(&rp->r_fh->sfh_fh, &gf_res->object) != 0);
2101 rp->r_attr.va_mask & AT_NODEID &&
2102 rp->r_attr.va_nodeid != garp->n4g_va.va_nodeid) {
2130 sfh4_update(rp->r_fh, &gf_res->object);
2178 nfs4_delegation_accept(rp, claim, op_res, garp, cred_otw);
2197 "nfs4_reopen: setting os_failed_reopen for osp %p, cr %p, rp %s",
2198 (void *)osp, (void *)cr, rnode4info(rp)));
2218 rnode4_t *rp;
2231 rp = VTOR4(*vpp);
2233 (rp->r_dir == NULL && !nfs4_has_pages(*vpp)))
2247 rnode4_t *rp;
2258 rp = VTOR4(vp);
2322 if (rp->r_unldvp != NULL)
2334 mutex_enter(&rp->r_statelock);
2335 r_error = rp->r_error;
2336 rp->r_error = 0;
2337 mutex_exit(&rp->r_statelock);
2418 nfs4close_otw(rnode4_t *rp, cred_t *cred_otw, nfs4_open_owner_t *oop,
2435 ASSERT(nfs_zone() == VTOMI4(RTOV4(rp))->mi_zone);
2456 vp = RTOV4(rp);
2462 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
2477 "nfs4close_otw: %s call, rp %s", needrecov ? "recov" : "first",
2478 rnode4info(rp)));
2495 mutex_enter(&rp->r_statelock);
2496 PURGE_ATTRCACHE4_LOCKED(rp);
2497 rp->r_flags &= ~R4WRITEMODIFIED;
2498 mutex_exit(&rp->r_statelock);
2561 mutex_enter(&rp->r_statev4_lock);
2562 rp->created_v4 = 0;
2563 mutex_exit(&rp->r_statev4_lock);
2607 rnode4_t *rp;
2617 rp = VTOR4(vp);
2619 ASSERT(nfs_rw_lock_held(&rp->r_rwlock, RW_READER));
2621 if (IS_SHADOW(vp, rp))
2622 vp = RTOV4(rp);
2638 mutex_enter(&rp->r_statelock);
2639 if (rp->r_flags & R4RECOVERRP)
2640 error = (rp->r_error ? rp->r_error : EIO);
2643 mutex_exit(&rp->r_statelock);
2653 (((rp->r_flags & R4DIRECTIO) || (mi->mi_flags & MI4_DIRECTIO)) &&
2654 rp->r_mapcnt == 0 && rp->r_inmap == 0 && !nfs4_has_pages(vp))) {
2671 mutex_enter(&rp->r_statelock);
2672 while (rp->r_flags & R4INCACHEPURGE) {
2673 if (!cv_wait_sig(&rp->r_cv, &rp->r_statelock)) {
2674 mutex_exit(&rp->r_statelock);
2678 diff = rp->r_size - uiop->uio_loffset;
2679 mutex_exit(&rp->r_statelock);
2703 mutex_enter(&rp->r_statelock);
2705 uiop->uio_loffset == rp->r_size)
2709 mutex_exit(&rp->r_statelock);
2733 rnode4_t *rp;
2746 rp = VTOR4(vp);
2748 if (IS_SHADOW(vp, rp))
2749 vp = RTOV4(rp);
2762 mutex_enter(&rp->r_statelock);
2763 if (rp->r_flags & R4RECOVERRP)
2764 error = (rp->r_error ? rp->r_error : EIO);
2767 mutex_exit(&rp->r_statelock);
2777 if (nfs_rw_lock_held(&rp->r_rwlock, RW_READER)) {
2778 nfs_rw_exit(&rp->r_rwlock);
2779 if (nfs_rw_enter_sig(&rp->r_rwlock, RW_WRITER,
2824 mutex_enter(&rp->r_statev4_lock);
2825 if (rp->r_deleg_type == OPEN_DELEGATE_WRITE)
2826 rp->r_deleg_change++;
2828 mutex_exit(&rp->r_statev4_lock);
2830 if (nfs_rw_enter_sig(&rp->r_lkserlock, RW_READER, INTR4(vp)))
2839 (((rp->r_flags & R4DIRECTIO) || (mi->mi_flags & MI4_DIRECTIO)) &&
2840 rp->r_mapcnt == 0 && rp->r_inmap == 0 && !nfs4_has_pages(vp))) {
2846 if (rp->r_flags & R4STALE) {
2849 error = rp->r_error;
2875 mutex_enter(&rp->r_statelock);
2876 if (rp->r_size < uiop->uio_loffset)
2877 rp->r_size = uiop->uio_loffset;
2878 mutex_exit(&rp->r_statelock);
2896 if (rp->r_flags & R4STALE) {
2897 error = rp->r_error;
2917 mutex_enter(&rp->r_statelock);
2919 rp->r_awcount > 2 * mi->mi_max_threads) ||
2920 rp->r_gcount > 0) {
2926 if (!cv_wait_sig(&rp->r_cv, &rp->r_statelock)) {
2927 mutex_exit(&rp->r_statelock);
2936 cv_wait(&rp->r_cv, &rp->r_statelock);
2938 mutex_exit(&rp->r_statelock);
2953 error = writerp4(rp, NULL, n, uiop, 0);
2961 mutex_enter(&rp->r_statelock);
2963 uiop->uio_loffset + pn >= rp->r_size);
2964 mutex_exit(&rp->r_statelock);
2969 error = writerp4(rp, base + pon, n, uiop,
2975 error = writerp4(rp, base + on, n, uiop, 0);
2995 (rp->r_flags & R4OUTOFSPACE)) {
3027 mutex_enter(&rp->r_statev4_lock);
3028 if (rp->r_deleg_type == OPEN_DELEGATE_WRITE) {
3029 gethrestime(&rp->r_attr.va_mtime);
3030 rp->r_attr.va_ctime = rp->r_attr.va_mtime;
3032 mutex_exit(&rp->r_statev4_lock);
3035 nfs_rw_exit(&rp->r_lkserlock);
3104 rnode4_t *rp = VTOR4(vp);
3116 osp = find_open_stream(oop, rp);
3124 open_stream_rele(osp, rp);
3146 open_stream_rele(osp, rp);
3151 open_stream_rele(osp, rp);
3173 rnode4_t *rp;
3181 rp = VTOR4(vp);
3213 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
3216 nfs4args_write(&argop[1], stable, rp, cr, &wargs, &sid_types);
3230 (rp->r_flags & R4DIRECTIO) ||
3276 mutex_enter(&rp->r_statev4_lock);
3277 rp->r_deleg_return_pending = TRUE;
3278 mutex_exit(&rp->r_statev4_lock);
3292 nfs4delegreturn_async(rp, (NFS4_DR_PUSH|NFS4_DR_REOPEN|
3352 rp->r_server->sv_hostname);
3372 mutex_enter(&rp->r_statelock);
3373 if (rp->r_flags & R4HAVEVERF) {
3374 if (rp->r_writeverf != wres->writeverf) {
3376 rp->r_writeverf = wres->writeverf;
3379 rp->r_writeverf = wres->writeverf;
3380 rp->r_flags |= R4HAVEVERF;
3382 PURGE_ATTRCACHE4_LOCKED(rp);
3383 rp->r_flags |= R4WRITEMODIFIED;
3384 gethrestime(&rp->r_attr.va_mtime);
3385 rp->r_attr.va_ctime = rp->r_attr.va_mtime;
3386 mutex_exit(&rp->r_statelock);
3411 rnode4_t *rp;
3419 rp = VTOR4(vp);
3443 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
3448 rargs->stateid = nfs4_get_stateid(cr, rp, curproc->p_pidp->pid_id, mi,
3459 "nfs4read: %s call, rp %s",
3461 rnode4info(rp)));
3464 (rp->r_flags & R4DIRECTIO) ||
3541 mutex_enter(&rp->r_statev4_lock);
3542 rp->r_deleg_return_pending = TRUE;
3543 mutex_exit(&rp->r_statev4_lock);
3555 nfs4delegreturn_async(rp, (NFS4_DR_PUSH|NFS4_DR_REOPEN|
3652 rnode4_t *rp = VTOR4(vp);
3667 mutex_enter(&rp->r_statelock);
3669 vap->va_size = rp->r_size;
3671 vap->va_fsid = rp->r_attr.va_fsid;
3673 vap->va_rdev = rp->r_attr.va_rdev;
3674 mutex_exit(&rp->r_statelock);
3685 rp = VTOR4(vp);
3687 mutex_enter(&rp->r_statev4_lock);
3688 if (rp->r_deleg_type != OPEN_DELEGATE_WRITE) {
3689 mutex_exit(&rp->r_statev4_lock);
3690 if (rp->r_flags & R4DIRTY ||
3691 rp->r_awcount > 0) {
3692 mutex_enter(&rp->r_statelock);
3693 rp->r_gcount++;
3694 mutex_exit(&rp->r_statelock);
3698 mutex_enter(&rp->r_statelock);
3701 if (!rp->r_error)
3702 rp->r_error = error;
3704 if (--rp->r_gcount == 0)
3705 cv_broadcast(&rp->r_cv);
3706 mutex_exit(&rp->r_statelock);
3709 mutex_exit(&rp->r_statev4_lock);
3789 rnode4_t *rp;
3805 rp = VTOR4(vp);
3820 ((rp->r_flags & R4DIRTY) ||
3821 rp->r_count > 0 ||
3822 rp->r_mapcnt > 0)) {
3826 mutex_enter(&rp->r_statelock);
3827 if (!rp->r_error)
3828 rp->r_error = e.error;
3829 mutex_exit(&rp->r_statelock);
3844 mutex_enter(&rp->r_statev4_lock);
3845 if (rp->r_deleg_type == OPEN_DELEGATE_NONE ||
3846 rp->r_deleg_return_pending) {
3848 ctime = rp->r_attr.va_ctime;
3850 mutex_exit(&rp->r_statev4_lock);
3871 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
3888 svp = rp->r_server;
3893 nfs4args_setattr(&argop[setattr_argop], vap, vsap, flags, rp, cr,
3903 omode = rp->r_attr.va_mode;
3930 svp = rp->r_server;
3957 (void) nfs4_access_purge_rp(rp);
3958 if (rp->r_secattr != NULL) {
3959 mutex_enter(&rp->r_statelock);
3960 vsp = rp->r_secattr;
3961 rp->r_secattr = NULL;
3962 mutex_exit(&rp->r_statelock);
4180 nfs4_acl_fill_cache(rp, &garp->n4g_vsa);
4191 if (rp->r_secattr != NULL) {
4192 mutex_enter(&rp->r_statelock);
4193 vsp = rp->r_secattr;
4194 rp->r_secattr = NULL;
4195 mutex_exit(&rp->r_statelock);
4209 mutex_enter(&rp->r_statelock);
4210 rp->r_size = vap->va_size;
4211 mutex_exit(&rp->r_statelock);
4278 rnode4_t *rp;
4317 rp = VTOR4(vp);
4339 cacc = nfs4_access_check(rp, acc, cred);
4366 do_getattr = (rp->r_deleg_type == OPEN_DELEGATE_NONE);
4397 "nfs4_access: %s call, rp %s", needrecov ? "recov" : "first",
4446 nfs4_access_cache(rp, argacc, resacc, cred);
4493 rnode4_t *rp;
4513 rp = VTOR4(vp);
4514 if (nfs4_do_symlink_cache && rp->r_symlink.contents != NULL) {
4518 mutex_enter(&rp->r_statelock);
4519 if (rp->r_symlink.contents != NULL) {
4520 e.error = uiomove(rp->r_symlink.contents,
4521 rp->r_symlink.len, UIO_READ, uiop);
4522 mutex_exit(&rp->r_statelock);
4525 mutex_exit(&rp->r_statelock);
4555 "nfs4_readlink: %s call, rp %s", needrecov ? "recov" : "first",
4612 if (nfs4_do_symlink_cache && rp->r_symlink.contents == NULL) {
4613 mutex_enter(&rp->r_statelock);
4614 if (rp->r_symlink.contents == NULL) {
4615 rp->r_symlink.contents = linkdata;
4616 rp->r_symlink.len = uio_len;
4617 rp->r_symlink.size = len;
4618 mutex_exit(&rp->r_statelock);
4620 mutex_exit(&rp->r_statelock);
4675 rnode4_t *rp;
4679 rp = VTOR4(vp);
4681 if (IS_SHADOW(vp, rp)) {
4708 mutex_enter(&rp->r_os_lock);
4709 mutex_enter(&rp->r_statelock);
4710 mutex_enter(&rp->r_statev4_lock);
4712 if (vp->v_type == VREG && list_head(&rp->r_open_streams) != NULL) {
4713 mutex_exit(&rp->r_statev4_lock);
4714 mutex_exit(&rp->r_statelock);
4715 mutex_exit(&rp->r_os_lock);
4720 if (rp->r_deleg_type == OPEN_DELEGATE_READ ||
4721 rp->r_deleg_type == OPEN_DELEGATE_WRITE) {
4722 mutex_exit(&rp->r_statev4_lock);
4723 mutex_exit(&rp->r_statelock);
4724 mutex_exit(&rp->r_os_lock);
4729 if (rp->r_unldvp != NULL) {
4730 mutex_exit(&rp->r_statev4_lock);
4731 mutex_exit(&rp->r_statelock);
4732 mutex_exit(&rp->r_os_lock);
4736 mutex_exit(&rp->r_statev4_lock);
4737 mutex_exit(&rp->r_statelock);
4738 mutex_exit(&rp->r_os_lock);
4740 rp4_addfree(rp, cr);
4751 rnode4_t *rp = VTOR4(vp);
4766 ASSERT(!IS_SHADOW(vp, rp));
4786 mutex_enter(&rp->r_statelock);
4787 if (rp->r_flags & R4RECOVERR)
4789 mutex_exit(&rp->r_statelock);
4800 if (rp->r_unldvp == NULL) {
4801 rp4_addfree(rp, cr);
4816 mutex_enter(&rp->r_statelock);
4817 if (rp->r_unldvp == NULL) {
4818 mutex_exit(&rp->r_statelock);
4819 rp4_addfree(rp, cr);
4823 unldvp = rp->r_unldvp;
4824 rp->r_unldvp = NULL;
4825 unlname = rp->r_unlname;
4826 rp->r_unlname = NULL;
4827 unlcred = rp->r_unlcred;
4828 rp->r_unlcred = NULL;
4829 mutex_exit(&rp->r_statelock);
4838 ((rp->r_flags & R4DIRTY) || rp->r_count > 0)) {
4842 mutex_enter(&rp->r_statelock);
4843 if (!rp->r_error)
4844 rp->r_error = e.error;
4845 mutex_exit(&rp->r_statelock);
6534 rnode4_t *rp;
6619 rp = VTOR4(vp);
6626 mutex_enter(&rp->r_statelock);
6627 if (rp->r_size > MAXOFF32_T)
6629 mutex_exit(&rp->r_statelock);
6651 ((rp->r_flags & R4DIRTY) ||
6652 rp->r_count > 0 ||
6653 rp->r_mapcnt > 0)) {
6659 &rp->r_statelock);
6660 if (!rp->r_error)
6661 rp->r_error =
6664 &rp->r_statelock);
7005 * rp since we're only interested in setting owner_group
7245 rnode4_t *rp;
7277 rp = VTOR4(vp);
7302 mutex_enter(&rp->r_os_lock);
7303 isopen = list_head(&rp->r_open_streams) != NULL;
7304 mutex_exit(&rp->r_os_lock);
7307 mutex_enter(&rp->r_statelock);
7309 (rp->r_unldvp == NULL || strcmp(nm, rp->r_unlname) == 0)) {
7310 mutex_exit(&rp->r_statelock);
7316 mutex_enter(&rp->r_statelock);
7317 if (rp->r_unldvp == NULL) {
7319 rp->r_unldvp = dvp;
7320 if (rp->r_unlcred != NULL)
7321 crfree(rp->r_unlcred);
7323 rp->r_unlcred = cr;
7324 rp->r_unlname = tmpname;
7326 kmem_free(rp->r_unlname, MAXNAMELEN);
7327 rp->r_unlname = tmpname;
7329 mutex_exit(&rp->r_statelock);
7338 mutex_exit(&rp->r_statelock);
7347 ((rp->r_flags & R4DIRTY) || rp->r_count > 0)) {
7350 mutex_enter(&rp->r_statelock);
7351 if (!rp->r_error)
7352 rp->r_error = e.error;
7353 mutex_exit(&rp->r_statelock);
7359 (void) nfs4delegreturn(rp, NFS4_DR_REOPEN);
7719 rnode4_t *rp;
7784 rp = VTOR4(nvp);
7797 mutex_enter(&rp->r_os_lock);
7798 isactive = list_head(&rp->r_open_streams) != NULL;
7799 mutex_exit(&rp->r_os_lock);
7896 mutex_enter(&rp->r_statelock);
7897 if (rp->r_unldvp == NULL) {
7899 rp->r_unldvp = ndvp;
7900 if (rp->r_unlcred != NULL)
7901 crfree(rp->r_unlcred);
7903 rp->r_unlcred = cr;
7904 rp->r_unlname = tmpname;
7906 if (rp->r_unlname)
7907 kmem_free(rp->r_unlname, MAXNAMELEN);
7908 rp->r_unlname = tmpname;
7910 mutex_exit(&rp->r_statelock);
8012 mutex_enter(&rp->r_statelock);
8013 if (rp->r_unldvp) {
8015 rp->r_unldvp = NULL;
8016 if (rp->r_unlcred != NULL)
8017 crfree(rp->r_unlcred);
8018 rp->r_unlcred = NULL;
8019 /* rp->r_unlanme points to tmpname */
8020 if (rp->r_unlname)
8021 kmem_free(rp->r_unlname, MAXNAMELEN);
8022 rp->r_unlname = NULL;
8024 mutex_exit(&rp->r_statelock);
8047 rp = VTOR4(ovp);
8051 if (rp->r_dir != NULL)
8060 mutex_enter(&rp->r_statelock);
8061 if (rp->r_unldvp != NULL) {
8062 if (strcmp(rp->r_unlname, onm) == 0) {
8063 (void) strncpy(rp->r_unlname, nnm, MAXNAMELEN);
8064 rp->r_unlname[MAXNAMELEN - 1] = '\0';
8065 if (ndvp != rp->r_unldvp) {
8066 VN_RELE(rp->r_unldvp);
8067 rp->r_unldvp = ndvp;
8072 mutex_exit(&rp->r_statelock);
8867 rnode4_t *rp;
8881 rp = VTOR4(vp);
8882 if (nfs4_do_symlink_cache && rp->r_symlink.contents == NULL) {
8887 mutex_enter(&rp->r_statelock);
8888 if (rp->r_symlink.contents == NULL) {
8889 rp->r_symlink.len = strlen(tnm);
8890 bcopy(tnm, contents, rp->r_symlink.len);
8891 rp->r_symlink.contents = contents;
8892 rp->r_symlink.size = MAXPATHLEN;
8893 mutex_exit(&rp->r_statelock);
8895 mutex_exit(&rp->r_statelock);
8923 rnode4_t *rp;
8929 rp = VTOR4(vp);
8931 ASSERT(nfs_rw_lock_held(&rp->r_rwlock, RW_READER));
8936 if (rp->r_dir != NULL) {
8961 mutex_enter(&rp->r_statelock);
8962 if (rp->r_direof != NULL &&
8963 uiop->uio_loffset == rp->r_direof->nfs4_ncookie) {
8964 mutex_exit(&rp->r_statelock);
8977 rdc = rddir4_cache_lookup(rp, uiop->uio_loffset, count);
8983 mutex_exit(&rp->r_statelock);
8993 mutex_exit(&rp->r_statelock);
9003 mutex_enter(&rp->r_statelock);
9020 rddir4_cache_rele(rp, rdc);
9021 mutex_exit(&rp->r_statelock);
9053 rp->r_direof = rdc;
9054 rddir4_cache_rele(rp, rdc);
9055 mutex_exit(&rp->r_statelock);
9060 if (!(rp->r_flags & R4LOOKUP)) {
9061 rddir4_cache_rele(rp, rdc);
9062 mutex_exit(&rp->r_statelock);
9075 rrdc = rddir4_cache_lookup(rp, rdc->nfs4_ncookie, count);
9082 rddir4_cache_rele(rp, rdc);
9083 mutex_exit(&rp->r_statelock);
9093 rddir4_cache_rele(rp, rdc);
9094 mutex_exit(&rp->r_statelock);
9105 rddir4_cache_rele(rp, rrdc);
9106 rddir4_cache_rele(rp, rdc);
9107 mutex_exit(&rp->r_statelock);
9115 rnode4_t *rp;
9119 rp = VTOR4(vp);
9126 mutex_enter(&rp->r_statelock);
9135 rddir4_cache_rele(rp, rdc);
9136 mutex_exit(&rp->r_statelock);
9170 rnode4_t *rp = VTOR4(vp);
9187 * If rp were a stub, it should have triggered and caused
9190 ASSERT(!RP_ISSTUB(rp));
9203 nodeid = rp->r_attr.va_nodeid;
9253 if (rp->r_flags & (R4LOOKUP | R4READDIRWATTR)) {
9261 if (rp->r_flags & R4READDIRWATTR) {
9262 mutex_enter(&rp->r_statelock);
9263 rp->r_flags &= ~R4READDIRWATTR;
9264 mutex_exit(&rp->r_statelock);
9267 servinfo4_t *svp = rp->r_server;
9288 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
9304 mutex_enter(&rp->r_statelock);
9305 rargs->cookieverf = rp->r_cookieverf4;
9306 mutex_exit(&rp->r_statelock);
9447 mutex_enter(&rp->r_statelock);
9448 rp->r_cookieverf4 = rd_res->cookieverf;
9449 mutex_exit(&rp->r_statelock);
9533 rnode4_t *rp = VTOR4(bp->b_vp);
9553 cred_otw = nfs4_get_otw_cred_by_osp(rp, cr, &osp,
9569 mutex_enter(&rp->r_statelock);
9571 offset >= rp->r_size) {
9579 mutex_exit(&rp->r_statelock);
9584 if (!(rp->r_flags & R4STALE)) {
9591 cred_otw = nfs4_get_otw_cred_by_osp(rp, cr, &osp,
9593 mutex_enter(&rp->r_statelock);
9594 count = MIN(bp->b_bcount, rp->r_size - offset);
9595 mutex_exit(&rp->r_statelock);
9607 rp->r_flags, (long)bp->b_bcount,
9608 rp->r_size);
9644 mutex_enter(&rp->r_statelock);
9646 rp->r_flags |= R4STALE;
9647 if (!rp->r_error)
9648 rp->r_error = error;
9649 } else if (!rp->r_error &&
9653 rp->r_error = error;
9655 mutex_exit(&rp->r_statelock);
9659 error = rp->r_error;
9673 open_stream_rele(osp, rp);
9691 rnode4_t *rp = VTOR4(vp);
9694 (void) nfs_rw_enter_sig(&rp->r_rwlock, RW_READER, FALSE);
9698 if ((rp->r_flags & R4DIRECTIO) ||
9700 (void) nfs_rw_enter_sig(&rp->r_rwlock, RW_READER, FALSE);
9701 if (rp->r_mapcnt == 0 && !nfs4_has_pages(vp))
9703 nfs_rw_exit(&rp->r_rwlock);
9706 (void) nfs_rw_enter_sig(&rp->r_rwlock, RW_WRITER, FALSE);
9714 rnode4_t *rp = VTOR4(vp);
9716 nfs_rw_exit(&rp->r_rwlock);
9748 rnode4_t *rp;
9754 rp = VTOR4(vp);
9755 if (IS_SHADOW(vp, rp))
9756 vp = RTOV4(rp);
9772 mutex_enter(&rp->r_statelock);
9786 rp->r_awcount > 2 * mi->mi_max_threads) ||
9787 rp->r_gcount > 0)
9788 cv_wait(&rp->r_cv, &rp->r_statelock);
9796 if (off + len > rp->r_size + PAGEOFFSET && seg != segkmap) {
9800 (u_longlong_t)len, rp->r_size, rp->r_attr.va_size));
9801 mutex_exit(&rp->r_statelock);
9805 mutex_exit(&rp->r_statelock);
9833 rnode4_t *rp;
9853 rp = VTOR4(vp);
9854 ASSERT(!IS_SHADOW(vp, rp));
9878 mutex_enter(&rp->r_statelock);
9887 * d) No readaheads if rp->r_nextr is not within the scope
9893 else if (blkoff == rp->r_nextr)
9895 else if (rp->r_nextr > blkoff &&
9896 ((ra_window = (rp->r_nextr - blkoff) / bsize)
9902 rablkoff = rp->r_nextr;
9903 while (readahead > 0 && rablkoff + bsize < rp->r_size) {
9904 mutex_exit(&rp->r_statelock);
9908 mutex_enter(&rp->r_statelock);
9919 mutex_enter(&rp->r_statelock);
9925 rp->r_nextr = rablkoff;
9927 mutex_exit(&rp->r_statelock);
9946 mutex_enter(&rp->r_statelock);
9947 rp->r_nextr = off + PAGESIZE;
9948 mutex_exit(&rp->r_statelock);
9953 mutex_enter(&rp->r_statelock);
9954 if (blkoff < rp->r_size &&
9955 blkoff + bsize > rp->r_size) {
9960 if (rp->r_size <= off) {
9967 blksize = rp->r_size - blkoff;
9969 (off != rp->r_nextr && !readahead_issued)) {
9974 mutex_exit(&rp->r_statelock);
10020 mutex_enter(&rp->r_statelock);
10021 if (io_off >= rp->r_size && seg == segkmap) {
10022 mutex_exit(&rp->r_statelock);
10025 mutex_exit(&rp->r_statelock);
10056 mutex_enter(&rp->r_statelock);
10057 rp->r_nextr = io_off + io_len;
10058 mutex_exit(&rp->r_statelock);
10107 rnode4_t *rp = VTOR4(vp);
10114 mutex_enter(&rp->r_statelock);
10115 if (blkoff < rp->r_size && blkoff + bsize > rp->r_size) {
10120 blksize = rp->r_size - blkoff;
10123 mutex_exit(&rp->r_statelock);
10168 mutex_enter(&rp->r_statelock);
10169 if (io_off >= rp->r_size && seg == segkmap) {
10170 mutex_exit(&rp->r_statelock);
10174 mutex_exit(&rp->r_statelock);
10198 if (error && rp->r_nextr > io_off) {
10199 mutex_enter(&rp->r_statelock);
10200 if (rp->r_nextr > io_off)
10201 rp->r_nextr = io_off;
10202 mutex_exit(&rp->r_statelock);
10220 rnode4_t *rp;
10227 rp = VTOR4(vp);
10228 if (IS_SHADOW(vp, rp))
10229 vp = RTOV4(rp);
10241 mutex_enter(&rp->r_statelock);
10242 rp->r_count++;
10243 mutex_exit(&rp->r_statelock);
10245 mutex_enter(&rp->r_statelock);
10246 rp->r_count--;
10247 cv_broadcast(&rp->r_cv);
10248 mutex_exit(&rp->r_statelock);
10266 rnode4_t *rp;
10273 rp = VTOR4(vp);
10274 ASSERT(rp->r_count > 0);
10275 ASSERT(!IS_SHADOW(vp, rp));
10330 if (rp->r_flags & R4MODINPROGRESS) {
10331 mutex_enter(&rp->r_statelock);
10332 if ((rp->r_flags & R4MODINPROGRESS) &&
10333 rp->r_modaddr + MAXBSIZE > io_off &&
10334 rp->r_modaddr < io_off + io_len) {
10354 rp->r_flags |= R4DIRTY;
10355 mutex_exit(&rp->r_statelock);
10362 mutex_exit(&rp->r_statelock);
10383 rnode4_t *rp;
10391 rp = VTOR4(vp);
10396 if (!(rp->r_flags & R4OUTOFSPACE)) {
10397 mutex_enter(&rp->r_statelock);
10398 rp->r_flags |= R4OUTOFSPACE;
10399 mutex_exit(&rp->r_statelock);
10427 else if (rp->r_flags & R4OUTOFSPACE) {
10428 mutex_enter(&rp->r_statelock);
10429 rp->r_flags &= ~R4OUTOFSPACE;
10430 mutex_exit(&rp->r_statelock);
10453 rnode4_t *rp = VTOR4(vp);
10472 mutex_enter(&rp->r_statev4_lock);
10473 if (rp->r_deleg_type == OPEN_DELEGATE_NONE) {
10474 mutex_exit(&rp->r_statev4_lock);
10479 mutex_exit(&rp->r_statev4_lock);
10486 * rp->r_lkserlock to avoid a race with concurrent lock requests.
10500 if (nfs_rw_enter_sig(&rp->r_rwlock, RW_WRITER, INTR4(vp)))
10502 atomic_inc_uint(&rp->r_inmap);
10503 nfs_rw_exit(&rp->r_rwlock);
10505 if (nfs_rw_enter_sig(&rp->r_lkserlock, RW_READER, INTR4(vp))) {
10506 atomic_dec_uint(&rp->r_inmap);
10564 osp = find_open_stream(oop, rp);
10586 open_stream_rele(osp, rp);
10589 "osp %p, cr %p, rp %s", (void *)osp,
10590 (void *)cr, rnode4info(rp)));
10595 open_stream_rele(osp, rp);
10613 nfs_rw_exit(&rp->r_lkserlock);
10614 atomic_dec_uint(&rp->r_inmap);
10636 rnode4_t *rp, *drp;
10647 rp = VTOR4(open_vp);
10663 mutex_enter(&rp->r_statev4_lock);
10664 if (rp->created_v4) {
10665 rp->created_v4 = 0;
10666 mutex_exit(&rp->r_statev4_lock);
10672 mutex_exit(&rp->r_statev4_lock);
10725 osp = find_open_stream(oop, rp);
10741 rnode4_t *rp;
10746 rp = VTOR4(vp);
10757 * open/mmap/only update rp->r_mapcnt/server reboots/reopen doesn't
10760 atomic_add_long((ulong_t *)&rp->r_mapcnt, btopr(len));
10773 osp = find_open_stream(oop, rp);
10820 open_stream_rele(osp, rp);
10830 atomic_add_long((ulong_t *)&rp->r_mapcnt, -btopr(len));
10831 ASSERT(rp->r_mapcnt >= 0);
10852 rnode4_t *rp;
10907 rp = VTOR4(vp);
10913 if (nfs_rw_enter_sig(&rp->r_lkserlock, RW_WRITER, intr))
10932 mutex_enter(&rp->r_statelock);
10933 while (rp->r_count > 0) {
10939 if (cv_wait_sig(&rp->r_cv,
10940 &rp->r_statelock) == 0) {
10949 cv_wait(&rp->r_cv, &rp->r_statelock);
10951 mutex_exit(&rp->r_statelock);
10957 mutex_enter(&rp->r_statelock);
10958 if (!rp->r_error)
10959 rp->r_error = error;
10960 mutex_exit(&rp->r_statelock);
10981 nfs_rw_exit(&rp->r_lkserlock);
11031 rnode4_t *rp;
11032 rp = VTOR4(vp);
11034 if (vp->v_type == VREG && IS_SHADOW(vp, rp)) {
11035 vp = RTOV4(rp);
11059 rnode4_t *rp;
11072 rp = VTOR4(vp);
11104 caller_found = nfs4_find_and_delete_delmapcall(rp, &error);
11122 mutex_enter(&rp->r_statelock);
11123 list_insert_tail(&rp->r_indelmap, delmap_call);
11124 mutex_exit(&rp->r_statelock);
11171 nfs4_find_and_delete_delmapcall(rnode4_t *rp, int *errp)
11179 mutex_enter(&rp->r_statelock);
11180 if (!(rp->r_flags & R4DELMAPLIST)) {
11182 list_create(&rp->r_indelmap, sizeof (nfs4_delmapcall_t),
11184 rp->r_flags |= R4DELMAPLIST;
11185 mutex_exit(&rp->r_statelock);
11189 for (delmap_call = list_head(&rp->r_indelmap);
11191 delmap_call = list_next(&rp->r_indelmap, delmap_call)) {
11195 list_remove(&rp->r_indelmap, delmap_call);
11196 mutex_exit(&rp->r_statelock);
11202 mutex_exit(&rp->r_statelock);
11219 rnode4_t *rp;
11223 rp = VTOR4(dmapp->vp);
11226 atomic_add_long((ulong_t *)&rp->r_mapcnt, -btopr(dmapp->len));
11227 ASSERT(rp->r_mapcnt >= 0);
11237 mutex_enter(&rp->r_statelock);
11238 rp->r_flags |= R4DIRTY;
11239 mutex_exit(&rp->r_statelock);
11243 mutex_enter(&rp->r_statelock);
11244 e.error = rp->r_error;
11245 rp->r_error = 0;
11246 mutex_exit(&rp->r_statelock);
11251 if ((rp->r_flags & R4DIRECTIO) || (mi->mi_flags & MI4_DIRECTIO))
11343 rnode4_t *rp;
11360 rp = VTOR4(vp);
11375 if (ATTRCACHE4_VALID(vp) && rp->r_pathconf.pc4_xattr_valid &&
11376 rp->r_xattr_dir == NULL) {
11381 mutex_enter(&rp->r_statelock);
11382 if (rp->r_pathconf.pc4_cache_valid) {
11387 rp->r_pathconf.pc4_filesizebits;
11391 rp->r_pathconf.pc4_link_max;
11395 rp->r_pathconf.pc4_name_max;
11399 rp->r_pathconf.pc4_chown_restricted;
11403 rp->r_pathconf.pc4_no_trunc;
11409 mutex_exit(&rp->r_statelock);
11415 mutex_exit(&rp->r_statelock);
11427 mutex_enter(&rp->r_statelock);
11428 rp->r_pathconf.pc4_cache_valid = FALSE;
11429 rp->r_pathconf.pc4_xattr_valid = FALSE;
11430 mutex_exit(&rp->r_statelock);
11496 rnode4_t *rp;
11504 rp = VTOR4(vp);
11505 mutex_enter(&rp->r_statelock);
11506 rp->r_count++;
11507 mutex_exit(&rp->r_statelock);
11514 mutex_enter(&rp->r_statelock);
11515 rp->r_count--;
11516 cv_broadcast(&rp->r_cv);
11517 mutex_exit(&rp->r_statelock);
11527 rnode4_t *rp;
11545 rp = VTOR4(vp);
11553 if (pp->p_fsdata == C_NOCOMMIT || (rp->r_flags & R4STALE)) {
11568 mutex_enter(&rp->r_statelock);
11569 if ((rp->r_flags & R4TRUNCATE) && pp->p_offset >= rp->r_truncaddr) {
11570 mutex_exit(&rp->r_statelock);
11592 if (rp->r_flags & R4COMMITWAIT) {
11594 mutex_exit(&rp->r_statelock);
11600 mutex_exit(&rp->r_statelock);
11616 mutex_exit(&rp->r_statelock);
11630 while (rp->r_flags & R4COMMIT) {
11631 rp->r_flags |= R4COMMITWAIT;
11632 cv_wait(&rp->r_commit.c_cv, &rp->r_statelock);
11633 rp->r_flags &= ~R4COMMITWAIT;
11635 rp->r_flags |= R4COMMIT;
11636 mutex_exit(&rp->r_statelock);
11637 ASSERT(rp->r_commit.c_pages == NULL);
11638 rp->r_commit.c_pages = pp;
11639 rp->r_commit.c_commbase = (offset3)pp->p_offset;
11640 rp->r_commit.c_commlen = PAGESIZE;
11654 plist = rp->r_commit.c_pages;
11655 rp->r_commit.c_pages = NULL;
11656 offset = rp->r_commit.c_commbase;
11657 len = rp->r_commit.c_commlen;
11658 mutex_enter(&rp->r_statelock);
11659 rp->r_flags &= ~R4COMMIT;
11660 cv_broadcast(&rp->r_commit.c_cv);
11661 mutex_exit(&rp->r_statelock);
11743 rnode4_t *rp;
11754 rp = VTOR4(vp);
11764 cred_otw = nfs4_get_otw_cred_by_osp(rp, cr, &osp,
11779 open_stream_rele(osp, rp);
11785 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
11803 open_stream_rele(osp, rp);
11822 open_stream_rele(osp, rp);
11845 mutex_enter(&rp->r_statelock);
11846 rp->r_flags |= R4STALE;
11847 if (!rp->r_error)
11848 rp->r_error = e.error;
11849 mutex_exit(&rp->r_statelock);
11852 mutex_enter(&rp->r_statelock);
11853 if (!rp->r_error)
11854 rp->r_error = e.error;
11855 mutex_exit(&rp->r_statelock);
11858 ASSERT(rp->r_flags & R4HAVEVERF);
11861 mutex_enter(&rp->r_statelock);
11862 if (cm_res->writeverf == rp->r_writeverf) {
11863 mutex_exit(&rp->r_statelock);
11869 open_stream_rele(osp, rp);
11873 rp->r_writeverf = cm_res->writeverf;
11874 mutex_exit(&rp->r_statelock);
11882 open_stream_rele(osp, rp);
11914 rnode4_t *rp;
11918 rp = VTOR4(vp);
11920 ASSERT(rp->r_flags & R4COMMIT);
11924 if (IS_SHADOW(vp, rp))
11925 vp = RTOV4(rp);
11981 if (rp->r_commit.c_pages == NULL) {
11982 rp->r_commit.c_commbase = (offset3)pp->p_offset;
11983 rp->r_commit.c_commlen = PAGESIZE;
11984 } else if (pp->p_offset < rp->r_commit.c_commbase) {
11985 rp->r_commit.c_commlen = rp->r_commit.c_commbase -
11986 (offset3)pp->p_offset + rp->r_commit.c_commlen;
11987 rp->r_commit.c_commbase = (offset3)pp->p_offset;
11988 } else if ((rp->r_commit.c_commbase + rp->r_commit.c_commlen)
11990 rp->r_commit.c_commlen = (offset3)pp->p_offset -
11991 rp->r_commit.c_commbase + PAGESIZE;
11993 page_add(&rp->r_commit.c_pages, pp);
12013 rnode4_t *rp;
12018 rp = VTOR4(vp);
12019 ASSERT(rp->r_flags & R4COMMIT);
12025 if (IS_SHADOW(vp, rp))
12026 vp = RTOV4(rp);
12059 if (rp->r_commit.c_pages == NULL) {
12060 rp->r_commit.c_commbase = (offset3)pp->p_offset;
12061 rp->r_commit.c_commlen = PAGESIZE;
12063 rp->r_commit.c_commlen = (offset3)pp->p_offset -
12064 rp->r_commit.c_commbase + PAGESIZE;
12066 page_add(&rp->r_commit.c_pages, pp);
12079 rnode4_t *rp = VTOR4(vp);
12104 mutex_enter(&rp->r_statelock);
12105 write_verf = rp->r_writeverf;
12106 mutex_exit(&rp->r_statelock);
12124 mutex_enter(&rp->r_statelock);
12125 if (rp->r_writeverf != write_verf) {
12126 mutex_exit(&rp->r_statelock);
12129 mutex_exit(&rp->r_statelock);
12154 rnode4_t *rp;
12161 rp = VTOR4(vp);
12167 if (rp->r_count && wait_on_writes == NFS4_WRITE_WAIT) {
12168 mutex_enter(&rp->r_statelock);
12169 while (rp->r_count > 0) {
12170 cv_wait(&rp->r_cv, &rp->r_statelock);
12172 mutex_exit(&rp->r_statelock);
12179 mutex_enter(&rp->r_statelock);
12180 while (rp->r_flags & R4COMMIT) {
12181 rp->r_flags |= R4COMMITWAIT;
12182 cv_wait(&rp->r_commit.c_cv, &rp->r_statelock);
12183 rp->r_flags &= ~R4COMMITWAIT;
12185 rp->r_flags |= R4COMMIT;
12186 mutex_exit(&rp->r_statelock);
12201 plist = rp->r_commit.c_pages;
12202 rp->r_commit.c_pages = NULL;
12203 offset = rp->r_commit.c_commbase;
12204 len = rp->r_commit.c_commlen;
12205 mutex_enter(&rp->r_statelock);
12206 rp->r_flags &= ~R4COMMIT;
12207 cv_broadcast(&rp->r_commit.c_cv);
12208 mutex_exit(&rp->r_statelock);
12331 rnode4_t *rp = VTOR4(vp);
12360 if (rp->r_secattr != NULL && ATTRCACHE4_VALID(vp)) {
12361 mutex_enter(&rp->r_statelock);
12362 if (rp->r_secattr != NULL) {
12364 rp->r_secattr, vsecattr, rp->r_attr.va_uid,
12365 rp->r_attr.va_gid,
12368 mutex_exit(&rp->r_statelock);
12372 mutex_exit(&rp->r_statelock);
12401 nfs4_acl_fill_cache(rp, &gar.n4g_vsa);
13052 rnode4_t *rp;
13068 rp = VTOR4(vp);
13071 mutex_enter(&rp->r_statelock);
13072 if (rp->r_flags & R4RECOVERR) {
13075 mutex_exit(&rp->r_statelock);
13185 rnode4_t *rp)
13189 ASSERT(nfs_zone() == VTOMI4(RTOV4(rp))->mi_zone);
13207 lockt_args->owner.clientid = mi2clientid(VTOMI4(RTOV4(rp)));
13209 nfs4_setlockowner_args(&lockt_args->owner, rp,
13234 rnode4_t *rp = VTOR4(vp);
13241 mutex_enter(&rp->r_statev4_lock);
13242 dt = rp->r_deleg_type;
13243 mutex_exit(&rp->r_statev4_lock);
13254 osp = find_open_stream(oop, rp);
13265 "for osp %p, cr %p, rp %s", (void *)osp,
13266 (void *)cr, rnode4info(rp)));
13268 open_stream_rele(osp, rp);
13314 open_stream_rele(osp, rp);
13339 rnode4_t *rp = VTOR4(vp);
13371 lop = find_lock_owner(rp, pid, LOWN_ANY);
13450 rnode4_t *rp = VTOR4(vp);
13477 nfs4_find_or_create_lock_owner(pid, rp, cr, &oop, &osp, &lop);
13663 * Note: the rp's r_lkserlock is *not* dropped during this path.
13670 nfs4_lock_owner_t **lopp, rnode4_t *rp, vnode_t *vp,
13770 open_stream_rele(osp, rp);
13844 rnode4_t *rp = VTOR4(vp);
13867 open_stream_rele(osp, rp);
13876 nfs_rw_exit(&rp->r_lkserlock);
13878 intr = nfs4_block_and_wait(tick_delayp, rp);
13881 (void) nfs_rw_enter_sig(&rp->r_lkserlock,
13887 (void) nfs_rw_enter_sig(&rp->r_lkserlock,
14040 rnode4_t *rp = VTOR4(vp);
14094 open_stream_rele(osp, rp);
14171 rnode4_t *rp;
14223 rp = VTOR4(vp);
14241 lop = find_lock_owner(rp, curproc->p_pid, LOWN_ANY);
14260 argop[0].nfs_argop4_u.opcputfh.sfh = rp->r_fh;
14280 &lockt_args, argsp, flk, rp);
14353 "nfs4frlock: %s call, rp %s", needrecov ? "recov" : "first",
14354 rnode4info(rp)));
14423 rp, vp, &recov_state, op_hint, &did_start_fop,
14488 lock_args, locku_args, &oop, &osp, &lop, rp, vp,
14524 rnode4_t *rp = VTOR4(vp);
14529 ASSERT(rp->r_mapcnt >= 0);
14533 bfp->l_start, bfp->l_len, rp->r_mapcnt));
14535 if (rp->r_mapcnt == 0)
14639 rnode4_t *rp;
14649 rp = VTOR4(vp);
14656 if (rp->r_lo_head.lo_next_rnode == &rp->r_lo_head) {
14671 mutex_enter(&rp->r_statelock);
14672 rp->r_flags |= R4LODANGLERS;
14673 mutex_exit(&rp->r_statelock);
14677 lop = find_lock_owner(rp, curproc->p_pid, LOWN_ANY);
14733 mutex_enter(&rp->r_statelock);
14734 rp->r_flags |= R4LODANGLERS;
14735 mutex_exit(&rp->r_statelock);
14744 lop = find_lock_owner(rp, curproc->p_pid, LOWN_ANY);
14747 nfs4_rnode_remove_lock_owner(rp, lop);
14763 nfs4_block_and_wait(clock_t *tick_delay, rnode4_t *rp)
14777 lock_lease_time = r2lease_time(rp);
14942 rnode4_t *rp;
14946 rp = VTOR4(vp);
14949 "rp=%p osp=%p", (void *)rp, (void *)osp));
14990 rnode4_t *rp;
14995 rp = VTOR4(vp);
15021 rw_enter(&rp->r_hashq->r_lock, RW_READER);
15025 rw_exit(&rp->r_hashq->r_lock);
15034 mutex_enter(&rp->r_os_lock);
15037 osp = list_head(&rp->r_open_streams);
15040 mutex_exit(&rp->r_os_lock);
15041 rw_exit(&rp->r_hashq->r_lock);
15045 mutex_enter(&rp->r_statev4_lock);
15047 ASSERT(rp->r_mapcnt == 0);
15048 if (rp->created_v4)
15049 rp->created_v4 = 0;
15050 mutex_exit(&rp->r_statev4_lock);
15060 mutex_exit(&rp->r_os_lock);
15061 rw_exit(&rp->r_hashq->r_lock);
15077 open_stream_rele(osp, rp);
15120 rnode4_t *rp;
15142 rp = VTOR4(vp);
15160 "nfs4close_one: no oop, rp %p, mi %p, cr %p, osp %p, "
15161 "close type %d", (void *)rp, (void *)mi, (void *)cr,
15237 osp = find_open_stream(oop, rp);
15362 mutex_enter(&rp->r_statelock);
15363 if (rp->r_flags & R4RECOVERR) {
15366 mutex_exit(&rp->r_statelock);
15434 open_stream_rele(osp, rp);
15510 nfs4close_otw(rp, cred_otw, oop, osp, &retry, &did_start_seqid_sync,
15545 open_stream_rele(osp, rp);
15611 open_stream_rele(osp, rp);