/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 *

 * $Id: //eng/vdo-releases/aluminum/src/c++/vdo/base/vdoResume.c#3 $

 */

#include "vdoResume.h"

#include "logger.h"

#include "adminCompletion.h"

#include "blockMap.h"

#include "completion.h"

#include "logicalZone.h"

#include "recoveryJournal.h"

#include "slabDepot.h"

#include "slabSummary.h"

#include "threadConfig.h"

#include "vdoInternal.h"

typedef enum {

  RESUME_PHASE_START = 0,

  RESUME_PHASE_ALLOW_READ_ONLY_MODE,

  RESUME_PHASE_DEPOT,

  RESUME_PHASE_JOURNAL,

  RESUME_PHASE_BLOCK_MAP,

  RESUME_PHASE_LOGICAL_ZONES,

  RESUME_PHASE_PACKER,

  RESUME_PHASE_END,

} ResumePhase;

static const char *RESUME_PHASE_NAMES[] = {

  "RESUME_PHASE_START",

  "RESUME_PHASE_ALLOW_READ_ONLY_MODE",

  "RESUME_PHASE_DEPOT",

  "RESUME_PHASE_JOURNAL",

  "RESUME_PHASE_BLOCK_MAP",

  "RESUME_PHASE_LOGICAL_ZONES",

  "RESUME_PHASE_PACKER",

  "RESUME_PHASE_END",

};

/**

 * Implements ThreadIDGetterForPhase.

 **/

__attribute__((warn_unused_result))

static ThreadID getThreadIDForPhase(AdminCompletion *adminCompletion)

{

  const ThreadConfig *threadConfig

    = getThreadConfig(adminCompletion->completion.parent);

  switch (adminCompletion->phase) {

  case RESUME_PHASE_JOURNAL:

    return getJournalZoneThread(threadConfig);

  case RESUME_PHASE_PACKER:

    return getPackerZoneThread(threadConfig);

  default:

    return getAdminThread(threadConfig);

  }

}

/**

 * Update the VDO state and save the super block.

 *

 * @param vdo         The VDO being resumed

 * @param completion  The AdminCompletion's sub-task completion

 **/

static void writeSuperBlock(VDO *vdo, VDOCompletion *completion)

{

  switch (vdo->state) {

  case VDO_CLEAN:

  case VDO_NEW:

    vdo->state = VDO_DIRTY;

    saveVDOComponentsAsync(vdo, completion);

    return;

  case VDO_DIRTY:

  case VDO_READ_ONLY_MODE:

  case VDO_FORCE_REBUILD:

  case VDO_RECOVERING:

  case VDO_REBUILD_FOR_UPGRADE:

    // No need to write the super block in these cases

    completeCompletion(completion);

    return;

  case VDO_REPLAYING:

  default:

    finishCompletion(completion, UDS_BAD_STATE);

  }

}

/**

 * Callback to resume a VDO.

 *

 * @param completion  The sub-task completion

 **/

static void resumeCallback(VDOCompletion *completion)

{

  AdminCompletion *adminCompletion = adminCompletionFromSubTask(completion);

  assertAdminOperationType(adminCompletion, ADMIN_OPERATION_RESUME);

  assertAdminPhaseThread(adminCompletion, __func__, RESUME_PHASE_NAMES);

  VDO *vdo = adminCompletion->completion.parent;

  switch (adminCompletion->phase++) {

  case RESUME_PHASE_START:

    if (startResuming(&vdo->adminState, ADMIN_STATE_RESUMING,

                      &adminCompletion->completion, NULL)) {

      writeSuperBlock(vdo, completion);

    }

    return;

  case RESUME_PHASE_ALLOW_READ_ONLY_MODE:

    allowReadOnlyModeEntry(vdo->readOnlyNotifier,

                           resetAdminSubTask(completion));

    return;

  case RESUME_PHASE_DEPOT:

    resumeSlabDepot(vdo->depot, resetAdminSubTask(completion));

    return;

  case RESUME_PHASE_JOURNAL:

    resumeRecoveryJournal(vdo->recoveryJournal, resetAdminSubTask(completion));

    return;

  case RESUME_PHASE_BLOCK_MAP:

    resumeBlockMap(vdo->blockMap, resetAdminSubTask(completion));

    return;

  case RESUME_PHASE_LOGICAL_ZONES:

      resumeLogicalZones(vdo->logicalZones,resetAdminSubTask(completion));

      return;

  case RESUME_PHASE_PACKER:

    resumePacker(vdo->packer, resetAdminSubTask(completion));

    return;

  case RESUME_PHASE_END:

    break;

  default:

    setCompletionResult(resetAdminSubTask(completion), UDS_BAD_STATE);

  }

  finishResumingWithResult(&vdo->adminState, completion->result);

}

/**********************************************************************/

int performVDOResume(VDO *vdo)

{

  return performAdminOperation(vdo, ADMIN_OPERATION_RESUME,

                               getThreadIDForPhase, resumeCallback,

                               preserveErrorAndContinue);

}