fsal_internal.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 * Copyright CEA/DAM/DIF  (2008)
 * contributeur : Philippe DENIEL   philippe.deniel@cea.fr
 *                Thomas LEIBOVICI  thomas.leibovici@cea.fr
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * -------------
 */

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

#include  "fsal.h"
#include "fsal_internal.h"
#include "abstract_mem.h"
#include "SemN.h"
#include "fsal_convert.h"
#include <libgen.h>             /* used for 'dirname' */
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <xfs/xfs.h>
#include <xfs/handle.h>
#include <mntent.h>

/* Add missing prototype */
int fd_to_handle(int fd, void **hanp, size_t * hlen);

/* credential lifetime (1h) */
fsal_uint_t CredentialLifetime = 3600;

/* static filesystem info.
 * The access is thread-safe because
 * it is read-only, except during initialization.
 */
fsal_staticfsinfo_t global_fs_info;

/* filesystem info for HPSS */
static fsal_staticfsinfo_t default_posix_info = {
  0xFFFFFFFFFFFFFFFFLL,         /* max file size (64bits) */
  _POSIX_LINK_MAX,              /* max links */
  FSAL_MAX_NAME_LEN,            /* max filename */
  FSAL_MAX_PATH_LEN,            /* max pathlen */
  TRUE,                         /* no_trunc */
  TRUE,                         /* chown restricted */
  FALSE,                        /* case insensitivity */
  TRUE,                         /* case preserving */
  FSAL_EXPTYPE_PERSISTENT,      /* FH expire type */
  TRUE,                         /* hard link support */
  TRUE,                         /* symlink support */
  FALSE,                        /* lock management */
  FALSE,                        /* lock owners */
  FALSE,                        /* async blocking locks */
  TRUE,                         /* named attributes */
  TRUE,                         /* handles are unique and persistent */
  {10, 0},                      /* Duration of lease at FS in seconds */
  FSAL_ACLSUPPORT_ALLOW,        /* ACL support */
  TRUE,                         /* can change times */
  TRUE,                         /* homogenous */
  POSIX_SUPPORTED_ATTRIBUTES,   /* supported attributes */
  0,                            /* maxread size */
  0,                            /* maxwrite size */
  0,                            /* default umask */
  0,                            /* cross junctions */
  0400,                         /* default access rights for xattrs: root=RW, owner=R */
  0,                            /* default access check support in FSAL */
  0,                            /* default share reservation support in FSAL */
  0                             /* default share reservation support with open owners in FSAL */
};

/* variables for limiting the calls to the filesystem */
static int limit_calls = FALSE;
semaphore_t sem_fs_calls;

/* threads keys for stats */
static pthread_key_t key_stats;
static pthread_once_t once_key = PTHREAD_ONCE_INIT;

/* init keys */
static void init_keys(void)
{
  if(pthread_key_create(&key_stats, NULL) == -1)
    LogError(COMPONENT_FSAL, ERR_SYS, ERR_PTHREAD_KEY_CREATE, errno);

  return;
}                               /* init_keys */

void fsal_increment_nbcall(int function_index, fsal_status_t status)
{

  fsal_statistics_t *bythread_stat = NULL;

  /* verify index */

  if(function_index >= FSAL_NB_FUNC)
    return;

  /* first, we init the keys if this is the first time */

  if(pthread_once(&once_key, init_keys) != 0)
    {
      LogError(COMPONENT_FSAL, ERR_SYS, ERR_PTHREAD_ONCE, errno);
      return;
    }

  /* we get the specific value */

  bythread_stat = (fsal_statistics_t *) pthread_getspecific(key_stats);

  /* we allocate stats if this is the first time */

  if(bythread_stat == NULL)
    {
      int i;

      bythread_stat = gsh_malloc(sizeof(fsal_statistics_t));

      if(bythread_stat == NULL)
        {
          LogError(COMPONENT_FSAL, ERR_SYS, ERR_MALLOC, ENOMEM);
        }

      /* inits the struct */

      for(i = 0; i < FSAL_NB_FUNC; i++)
        {
          bythread_stat->func_stats.nb_call[i] = 0;
          bythread_stat->func_stats.nb_success[i] = 0;
          bythread_stat->func_stats.nb_err_retryable[i] = 0;
          bythread_stat->func_stats.nb_err_unrecover[i] = 0;
        }

      /* set the specific value */
      pthread_setspecific(key_stats, (void *)bythread_stat);

    }

  /* we increment the values */

  if(bythread_stat)
    {
      bythread_stat->func_stats.nb_call[function_index]++;

      if(!FSAL_IS_ERROR(status))
        bythread_stat->func_stats.nb_success[function_index]++;
      else if(status.major == ERR_FSAL_DELAY)   /* Error is retryable */
        bythread_stat->func_stats.nb_err_retryable[function_index]++;
      else
        bythread_stat->func_stats.nb_err_unrecover[function_index]++;
    }

  return;
}

