/*

 * 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/vdoSuspend.c#4 $

 */

#include "vdoSuspend.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 {

  SUSPEND_PHASE_START = 0,

  SUSPEND_PHASE_PACKER,

  SUSPEND_PHASE_LOGICAL_ZONES,

  SUSPEND_PHASE_BLOCK_MAP,

  SUSPEND_PHASE_JOURNAL,

  SUSPEND_PHASE_DEPOT,

  SUSPEND_PHASE_WRITE_SUPER_BLOCK,

  SUSPEND_PHASE_END,

} SuspendPhase;

static const char *SUSPEND_PHASE_NAMES[] = {

  "SUSPEND_PHASE_START",

  "SUSPEND_PHASE_PACKER",

  "SUSPEND_PHASE_LOGICAL_ZONES",

  "SUSPEND_PHASE_BLOCK_MAP",

  "SUSPEND_PHASE_JOURNAL",

  "SUSPEND_PHASE_DEPOT",

  "SUSPEND_PHASE_WRITE_SUPER_BLOCK",

  "SUSPEND_PHASE_END",

};

/**

 * Implements ThreadIDGetterForPhase.

 **/

__attribute__((warn_unused_result))

static ThreadID getThreadIDForPhase(AdminCompletion *adminCompletion)

{

  const ThreadConfig *threadConfig

    = getThreadConfig(adminCompletion->completion.parent);

  switch (adminCompletion->phase) {

  case SUSPEND_PHASE_PACKER:

    return getPackerZoneThread(threadConfig);

  case SUSPEND_PHASE_JOURNAL:

    return getJournalZoneThread(threadConfig);

  default:

    return getAdminThread(threadConfig);

  }

}

/**

 * Update the VDO state and save the super block.

 *

 * @param vdo         The VDO being suspended

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

 **/

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

{

  switch (vdo->state) {

  case VDO_DIRTY:

  case VDO_NEW:

    vdo->state = VDO_CLEAN;

    break;

  case VDO_CLEAN:

  case VDO_READ_ONLY_MODE:

  case VDO_FORCE_REBUILD:

  case VDO_RECOVERING:

  case VDO_REBUILD_FOR_UPGRADE:

    break;

  case VDO_REPLAYING:

  default:

    finishCompletion(completion, UDS_BAD_STATE);

    return;

  }

  saveVDOComponentsAsync(vdo, completion);

}

/**

 * Callback to initiate a suspend, registered in performVDOSuspend().

 *

 * @param completion  The sub-task completion

 **/

static void suspendCallback(VDOCompletion *completion)

{

  AdminCompletion *adminCompletion = adminCompletionFromSubTask(completion);

  ASSERT_LOG_ONLY(((adminCompletion->type == ADMIN_OPERATION_SUSPEND)

                   || (adminCompletion->type == ADMIN_OPERATION_SAVE)),

                  "unexpected admin operation type %u is neither "

                  "suspend nor save", adminCompletion->type);

  assertAdminPhaseThread(adminCompletion, __func__, SUSPEND_PHASE_NAMES);

  VDO *vdo = adminCompletion->completion.parent;

  switch (adminCompletion->phase++) {

  case SUSPEND_PHASE_START:

    if (!startDraining(&vdo->adminState,

                       ((adminCompletion->type == ADMIN_OPERATION_SUSPEND)

                        ? ADMIN_STATE_SUSPENDING : ADMIN_STATE_SAVING),

                       &adminCompletion->completion, NULL)) {

      return;

    }

    if (!vdo->closeRequired) {

      // There's nothing to do.

      break;

    }

    waitUntilNotEnteringReadOnlyMode(vdo->readOnlyNotifier,

                                     resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_PACKER:

    /*

     * If the VDO was already resumed from a prior suspend while read-only,

     * some of the components may not have been resumed. By setting a read-only

     * error here, we guarantee that the result of this suspend will be

     * VDO_READ_ONLY and not VDO_INVALID_ADMIN_STATE in that case.

     */

    if (inReadOnlyMode(vdo)) {

      setCompletionResult(&adminCompletion->completion, VDO_READ_ONLY);

    }

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

    return;

  case SUSPEND_PHASE_LOGICAL_ZONES:

    drainLogicalZones(vdo->logicalZones, vdo->adminState.state,

                      resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_BLOCK_MAP:

    drainBlockMap(vdo->blockMap, vdo->adminState.state,

                  resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_JOURNAL:

    drainRecoveryJournal(vdo->recoveryJournal, vdo->adminState.state,

                         resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_DEPOT:

    drainSlabDepot(vdo->depot, vdo->adminState.state,

                   resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_WRITE_SUPER_BLOCK:

    if (isSuspending(&vdo->adminState)

        || (adminCompletion->completion.result != VDO_SUCCESS)) {

      // If we didn't save the VDO or there was an error, we're done.

      break;

    }

    writeSuperBlock(vdo, resetAdminSubTask(completion));

    return;

  case SUSPEND_PHASE_END:

    break;

  default:

    setCompletionResult(completion, UDS_BAD_STATE);

  }

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

}

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

int performVDOSuspend(VDO *vdo, bool save)

{

  return performAdminOperation(vdo, (save

                                     ? ADMIN_OPERATION_SAVE

                                     : ADMIN_OPERATION_SUSPEND),

                               getThreadIDForPhase, suspendCallback,

                               preserveErrorAndContinue);

}