Lines Matching defs:recovery
531 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1420 /* active but not in sync implies recovery up to
2013 &mddev->recovery))
2515 /* May as well allow recovery to be retried once */
2750 * curr_resync_completed can only be used during recovery.
2757 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
2758 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
2759 !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
2807 * then a recovery will happen and soon that array won't
2895 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2937 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2938 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3086 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3118 * check if recovery is needed.
3124 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3254 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3265 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
3350 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
4000 * - array is not engaged in resync/recovery/reshape
4007 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4357 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4859 unsigned long recovery = mddev->recovery;
4860 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4862 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4863 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4864 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4866 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4867 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4869 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4873 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4890 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4892 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4893 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4898 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4903 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4906 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4908 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4909 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4916 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
4921 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4930 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4939 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4942 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4943 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4944 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4953 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5095 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5102 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
5103 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5136 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5180 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6001 mddev->recovery = 0;
6105 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
6106 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6169 set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6172 clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6213 /* Kick recovery or resync if necessary */
6214 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6254 mddev->recovery = 0;
6272 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6276 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6337 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6360 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6362 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6365 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6366 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6376 &mddev->recovery));
6384 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6387 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6388 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6402 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6403 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6424 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6426 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6429 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6430 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6439 &mddev->recovery)));
6446 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6450 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6451 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7072 * Kick recovery, maybe this spare has to be added to the
7075 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7092 if (mddev->recovery || mddev->sync_thread)
7285 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7324 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7325 test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||
7422 if (mddev->recovery || mddev->sync_thread) {
7623 /* need to ensure recovery thread has run */
7626 &mddev->recovery),
7777 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8049 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8051 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8052 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8089 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8090 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8097 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
8106 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
8160 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
8162 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
8164 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
8165 "resync" : "recovery"))),
8543 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8544 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
8546 // stop recovery, signal do_sync ....
8569 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8697 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8698 test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
8701 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8711 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8712 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
8713 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
8719 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8720 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
8723 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8728 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8731 desc = "recovery";
8756 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8780 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8801 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8808 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8813 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
8824 /* recovery follows the physical size of devices */
8839 * complete before we start doing a recovery.
8842 * recovery has checked that bit and skipped that
8894 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8907 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8916 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8925 &mddev->recovery));
8928 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8933 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8942 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8974 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9007 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
9015 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9016 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9023 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
9025 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
9026 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9031 &mddev->recovery))
9041 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9043 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9044 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
9065 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9066 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9081 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9083 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9086 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9088 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
9106 if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
9202 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9203 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9204 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9205 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9206 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9209 &mddev->recovery))
9222 * need this as they never do any recovery or update the superblock.
9227 * "->recovery" and create a thread at ->sync_thread.
9234 * 2/ If a recovery thread is running, don't do anything else.
9235 * 3/ If recovery has finished, clean up, possibly marking spares active.
9269 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
9273 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9274 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
9309 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
9311 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9312 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9338 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
9339 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9340 /* resync/recovery still happening */
9341 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9353 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9358 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
9359 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9361 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9362 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
9364 /* no recovery is running.
9376 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9377 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9379 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9380 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9381 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9382 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9384 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9385 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9386 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
9404 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9407 &mddev->recovery))
9426 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9427 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
9436 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9456 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9457 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9458 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9459 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9460 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9461 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9471 /* flag recovery needed just to double check */
9472 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9687 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9692 * as faulty. The recovery is performed by the
9712 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9723 } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9771 /* The other node finished recovery, call spare_active to set