Lines Matching defs:mi
702 mntinfo4_t *mi; /* mount info, pointed at by vfs */
757 if ((mi = VFTOMI4(vfsp)) != NULL) {
761 old_mi_llock = (mi->mi_flags & MI4_LLOCK) ? 1 : 0;
805 mi = NULL;
1134 mi = VTOMI4(rtvp);
1140 nfs4setclientid(mi, cr, FALSE, &n4e);
1152 mutex_enter(&mi->mi_lock);
1153 mi->mi_flags |= MI4_LLOCK;
1154 mutex_exit(&mi->mi_lock);
1164 error = nfs4_record_ephemeral_mount(mi, mvp);
1173 if (mi != NULL) {
1176 nfs4_remove_mi_from_server(mi, NULL);
1182 removed = nfs4_mi_zonelist_remove(mi);
1184 zone_rele_ref(&mi->mi_zone_ref,
1186 MI4_RELE(mi);
1230 getlinktext_otw(mntinfo4_t *mi, nfs_fh4 *fh, char **linktextp, cred_t *cr,
1247 sfh = sfh4_get(fh, mi);
1259 e.error = nfs4_start_op(mi, NULL, NULL, &recov_state);
1275 rfs4call(mi, &args, &res, cr, &doqueue, 0, &e);
1277 needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp);
1284 if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL,
1286 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1299 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1308 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1323 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1359 resolve_sympath(mntinfo4_t *mi, servinfo4_t *svp, int nth, nfs_fh4 *fh,
1370 error = getlinktext_otw(mi, fh, &symlink, cr, flags);
1612 resolve_referral(mntinfo4_t *mi, servinfo4_t *svp, cred_t *cr, int nth,
1634 sfh = sfh4_get(fh, mi);
1635 index = nfs4_process_referral(mi, sfh, nm, cr,
1649 mutex_enter(&mi->mi_lock);
1650 mi->mi_vfs_referral_loop_cnt++;
1651 mutex_exit(&mi->mi_lock);
1674 nfs4getfh_otw(struct mntinfo4 *mi, servinfo4_t *svp, vtype_t *vtp,
1706 if (mi->mi_vfs_referral_loop_cnt >= NFS4_REFERRAL_LOOP_MAX) {
1708 mi, servinfo4_t *, svp, char *, "nfs4getfh_otw");
1715 ep->error = nfs4_start_fop(mi, NULL, NULL, OH_MOUNT,
1726 mutex_enter(&mi->mi_lock);
1727 if (mi->mi_flags & MI4_MOUNTING) {
1728 mi->mi_flags |= MI4_RECOV_FAIL;
1729 mi->mi_error = EIO;
1734 while (mi->mi_flags & MI4_RECOV_ACTIV)
1735 cv_wait(&mi->mi_failover_cv,
1736 &mi->mi_lock);
1738 mutex_exit(&mi->mi_lock);
1753 (void) nfs4_secinfo_path(mi, cr, FALSE);
1768 lookuparg.mi = mi;
1788 "nfs4getfh_otw: %s call, mi 0x%p",
1789 needrecov ? "recov" : "first", (void *)mi));
1791 rfs4call(mi, &args, &res, cr, &doqueue, RFSCALL_SOFT, ep);
1793 needrecov = nfs4_needs_recovery(ep, FALSE, mi->mi_vfsp);
1811 abort = nfs4_start_recovery(ep, mi, NULL,
1819 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
1833 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1844 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1865 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1889 ep->error = resolve_sympath(mi, svp, nthcomp,
1898 ep->error = resolve_referral(mi, svp, cr, nthcomp,
1923 mi->mi_fh_expire_type = garp->n4g_ext_res->n4g_fet;
1925 mutex_enter(&mi->mi_lock);
1927 mi->mi_flags |= MI4_LINK;
1929 mi->mi_flags |= MI4_SYMLINK;
1931 mi->mi_flags |= MI4_ACL;
1932 mutex_exit(&mi->mi_lock);
1935 mi->mi_tsize =
1936 MIN(MAXBSIZE, mi->mi_tsize);
1938 mi->mi_tsize =
1940 mi->mi_tsize);
1943 mi->mi_stsize =
1944 MIN(MAXBSIZE, mi->mi_stsize);
1946 mi->mi_stsize =
1948 mi->mi_stsize);
1951 mi->mi_maxfilesize =
1953 mi->mi_maxfilesize);
1979 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1982 ep->error = resolve_sympath(mi, svp, nthcomp, resfhp, cr,
2038 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
2123 restore_svp(mntinfo4_t *mi, servinfo4_t *svp, servinfo4_t *origsvp)
2139 mutex_enter(&mi->mi_lock);
2140 mi->mi_servers = svp;
2141 mi->mi_curr_serv = svp;
2142 mutex_exit(&mi->mi_lock);
2174 nfs4_remap_root(mntinfo4_t *mi, nfs4_error_t *ep, int flags)
2182 mutex_enter(&mi->mi_lock);
2185 svp = mi->mi_curr_serv;
2189 (mi->mi_flags & MI4_PUBLIC) ? NFS4_GETFH_PUBLIC : 0;
2190 mutex_exit(&mi->mi_lock);
2218 nfs4getfh_otw(mi, svp, &vtype, getfh_flags, CRED(), ep);
2227 svp = restore_svp(mi, svp, origsvp);
2237 if (vtype != VNON && vtype != mi->mi_type) {
2239 zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2241 "match mount info (%d)", vtype, mi->mi_type);
2248 sfh4_update(mi->mi_rootfh, &rootfh);
2256 mutex_enter(&mi->mi_lock);
2257 if (mi->mi_curr_serv != svp)
2260 mutex_exit(&mi->mi_lock);
2268 mntinfo4_t *mi;
2297 mi = kmem_zalloc(sizeof (*mi), KM_SLEEP);
2298 mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL);
2299 nfs_rw_init(&mi->mi_recovlock, NULL, RW_DEFAULT, NULL);
2300 nfs_rw_init(&mi->mi_rename_lock, NULL, RW_DEFAULT, NULL);
2301 nfs_rw_init(&mi->mi_fh_lock, NULL, RW_DEFAULT, NULL);
2304 mi->mi_flags |= MI4_HARD;
2306 mi->mi_flags |= MI4_NOPRINT;
2308 mi->mi_flags |= MI4_INT;
2310 mi->mi_flags |= MI4_PUBLIC;
2312 mi->mi_flags |= MI4_MIRRORMOUNT;
2314 mi->mi_flags |= MI4_REFERRAL;
2315 mi->mi_retrans = NFS_RETRIES;
2318 mi->mi_timeo = nfs4_cots_timeo;
2320 mi->mi_timeo = NFS_TIMEO;
2321 mi->mi_prog = NFS_PROGRAM;
2322 mi->mi_vers = NFS_V4;
2323 mi->mi_rfsnames = rfsnames_v4;
2324 mi->mi_reqs = nfsstatsp->nfs_stats_v4.rfsreqcnt_ptr;
2325 cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL);
2326 mi->mi_servers = svp;
2327 mi->mi_curr_serv = svp;
2328 mi->mi_acregmin = SEC2HR(ACREGMIN);
2329 mi->mi_acregmax = SEC2HR(ACREGMAX);
2330 mi->mi_acdirmin = SEC2HR(ACDIRMIN);
2331 mi->mi_acdirmax = SEC2HR(ACDIRMAX);
2332 mi->mi_fh_expire_type = FH4_PERSISTENT;
2333 mi->mi_clientid_next = NULL;
2334 mi->mi_clientid_prev = NULL;
2335 mi->mi_srv = NULL;
2336 mi->mi_grace_wait = 0;
2337 mi->mi_error = 0;
2338 mi->mi_srvsettime = 0;
2339 mi->mi_srvset_cnt = 0;
2341 mi->mi_count = 1;
2343 mi->mi_tsize = nfs4_tsize(svp->sv_knconf);
2344 mi->mi_stsize = mi->mi_tsize;
2347 mi->mi_flags |= MI4_DIRECTIO;
2349 mi->mi_flags |= MI4_MOUNTING;
2366 vfsp->vfs_data = (caddr_t)mi;
2374 mi->mi_async_clusters[i] = nfs4_async_clusters;
2375 mi->mi_async_init_clusters = nfs4_async_clusters;
2376 mi->mi_async_curr[NFS4_ASYNC_QUEUE] =
2377 mi->mi_async_curr[NFS4_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0];
2378 mi->mi_max_threads = nfs4_max_threads;
2379 mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL);
2380 cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL);
2381 cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_QUEUE], NULL, CV_DEFAULT,
2383 cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE], NULL,
2385 cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL);
2386 cv_init(&mi->mi_inact_req_cv, NULL, CV_DEFAULT, NULL);
2388 mi->mi_vfsp = vfsp;
2389 mi->mi_zone = zone;
2390 zone_init_ref(&mi->mi_zone_ref);
2391 zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFSV4);
2392 nfs4_mi_zonelist_add(mi);
2398 bucketp = &(mi->mi_oo_list[i]);
2408 mi->mi_foo_num = 0;
2409 mi->mi_foo_max = NFS4_NUM_FREED_OPEN_OWNERS;
2410 list_create(&mi->mi_foo_list, sizeof (nfs4_open_owner_t),
2413 list_create(&mi->mi_lost_state, sizeof (nfs4_lost_rqst_t),
2416 list_create(&mi->mi_bseqid_list, sizeof (nfs4_bseqid_entry_t),
2422 list_create(&mi->mi_msg_list, sizeof (nfs4_debug_msg_t),
2424 mi->mi_msg_count = 0;
2425 mutex_init(&mi->mi_msg_list_lock, NULL, MUTEX_DEFAULT, NULL);
2435 sfh4_createtab(&mi->mi_filehandles);
2472 mi->mi_curr_serv = svp;
2493 nfs4getfh_otw(mi, svp, &tmp_vtype,
2504 svp = restore_svp(mi, svp, origsvp);
2516 mi->mi_flags &= ~MI4_RECOV_FAIL;
2517 mi->mi_error = 0;
2522 zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2534 zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2552 mi->mi_curr_serv = svp = firstsvp;
2554 ASSERT((mi->mi_curr_serv->sv_flags & SV4_NOTINUSE) == 0);
2557 mi->mi_rootfh = sfh4_get(&fh, mi);
2560 mi->mi_srvparentfh = sfh4_get(&fh, mi);
2566 mi->mi_fname = fn_get(NULL, ".", mi->mi_rootfh);
2567 mfname = mi->mi_fname;
2573 rtvp = makenfs4node_by_fh(mi->mi_rootfh, NULL,
2574 &mfname, NULL, mi, cr, gethrtime());
2577 mi->mi_curread = mi->mi_tsize;
2578 mi->mi_curwrite = mi->mi_stsize;
2584 MI4_HOLD(mi);
2586 mi->mi_manager_thread = zthread_create(NULL, 0, nfs4_async_manager,
2588 ASSERT(mi->mi_manager_thread != NULL);
2595 MI4_HOLD(mi);
2596 mi->mi_inactive_thread = zthread_create(NULL, 0, nfs4_inactive_thread,
2597 mi, 0, minclsyspri);
2598 ASSERT(mi->mi_inactive_thread != NULL);
2609 mi->mi_type = rtvp->v_type;
2611 mutex_enter(&mi->mi_lock);
2612 mi->mi_flags &= ~MI4_MOUNTING;
2613 mutex_exit(&mi->mi_lock);
2652 removed = nfs4_mi_zonelist_remove(mi);
2654 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2657 * This releases the initial "hold" of the mi since it will never
2661 MI4_RELE(mi);
2676 mntinfo4_t *mi;
2687 mi = VFTOMI4(vfsp);
2691 if (nfs_zone() != mi->mi_zone) {
2719 omax = mi->mi_max_threads;
2731 if (nfs4_ephemeral_umount(mi, flag, cr,
2734 mutex_enter(&mi->mi_async_lock);
2735 mi->mi_max_threads = omax;
2736 mutex_exit(&mi->mi_async_lock);
2748 mutex_enter(&mi->mi_async_lock);
2749 mi->mi_max_threads = omax;
2750 mutex_exit(&mi->mi_async_lock);
2759 nfs4_ephemeral_umount_activate(mi, &must_unlock, &eph_tree);
2776 nfs4_remove_mi_from_server(mi, NULL);
2777 removed = nfs4_mi_zonelist_remove(mi);
2779 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2790 mntinfo4_t *mi;
2795 mi = VFTOMI4(vfsp);
2797 if (nfs_zone() != mi->mi_zone)
2800 svp = mi->mi_curr_serv;
2817 mfname = mi->mi_fname;
2819 vp = makenfs4node_by_fh(mi->mi_rootfh, NULL, &mfname, NULL,
2827 ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type);
2829 vp->v_type = mi->mi_type;
2912 mntinfo4_t *mi;
2914 mi = VFTOMI4(vfsp);
2915 if (!(mi->mi_flags & MI4_SHUTDOWN)) {
2916 mutex_enter(&mi->mi_lock);
2917 mi->mi_flags |= MI4_SHUTDOWN;
2918 mutex_exit(&mi->mi_lock);
2960 mntinfo4_t *mi;
3056 mi = VTOMI4(rtvp);
3062 nfs4setclientid(mi, cr, FALSE, &n4e);
3127 mntinfo4_t *mi;
3130 mi = VFTOMI4(vfsp);
3137 mi->mi_vfsp = NULL;
3139 MI4_RELE(mi);
3166 * Set the clientid for the server for "mi". No-op if the clientid is
3178 nfs4setclientid(mntinfo4_t *mi, cred_t *cr, bool_t recovery, nfs4_error_t *n4ep)
3181 struct servinfo4 *svp = mi->mi_curr_serv;
3197 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0);
3233 /* add mi to np's mntinfo4_list */
3234 nfs4_add_mi_to_server(np, mi);
3236 nfs_rw_exit(&mi->mi_recovlock);
3249 nfs_rw_exit(&mi->mi_recovlock);
3251 n4ep->error = nfs4_start_op(mi, NULL, NULL, &recov_state);
3264 nfs4_end_op(mi, NULL, NULL, &recov_state,
3273 /* add mi to np's mntinfo4_list */
3274 nfs4_add_mi_to_server(np, mi);
3278 nfs4_end_op(mi, NULL, NULL, &recov_state, recovery);
3291 nfs4setclientid_otw(mi, svp, cr, np, n4ep, &retry_inuse);
3311 nfs4setclientid_otw(mi, svp, lcr, np, n4ep,
3330 if (FAILOVER_MOUNT4(mi) && nfs4_try_failover(n4ep)) {
3331 (void) nfs4_start_recovery(n4ep, mi, NULL,
3374 nfs4_end_op(mi, NULL, NULL, &recov_state, recovery);
3405 nfs4setclientid_otw(mntinfo4_t *mi, struct servinfo4 *svp, cred_t *cr,
3432 argop[1].nfs_argop4_u.opgetattr.mi = mi;
3458 rfs4call(mi, &args, &res, cr, &doqueue, 0, ep);
3489 * Keep track of the lease period for the mi's
3494 mutex_enter(&mi->mi_msg_list_lock);
3495 mi->mi_lease_period = np->s_lease_time;
3496 mutex_exit(&mi->mi_msg_list_lock);
3508 zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3545 zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3572 rfs4call(mi, &args, &res, cr, &doqueue, 0, ep);
3597 zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3617 /* Add mi to np's mntinfo4 list */
3618 nfs4_add_mi_to_server(np, mi);
3636 * Add mi to sp's mntinfo4_list if it isn't already in the list. Makes
3637 * mi's clientid the same as sp's.
3641 nfs4_add_mi_to_server(nfs4_server_t *sp, mntinfo4_t *mi)
3646 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
3647 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
3652 "nfs4_add_mi_to_server: add mi %p to sp %p",
3653 (void*)mi, (void*)sp));
3658 if (tmi == mi) {
3661 "nfs4_add_mi_to_server: mi in list"));
3671 VFS_HOLD(mi->mi_vfsp);
3674 "hold vfs %p for mi: %p", (void*)mi->mi_vfsp, (void*)mi));
3678 sp->mntinfo4_list->mi_clientid_prev = mi;
3679 mi->mi_clientid_next = sp->mntinfo4_list;
3680 mi->mi_srv = sp;
3681 sp->mntinfo4_list = mi;
3682 mi->mi_srvsettime = gethrestime_sec();
3683 mi->mi_srvset_cnt++;
3686 /* set mi's clientid to that of sp's for later matching */
3687 mi->mi_clientid = sp->clientid;
3690 * Update the clientid for any other mi's belonging to sp. This
3698 if (tmi != mi) {
3705 * Remove the mi from sp's mntinfo4_list and release its reference.
3706 * Exception: if mi still has open files, flag it for later removal (when
3713 nfs4_remove_mi_from_server_nolock(mntinfo4_t *mi, nfs4_server_t *sp)
3716 "nfs4_remove_mi_from_server_nolock: remove mi %p from sp %p",
3717 (void*)mi, (void*)sp));
3721 ASSERT(mi->mi_open_files >= 0);
3727 if (mi->mi_open_files > 0) {
3730 "remove mi since it still has files open"));
3732 mutex_enter(&mi->mi_lock);
3733 mi->mi_flags |= MI4_REMOVE_ON_LAST_CLOSE;
3734 mutex_exit(&mi->mi_lock);
3738 VFS_HOLD(mi->mi_vfsp);
3739 remove_mi(sp, mi);
3740 VFS_RELE(mi->mi_vfsp);
3751 * Remove mi from sp's mntinfo4_list and release the vfs reference.
3754 remove_mi(nfs4_server_t *sp, mntinfo4_t *mi)
3762 ASSERT(mi->mi_vfsp->vfs_count >= 2);
3764 if (mi->mi_clientid_prev) {
3765 mi->mi_clientid_prev->mi_clientid_next = mi->mi_clientid_next;
3767 /* This is the first mi in sp's mntinfo4_list */
3772 ASSERT(sp->mntinfo4_list == mi);
3774 sp->mntinfo4_list = mi->mi_clientid_next;
3776 if (mi->mi_clientid_next)
3777 mi->mi_clientid_next->mi_clientid_prev = mi->mi_clientid_prev;
3780 mi->mi_clientid_prev = mi->mi_clientid_next = NULL;
3781 mi->mi_srv = NULL;
3782 mi->mi_srvset_cnt++;
3784 VFS_RELE(mi->mi_vfsp);
3793 mntinfo4_t *mi;
3798 mi = sp->mntinfo4_list;
3803 VFS_HOLD(mi->mi_vfsp);
3804 remove_mi(sp, mi);
3805 VFS_RELE(mi->mi_vfsp);
3810 * Remove the mi from sp's mntinfo4_list as above, and rele the vfs.
3814 * do nothing because the mi wasn't added to an sp's mntinfo4_list.
3817 nfs4_remove_mi_from_server(mntinfo4_t *mi, nfs4_server_t *esp)
3822 nfs4_remove_mi_from_server_nolock(mi, esp);
3826 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0);
3827 if (sp = find_nfs4_server_all(mi, 1)) {
3828 nfs4_remove_mi_from_server_nolock(mi, sp);
3832 nfs_rw_exit(&mi->mi_recovlock);
3842 mntinfo4_t *mi;
3846 for (mi = sp->mntinfo4_list; mi != NULL; mi = mi->mi_clientid_next) {
3847 if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
3975 dumpnfs4slist(char *txt, mntinfo4_t *mi, clientid4 clientid, servinfo4_t *srv_p)
3983 "mi 0x%p, want clientid %llx, addr %d/%04X",
3984 mi, (longlong_t)clientid, srv_p->sv_addr.len,
4020 nfs4_move_mi(mntinfo4_t *mi, servinfo4_t *old, servinfo4_t *new)
4026 ASSERT(nfs_zone() == mi->mi_zone);
4031 dumpnfs4slist("nfs4_move_mi", mi, (clientid4)0, new);
4073 "nfs4_move_mi: for mi 0x%p, "
4076 (void*)mi, (void*)old, (void*)new,
4081 nfs4_deleg_discard(mi, op);
4083 num_open = mi->mi_open_files;
4084 mi->mi_open_files = 0;
4088 nfs4_remove_mi_from_server_nolock(mi, op);
4089 mi->mi_open_files = num_open;
4092 mi->mi_open_files, op->state_ref_count, np->state_ref_count));
4094 nfs4_add_mi_to_server(np, mi);
4158 * The caller should be holding mi->mi_recovlock, and it should continue to
4160 * mi->mi_recovlock is released, there is no guarantee that the returned
4161 * mi->nfs4_server_t will continue to correspond to mi.
4164 find_nfs4_server(mntinfo4_t *mi)
4166 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
4167 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
4169 return (lookup_nfs4_server(mi->mi_srv, 0));
4180 find_nfs4_server_all(mntinfo4_t *mi, int any_state)
4182 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
4183 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
4185 return (lookup_nfs4_server(mi->mi_srv, any_state));
4276 mntinfo4_t *mi;
4278 mi = VFTOMI4(args->fm_vfsp);
4281 MI4_RELE(mi);
4293 mntinfo4_t *mi = VFTOMI4(vfsp);
4316 * and recovery to finish before we remove the mi
4321 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, FALSE);
4322 sp = find_nfs4_server(mi);
4323 nfs_rw_exit(&mi->mi_recovlock);
4344 mutex_enter(&mi->mi_lock);
4345 while (mi->mi_in_recovery != 0) {
4351 cv_wait(&mi->mi_cv_in_recov, &mi->mi_lock);
4358 mutex_exit(&mi->mi_lock);
4373 if (!nfs4_ephemeral_umount(mi, flag, cr,
4375 nfs4_ephemeral_umount_activate(mi, &must_unlock,
4391 mutex_enter(&mi->mi_async_lock);
4392 mi->mi_max_threads = 0;
4393 NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
4394 mutex_exit(&mi->mi_async_lock);
4395 if (mi->mi_manager_thread)
4400 nfs4_remove_mi_from_server(mi, NULL);
4408 removed = nfs4_mi_zonelist_remove(mi);
4410 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);