Lines Matching refs:mi
755 mntinfo_t *mi;
765 mi = VTOMI(vp);
787 if ((mi->mi_flags & MI_NOAC) || (vp->v_flag & VNOCACHE))
792 if (delta < mi->mi_acdirmin)
793 delta = mi->mi_acdirmin;
794 else if (delta > mi->mi_acdirmax)
795 delta = mi->mi_acdirmax;
797 if (delta < mi->mi_acregmin)
798 delta = mi->mi_acregmin;
799 else if (delta > mi->mi_acregmax)
800 delta = mi->mi_acregmax;
862 mntinfo_t *mi;
866 mi = VTOMI(vp);
873 if (mi->mi_flags & MI_ACL) {
875 if (mi->mi_flags & MI_ACL)
883 error = rfs2call(mi, RFS_GETATTR,
1233 mntinfo_t *mi;
1236 mi = VFTOMI(vfsp);
1238 CALLB_CPR_INIT(&cprinfo, &mi->mi_async_lock, callb_generic_cpr,
1241 mutex_enter(&mi->mi_async_lock);
1250 max_threads = MAX(mi->mi_max_threads, 1);
1268 while (mi->mi_async_req_count > 0) {
1271 * (mi->mi_max_threads == 0), and the value was
1276 * mi->mi_max_threads, now non-zero) thinks we
1283 * mi->mi_max_threads are ignored for our
1287 if (mi->mi_threads[NFS_ASYNC_QUEUE] <
1288 MAX(mi->mi_max_threads, max_threads)) {
1289 mi->mi_threads[NFS_ASYNC_QUEUE]++;
1290 mutex_exit(&mi->mi_async_lock);
1294 mutex_enter(&mi->mi_async_lock);
1295 } else if (mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] <
1297 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE]++;
1298 mutex_exit(&mi->mi_async_lock);
1303 mutex_enter(&mi->mi_async_lock);
1305 NFS_WAKE_ASYNC_WORKER(mi->mi_async_work_cv);
1306 ASSERT(mi->mi_async_req_count != 0);
1307 mi->mi_async_req_count--;
1310 mutex_enter(&mi->mi_lock);
1311 if (mi->mi_flags & MI_ASYNC_MGR_STOP) {
1312 mutex_exit(&mi->mi_lock);
1315 mutex_exit(&mi->mi_lock);
1318 cv_wait(&mi->mi_async_reqs_cv, &mi->mi_async_lock);
1319 CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_async_lock);
1324 mi->mi_manager_thread = NULL;
1325 cv_broadcast(&mi->mi_async_cv);
1328 * There is no explicit call to mutex_exit(&mi->mi_async_lock)
1343 mntinfo_t *mi = VFTOMI(vfsp);
1345 mutex_enter(&mi->mi_async_lock);
1346 mutex_enter(&mi->mi_lock);
1347 mi->mi_flags |= MI_ASYNC_MGR_STOP;
1348 mutex_exit(&mi->mi_lock);
1349 cv_broadcast(&mi->mi_async_reqs_cv);
1350 while (mi->mi_manager_thread != NULL)
1351 cv_wait(&mi->mi_async_cv, &mi->mi_async_lock);
1352 mutex_exit(&mi->mi_async_lock);
1361 mntinfo_t *mi;
1367 mi = VTOMI(vp);
1410 mutex_enter(&mi->mi_async_lock);
1415 if (mi->mi_max_threads == 0) {
1416 mutex_exit(&mi->mi_async_lock);
1424 if (mi->mi_async_reqs[NFS_READ_AHEAD] == NULL) {
1425 mi->mi_async_reqs[NFS_READ_AHEAD] = args;
1426 mi->mi_async_tail[NFS_READ_AHEAD] = args;
1428 mi->mi_async_tail[NFS_READ_AHEAD]->a_next = args;
1429 mi->mi_async_tail[NFS_READ_AHEAD] = args;
1432 if (mi->mi_io_kstats) {
1433 mutex_enter(&mi->mi_lock);
1434 kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats));
1435 mutex_exit(&mi->mi_lock);
1438 mi->mi_async_req_count++;
1439 ASSERT(mi->mi_async_req_count != 0);
1440 cv_signal(&mi->mi_async_reqs_cv);
1441 mutex_exit(&mi->mi_async_lock);
1461 mntinfo_t *mi;
1470 mi = VTOMI(vp);
1495 mutex_enter(&mi->mi_async_lock);
1503 if (mi->mi_max_threads == 0) {
1504 mutex_exit(&mi->mi_async_lock);
1512 if (mi->mi_async_reqs[NFS_PUTAPAGE] == NULL) {
1513 mi->mi_async_reqs[NFS_PUTAPAGE] = args;
1514 mi->mi_async_tail[NFS_PUTAPAGE] = args;
1516 mi->mi_async_tail[NFS_PUTAPAGE]->a_next = args;
1517 mi->mi_async_tail[NFS_PUTAPAGE] = args;
1525 if (mi->mi_io_kstats) {
1526 mutex_enter(&mi->mi_lock);
1527 kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats));
1528 mutex_exit(&mi->mi_lock);
1531 mi->mi_async_req_count++;
1532 ASSERT(mi->mi_async_req_count != 0);
1533 cv_signal(&mi->mi_async_reqs_cv);
1534 mutex_exit(&mi->mi_async_lock);
1562 if (nfs_zone() != mi->mi_zone) {
1583 mntinfo_t *mi;
1592 mi = VTOMI(vp);
1617 mutex_enter(&mi->mi_async_lock);
1625 if (mi->mi_max_threads == 0) {
1626 mutex_exit(&mi->mi_async_lock);
1634 if (mi->mi_async_reqs[NFS_PAGEIO] == NULL) {
1635 mi->mi_async_reqs[NFS_PAGEIO] = args;
1636 mi->mi_async_tail[NFS_PAGEIO] = args;
1638 mi->mi_async_tail[NFS_PAGEIO]->a_next = args;
1639 mi->mi_async_tail[NFS_PAGEIO] = args;
1647 if (mi->mi_io_kstats) {
1648 mutex_enter(&mi->mi_lock);
1649 kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats));
1650 mutex_exit(&mi->mi_lock);
1653 mi->mi_async_req_count++;
1654 ASSERT(mi->mi_async_req_count != 0);
1655 cv_signal(&mi->mi_async_reqs_cv);
1656 mutex_exit(&mi->mi_async_lock);
1695 if (nfs_zone() != mi->mi_zone) {
1715 mntinfo_t *mi;
1721 mi = VTOMI(vp);
1743 mutex_enter(&mi->mi_async_lock);
1748 if (mi->mi_max_threads == 0) {
1749 mutex_exit(&mi->mi_async_lock);
1757 if (mi->mi_async_reqs[NFS_READDIR] == NULL) {
1758 mi->mi_async_reqs[NFS_READDIR] = args;
1759 mi->mi_async_tail[NFS_READDIR] = args;
1761 mi->mi_async_tail[NFS_READDIR]->a_next = args;
1762 mi->mi_async_tail[NFS_READDIR] = args;
1769 if (mi->mi_io_kstats) {
1770 mutex_enter(&mi->mi_lock);
1771 kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats));
1772 mutex_exit(&mi->mi_lock);
1775 mi->mi_async_req_count++;
1776 ASSERT(mi->mi_async_req_count != 0);
1777 cv_signal(&mi->mi_async_reqs_cv);
1778 mutex_exit(&mi->mi_async_lock);
1813 mntinfo_t *mi;
1818 mi = VTOMI(vp);
1842 mutex_enter(&mi->mi_async_lock);
1850 if (mi->mi_max_threads == 0) {
1851 mutex_exit(&mi->mi_async_lock);
1859 if (mi->mi_async_reqs[NFS_COMMIT] == NULL) {
1860 mi->mi_async_reqs[NFS_COMMIT] = args;
1861 mi->mi_async_tail[NFS_COMMIT] = args;
1863 mi->mi_async_tail[NFS_COMMIT]->a_next = args;
1864 mi->mi_async_tail[NFS_COMMIT] = args;
1871 if (mi->mi_io_kstats) {
1872 mutex_enter(&mi->mi_lock);
1873 kstat_waitq_enter(KSTAT_IO_PTR(mi->mi_io_kstats));
1874 mutex_exit(&mi->mi_lock);
1877 mi->mi_async_req_count++;
1878 ASSERT(mi->mi_async_req_count != 0);
1879 cv_signal(&mi->mi_async_reqs_cv);
1880 mutex_exit(&mi->mi_async_lock);
1891 nfs_zone() != mi->mi_zone) {
1907 mntinfo_t *mi;
1910 mi = VTOMI(vp);
1925 * Note that we don't check mi->mi_max_threads here, since we
1932 mutex_enter(&mi->mi_async_lock);
1933 if (mi->mi_manager_thread == NULL) {
1936 mutex_exit(&mi->mi_async_lock);
1975 if (mi->mi_async_reqs[NFS_INACTIVE] == NULL) {
1976 mi->mi_async_reqs[NFS_INACTIVE] = args;
1978 mi->mi_async_tail[NFS_INACTIVE]->a_next = args;
1980 mi->mi_async_tail[NFS_INACTIVE] = args;
1985 mi->mi_async_req_count++;
1986 ASSERT(mi->mi_async_req_count != 0);
1987 cv_signal(&mi->mi_async_reqs_cv);
1988 mutex_exit(&mi->mi_async_lock);
2022 mntinfo_t *mi = VFTOMI(vfsp);
2031 async_work_cv = &mi->mi_async_work_cv[NFS_ASYNC_QUEUE];
2034 async_work_cv = &mi->mi_async_work_cv[NFS_ASYNC_PGOPS_QUEUE];
2044 CALLB_CPR_INIT(&cprinfo, &mi->mi_async_lock, callb_generic_cpr, "nas");
2046 mutex_enter(&mi->mi_async_lock);
2055 args = *mi->mi_async_curr[async_queue];
2058 mi->mi_async_curr[async_queue]++;
2059 if (mi->mi_async_curr[async_queue] ==
2060 &mi->mi_async_reqs[async_types]) {
2061 mi->mi_async_curr[async_queue] =
2062 &mi->mi_async_reqs[0];
2082 if (mi->mi_max_threads == 0 || time_left <= 0) {
2083 --mi->mi_threads[async_queue];
2085 if (mi->mi_threads[NFS_ASYNC_QUEUE] == 0 &&
2086 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] == 0)
2087 cv_signal(&mi->mi_async_cv);
2094 &mi->mi_async_lock, nfs_async_timeout,
2097 CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_async_lock);
2111 *mi->mi_async_curr[async_queue] = args->a_next;
2112 if (*mi->mi_async_curr[async_queue] == NULL ||
2113 --mi->mi_async_clusters[args->a_io] == 0) {
2114 mi->mi_async_clusters[args->a_io] =
2115 mi->mi_async_init_clusters;
2116 mi->mi_async_curr[async_queue]++;
2117 if (mi->mi_async_curr[async_queue] ==
2118 &mi->mi_async_reqs[async_types]) {
2119 mi->mi_async_curr[async_queue] =
2120 &mi->mi_async_reqs[0];
2124 if (args->a_io != NFS_INACTIVE && mi->mi_io_kstats) {
2125 mutex_enter(&mi->mi_lock);
2126 kstat_waitq_exit(KSTAT_IO_PTR(mi->mi_io_kstats));
2127 mutex_exit(&mi->mi_lock);
2130 mutex_exit(&mi->mi_async_lock);
2135 if (args->a_io == NFS_READ_AHEAD && mi->mi_max_threads > 0) {
2168 mutex_enter(&mi->mi_async_lock);
2175 mntinfo_t *mi = VFTOMI(vfsp);
2181 mutex_enter(&mi->mi_async_lock);
2182 mi->mi_max_threads = 0;
2183 NFS_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
2184 while (mi->mi_threads[NFS_ASYNC_QUEUE] != 0 ||
2185 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] != 0)
2186 cv_wait(&mi->mi_async_cv, &mi->mi_async_lock);
2187 mutex_exit(&mi->mi_async_lock);
2200 mntinfo_t *mi = VFTOMI(vfsp);
2208 mutex_enter(&mi->mi_async_lock);
2209 omax = mi->mi_max_threads;
2210 mi->mi_max_threads = 0;
2214 NFS_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
2215 while (mi->mi_threads[NFS_ASYNC_QUEUE] != 0 ||
2216 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] != 0) {
2217 if (!cv_wait_sig(&mi->mi_async_cv, &mi->mi_async_lock))
2220 rval = (mi->mi_threads[NFS_ASYNC_QUEUE] != 0 ||
2221 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] != 0); /* Interrupted */
2223 mi->mi_max_threads = omax;
2224 mutex_exit(&mi->mi_async_lock);
2602 mntinfo_t *mi;
2605 mi = VTOMI(vp);
2610 if (FS_OR_ZONE_GONE(mi->mi_vfsp))
2619 now - mi->mi_printftime > 0) {
2620 zoneid_t zoneid = mi->mi_zone->zone_id;
2624 mi->mi_vers, VTOR(vp)->r_server->sv_hostname, NULL);
2639 mi->mi_printftime = now +
2676 mntinfo_t *mi;
2681 for (mi = list_head(&mig->mig_list); mi != NULL;
2682 mi = list_next(&mig->mig_list, mi)) {
2688 if (mi->mi_flags & MI_DEAD)
2694 VFS_HOLD(mi->mi_vfsp);
2699 (void) dnlc_purge_vfsp(mi->mi_vfsp, 0);
2701 mutex_enter(&mi->mi_async_lock);
2705 mi->mi_max_threads = 0;
2706 NFS_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
2712 mutex_enter(&mi->mi_lock);
2713 mi->mi_flags |= (MI_ASYNC_MGR_STOP|MI_DEAD);
2714 mutex_exit(&mi->mi_lock);
2718 cv_broadcast(&mi->mi_async_reqs_cv);
2719 mutex_exit(&mi->mi_async_lock);
2723 * We're done when every mi has been done or the list is empty.
2726 VFS_RELE(mi->mi_vfsp);
2762 nfs_mi_zonelist_add(mntinfo_t *mi)
2766 mig = zone_getspecific(mi_list_key, mi->mi_zone);
2768 list_insert_head(&mig->mig_list, mi);
2776 nfs_mi_zonelist_remove(mntinfo_t *mi)
2780 mig = zone_getspecific(mi_list_key, mi->mi_zone);
2782 list_remove(&mig->mig_list, mi);
2786 * mi globals.
3208 nfs_free_mi(mntinfo_t *mi)
3210 ASSERT(mi->mi_flags & MI_ASYNC_MGR_STOP);
3211 ASSERT(mi->mi_manager_thread == NULL);
3212 ASSERT(mi->mi_threads[NFS_ASYNC_QUEUE] == 0 &&
3213 mi->mi_threads[NFS_ASYNC_PGOPS_QUEUE] == 0);
3218 nfs_mi_zonelist_remove(mi);
3219 if (mi->mi_klmconfig) {
3220 lm_free_config(mi->mi_klmconfig);
3221 kmem_free(mi->mi_klmconfig, sizeof (struct knetconfig));
3223 mutex_destroy(&mi->mi_lock);
3224 mutex_destroy(&mi->mi_remap_lock);
3225 mutex_destroy(&mi->mi_async_lock);
3226 cv_destroy(&mi->mi_failover_cv);
3227 cv_destroy(&mi->mi_async_work_cv[NFS_ASYNC_QUEUE]);
3228 cv_destroy(&mi->mi_async_work_cv[NFS_ASYNC_PGOPS_QUEUE]);
3229 cv_destroy(&mi->mi_async_reqs_cv);
3230 cv_destroy(&mi->mi_async_cv);
3231 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFS);
3232 kmem_free(mi, sizeof (*mi));
3238 mntinfo_t *mi;
3255 mi = VFTOMI(vfsp);
3259 (void) strcpy(mik->mik_proto, mi->mi_curr_serv->sv_knconf->knc_proto);
3260 mik->mik_vers = (uint32_t)mi->mi_vers;
3261 mik->mik_flags = mi->mi_flags;
3262 mik->mik_secmod = mi->mi_curr_serv->sv_secdata->secmod;
3263 mik->mik_curread = (uint32_t)mi->mi_curread;
3264 mik->mik_curwrite = (uint32_t)mi->mi_curwrite;
3265 mik->mik_retrans = mi->mi_retrans;
3266 mik->mik_timeo = mi->mi_timeo;
3267 mik->mik_acregmin = HR2SEC(mi->mi_acregmin);
3268 mik->mik_acregmax = HR2SEC(mi->mi_acregmax);
3269 mik->mik_acdirmin = HR2SEC(mi->mi_acdirmin);
3270 mik->mik_acdirmax = HR2SEC(mi->mi_acdirmax);
3272 mik->mik_timers[i].srtt = (uint32_t)mi->mi_timers[i].rt_srtt;
3274 (uint32_t)mi->mi_timers[i].rt_deviate;
3276 (uint32_t)mi->mi_timers[i].rt_rtxcur;
3278 mik->mik_noresponse = (uint32_t)mi->mi_noresponse;
3279 mik->mik_failover = (uint32_t)mi->mi_failover;
3280 mik->mik_remap = (uint32_t)mi->mi_remap;
3281 (void) strcpy(mik->mik_curserver, mi->mi_curr_serv->sv_hostname);
3289 mntinfo_t *mi = VFTOMI(vfsp);
3304 mi->mi_io_kstats = kstat_create_zone("nfs", getminor(vfsp->vfs_dev),
3305 NULL, "nfs", KSTAT_TYPE_IO, 1, 0, mi->mi_zone->zone_id);
3306 if (mi->mi_io_kstats) {
3307 if (mi->mi_zone->zone_id != GLOBAL_ZONEID)
3308 kstat_zone_add(mi->mi_io_kstats, GLOBAL_ZONEID);
3309 mi->mi_io_kstats->ks_lock = &mi->mi_lock;
3310 kstat_install(mi->mi_io_kstats);
3313 if ((mi->mi_ro_kstats = kstat_create_zone("nfs",
3315 sizeof (struct mntinfo_kstat), 0, mi->mi_zone->zone_id)) != NULL) {
3316 if (mi->mi_zone->zone_id != GLOBAL_ZONEID)
3317 kstat_zone_add(mi->mi_ro_kstats, GLOBAL_ZONEID);
3318 mi->mi_ro_kstats->ks_update = mnt_kstat_update;
3319 mi->mi_ro_kstats->ks_private = (void *)vfsp;
3320 kstat_install(mi->mi_ro_kstats);