/*
 * 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/statusCodes.c#3 $
 */

#include "statusCodes.h"

#include "errors.h"
#include "permassert.h"
#include "threadOnce.h"

const struct errorInfo vdoStatusList[] = {
  { "VDO_NOT_IMPLEMENTED",       "Not implemented"                           },
  { "VDO_OUT_OF_RANGE",          "Out of range"                              },
  { "VDO_REF_COUNT_INVALID",     "Reference count would become invalid"      },
  { "VDO_NO_SPACE",              "Out of space"                              },
  { "VDO_UNEXPECTED_EOF",        "Unexpected EOF on block read"              },
  { "VDO_BAD_CONFIGURATION",     "Bad configuration option"                  },
  { "VDO_SOCKET_ERROR",          "Socket error"                              },
  { "VDO_BAD_ALIGNMENT",         "Mis-aligned block reference"               },
  { "VDO_COMPONENT_BUSY",        "Prior operation still in progress"         },
  { "VDO_BAD_PAGE",              "Corrupt or incorrect page"                 },
  { "VDO_UNSUPPORTED_VERSION",   "Unsupported component version"             },
  { "VDO_INCORRECT_COMPONENT",   "Component id mismatch in decoder"          },
  { "VDO_PARAMETER_MISMATCH",    "Parameters have conflicting values"        },
  { "VDO_BLOCK_SIZE_TOO_SMALL",  "The block size is too small"               },
  { "VDO_UNKNOWN_PARTITION",     "No partition exists with a given id"       },
  { "VDO_PARTITION_EXISTS",      "A partition already exists with a given id"},
  { "VDO_NOT_READ_ONLY",         "The device is not in read-only mode"       },
  { "VDO_INCREMENT_TOO_SMALL",   "Physical block growth of too few blocks"   },
  { "VDO_CHECKSUM_MISMATCH",     "Incorrect checksum"                        },
  { "VDO_RECOVERY_JOURNAL_FULL", "The recovery journal is full"              },
  { "VDO_LOCK_ERROR",            "A lock is held incorrectly"                },
  { "VDO_READ_ONLY",             "The device is in read-only mode"           },
  { "VDO_SHUTTING_DOWN",         "The device is shutting down"               },
  { "VDO_CORRUPT_JOURNAL",       "Recovery journal entries corrupted"        },
  { "VDO_TOO_MANY_SLABS",        "Exceeds maximum number of slabs supported" },
  { "VDO_INVALID_FRAGMENT",      "Compressed block fragment is invalid"      },
  { "VDO_RETRY_AFTER_REBUILD",   "Retry operation after rebuilding finishes" },
  { "VDO_UNKNOWN_COMMAND",       "The extended command is not known"         },
  { "VDO_COMMAND_ERROR",         "Bad extended command parameters"           },
  { "VDO_CANNOT_DETERMINE_SIZE", "Cannot determine config sizes to fit"      },
  { "VDO_BAD_MAPPING",           "Invalid page mapping"                      },
  { "VDO_READ_CACHE_BUSY",       "Read cache has no free slots"              },
  { "VDO_BIO_CREATION_FAILED",   "Bio creation failed"                       },
  { "VDO_BAD_MAGIC",             "Bad magic number"                          },
  { "VDO_BAD_NONCE",             "Bad nonce"                                 },
  { "VDO_JOURNAL_OVERFLOW",      "Journal sequence number overflow"          },
  { "VDO_INVALID_ADMIN_STATE",   "Invalid operation for current state"       },
};

#ifndef __KERNEL__
static OnceState vdoStatusCodesRegistered = ONCE_STATE_INITIALIZER;
static int       statusCodeRegistrationResult;

/**********************************************************************/
static void doStatusCodeRegistration(void)
{
  STATIC_ASSERT((VDO_STATUS_CODE_LAST - VDO_STATUS_CODE_BASE)
                == COUNT_OF(vdoStatusList));

  int result = registerErrorBlock("VDO Status",
                                  VDO_STATUS_CODE_BASE,
                                  VDO_STATUS_CODE_BLOCK_END,
                                  vdoStatusList,
                                  sizeof(vdoStatusList));
  /*
   *  The following test handles cases where libvdo is statically linked
   *  against both the test modules and the test driver (because multiple
   *  instances of this module call their own copy of this function
   *  once each, resulting in multiple calls to registerErrorBlock which
   *  is shared in libuds).
   */
  if (result == UDS_DUPLICATE_NAME) {
    result = UDS_SUCCESS;
  }

  statusCodeRegistrationResult
    = (result == UDS_SUCCESS) ? VDO_SUCCESS : result;
}
#endif

/**********************************************************************/
int registerStatusCodes(void)
{
#ifdef __KERNEL__
  return VDO_SUCCESS;
#else
  performOnce(&vdoStatusCodesRegistered, doStatusCodeRegistration);
  return statusCodeRegistrationResult;
#endif
}