fsal_fileop.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"

fsal_status_t POSIXFSAL_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;
  posixfsal_handle_t filehandle;

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

  fsal_status =
      POSIXFSAL_lookup(dirhandle, filename, p_context,
                       (fsal_handle_t *)&filehandle, file_attributes);
  if(FSAL_IS_ERROR(fsal_status))
    return fsal_status;

  return POSIXFSAL_open((fsal_handle_t *)&filehandle, p_context,
                        openflags, file_descriptor,
                        file_attributes);
}

fsal_status_t POSIXFSAL_open(fsal_handle_t * filehandle, /* IN */
                             fsal_op_context_t * context,        /* IN */
                             fsal_openflags_t openflags,        /* IN */
                             fsal_file_t * file_descriptor,      /* OUT */
                             fsal_attrib_list_t * p_file_attributes     /* [ IN/OUT ] */
    )
{
  posixfsal_handle_t * p_filehandle = (posixfsal_handle_t *) filehandle;
  posixfsal_op_context_t * p_context = (posixfsal_op_context_t *) context;
  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  int rc, errsv;
  fsal_status_t status;

  fsal_path_t fsalpath;
  struct stat buffstat;
#ifdef _FSAL_POSIX_USE_STREAM
  char posix_flags[4];          /* stores r, r+, w, w+, a, or a+ */
#else
  int posix_flags;
#endif

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

  status =
      fsal_internal_getPathFromHandle(p_context, p_filehandle, 0, &fsalpath, &buffstat);
  if(FSAL_IS_ERROR(status))
    Return(status.major, status.minor, INDEX_FSAL_open);

  status =
      fsal_internal_testAccess(p_context,
                               (openflags & FSAL_O_RDONLY ? FSAL_R_OK : FSAL_W_OK) |
                               FSAL_OWNER_OK, &buffstat, NULL);
  if(FSAL_IS_ERROR(status))
    Return(status.major, status.minor, INDEX_FSAL_open);

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

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

  TakeTokenFSCall();
#ifdef _FSAL_POSIX_USE_STREAM
  p_file_descriptor->p_file = fopen(fsalpath.path, posix_flags);
  errsv = errno;
  ReleaseTokenFSCall();

  if(!(p_file_descriptor->p_file))
    Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_open);
#else
  p_file_descriptor->filefd = open(fsalpath.path, posix_flags);
  errsv = errno;
  ReleaseTokenFSCall();
#endif

  /* set the read-only flag of the file descriptor */
  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, errsv, INDEX_FSAL_open); /* use the error... */

}

#ifdef _FSAL_POSIX_USE_STREAM
fsal_status_t POSIXFSAL_read(fsal_file_t * file_descriptor,      /* 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 */
    )
{
  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  size_t i_size;
  size_t nb_read;
  int rc, errsv;

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

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

        case FSAL_SEEK_SET:
          /* set absolute position to offset */

          TakeTokenFSCall();
          rc = fseek(p_file_descriptor->p_file, p_seek_descriptor->offset, SEEK_SET);
          errsv = errno;
          ReleaseTokenFSCall();

          break;

        case FSAL_SEEK_END:
          /* set end of file plus offset */

          TakeTokenFSCall();
          rc = fseek(p_file_descriptor->p_file, p_seek_descriptor->offset, SEEK_END);
          errsv = errno;
          ReleaseTokenFSCall();

          break;
        }

      if(rc)
        {

          LogEvent(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"))),
                   p_seek_descriptor->offset);

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

    }

  /* read operation */

  TakeTokenFSCall();

  nb_read = fread(buffer, 1, i_size, p_file_descriptor->p_file);

  ReleaseTokenFSCall();

  if(feof(p_file_descriptor->p_file))
    *p_end_of_file = 1;

  if(nb_read == 0 && ferror(p_file_descriptor->p_file))
    {
      Return(posix2fsal_error(EBADF), EBADF, INDEX_FSAL_read);
    }

  *p_read_amount = nb_read;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_read);

}
#else
fsal_status_t POSIXFSAL_read(fsal_file_t * file_descriptor,      /* 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 */
    )
{

  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  size_t i_size;
  size_t nb_read;
  int rc, errsv;
  char c;

  /* 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:
        case FSAL_SEEK_END:
          /* set position plus offset */

          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->filefd, p_seek_descriptor->offset,
                     p_seek_descriptor->whence);
          errsv = errno;

          if(rc)
            {
              LogEvent(COMPONENT_FSAL,
                       "Error in posix fseek operation (whence=%s, offset=%"PRId64")",
                       (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"))),
                       p_seek_descriptor->offset);

              ReleaseTokenFSCall();

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

          nb_read = read(p_file_descriptor->filefd, buffer, i_size);

          ReleaseTokenFSCall();
          break;

        case FSAL_SEEK_SET:
          /* set absolute position to offset */

          TakeTokenFSCall();
          nb_read =
              pread(p_file_descriptor->filefd, buffer, i_size, p_seek_descriptor->offset);
          errsv = errno;

          rc = pread(p_file_descriptor->filefd, &c, 1,
                     p_seek_descriptor->offset + i_size);
          if(rc == 0)
            *p_end_of_file = 1;

          ReleaseTokenFSCall();

          break;
        }
    }
  else
    {
      TakeTokenFSCall();

      nb_read = read(p_file_descriptor->filefd, buffer, i_size);

      ReleaseTokenFSCall();
    }

  if(nb_read == -1)
    Return(posix2fsal_error(EBADF), EBADF, INDEX_FSAL_read);

  if(nb_read == 0 && i_size != 0)
    *p_end_of_file = 1;

  *p_read_amount = nb_read;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_read);

}
#endif                          /* _FSAL_POSIX_USE_STREAM */

