cache_content_misc.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"
#define NAME_MAX         255
#include <sys/statvfs.h>        /* For statfs */
#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 "nfs_exports.h"

#include <unistd.h>
#include <sys/types.h>
#include <sys/param.h>
#include <time.h>
#include <pthread.h>
#include <string.h>
#include <libgen.h>

#ifdef _LINUX
#include <sys/vfs.h>            /* For statfs */
#endif

#ifdef _APPLE
#include <sys/param.h>          /* For Statfs */
#include <sys/mount.h>
#endif

unsigned int cache_content_dir_errno;

/* HashFileID4 : creates a 16bits hash of the 64bits fileid4 buffer.
 *
 * @param fileid4 [IN] 64bits fileid to be hashed.
 */
short HashFileID4(u_int64_t fileid4)
{
  int i;
  short hash_val = 0;

  for(i = 0; i <= 56; i += 8)
    {
#define ALPHABET_LEN      16
#define PRIME_16BITS   65521

      hash_val = (hash_val * ALPHABET_LEN + ((fileid4 >> i) & 0xFF)) % PRIME_16BITS;
    }

  return hash_val;
}

cache_content_status_t cache_content_create_name(char *path,
                                                 cache_content_nametype_t type,
                                                 fsal_op_context_t * pcontext,
                                                 cache_entry_t * pentry_inode,
                                                 cache_content_client_t * pclient)
{
  fsal_status_t fsal_status;
  u_int64_t fileid4;            /* Don't want to include nfs_prot.h at this level */
  fsal_handle_t *pfsal_handle = NULL;
  struct fsal_handle_desc fh_desc;
  char entrydir[MAXPATHLEN];
  int i, nb_char;
  short hash_val;

  pfsal_handle = &pentry_inode->handle;

  fh_desc.start = (caddr_t)&fileid4;
  fh_desc.len = sizeof(fileid4);
  /* Get the digest for the handle, for computing an entry name */
  fsal_status = FSAL_DigestHandle(FSAL_GET_EXP_CTX(pcontext),
                                  FSAL_DIGEST_FILEID4, pfsal_handle, &fh_desc);

  if(FSAL_IS_ERROR(fsal_status))
    return CACHE_CONTENT_FSAL_ERROR;

  /* computes a 16bits hash of the 64bits fileid4 buffer */
  hash_val = HashFileID4(fileid4);

  /* for limiting the number of entries into each datacache directory
   * we create 256 subdirectories on 2 levels, depending on the entry's fileid.
   */
  nb_char = snprintf(entrydir, MAXPATHLEN, "%s/export_id=%d", pclient->cache_dir, 0);

  for(i = 0; i <= 8; i += 8)
    {
      /* concatenation of hashval */
      nb_char += snprintf((char *)(entrydir + nb_char), MAXPATHLEN - nb_char,
                          "/%02hhX", (char)((hash_val >> i) & 0xFF));

      /* creating the directory if necessary */
      if((mkdir(entrydir, 0750) != 0) && (errno != EEXIST))
        {
          return CACHE_CONTENT_LOCAL_CACHE_ERROR;
        }
    }

  /* Create files for caching the entry: index file */
  switch (type)
    {
    case CACHE_CONTENT_DATA_FILE:
      snprintf(path, MAXPATHLEN, "%s/node=%llx.data", entrydir,
               (unsigned long long)fileid4);
      break;

    case CACHE_CONTENT_INDEX_FILE:
      snprintf(path, MAXPATHLEN, "%s/node=%llx.index", entrydir,
               (unsigned long long)fileid4);
      break;

    case CACHE_CONTENT_DIR:
      snprintf(path, MAXPATHLEN, "%s/export_id=%d", pclient->cache_dir, 0);
      break;

    default:
      return CACHE_CONTENT_INVALID_ARGUMENT;
    }

  return CACHE_CONTENT_SUCCESS;
}                               /* cache_content_create_name */

int cache_content_get_export_id(char *dirname)
{
  int exportid;

  if(strncmp(dirname, "export_id=", strlen("export_id=")))
    return -1;

  if(sscanf(dirname, "export_id=%d", &exportid) == 0)
    return -1;
  else
    return exportid;
}                               /* cache_content_get_export_id */