void fsal_internal_getstats(fsal_statistics_t * output_stats)
{

  fsal_statistics_t *bythread_stat = NULL;

  /* first, we init the keys if this is the first time */
  if(pthread_once(&once_key, init_keys) != 0)
    {
      LogError(COMPONENT_FSAL, ERR_SYS, ERR_PTHREAD_ONCE, errno);
      return;
    }

  /* we get the specific value */
  bythread_stat = (fsal_statistics_t *) pthread_getspecific(key_stats);

  /* we allocate stats if this is the first time */
  if(bythread_stat == NULL)
    {
      int i;

      if((bythread_stat =
          gsh_malloc(sizeof(fsal_statistics_t))) == NULL)
        LogError(COMPONENT_FSAL, ERR_SYS, ERR_MALLOC, ENOMEM);

      /* inits the struct */
      for(i = 0; i < FSAL_NB_FUNC; i++)
        {
          bythread_stat->func_stats.nb_call[i] = 0;
          bythread_stat->func_stats.nb_success[i] = 0;
          bythread_stat->func_stats.nb_err_retryable[i] = 0;
          bythread_stat->func_stats.nb_err_unrecover[i] = 0;
        }

      /* set the specific value */
      pthread_setspecific(key_stats, (void *)bythread_stat);

    }

  if(output_stats)
    (*output_stats) = (*bythread_stat);

  return;

}

void TakeTokenFSCall()
{
  /* no limits */
  if(limit_calls == FALSE)
    return;

  /* there is a limit */
  semaphore_P(&sem_fs_calls);

}

void ReleaseTokenFSCall()
{
  /* no limits */
  if(limit_calls == FALSE)
    return;

  /* there is a limit */
  semaphore_V(&sem_fs_calls);

}

/*
 *  This function initializes shared variables of the fsal.
 */
fsal_status_t fsal_internal_init_global(fsal_init_info_t * fsal_info,
                                        fs_common_initinfo_t * fs_common_info,
                                        xfsfs_specific_initinfo_t * fs_specific_info)
{

  /* sanity check */
  if(!fsal_info || !fs_common_info || !fs_specific_info)
    ReturnCode(ERR_FSAL_FAULT, 0);

  /* inits FS call semaphore */
  if(fsal_info->max_fs_calls > 0)
    {
      int rc;

      limit_calls = TRUE;

      rc = semaphore_init(&sem_fs_calls, fsal_info->max_fs_calls);

      if(rc != 0)
        ReturnCode(ERR_FSAL_SERVERFAULT, rc);

      LogDebug(COMPONENT_FSAL,
                        "FSAL INIT: Max simultaneous calls to filesystem is limited to %u.",
                        fsal_info->max_fs_calls);

    }
  else
    {
      LogDebug(COMPONENT_FSAL,
                        "FSAL INIT: Max simultaneous calls to filesystem is unlimited.");
    }

  /* setting default values. */
  global_fs_info = default_posix_info;

  display_fsinfo(&default_posix_info);

  /* Analyzing fs_common_info struct */

  if((fs_common_info->behaviors.maxfilesize != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.maxlink != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.maxnamelen != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.maxpathlen != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.no_trunc != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.case_insensitive != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.case_preserving != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.named_attr != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.lease_time != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.supported_attrs != FSAL_INIT_FS_DEFAULT) ||
     (fs_common_info->behaviors.homogenous != FSAL_INIT_FS_DEFAULT))
    ReturnCode(ERR_FSAL_NOTSUPP, 0);

  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, symlink_support);
  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, link_support);
  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support);
  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_owner);
  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, lock_support_async_block);
  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, cansettime);

  SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxread);
  SET_INTEGER_PARAM(global_fs_info, fs_common_info, maxwrite);

  SET_BITMAP_PARAM(global_fs_info, fs_common_info, umask);

  SET_BOOLEAN_PARAM(global_fs_info, fs_common_info, auth_exportpath_xdev);

  SET_BITMAP_PARAM(global_fs_info, fs_common_info, xattr_access_rights);

  LogFullDebug(COMPONENT_FSAL,
                    "Supported attributes constant = 0x%llX.",
                    POSIX_SUPPORTED_ATTRIBUTES);

  LogFullDebug(COMPONENT_FSAL,
                    "Supported attributes default = 0x%llX.",
                    default_posix_info.supported_attrs);

  LogDebug(COMPONENT_FSAL,
                    "FSAL INIT: Supported attributes mask = 0x%llX.",
                    global_fs_info.supported_attrs);

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}