#ifdef _FSAL_POSIX_USE_STREAM
fsal_status_t POSIXFSAL_write(fsal_file_t * file_descriptor,     /* 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 */
    )
{

  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  size_t nb_written;
  size_t i_size;
  int rc, errsv;

  /* 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;

  /* positioning */

  if(p_seek_descriptor)
    {

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

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

        case FSAL_SEEK_SET:
          /* set absolute position to offset */

          TakeTokenFSCall();
          rc = fseek(p_file_descriptor->p_file, p_seek_descriptor->offset, SEEK_SET);
          errsv = errno;
          ReleaseTokenFSCall();

          break;

        case FSAL_SEEK_END:
          /* set end of file plus offset */

          TakeTokenFSCall();
          rc = fseek(p_file_descriptor->p_file, p_seek_descriptor->offset, SEEK_END);
          errsv = errno;
          ReleaseTokenFSCall();

          break;
        }

      if(rc)
        {

          LogEvent(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"))),
                   p_seek_descriptor->offset);

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

        }

      LogFullDebug(COMPONENT_FSAL,
                   "Write operation (whence=%s, offset=%lld, size=%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"))),
                   p_seek_descriptor->offset, buffer_size);

    }

  /* write operation */

  TakeTokenFSCall();

  nb_written = fwrite(buffer, 1, i_size, p_file_descriptor->p_file);

  /* With no flush, uncommited write may occur on 64 bits platforms */
  (void)fflush(p_file_descriptor->p_file);

  ReleaseTokenFSCall();

  if(nb_written <= 0 && ferror(p_file_descriptor->p_file))
    {
      Return(posix2fsal_error(EBADF), EBADF, INDEX_FSAL_write);
    }

  /* set output vars */

  *p_write_amount = (fsal_size_t) nb_written;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_write);

}
#else
fsal_status_t POSIXFSAL_write(fsal_file_t * file_descriptor,     /* 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 */
    )
{

  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  size_t i_size;
  size_t nb_written;
  int rc, errsv;

  /* sanity checks. */
  if(!p_file_descriptor || !buffer || !p_write_amount)
    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:
        case FSAL_SEEK_END:
          /* set position plus offset */

          TakeTokenFSCall();
          rc = lseek(p_file_descriptor->filefd, p_seek_descriptor->offset,
                     p_seek_descriptor->whence);
          errsv = errno;

          if(rc)
            {
              LogEvent(COMPONENT_FSAL,
                       "Error in posix fseek operation (whence=%s, offset=%"PRId64")",
                       (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"))),
                       p_seek_descriptor->offset);

              ReleaseTokenFSCall();

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

          nb_written = write(p_file_descriptor->filefd, buffer, i_size);

          ReleaseTokenFSCall();
          break;

        case FSAL_SEEK_SET:
          /* set absolute position to offset */

          TakeTokenFSCall();
          nb_written =
              pwrite(p_file_descriptor->filefd, buffer, i_size,
                     p_seek_descriptor->offset);
          errsv = errno;

          ReleaseTokenFSCall();

          break;
        }
    }
  else
    {
      TakeTokenFSCall();

      nb_written = write(p_file_descriptor->filefd, buffer, i_size);

      ReleaseTokenFSCall();
    }

  if(nb_written == -1)
    Return(posix2fsal_error(EBADF), EBADF, INDEX_FSAL_write);

  *p_write_amount = nb_written;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_write);

}

#endif                          /* _FSAL_POSIX_USE_STREAM */

fsal_status_t POSIXFSAL_close(fsal_file_t * file_descriptor      /* IN */
    )
{
  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  int rc, errsv;

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

  /* call to close */

  TakeTokenFSCall();

#ifdef _FSAL_POSIX_USE_STREAM
  rc = fclose(p_file_descriptor->p_file);
#else
  rc = close(p_file_descriptor->filefd);
#endif

  errsv = errno;

  ReleaseTokenFSCall();

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

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_close);

}

unsigned int POSIXFSAL_GetFileno(fsal_file_t * pfile)
{
  return ((posixfsal_file_t *)pfile)->filefd;
}

fsal_status_t POSIXFSAL_commit(fsal_file_t * file_descriptor,
                             fsal_off_t    offset, 
                             fsal_size_t   length )

{
  posixfsal_file_t * p_file_descriptor = (posixfsal_file_t *) file_descriptor;
  int rc, errsv;

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

  /* Flush data. */
  TakeTokenFSCall();
  rc = fsync(p_file_descriptor->filefd);
  errsv = errno;
  ReleaseTokenFSCall();
  
  if(rc)
    {
      LogEvent(COMPONENT_FSAL, "Error in fsync operation");
      Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_commit);
    }

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_commit);
}