u_int64_t cache_content_get_inum(char *filename)
{
  unsigned long long inum;
  char buff[MAXNAMLEN];
  char *bname = NULL;

  /* splits the dirent->d_name into path and filename */
  strncpy(buff, filename, MAXNAMLEN);
  bname = basename(buff);

  if(strncmp(bname, "node=", strlen("node=")))
    return 0;

  if(strlen(bname) < 5)
    return 0;

  if(strncmp(bname + strlen(bname) - 5, "index", NAME_MAX))
    return 0;

  if(sscanf(bname, "node=%llx.index", &inum) == 0)
    return 0;
  else
    return (u_int64_t) inum;
}                               /* cache_content_get_inum */

int cache_content_get_datapath(char *basepath, u_int64_t inum, char *datapath)
{
  short hash_val;

  hash_val = HashFileID4(inum);

  snprintf(datapath, MAXPATHLEN, "%s/%02hhX/%02hhX/node=%llx.data", basepath,
           (char)((hash_val) & 0xFF),
           (char)((hash_val >> 8) & 0xFF), (unsigned long long)inum);

  LogFullDebug(COMPONENT_CACHE_CONTENT, "cache_content_get_datapath : datapath ----> %s",
                  datapath);

  /* it is ok, we now return 0 */
  return 0;
}                               /* cache_content_get_datapath */

off_t cache_content_recover_size(char *basepath, u_int64_t inum)
{
  char path[MAXPATHLEN];
  struct stat buffstat;

  cache_content_get_datapath(basepath, inum, path);

  if(stat(path, &buffstat) != 0)
    {
      LogCrit(COMPONENT_CACHE_CONTENT,
          "Failure in cache_content_recover_size while stat on local cache: path=%s errno = %u",
           path, errno);

      return -1;
    }

  LogFullDebug(COMPONENT_CACHE_CONTENT, "path ----> %s %"PRIu64, path, buffstat.st_size);

  /* Stat is ok, we now return the size */
  return buffstat.st_size;
}                               /* cache_content_recover_size */

off_t cache_content_get_cached_size(cache_content_entry_t * pentry)
{
  struct stat buffstat;

  if(stat(pentry->local_fs_entry.cache_path_data, &buffstat) != 0)
    {
      LogCrit(COMPONENT_CACHE_CONTENT,
          "Failure in cache_content_get_cached_size while stat on local cache: path=%s errno = %u",
           pentry->local_fs_entry.cache_path_index, errno);

      return -1;
    }

  /* Stat is ok, we now return the size */

  return buffstat.st_size;

}                               /* cache_content_get_cached_size */

cache_inode_status_t cache_content_error_convert(cache_content_status_t status)
{
  cache_inode_status_t converted_status;

  switch (status)
    {
    case CACHE_CONTENT_SUCCESS:
      converted_status = CACHE_INODE_SUCCESS;
      break;

    case CACHE_CONTENT_INVALID_ARGUMENT:
      converted_status = CACHE_INODE_INVALID_ARGUMENT;
      break;

    case CACHE_CONTENT_BAD_CACHE_INODE_ENTRY:
      converted_status = CACHE_INODE_INVALID_ARGUMENT;
      break;

    case CACHE_CONTENT_ENTRY_EXISTS:
      converted_status = CACHE_INODE_ENTRY_EXISTS;
      break;

    case CACHE_CONTENT_FSAL_ERROR:
      converted_status = CACHE_INODE_FSAL_ERROR;
      break;

    case CACHE_CONTENT_LOCAL_CACHE_ERROR:
      converted_status = CACHE_INODE_CACHE_CONTENT_ERROR;
      break;

    case CACHE_CONTENT_MALLOC_ERROR:
      converted_status = CACHE_INODE_MALLOC_ERROR;
      break;

    case CACHE_CONTENT_LRU_ERROR:
      converted_status = CACHE_INODE_LRU_ERROR;
      break;

    default:
      converted_status = CACHE_INODE_INVALID_ARGUMENT;
      break;
    }

  return converted_status;
}                               /* cache_content_error_convert */

size_t cache_content_fsal_size_convert(fsal_size_t size, cache_content_status_t * pstatus)
{
  size_t taille;

  *pstatus = CACHE_CONTENT_SUCCESS;
  taille = (size_t) size;

  return taille;
}                               /* cache_content_fsal_size_convert */

