fsal_fileop.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
 *
 * -------------
 */

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

#include "fsal.h"
#include "fsal_internal.h"
#include "FSAL/access_check.h"
#include "fsal_convert.h"

fsal_status_t VFSFSAL_open_by_name(fsal_handle_t * dirhandle,      /* IN */
                                fsal_name_t * filename, /* IN */
                                fsal_op_context_t * p_context,  /* IN */
                                fsal_openflags_t openflags,     /* IN */
                                fsal_file_t * file_descriptor,  /* OUT */
                                fsal_attrib_list_t * file_attributes /* [ IN/OUT ] */ )
{
  fsal_status_t fsal_status;
  fsal_handle_t filehandle;

  if(!dirhandle || !filename || !p_context || !file_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_open_by_name);

  fsal_status = FSAL_lookup(dirhandle, filename, p_context, &filehandle, file_attributes);
  if(FSAL_IS_ERROR(fsal_status))
    return fsal_status;

  return FSAL_open(&filehandle, p_context, openflags, file_descriptor, file_attributes);
}

fsal_status_t VFSFSAL_open(fsal_handle_t * p_filehandle,   /* IN */
                        fsal_op_context_t * p_context,  /* IN */
                        fsal_openflags_t openflags,     /* IN */
                        fsal_file_t * p_file_descriptor,        /* OUT */
                        fsal_attrib_list_t * p_file_attributes  /* [ IN/OUT ] */
    )
{

  int rc, errsv;
  fsal_status_t status;

  int fd;
  struct stat buffstat;
  int posix_flags = 0;

  /* sanity checks.
   * note : file_attributes is optional.
   */
  if(!p_filehandle || !p_context || !p_file_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_open);

  /* convert fsal open flags to posix open flags */
  rc = fsal2posix_openflags(openflags, &posix_flags);

  /* flags conflicts. */
  if(rc)
    {
      LogWarn(COMPONENT_FSAL, "Invalid/conflicting flags : %#X", openflags);
      Return(rc, 0, INDEX_FSAL_open);
    }

  TakeTokenFSCall();
  status = fsal_internal_handle2fd(p_context, p_filehandle, &fd, posix_flags);
  ReleaseTokenFSCall();

  if(FSAL_IS_ERROR(status))
    ReturnStatus(status, INDEX_FSAL_open);

  /* retrieve file attributes for checking access rights */

  TakeTokenFSCall();
  rc = fstat(fd, &buffstat);
  errsv = errno;
  ReleaseTokenFSCall();

  if(rc)
    {
      close(fd);

      if(errsv == ENOENT)
        Return(ERR_FSAL_STALE, errsv, INDEX_FSAL_open);
      else
        Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_open);
    }

  status =
      fsal_check_access(p_context,
                               (openflags & FSAL_O_RDONLY ? FSAL_R_OK : FSAL_W_OK) |
                               FSAL_OWNER_OK, &buffstat, NULL);
  if(FSAL_IS_ERROR(status))
    {
      close(fd);
      ReturnStatus(status, INDEX_FSAL_open);
    }

  TakeTokenFSCall();
  ((vfsfsal_file_t *)p_file_descriptor)->fd = fd;
  errsv = errno;
  ReleaseTokenFSCall();

  /* set the read-only flag of the file descriptor */
  ((vfsfsal_file_t *)p_file_descriptor)->ro = openflags & FSAL_O_RDONLY;

  /* output attributes */
  if(p_file_attributes)
    {

      status = posix2fsal_attributes(&buffstat, p_file_attributes);

      if(FSAL_IS_ERROR(status))
        {
          FSAL_CLEAR_MASK(p_file_attributes->asked_attributes);
          FSAL_SET_MASK(p_file_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
        }
    }

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_open);

}

