Lines Matching defs:activity
3507 * Determine whether the activity check is required.
3533 * Disable the MMP activity check - This is used by zdb which
3540 * Skip the activity check when the MMP feature is disabled.
3558 * Allow the activity check to be skipped when importing the pool
3569 * Skip the activity test when the pool was cleanly exported.
3578 * Nanoseconds the activity check must watch for changes on-disk.
3655 * Remote host activity check.
3658 * 0 - no activity detected
3659 * EREMOTEIO - remote activity detected
3683 * If ZPOOL_CONFIG_MMP_TXG is present an activity check was performed
3710 spa_import_progress_set_notes(spa, "Checking MMP activity, "
3718 "activity, %llu ms remaining",
3731 zfs_dbgmsg("multihost activity detected "
3856 * Perform an activity check looking for any remote writer
7117 * we stop all initialization and trim activity here before
8526 * Temporarily stop the initializing and TRIM activity. We set the
10639 * Notify any waiting threads that some activity has switched from being in-
10673 spa_vdev_activity_in_progress_impl(vdev_t *vd, zpool_wait_activity_t activity)
10679 ASSERT(activity == ZPOOL_WAIT_INITIALIZE ||
10680 activity == ZPOOL_WAIT_TRIM);
10682 kmutex_t *lock = activity == ZPOOL_WAIT_INITIALIZE ?
10689 boolean_t in_progress = (activity == ZPOOL_WAIT_INITIALIZE) ?
10699 activity))
10714 zpool_wait_activity_t activity, boolean_t *in_progress)
10731 *in_progress = spa_vdev_activity_in_progress_impl(vd, activity);
10741 * Waiting threads need a way to check whether a given activity is in progress,
10742 * and then, if it is, wait for it to complete. Each activity will have some
10744 * determine whether or not the activity is in progress. The in-memory state and
10745 * the locking used to protect it will be different for each activity, and may
10750 * When the state is checked, both the activity-specific lock (if there is one)
10751 * and spa_activities_lock are held. In some cases, the activity-specific lock
10754 * thread releases the activity-specific lock and, if the activity is in
10758 * activity, updates the state of the activity and then calls
10760 * needs to hold its activity-specific lock when updating the state, and this
10765 * activity, it can never be the case that the completing thread both updates
10766 * the activity state and cv_broadcasts in between the waiting thread's check
10771 * activity-specific lock. The order in which spa_activities_lock and the
10772 * activity specific lock are acquired in the waiting thread is determined by
10774 * completing thread calls spa_notify_waiters with the activity-specific lock
10775 * held, then the waiting thread must also acquire the activity-specific lock
10780 spa_activity_in_progress(spa_t *spa, zpool_wait_activity_t activity,
10787 switch (activity) {
10804 activity, in_progress);
10832 is_scrub == (activity == ZPOOL_WAIT_SCRUB));
10842 panic("unrecognized value for activity %d", activity);
10849 spa_wait_common(const char *pool, zpool_wait_activity_t activity,
10853 * The tag is used to distinguish between instances of an activity.
10862 if (use_tag && activity != ZPOOL_WAIT_INITIALIZE &&
10863 activity != ZPOOL_WAIT_TRIM)
10866 if (activity < 0 || activity >= ZPOOL_WAIT_NUM_ACTIVITIES)
10889 error = spa_activity_in_progress(spa, activity, use_tag, tag,
10912 * Wait for a particular instance of the specified activity to complete, where
10916 spa_wait_tag(const char *pool, zpool_wait_activity_t activity, uint64_t tag,
10919 return (spa_wait_common(pool, activity, B_TRUE, tag, waited));
10923 * Wait for all instances of the specified activity complete
10926 spa_wait(const char *pool, zpool_wait_activity_t activity, boolean_t *waited)
10929 return (spa_wait_common(pool, activity, B_FALSE, 0, waited));