cache_content_status_t cache_content_prepare_directories(exportlist_t * pexportlist,
                                                         char *cache_dir,
                                                         cache_content_status_t * pstatus)
{
  exportlist_t *pexport = NULL;
  char cache_sub_dir[MAXPATHLEN];

  /* Does the cache root directory exist ? */
  if(access(cache_dir, F_OK) == -1)
    {
      /* Create the cache root directory */
      if(mkdir(cache_dir, 0750) == -1)
        return CACHE_CONTENT_LOCAL_CACHE_ERROR;
    }

  /* Create the sub directories if needed */
  for(pexport = pexportlist; pexport != NULL; pexport = pexport->next)
    {
      /* Create a directory only if the export entry is to be datya cached */
      if(pexport->options & EXPORT_OPTION_USE_DATACACHE)
        {
          snprintf(cache_sub_dir, MAXPATHLEN, "%s/export_id=%d", cache_dir, 0);

          if(access(cache_sub_dir, F_OK) == -1)
            {
              /* Create the cache  directory */
              if(mkdir(cache_sub_dir, 0750) == -1)
                return CACHE_CONTENT_LOCAL_CACHE_ERROR;
            }
        }
    }

  /* If this point is reached, everything went ok */
  return CACHE_CONTENT_SUCCESS;
}                               /* cache_content_prepare_directories */

cache_content_status_t cache_content_check_threshold(char *datacache_path,
                                                     unsigned int threshold_min,
                                                     unsigned int threshold_max,
                                                     int *p_bool_overflow,
                                                     unsigned long *p_blocks_to_lwm)
{
  char fspath[MAXPATHLEN];
#ifdef _SOLARIS
  struct statvfs info_fs;
#else
  struct statfs info_fs;
#endif
  unsigned long total_user_blocs, dispo_hw __attribute__((unused)), dispo_lw;
  double tx_used, hw, lw;

  /* defensive checks */

  if(!datacache_path || !p_bool_overflow || !p_blocks_to_lwm
     || (threshold_min > threshold_max) || (threshold_max > 100))
    return CACHE_CONTENT_INVALID_ARGUMENT;

  /* cross mountpoint */

  snprintf(fspath, MAXPATHLEN, "%s/.", datacache_path);

  /* retieve FS info */

  if(statfs(fspath, &info_fs) != 0)
    {
      LogCrit(COMPONENT_CACHE_CONTENT, "Error getting local filesystem info: path=%s errno=%u", fspath,
                 errno);
      return CACHE_CONTENT_LOCAL_CACHE_ERROR;
    }

  /* Compute thresholds and total block count.
   * Those formulas are based on the df's code:
   * used = f_blocks - available_to_root
   *      = f_blocks - f_bfree
   * total = used + available
   *       = f_blocks - f_bfree + f_bavail
   */
  hw = (double)threshold_max;   /* cast to double */
  lw = (double)threshold_min;   /* cast to double */

  total_user_blocs = (info_fs.f_blocks + info_fs.f_bavail - info_fs.f_bfree);
  dispo_hw = (unsigned long)(((100.0 - hw) * total_user_blocs) / 100.0);
  dispo_lw = (unsigned long)(((100.0 - lw) * total_user_blocs) / 100.0);

  tx_used = 100.0 * ((double)info_fs.f_blocks - (double)info_fs.f_bfree) /
      ((double)info_fs.f_blocks + (double)info_fs.f_bavail - (double)info_fs.f_bfree);

  LogEvent(COMPONENT_CACHE_CONTENT,
                  "Datacache: %s: %.2f%% used, low_wm = %.2f%%, high_wm = %.2f%%",
                  datacache_path, tx_used, lw, hw);

  /* threshold test */

  /* if the threshold is under high watermark, nothing to do */

  if(tx_used < hw)
    {
      *p_bool_overflow = FALSE;
      *p_blocks_to_lwm = 0;
      LogEvent(COMPONENT_CACHE_CONTENT, "Datacache: no purge needed");
    }
  else
    {
      *p_bool_overflow = TRUE;
      *p_blocks_to_lwm = dispo_lw - info_fs.f_bavail;
      LogEvent(COMPONENT_CACHE_CONTENT,
                      "Datacache: need to purge %lu blocks for reaching low WM",
                      *p_blocks_to_lwm);
    }

  return CACHE_CONTENT_SUCCESS;

}

