fsal_tools.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "fsal.h"
#include "fsal_internal.h"
#include "fsal_convert.h"
#include "config_parsing.h"
#include <string.h>

/* case unsensitivity */
#define STRCMP   strcasecmp

char *POSIXFSAL_GetFSName()
{
  return "POSIX";
}

int POSIXFSAL_handlecmp(fsal_handle_t * hdl1, fsal_handle_t * hdl2,
                        fsal_status_t * status)
{
  posixfsal_handle_t * handle1 = (posixfsal_handle_t *) hdl1;
  posixfsal_handle_t * handle2 = (posixfsal_handle_t *) hdl2;
  *status = FSAL_STATUS_NO_ERROR;

  if(!handle1 || !handle2)
    {
      status->major = ERR_FSAL_FAULT;
      return -1;
    }

  return (handle1->data.id != handle2->data.id) || (handle1->data.ts != handle2->data.ts);

}

unsigned int POSIXFSAL_Handle_to_HashIndex(fsal_handle_t * handle,
                                           unsigned int cookie,
                                           unsigned int alphabet_len,
                                           unsigned int index_size)
{
  posixfsal_handle_t * p_handle = (posixfsal_handle_t *) handle;
  unsigned int h;
  h = (cookie * alphabet_len + ((unsigned int)p_handle->data.id ^ (unsigned int)p_handle->data.ts));
  return (3 * h + 1999) % index_size;
}

/*
 * FSAL_Handle_to_RBTIndex
 * This function is used for generating a RBT node ID
 * in order to identify entries into the RBT.
 *
 * \param p_handle      The handle to be hashed
 * \param cookie        Makes it possible to have different hash value for the
 *                      same handle, when cookie changes.
 *
 * \return The hash value
 */

unsigned int POSIXFSAL_Handle_to_RBTIndex(fsal_handle_t * handle,
                                          unsigned int cookie)
{
#define MAGIC   0xABCD1234
  posixfsal_handle_t * p_handle = (posixfsal_handle_t *) handle;
  unsigned int h;

  h = (cookie ^ (unsigned int)p_handle->data.id ^ (unsigned int)p_handle->data.ts ^ MAGIC);
  return h;
}

fsal_status_t POSIXFSAL_DigestHandle(fsal_export_context_t * expcontext, /* IN */
                                     fsal_digesttype_t output_type,     /* IN */
                                     fsal_handle_t * in_fsal_handle,     /* IN */
                                     struct fsal_handle_desc *fh_desc     /* IN/OUT */
    )
{
  posixfsal_export_context_t * p_expcontext
    = (posixfsal_export_context_t *) expcontext;
  posixfsal_handle_t * p_in_fsal_handle = (posixfsal_handle_t *) in_fsal_handle;
  size_t fh_size;
  caddr_t fh_data;

  /* sanity checks */
  if(!p_in_fsal_handle || !fh_desc || !fh_desc->start || !p_expcontext)
    ReturnCode(ERR_FSAL_FAULT, 0);

  switch (output_type)
    {
    /* NFS handle digest */
    case FSAL_DIGEST_NFSV2:
    case FSAL_DIGEST_NFSV3:
    case FSAL_DIGEST_NFSV4:
      fh_size = sizeof(p_in_fsal_handle->data.id) + sizeof(p_in_fsal_handle->data.ts);
      fh_data = (caddr_t) p_in_fsal_handle;
      break;

    /* FileId digest */
    case FSAL_DIGEST_FILEID2:
    case FSAL_DIGEST_FILEID3:
    case FSAL_DIGEST_FILEID4:
      /* XXX: does fh_desc need to be padded to FSAL_DIGEST_SIZE_FILEID{2,3,4} ?
       *      or is setting fh_size = sizeof(ino_t) sufficient? */
      fh_size = sizeof(p_in_fsal_handle->data.info.inode);
      fh_data = (caddr_t) &p_in_fsal_handle->data.info.inode;
      break;

    /* Nodetype digest. */
    case FSAL_DIGEST_NODETYPE:
      /* XXX: should fh_desc be padded to FSAL_DIGEST_SIZE_NODETYPE ? */
      fh_size = sizeof(p_in_fsal_handle->data.info.ftype);
      fh_data = (caddr_t) &p_in_fsal_handle->data.info.ftype;
      break;

    default:
      ReturnCode(ERR_FSAL_SERVERFAULT, 0);
    }

  if(fh_desc->len < fh_size)
    {
      LogMajor( COMPONENT_FSAL, "POSIX DigestHandle: too small for handle.  need %lu, have %lu",
                fh_size, fh_desc->len);
      ReturnCode(ERR_FSAL_TOOSMALL, 0);
    }

  memcpy(fh_desc->start, fh_data, fh_size);
  fh_desc->len = fh_size;

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}

