Lines Matching refs:recovery
509 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1476 /* active but not in sync implies recovery up to
2060 &mddev->recovery))
2569 /* May as well allow recovery to be retried once */
2765 * curr_resync_completed can only be used during recovery.
2772 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
2773 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
2774 !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
2822 * then a recovery will happen and soon that array won't
2903 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2941 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2942 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3088 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3119 * check if recovery is needed.
3125 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3254 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3264 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
3348 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4015 * - array is not engaged in resync/recovery/reshape
4021 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4368 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4874 unsigned long recovery = mddev->recovery;
4875 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4877 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4878 (md_is_rdwr(mddev) && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4879 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4881 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4882 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4884 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4888 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4912 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
4920 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4930 !test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4941 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4950 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4959 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4960 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4969 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4983 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5005 else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5008 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5010 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5011 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5018 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
5023 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5032 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5041 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
5044 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5045 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
5046 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5056 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5198 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5205 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
5206 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5239 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5282 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6131 mddev->recovery = 0;
6241 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
6242 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6306 set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6308 clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6349 /* Kick recovery or resync if necessary */
6350 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6397 mddev->recovery = 0;
6439 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6474 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6503 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6505 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6513 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6531 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6532 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6549 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6551 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6557 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6560 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6561 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7178 * Kick recovery, maybe this spare has to be added to the
7181 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7197 if (mddev->recovery || mddev->sync_thread)
7395 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
7431 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7432 test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||
7529 if (mddev->recovery || mddev->sync_thread) {
7746 /* need to ensure recovery thread has run */
7749 &mddev->recovery),
7840 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8153 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8155 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8157 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8206 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8207 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8214 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
8233 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
8287 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
8289 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
8291 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
8292 "resync" : "recovery"))),
8629 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8630 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
8632 // stop recovery, signal do_sync ....
8656 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8859 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
8862 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8865 if (test_bit(MD_RECOVERY_WAIT, &mddev->recovery) ||
8867 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8877 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8878 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
8879 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
8885 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8886 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
8889 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8894 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8897 desc = "recovery";
8916 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8945 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8968 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8975 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8980 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
8991 /* recovery follows the physical size of devices */
9006 * complete before we start doing a recovery.
9009 * recovery has checked that bit and skipped that
9061 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9074 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
9083 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9092 &mddev->recovery));
9095 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9100 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
9109 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9141 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9174 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
9182 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9183 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9190 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
9192 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
9193 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9198 &mddev->recovery))
9208 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9210 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9211 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
9232 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9233 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9247 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9249 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9252 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9254 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
9355 if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
9407 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9408 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9419 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9420 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9421 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9423 /* Start new recovery. */
9424 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9428 /* Check if recovery is in progress. */
9430 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9431 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9436 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
9486 name = test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ?
9512 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9513 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9514 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9515 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9516 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9528 if (test_and_clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
9535 if (!test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9536 /* resync/recovery still happening */
9537 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9551 * need this as they never do any recovery or update the superblock.
9556 * "->recovery" and create a thread at ->sync_thread.
9563 * 2/ If a recovery thread is running, don't do anything else.
9564 * 3/ If recovery has finished, clean up, possibly marking spares active.
9584 !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) &&
9585 !test_bit(MD_RECOVERY_DONE, &mddev->recovery))
9589 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9590 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
9606 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
9625 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
9633 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9637 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9638 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9669 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
9679 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9684 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
9685 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9687 if (test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) &&
9688 !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
9691 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9712 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9713 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
9722 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9742 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9743 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9744 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9745 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9746 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9747 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9756 /* flag recovery needed just to double check */
9757 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9978 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9983 * as faulty. The recovery is performed by the
10004 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
10015 } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
10063 /* The other node finished recovery, call spare_active to set