int cache_content_local_cache_opendir(char *cache_dir,
                                      cache_content_dirinfo_t * pdirectory)
{
  pdirectory->level0_dir = NULL;
  pdirectory->level1_dir = NULL;
  pdirectory->level2_dir = NULL;
  pdirectory->level1_cnt = 0;
  pdirectory->cookie0 = NULL;
  pdirectory->cookie1 = NULL;
  pdirectory->cookie2 = NULL;
  strcpy(pdirectory->level0_path, "");
  strcpy(pdirectory->level1_name, "");
  strcpy(pdirectory->level2_name, "");

  /* opens the top level directory */
  if((pdirectory->level0_dir = opendir(cache_dir)) == NULL)
    {
      cache_content_dir_errno = errno;
      return FALSE;
    }
  else
    {
      cache_content_dir_errno = 0;
      strncpy(pdirectory->level0_path, cache_dir, MAXPATHLEN);
    }

  pdirectory->level1_cnt = 0;
  return TRUE;
}                               /* cache_content_local_cache_opendir */

cache_content_status_t cache_content_test_cached(cache_entry_t * pentry_inode,
                                                 cache_content_client_t * pclient,
                                                 fsal_op_context_t * pcontext,
                                                 cache_content_status_t * pstatus)
{
  char cache_path_index[MAXPATHLEN];

  if(pstatus == NULL)
    return CACHE_CONTENT_INVALID_ARGUMENT;

  if(pentry_inode == NULL || pclient == NULL || pcontext == NULL)
    {
      *pstatus = CACHE_CONTENT_INVALID_ARGUMENT;
      return *pstatus;
    }

  /* Build the cache index path */
  if((*pstatus = cache_content_create_name(cache_path_index,
                                           CACHE_CONTENT_INDEX_FILE,
                                           pcontext,
                                           pentry_inode,
                                           pclient)) != CACHE_CONTENT_SUCCESS)
    {
      return *pstatus;
    }

  /* Check if the file exists */
  if(access(cache_path_index, F_OK) == 0)
    {
      /* File is accessible and exists */
      *pstatus = CACHE_CONTENT_SUCCESS;
      return CACHE_CONTENT_SUCCESS;
    }

  /* No access */
  *pstatus = CACHE_CONTENT_NOT_FOUND;
  return CACHE_CONTENT_NOT_FOUND;

}                               /* cache_content_test_cached */