fsal_status_t VFSFSAL_read(fsal_file_t * file_desc,        /* IN */
                        fsal_seek_t * p_seek_descriptor,        /* [IN] */
                        fsal_size_t buffer_size,        /* IN */
                        caddr_t buffer, /* OUT */
                        fsal_size_t * p_read_amount,    /* OUT */
                        fsal_boolean_t * p_end_of_file  /* OUT */
    )
{
  vfsfsal_file_t * p_file_descriptor = (vfsfsal_file_t *) file_desc;
  size_t i_size;
  ssize_t nb_read;
  int rc = 0, errsv = 0;
  int pcall = FALSE;

  /* sanity checks. */

  if(!p_file_descriptor || !buffer || !p_read_amount || !p_end_of_file)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_read);

  i_size = (size_t) buffer_size;

  /* positioning */

  if(p_seek_descriptor)
    {
      switch (p_seek_descriptor->whence)
        {
        case FSAL_SEEK_CUR:
          /* set position plus offset */
          pcall = FALSE;
          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->fd, p_seek_descriptor->offset, SEEK_CUR);
          errsv = errno;
          ReleaseTokenFSCall();
          break;

        case FSAL_SEEK_SET:
          /* use pread/pwrite call */
          pcall = TRUE;
          rc = 0;
          errsv = 0;
          break;

        case FSAL_SEEK_END:
          /* set end of file plus offset */
          pcall = FALSE;

          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->fd, p_seek_descriptor->offset, SEEK_END);
          errsv = errno;
          ReleaseTokenFSCall();
          break;
        }

      if(rc)
        {
          LogFullDebug(COMPONENT_FSAL,
                       "Error in posix fseek operation (whence=%s, offset=%lld)",
                       (p_seek_descriptor->whence == FSAL_SEEK_CUR ? "SEEK_CUR" :
                        (p_seek_descriptor->whence == FSAL_SEEK_SET ? "SEEK_SET" :
                         (p_seek_descriptor->whence ==
                          FSAL_SEEK_END ? "SEEK_END" : "ERROR"))),
                       (long long) p_seek_descriptor->offset);

          Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_read);
        }

    }

  /* read operation */

  TakeTokenFSCall();

  if(pcall)
    nb_read = pread(p_file_descriptor->fd, buffer, i_size, p_seek_descriptor->offset);
  else
    nb_read = read(p_file_descriptor->fd, buffer, i_size);
  errsv = errno;
  ReleaseTokenFSCall();

  if(nb_read == -1)
    Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_read);
  else if(nb_read == 0)
    *p_end_of_file = 1;

  *p_read_amount = nb_read;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_read);

}