fsal_status_t fsal_internal_handle2fd(fsal_op_context_t * p_context,
                                      fsal_handle_t * phandle, int *pfd, int oflags)
{
  int rc = 0;
  int errsv = 0;
  xfsfsal_handle_t *xh = (xfsfsal_handle_t *)phandle;

  if(!phandle || !pfd || !p_context)
    ReturnCode(ERR_FSAL_FAULT, 0);

  rc = open_by_handle(xh->data.handle_val, xh->data.handle_len, oflags);
  errsv = errno;
  if(rc == -1)
    {
      if(errsv == EISDIR)
        {
          rc = open_by_handle(xh->data.handle_val, xh->data.handle_len,
                              O_DIRECTORY);
          if(rc < 0)
             ReturnCode(posix2fsal_error(errsv), errsv);
        }
      else
        ReturnCode(posix2fsal_error(errsv), errsv);
    }

  *pfd = rc;

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}                               /* fsal_internal_handle2fd */

fsal_status_t fsal_internal_fd2handle(fsal_op_context_t * p_context,
                                      int fd, fsal_handle_t * handle)
{
  xfsfsal_handle_t *phandle = (xfsfsal_handle_t *)handle;
  int rc = 0;
  struct stat ino;

  char *handle_val;
  size_t handle_len;

  if(!phandle)
    ReturnCode(ERR_FSAL_FAULT, 0);

  memset(phandle, 0, sizeof(xfsfsal_handle_t));

  /* retrieve inode */
  rc = fstat(fd, &ino);
  if(rc)
    ReturnCode(posix2fsal_error(errno), errno);

  phandle->data.inode = ino.st_ino;
  switch (ino.st_mode & S_IFMT)
    {
    case S_IFREG:
      phandle->data.type = DT_REG;
      break;
    case S_IFDIR:
      phandle->data.type = DT_DIR;
      break;
    default:
      LogCrit(COMPONENT_FSAL, "Unexpected type 0%o for inode %zd",
              ino.st_mode & S_IFMT, ino.st_ino);
      ReturnCode(ERR_FSAL_INVAL, EINVAL);
    }

  if((rc = fd_to_handle(fd, (void **)(&handle_val), &handle_len)) < 0)
    ReturnCode(posix2fsal_error(errno), errno);

  if(handle_len > sizeof(phandle->data.handle_val))
    {
      free_handle(handle_val, handle_len);
      ReturnCode(ERR_FSAL_TOOSMALL, 0);
    }

  memcpy(phandle->data.handle_val, handle_val, handle_len);
  phandle->data.handle_len = handle_len;

  free_handle(handle_val, handle_len);

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}                               /* fsal_internal_fd2handle */