fsal_status_t POSIXFSAL_ExpandHandle(fsal_export_context_t * expcontext, /* IN */
                                     fsal_digesttype_t in_type, /* IN */
                                     struct fsal_handle_desc *fh_desc /* IN/OUT */
    )
{
  posixfsal_export_context_t * p_expcontext
    = (posixfsal_export_context_t *) expcontext;

  /* sanity checks */
  if(!fh_desc || !fh_desc->start || !p_expcontext)
    ReturnCode(ERR_FSAL_FAULT, 0);

  size_t fh_size = sizeof(fsal_u64_t) + sizeof(int);
  if (in_type == FSAL_DIGEST_NFSV2 && fh_desc->len < fh_size)
    {
      LogMajor(COMPONENT_FSAL,
               "POSIX ExpandHandle: V2 size too small for handle.  should be %lu, got %lu",
               fh_size, fh_desc->len);
      ReturnCode(ERR_FSAL_SERVERFAULT, 0);
    }
  else if (in_type != FSAL_DIGEST_SIZEOF && fh_desc->len != fh_size)
    {
      LogMajor(COMPONENT_FSAL,
               "POSIX ExpandHandle: size mismatch for handle.  should be %lu, got %lu",
               fh_size, fh_desc->len);
      ReturnCode(ERR_FSAL_SERVERFAULT, 0);
    }

  fh_desc->len = fh_size; /* pass back the actual size */

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}

fsal_status_t POSIXFSAL_SetDefault_FS_specific_parameter(fsal_parameter_t * out_parameter)
{
  posixfs_specific_initinfo_t * p_init_info;

  /* defensive programming... */
  if(out_parameter == NULL)
    ReturnCode(ERR_FSAL_FAULT, 0);

  /* set default values for all parameters of fs_specific_info */
  p_init_info = (posixfs_specific_initinfo_t *)&out_parameter->fs_specific_info;

#ifdef _USE_PGSQL

  /* pgsql db */
  strcpy(p_init_info->dbparams.host, "localhost");
  strcpy(p_init_info->dbparams.port, "5432");
  p_init_info->dbparams.dbname[0] = '\0';
  p_init_info->dbparams.login[0] = '\0';
  p_init_info->dbparams.passwdfile[0] = '\0';

#elif defined(_USE_MYSQL)

  strcpy(p_init_info->dbparams.host, "localhost");
  strcpy(p_init_info->dbparams.port, "");
  p_init_info->dbparams.dbname[0] = '\0';
  p_init_info->dbparams.login[0] = '\0';
  p_init_info->dbparams.passwdfile[0] = '\0';

#endif

  ReturnCode(ERR_FSAL_NO_ERROR, 0);

}

/* load FSAL init info */