fsal_status_t VFSFSAL_write(fsal_file_t * file_desc,       /* IN */
                         fsal_op_context_t * p_context,    /* IN */
                         fsal_seek_t * p_seek_descriptor,       /* IN */
                         fsal_size_t buffer_size,       /* IN */
                         caddr_t buffer,        /* IN */
                         fsal_size_t * p_write_amount   /* OUT */
    )
{
  vfsfsal_file_t * p_file_descriptor = (vfsfsal_file_t *) file_desc;
  ssize_t nb_written;
  size_t i_size;
  int rc = 0, errsv = 0;
  int pcall = FALSE;

  /* sanity checks. */
  if(!p_file_descriptor || !buffer || !p_write_amount)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_write);

  if(p_file_descriptor->ro)
    Return(ERR_FSAL_PERM, 0, INDEX_FSAL_write);

  i_size = (size_t) buffer_size;

  *p_write_amount = 0;

  /* positioning */

  if(p_seek_descriptor)
    {

      switch (p_seek_descriptor->whence)
        {
        case FSAL_SEEK_CUR:
          /* set position plus offset */
          pcall = FALSE;

          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->fd, p_seek_descriptor->offset, SEEK_CUR);
          errsv = errno;
          ReleaseTokenFSCall();
          break;

        case FSAL_SEEK_SET:
          /* set absolute position to offset */
          pcall = TRUE;
          rc = 0;
          errsv = 0;
          break;

        case FSAL_SEEK_END:
          /* set end of file plus offset */
          pcall = FALSE;

          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->fd, p_seek_descriptor->offset, SEEK_END);
          errsv = errno;
          ReleaseTokenFSCall();
          break;
        }

      if(rc)
        {
          LogFullDebug(COMPONENT_FSAL,
                       "Error in posix fseek operation (whence=%s, offset=%lld)",
                       (p_seek_descriptor->whence == FSAL_SEEK_CUR ? "SEEK_CUR" :
                        (p_seek_descriptor->whence == FSAL_SEEK_SET ? "SEEK_SET" :
                         (p_seek_descriptor->whence ==
                          FSAL_SEEK_END ? "SEEK_END" : "ERROR"))),
                       (long long) p_seek_descriptor->offset);

          Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_write);

        }

      LogFullDebug(COMPONENT_FSAL,
                   "Write operation (whence=%s, offset=%lld, size=%zd)",
                   (p_seek_descriptor->whence ==
                    FSAL_SEEK_CUR ? "SEEK_CUR" : (p_seek_descriptor->whence ==
                                                  FSAL_SEEK_SET ? "SEEK_SET"
                                                  : (p_seek_descriptor->whence ==
                                                     FSAL_SEEK_END ? "SEEK_END" :
                                                     "ERROR"))),
                   (long long) p_seek_descriptor->offset, buffer_size);

    }

  /* write operation */

  TakeTokenFSCall();

  if(pcall)
    nb_written = pwrite(p_file_descriptor->fd, buffer, i_size, p_seek_descriptor->offset);
  else
    nb_written = write(p_file_descriptor->fd, buffer, i_size);
  errsv = errno;

  ReleaseTokenFSCall();

  if(nb_written <= 0)
    {
      if (p_seek_descriptor)
        LogDebug(COMPONENT_FSAL,
                 "Write operation of size %llu at offset %lld failed. fd=%d, errno=%d.",
                 (unsigned long long) i_size,
                 (long long) p_seek_descriptor->offset,
                 p_file_descriptor->fd,
                 errsv);
      else
        LogDebug(COMPONENT_FSAL,
                 "Write operation of size %llu at offset 0. fd=%d, errno=%d.",
                 (unsigned long long) i_size,
                 p_file_descriptor->fd,
                 errsv);

      Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_write);
    }

  /* set output vars */

  *p_write_amount = (fsal_size_t) nb_written;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_write);

}

fsal_status_t VFSFSAL_close(fsal_file_t * p_file_descriptor        /* IN */
    )
{

  int rc, errsv;

  /* sanity checks. */
  if(!p_file_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_close);

  if(((vfsfsal_file_t *)p_file_descriptor)->fd == 0 )
       Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_close);

  /* call to close */
  TakeTokenFSCall();

  rc = close(((vfsfsal_file_t *)p_file_descriptor)->fd);
  errsv = errno;

  ReleaseTokenFSCall();

  if(rc)
    Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_close);

  ((vfsfsal_file_t *)p_file_descriptor)->fd = 0 ;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_close);

}

unsigned int VFSFSAL_GetFileno(fsal_file_t * pfile)
{
        return ((vfsfsal_file_t *)pfile)->fd;
}

fsal_status_t VFSFSAL_commit(fsal_file_t * p_file_descriptor,
                           fsal_off_t    offset, 
                           fsal_size_t   length )
{
  int rc, errsv;

  /* sanity checks. */
  if(!p_file_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_commit);

  if(((vfsfsal_file_t *)p_file_descriptor)->fd == 0 )
    Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_commit); /* Nothing to sync, the fd is not opened */

  /* Flush data. */
  TakeTokenFSCall();
  rc = fsync(((vfsfsal_file_t *)p_file_descriptor)->fd);
  errsv = errno;
  ReleaseTokenFSCall();


  if(rc)
    Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_commit);

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_commit);
}