fsal_status_t fsal_internal_Path2Handle(xfsfsal_op_context_t * p_context,       /* IN */
                                        fsal_path_t * p_fsalpath,       /* IN */
                                        xfsfsal_handle_t * p_handle /* OUT */ )
{
  int objectfd;
  fsal_status_t st;

  if(!p_context || !p_handle || !p_fsalpath)
    ReturnCode(ERR_FSAL_FAULT, 0);

  memset(p_handle, 0, sizeof(xfsfsal_handle_t));

  LogFullDebug(COMPONENT_FSAL, "Lookup handle for %s", p_fsalpath->path);

  if((objectfd = open(p_fsalpath->path, O_RDONLY, 0600)) < 0)
    ReturnCode(posix2fsal_error(errno), errno);

  st = fsal_internal_fd2handle(p_context, objectfd, p_handle);
  close(objectfd);
  return st;
}                               /* fsal_internal_Path2Handle */

fsal_status_t fsal_internal_setattrs_symlink(fsal_handle_t * p_filehandle,   /* IN */
                                             fsal_op_context_t * p_context,  /* IN */
                                             fsal_attrib_list_t * p_attrib_set, /* IN */
                                             fsal_attrib_list_t * p_object_attributes)
{
  if(!p_filehandle || !p_context || !p_attrib_set)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_setattrs);

  *p_object_attributes = *p_attrib_set;

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}                               /* fsal_internal_setattrs_symlink */

/* The code that follows is intended to produce a xfs handle for a symlink. Roughly it is kind of "get handle by inode"
 * It may not be portable
 * I keep it for wanting of a better solution */

#define XFS_FSHANDLE_SZ             8
typedef struct xfs_fshandle
{
  char fsh_space[XFS_FSHANDLE_SZ];
} xfs_fshandle_t;

/* private file handle - for use by open_by_fshandle */
#define XFS_FILEHANDLE_SZ           24
#define XFS_FILEHANDLE_SZ_FOLLOWING 14
#define XFS_FILEHANDLE_SZ_PAD       2
typedef struct xfs_filehandle
{
  xfs_fshandle_t fh_fshandle;   /* handle of fs containing this inode */
  int16_t fh_sz_following;      /* bytes in handle after this member */
  char fh_pad[XFS_FILEHANDLE_SZ_PAD];   /* padding, must be zeroed */
  __uint32_t fh_gen;            /* generation count */
  xfs_ino_t fh_ino;             /* 64 bit ino */
} xfs_filehandle_t;

static void build_xfsfilehandle(xfs_filehandle_t * phandle,
                                xfs_fshandle_t * pfshandle, xfs_bstat_t * pxfs_bstat)
{
  /* Fill in the FS specific part */
  memcpy(&phandle->fh_fshandle, pfshandle, sizeof(xfs_fshandle_t));

  /* Do the required padding */
  phandle->fh_sz_following = XFS_FILEHANDLE_SZ_FOLLOWING;
  memset(phandle->fh_pad, 0, XFS_FILEHANDLE_SZ_PAD);

  /* Add object's specific information from xfs_bstat_t */
  phandle->fh_gen = pxfs_bstat->bs_gen;
  phandle->fh_ino = pxfs_bstat->bs_ino;
}                               /* build_xfsfilehandle */

int fsal_internal_get_bulkstat_by_inode(int fd, xfs_ino_t * p_ino, xfs_bstat_t * pxfs_bstat)
{
  xfs_fsop_bulkreq_t bulkreq;

  bulkreq.lastip = (__u64 *)p_ino;
  bulkreq.icount = 1;
  bulkreq.ubuffer = pxfs_bstat;
  bulkreq.ocount = NULL;
  return ioctl(fd, XFS_IOC_FSBULKSTAT_SINGLE, &bulkreq);
}                               /* get_bulkstat_by_inode */