int cache_content_local_cache_dir_iter(cache_content_dirinfo_t * directory,
                                       struct dirent *pdir_entry,
                                       unsigned int index, unsigned int mod)
{
  int rc_readdir = 0;

  /* sanity check */
  if(directory == NULL || pdir_entry == NULL)
    {
      cache_content_dir_errno = EFAULT;
      return FALSE;
    }

  do
    {

      errno = 0;

      /* if the lowest level directory is not opened,
       * proceed a readdir, on the topper level directory,
       * and so on.
       */
      if(directory->level2_dir != NULL)
        {
          rc_readdir =
              readdir_r(directory->level2_dir, pdir_entry, &(directory->cookie2));

          if(rc_readdir == 0 && directory->cookie2 != NULL)
            {
              char d_name_save[MAXNAMLEN];

              /* go to the next loop if the entry is . or .. */
              if(!strcmp(".", pdir_entry->d_name) || !strcmp("..", pdir_entry->d_name))
                continue;

              LogFullDebug(COMPONENT_CACHE_CONTENT,"iterator --> %s/%s/%s/%s", directory->level0_path,
                     directory->level1_name, directory->level2_name, pdir_entry->d_name);

              /* the d_name must actually be the relative path from
               * the cache directory path, so that a file can be
               * accessed using <rootpath>/<d_name> path.
               */
              strncpy(d_name_save, pdir_entry->d_name, MAXNAMLEN);
              snprintf(pdir_entry->d_name, MAXNAMLEN, "%s/%s/%s",
                       directory->level1_name, directory->level2_name, d_name_save);

              return TRUE;
            }
          else
            {
              /* test if it is an error or an end of dir */
              if(errno != 0)
                {
                  cache_content_dir_errno = errno;
                  return TRUE;
                }
              else
                {
                  /* the lowest level entry dir is finished,
                   * must proceed a readdir on the topper level
                   */
                  closedir(directory->level2_dir);
                  directory->level2_dir = NULL;
                  /* go to next loop */
                }
            }
        }
      /* continue directory at level 1 */
      else if(directory->level1_dir != NULL)
        {
          if(mod <= 1)
            {
              /* list all dirs */
              rc_readdir =
                  readdir_r(directory->level1_dir, pdir_entry, &(directory->cookie1));
              directory->level1_cnt += 1;
            }
          else
            {
              rc_readdir =
                  readdir_r(directory->level1_dir, pdir_entry, &(directory->cookie1));
              directory->level1_cnt++;

              LogFullDebug(COMPONENT_CACHE_CONTENT,
                  "---> directory->level1_cnt=%u mod=%u index=%u modulocalcule=%u name=%s",
                   directory->level1_cnt, mod, index, directory->level1_cnt % mod,
                   pdir_entry->d_name);

              /* skip entry if  cnt % mod == index */
              if((directory->level1_cnt % mod != index))
                continue;
            }

          if(rc_readdir == 0 && directory->cookie1 != NULL)
            {
              char dirpath[MAXPATHLEN];

              /* go to the next loop if this is the . or .. entry */
              if(!strcmp(".", pdir_entry->d_name) || !strcmp("..", pdir_entry->d_name))
                continue;

              strncpy(directory->level2_name, pdir_entry->d_name, MAXNAMLEN);

              /* must now open the entry as the level2 directory */
              snprintf(dirpath, MAXPATHLEN, "%s/%s/%s",
                       directory->level0_path,
                       directory->level1_name, directory->level2_name);

              if((directory->level2_dir = opendir(dirpath)) == NULL)
                {
                  cache_content_dir_errno = errno;
                  return FALSE;
                }
            }
          else
            {
              /* test if it is an error or an end of dir */
              if(errno != 0)
                {
                  cache_content_dir_errno = errno;
                  return TRUE;
                }
              else
                {
                  /* the lowest level entry dir is finished,
                   * must proceed a readdir on the topper level
                   */
                  closedir(directory->level1_dir);
                  directory->level1_dir = NULL;
                }
            }
        }
      /* continue directory at level 0 */
      else if(directory->level0_dir != NULL)
        {

          rc_readdir =
              readdir_r(directory->level0_dir, pdir_entry, &(directory->cookie0));

          if(rc_readdir == 0 && directory->cookie0 != NULL)
            {
              char dirpath[MAXPATHLEN];

              /* go to the next loop if this is the . or .. entry */
              if(!strcmp(".", pdir_entry->d_name) || !strcmp("..", pdir_entry->d_name))
                continue;

              strncpy(directory->level1_name, pdir_entry->d_name, MAXNAMLEN);

              /* must now open the entry as the level1 directory */
              snprintf(dirpath, MAXPATHLEN, "%s/%s",
                       directory->level0_path, directory->level1_name);

              directory->level1_cnt = 0;

              if((directory->level1_dir = opendir(dirpath)) == NULL)
                {
                  cache_content_dir_errno = errno;
                  return TRUE;
                }
            }
          else
            {
              /* test if it is an error or an end of dir */
              if(errno != 0)
                {
                  cache_content_dir_errno = errno;
                  return TRUE;
                }
              else
                {
                  /* we are at the end of the level directory
                   * return End of Dir
                   */
                  cache_content_dir_errno = 0;
                  return FALSE;
                }
            }
        }
      else
        {
          /* invalid base directory descriptor */
          cache_content_dir_errno = EINVAL;
          return TRUE;
        }

    }
  while(1);

  cache_content_dir_errno = -1;
  /* should never happen */
  return TRUE;

}                               /* cache_content_local_cache_dir_iter */

void cache_content_local_cache_closedir(cache_content_dirinfo_t * directory)
{
  if(directory != NULL)
    {
      if(directory->level2_dir != NULL)
        {
          closedir(directory->level2_dir);
          directory->level2_dir = NULL;
        }

      if(directory->level1_dir != NULL)
        {
          closedir(directory->level1_dir);
          directory->level1_dir = NULL;
        }

      if(directory->level0_dir != NULL)
        {
          closedir(directory->level0_dir);
          directory->level0_dir = NULL;
        }
    }
}                               /* cache_content_local_cache_closedir */