fsal_status_t POSIXFSAL_load_FS_specific_parameter_from_conf(config_file_t in_config,
                                                             fsal_parameter_t *
                                                             out_parameter)
{
  posixfs_specific_initinfo_t * p_init_info;
  int err;
  int var_max, var_index;
  char *key_name;
  char *key_value;
  config_item_t block;

  /* defensive programming... */
  if(out_parameter == NULL)
    ReturnCode(ERR_FSAL_FAULT, 0);

  /* set default values for all parameters of fs_specific_info */
  p_init_info = (posixfs_specific_initinfo_t *)&out_parameter->fs_specific_info;

  block = config_FindItemByName(in_config, CONF_LABEL_FS_SPECIFIC);

  /* cannot read item */
  if(block == NULL)
    {
      LogCrit(COMPONENT_CONFIG, "FSAL LOAD PARAMETER: Cannot read item \"%s\" from configuration file",
              CONF_LABEL_FS_SPECIFIC);
      ReturnCode(ERR_FSAL_NOENT, 0);
    }
  else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
    {
      LogCrit(COMPONENT_CONFIG, "FSAL LOAD PARAMETER: Item \"%s\" is expected to be a block",
              CONF_LABEL_FS_SPECIFIC);
      ReturnCode(ERR_FSAL_INVAL, 0);
    }

  var_max = config_GetNbItems(block);

  for(var_index = 0; var_index < var_max; var_index++)
    {
      config_item_t item;

      item = config_GetItemByIndex(block, var_index);

      err = config_GetKeyValue(item, &key_name, &key_value);
      if(err)
        {
          LogCrit(COMPONENT_CONFIG,
               "FSAL LOAD PARAMETER: ERROR reading key[%d] from section \"%s\" of configuration file.",
               var_index, CONF_LABEL_FS_SPECIFIC);
          ReturnCode(ERR_FSAL_SERVERFAULT, err);
        }
      /* does the variable exists ? */
      if(!STRCMP(key_name, "DB_Host"))
        {
          strncpy(p_init_info->dbparams.host,
                  key_value, FSAL_MAX_DBHOST_NAME_LEN);
        }
      else if(!STRCMP(key_name, "DB_Port"))
        {
          int port;
          port = atoi(key_value);       /* XXX: replace atoi by my_atoi ?! */
          if(port <= 0 || port > USHRT_MAX)
            {
              LogCrit(COMPONENT_CONFIG,
                   "FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: positive integer (< %i) expected.",
                   key_name, USHRT_MAX);
              ReturnCode(ERR_FSAL_INVAL, 0);
            }
          strncpy(p_init_info->dbparams.port,
                  key_value, FSAL_MAX_DBPORT_STR_LEN);
        }
      else if(!STRCMP(key_name, "DB_Name"))
        {
          strncpy(p_init_info->dbparams.dbname,
                  key_value, FSAL_MAX_DB_NAME_LEN);
        }
      else if(!STRCMP(key_name, "DB_Login"))
        {
          strncpy(p_init_info->dbparams.login,
                  key_value, FSAL_MAX_DB_LOGIN_LEN);
        }
      else if(!STRCMP(key_name, "DB_keytab"))
        {
          strncpy(p_init_info->dbparams.passwdfile,
                  key_value, FSAL_MAX_PATH_LEN);
        }
      else
        {
          LogCrit(COMPONENT_CONFIG,
               "FSAL LOAD PARAMETER: ERROR: Unknown or unsettable key: %s (item %s)",
               key_name, CONF_LABEL_FS_SPECIFIC);
          ReturnCode(ERR_FSAL_INVAL, 0);
        }
    }

  if(p_init_info->dbparams.host[0] == '\0'
     || p_init_info->dbparams.dbname[0] == '\0')
    {
      LogCrit(COMPONENT_CONFIG,
           "FSAL LOAD PARAMETER: DB_Host and DB_Name MUST be specified in the configuration file");
      ReturnCode(ERR_FSAL_NOENT, 0);
    }

  ReturnCode(ERR_FSAL_NO_ERROR, 0);

}                               /* FSAL_load_FS_specific_parameter_from_conf */