fsal_status_t fsal_internal_inum2handle(fsal_op_context_t * context,
                                        ino_t inum, fsal_handle_t * handle)
{
  xfsfsal_op_context_t * p_context = (xfsfsal_op_context_t *)context;
  xfsfsal_handle_t * phandle = (xfsfsal_handle_t *)handle;
  int fd = 0;

  xfs_ino_t xfs_ino;
  xfs_bstat_t bstat;

  xfs_filehandle_t xfsfilehandle;
  xfs_fshandle_t xfsfshandle;

  if((fd = open(p_context->export_context->mount_point, O_DIRECTORY)) == -1)
    ReturnCode(posix2fsal_error(errno), errno);

  xfs_ino = inum;
  if(fsal_internal_get_bulkstat_by_inode(fd, &xfs_ino, &bstat) < 0)
    {
      close(fd);
      ReturnCode(posix2fsal_error(errno), errno);
    }

  close(fd);

  memcpy(xfsfshandle.fsh_space, p_context->export_context->mnt_fshandle_val,
         XFS_FSHANDLE_SZ);
  build_xfsfilehandle(&xfsfilehandle, &xfsfshandle, &bstat);

  memcpy(phandle->data.handle_val, &xfsfilehandle, sizeof(xfs_filehandle_t));
  phandle->data.handle_len = sizeof(xfs_filehandle_t);
  phandle->data.inode = inum;
  switch (bstat.bs_mode & S_IFMT)
    {
    case S_IFSOCK:
      phandle->data.type = DT_SOCK;
      break;
    case S_IFLNK:
      phandle->data.type = DT_LNK;
      break;
    case S_IFREG:
    case S_IFDIR:
      LogCrit(COMPONENT_FSAL, "Why are you trying to fake handle on %ld?",
              xfs_ino);
      break;
    case S_IFBLK:
      phandle->data.type = DT_BLK;
      break;
    case S_IFCHR:
      phandle->data.type = DT_CHR;
      break;
    case S_IFIFO:
      phandle->data.type = DT_FIFO;
      break;
    default:
      LogCrit(COMPONENT_FSAL, "Unknown value %o for inode %ld",
              bstat.bs_mode & S_IFMT, xfs_ino);
      break;
    }

  ReturnCode(ERR_FSAL_NO_ERROR, 0);
}                               /* fsal_internal_inum2handle */

int fsal_internal_path2fsname(char *rpath, char *fs_spec)
{
  FILE *fp;
  struct mntent mnt;
  struct mntent *pmnt;
  char work[MAXPATHLEN];
  char mntdir[MAXPATHLEN];

  size_t pathlen, outlen;
  int rc = -1;

  pathlen = 0;
  outlen = 0;

  if(!rpath || !fs_spec)
    return -1;

  fp = setmntent(MOUNTED, "r");

  if(fp == NULL)
    return -1;

  while((pmnt = getmntent_r(fp, &mnt, work, MAXPATHLEN)) != NULL)
    {
      /* get the longer path that matches export path */
      if(mnt.mnt_dir != NULL)
        {

          /* Consider only xfs mount points */
          if(strncmp(mnt.mnt_type, "xfs", 256))
            continue;

          pathlen = strlen(mnt.mnt_dir);

          if((pathlen > outlen) && !strcmp(mnt.mnt_dir, "/"))
            {
              outlen = pathlen;
              strncpy(mntdir, mnt.mnt_dir, MAXPATHLEN);
              strncpy(fs_spec, mnt.mnt_fsname, MAXPATHLEN);
            }
          /* in other cases, the filesystem must be <mountpoint>/<smthg> or <mountpoint>\0 */
          else if((pathlen > outlen) &&
                  !strncmp(rpath, mnt.mnt_dir, pathlen) &&
                  ((rpath[pathlen] == '/') || (rpath[pathlen] == '\0')))
            {
              /* LogFullDebug(COMPONENT_FSAL, "%s is under mountpoint %s, type=%s, fs=%s", 
                 rpath, mnt.mnt_dir, mnt.mnt_type, mnt.mnt_fsname); */

              outlen = pathlen;
              strncpy(mntdir, mnt.mnt_dir, MAXPATHLEN);
              strncpy(fs_spec, mnt.mnt_fsname, MAXPATHLEN);
              rc = 0;
            }
        }

    }

  endmntent(fp);
  return rc;
}                               /* fsal_internal_path2fsname */