cache_content_rdwr.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

#ifdef _SOLARIS
#include "solaris_port.h"
#endif                          /* _SOLARIS */

#include "fsal.h"
#include "LRU_List.h"
#include "log.h"
#include "HashData.h"
#include "HashTable.h"
#include "cache_inode.h"
#include "cache_content.h"

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/param.h>
#include <time.h>
#include <pthread.h>

/* Missing prototypes */

cache_content_status_t cache_content_open(cache_content_entry_t * pentry,
                                          cache_content_client_t * pclient,
                                          cache_content_status_t * pstatus)
{
  int localfd;

  if((pentry == NULL) || (pstatus == NULL))
    return CACHE_CONTENT_INVALID_ARGUMENT;

  if(pclient->use_fd_cache == 0)
    pentry->local_fs_entry.opened_file.last_op = 0;     /* to force opening the file */

  if((pclient->use_fd_cache == 0) ||
     (time(NULL) - pentry->local_fs_entry.opened_file.last_op > pclient->retention))
    {

      if(pentry->local_fs_entry.opened_file.local_fd > 0)
        {
          close(pentry->local_fs_entry.opened_file.local_fd);
        }

      pentry->local_fs_entry.opened_file.local_fd = -1;
      pentry->local_fs_entry.opened_file.last_op = 0;
    }

  if(pentry->local_fs_entry.opened_file.last_op == 0)
    {
      /* Close file to be sure */
      if(pentry->local_fs_entry.opened_file.local_fd > 0)
        {
          close(pentry->local_fs_entry.opened_file.local_fd);
        }

      /* opened file is not preserved yet */
      if((localfd = open(pentry->local_fs_entry.cache_path_data, O_RDWR, 0750)) == -1)
        {
          if(errno == ENOENT)
            *pstatus = CACHE_CONTENT_LOCAL_CACHE_NOT_FOUND;
          else
            *pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;

          return *pstatus;
        }

      pentry->local_fs_entry.opened_file.local_fd = localfd;
    }

  /* Regular exit */
  pentry->local_fs_entry.opened_file.last_op = time(NULL);

  *pstatus = CACHE_CONTENT_SUCCESS;
  return *pstatus;

}                               /* cache_content_open */

cache_content_status_t cache_content_close(cache_content_entry_t * pentry,
                                           cache_content_client_t * pclient,
                                           cache_content_status_t * pstatus)
{
  if((pentry == NULL) || (pstatus == NULL))
    return CACHE_CONTENT_INVALID_ARGUMENT;

  /* if nothing is opened, do nothing */
  if(pentry->local_fs_entry.opened_file.local_fd < 0)
    {
      *pstatus = CACHE_CONTENT_SUCCESS;
      return *pstatus;
    }

  if((pclient->use_fd_cache == 0) ||
     (time(NULL) - pentry->local_fs_entry.opened_file.last_op > pclient->retention) ||
     (pentry->local_fs_entry.opened_file.local_fd > pclient->max_fd))
    {
      close(pentry->local_fs_entry.opened_file.local_fd);
      pentry->local_fs_entry.opened_file.local_fd = -1;
      pentry->local_fs_entry.opened_file.last_op = 0;
    }

  *pstatus = CACHE_CONTENT_SUCCESS;
  return *pstatus;
}                               /* cache_content_close */

cache_content_status_t cache_content_rdwr(cache_content_entry_t * pentry,
                                          cache_inode_io_direction_t read_or_write,
                                          uint64_t offset,
                                          size_t * pio_size_in,
                                          size_t * pio_size_out,
                                          void *buffer,
                                          fsal_boolean_t * p_fsal_eof,
                                          struct stat * pbuffstat,
                                          cache_content_client_t * pclient,
                                          fsal_op_context_t * pcontext,
                                          cache_content_status_t * pstatus)
{
  fsal_status_t fsal_status;
  fsal_path_t local_path;
  int statindex;
  size_t iosize_before;
  ssize_t iosize_after;
  struct stat buffstat;
  int rc;
  char c;

  *pstatus = CACHE_CONTENT_SUCCESS;

  /* Set the statindex variable */
  switch (read_or_write)
    {
    case CACHE_INODE_READ:
      statindex = CACHE_CONTENT_READ_ENTRY;
      break;

    case CACHE_INODE_WRITE:
      statindex = CACHE_CONTENT_WRITE_ENTRY;
      break;

    default:
      *pstatus = CACHE_CONTENT_INVALID_ARGUMENT;
      return *pstatus;
      break;
    }

  /* stat */
  pclient->stat.func_stats.nb_call[statindex] += 1;

  /* Convert the path to FSAL path */
  fsal_status =
      FSAL_str2path(pentry->local_fs_entry.cache_path_data, MAXPATHLEN, &local_path);

  if(FSAL_IS_ERROR(fsal_status))
    {
      *pstatus = CACHE_CONTENT_FSAL_ERROR;

      /* stat */
      pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;

      return *pstatus;
    }

  /* Parameters conversion */
  iosize_before = cache_content_fsal_size_convert(*pio_size_in, pstatus);
  if(*pstatus != CACHE_CONTENT_SUCCESS)
    {
      /* stat */
      pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;

      return *pstatus;
    }

  /* Open the local fd for reading */
  if(cache_content_open(pentry, pclient, pstatus) != CACHE_CONTENT_SUCCESS)
    {
      return *pstatus;
    }

  /* Perform the IO through the cache */
  if(read_or_write == CACHE_INODE_READ)
    {
      /* The file content was completely read before the IO. The read operation is fully done locally */
      if((iosize_after =
          pread(pentry->local_fs_entry.opened_file.local_fd, buffer, iosize_before,
                offset)) == -1)
        {
          /* stat */
          pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;

          *pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
          return *pstatus;
        }

      /* Get the eof */
      if(iosize_after == 0)
        *p_fsal_eof = TRUE;
      else
        {
          rc = pread(pentry->local_fs_entry.opened_file.local_fd, &c, 1,
                     offset + iosize_before);
          if(rc == 0)
            *p_fsal_eof = TRUE;
          else
            *p_fsal_eof = FALSE;
        }
    }
  else
    {
      /* The io is done on the cache before being flushed to the FSAL */
      if((iosize_after =
          pwrite(pentry->local_fs_entry.opened_file.local_fd, buffer, iosize_before,
                 offset)) == -1)
        {
          /* stat */
          pclient->stat.func_stats.nb_err_unrecover[statindex] += 1;

          *pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
          return *pstatus;
        }

    }

  /* close the local fd */
  if(cache_content_close(pentry, pclient, pstatus) != CACHE_CONTENT_SUCCESS)
    return *pstatus;

  *pio_size_out = (fsal_size_t) iosize_after;

  /* Return the 'stat' as seen in the cache */
  if(stat(pentry->local_fs_entry.cache_path_data, &buffstat) == -1)
    {
      *pstatus = CACHE_CONTENT_LOCAL_CACHE_ERROR;
    }
  else
    {
      if(pbuffstat != NULL)
        *pbuffstat = buffstat;
    }

  return *pstatus;
}                               /* cache_content_rdwr */