fsal_dirs.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 */

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

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

#include <string.h>
#ifdef _USE_GSSRPC
#include <gssrpc/rpc.h>
#include <gssrpc/xdr.h>
#else
#include <rpc/rpc.h>
#include <rpc/xdr.h>
#endif
#include "nfs4.h"

#include "abstract_mem.h"
#include "fsal_internal.h"
#include "fsal_convert.h"
#include "fsal_common.h"

#include "nfs_proto_functions.h"
#include "fsal_nfsv4_macros.h"

fsal_status_t PROXYFSAL_opendir(fsal_handle_t * dir_handle,        /* IN */
                                fsal_op_context_t * p_context,     /* IN */
                                fsal_dir_t * dir_desc,       /* OUT */
                                fsal_attrib_list_t * dir_attributes     /* [ IN/OUT ] */
    )
{
  proxyfsal_dir_t * dir_descriptor = (proxyfsal_dir_t *)dir_desc;

  /* sanity checks
   * note : dir_attributes is optional.
   */
  if(!dir_handle || !p_context || !dir_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_opendir);

  PRINT_HANDLE("FSAL_opendir", dir_handle);

  /* Set the context */
  memcpy(&dir_descriptor->fhandle, dir_handle, sizeof(dir_descriptor->fhandle));
  memset(dir_descriptor->verifier, 0, NFS4_VERIFIER_SIZE);
  dir_descriptor->pcontext = (proxyfsal_op_context_t *)p_context;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_opendir);

}

fsal_status_t PROXYFSAL_readdir(fsal_dir_t * dir_desc,       /* IN */
                                fsal_cookie_t start_pos,      /* IN */
                                fsal_attrib_mask_t get_attr_mask,       /* IN */
                                fsal_mdsize_t buffersize,       /* IN */
                                fsal_dirent_t * pdirent,        /* OUT */
                                fsal_cookie_t * end_position,      /* OUT */
                                fsal_count_t * nb_entries,      /* OUT */
                                fsal_boolean_t * end_of_dir     /* OUT */
    )
{
  nfs_fh4 nfs4fh;
  bitmap4 bitmap;
  uint32_t bitmap_val[2];
  count4 nbreaddir;
  int rc = 0;
  int i = 0;
  int cpt = 0;
  entry4 *piter_entry = NULL;
  struct proxy_entry4 {
        entry4 e4;
        char name[MAXNAMLEN];
        fsal_proxy_internal_fattr_readdir_t attr;
        uint32_t bitmap[2];
  } *pxy_e4;
  struct timeval timeout = TIMEOUTRPC;
#define FSAL_READDIR_NB_OP_ALLOC 2
  nfs_argop4 argoparray[FSAL_READDIR_NB_OP_ALLOC];
  nfs_resop4 resoparray[FSAL_READDIR_NB_OP_ALLOC];
  COMPOUND4args argnfs4;
  COMPOUND4res resnfs4;
  proxyfsal_dir_t * dir_descriptor = (proxyfsal_dir_t *)dir_desc;
  proxyfsal_cookie_t start_position;

  /* sanity checks */

  if(!dir_descriptor || !pdirent || !end_position || !nb_entries || !end_of_dir)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);

  /* How much data should I read ? */
  nbreaddir = buffersize / (sizeof(fsal_dirent_t));
  if(nbreaddir > FSAL_READDIR_SIZE)
    nbreaddir = FSAL_READDIR_SIZE;

  pxy_e4 = gsh_calloc(nbreaddir, sizeof(*pxy_e4));
  if(pxy_e4 == NULL)
   Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);

  memcpy(&start_position.data, &start_pos.data, sizeof( nfs_cookie4));

  LogFullDebug(COMPONENT_FSAL, "---> Readdir Offset=%llu sizeof(entry4)=%lu sizeof(fsal_dirent_t)=%lu \n",
               (unsigned long long)start_position.data, sizeof(entry4), sizeof(fsal_dirent_t));

  /* >> retrieve root handle filehandle here << */
  bitmap.bitmap4_len = 2;
  bitmap.bitmap4_val = bitmap_val;
  fsal_internal_proxy_create_fattr_readdir_bitmap(&bitmap);

  /* Setup results structures */
  argnfs4.argarray.argarray_val = argoparray;
  resnfs4.resarray.resarray_val = resoparray;
  argnfs4.minorversion = 0;
  /* argnfs4.tag.utf8string_val = "GANESHA NFSv4 Proxy: Readdir" ; */
  argnfs4.tag.utf8string_val = NULL;
  argnfs4.tag.utf8string_len = 0;
  argnfs4.argarray.argarray_len = 0;

#define FSAL_READDIR_IDX_OP_PUTFH      0
#define FSAL_READDIR_IDX_OP_READDIR    1

  /* Set up reply structure */
  resnfs4.resarray.resarray_val = resoparray;

  for(i = 0; i < nbreaddir; i++)
    {
      fsal_internal_proxy_setup_readdir_fattr(&pxy_e4[i].attr);

      pxy_e4[i].e4.name.utf8string_val = pxy_e4[i].name;
      pxy_e4[i].e4.name.utf8string_len = sizeof(pxy_e4[i].name);

      pxy_e4[i].e4.attrs.attr_vals.attrlist4_val = (char *)&(pxy_e4[i].attr);
      pxy_e4[i].e4.attrs.attr_vals.attrlist4_len = sizeof(pxy_e4[i].attr);

      pxy_e4[i].e4.attrs.attrmask.bitmap4_val = pxy_e4[i].bitmap;
      pxy_e4[i].e4.attrs.attrmask.bitmap4_len = 2;

      pxy_e4[i].e4.nextentry = &pxy_e4[i+1].e4; /* Last one cleared after the loop */
    }
  pxy_e4[i-1].e4.nextentry = NULL;
  resnfs4.resarray.resarray_val[FSAL_READDIR_IDX_OP_READDIR].nfs_resop4_u.opreaddir.
      READDIR4res_u.resok4.reply.entries = &pxy_e4->e4;

  /* >> Call your filesystem lookup function here << */
  if(fsal_internal_proxy_extract_fh(&nfs4fh, (fsal_handle_t *) &dir_descriptor->fhandle) == FALSE)
   {
    gsh_free(pxy_e4);
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
   }
  COMPOUNDV4_ARG_ADD_OP_PUTFH(argnfs4, nfs4fh);
  COMPOUNDV4_ARG_ADD_OP_READDIR(argnfs4, start_position.data, nbreaddir,
                                dir_descriptor->verifier, bitmap);

  TakeTokenFSCall();
  /* Call the NFSv4 function */
  COMPOUNDV4_EXECUTE(dir_descriptor->pcontext, argnfs4, resnfs4, rc);
  ReleaseTokenFSCall();
  if(rc != RPC_SUCCESS)
    {

      gsh_free(pxy_e4) ;
      Return(ERR_FSAL_IO, rc, INDEX_FSAL_readdir);
    }

  if(resnfs4.status != NFS4_OK)
    {
      gsh_free(pxy_e4);
      return fsal_internal_proxy_error_convert(resnfs4.status, INDEX_FSAL_readdir);
    }

  /* Set the reply structure */
  if(resnfs4.resarray.resarray_val[FSAL_READDIR_IDX_OP_READDIR].nfs_resop4_u.opreaddir.
     READDIR4res_u.resok4.reply.eof == TRUE)
    {
      *end_of_dir = TRUE;
    }

  /* until the requested count is reached
   * or the end of dir is reached...
   */

  /* Don't forget setting output vars : end_position, nb_entries, end_of_dir  */
  for(piter_entry =
      resnfs4.resarray.resarray_val[FSAL_READDIR_IDX_OP_READDIR].nfs_resop4_u.opreaddir.
      READDIR4res_u.resok4.reply.entries; piter_entry != NULL;
      piter_entry = piter_entry->nextentry)
    {
      if(proxy_Fattr_To_FSAL_attr(&pdirent[cpt].attributes,
                                  (proxyfsal_handle_t *) &(pdirent[cpt].handle), &(piter_entry->attrs)) != 1)
        {
          FSAL_CLEAR_MASK(pdirent[cpt].attributes.asked_attributes);
          FSAL_SET_MASK(pdirent[cpt].attributes.asked_attributes, FSAL_ATTR_RDATTR_ERR);

          gsh_free(pxy_e4);
          Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
        }

      if(fsal_internal_proxy_fsal_utf8_2_name(&(pdirent[cpt].name),
                                              &(piter_entry->name)) == FALSE)
        {
          gsh_free(pxy_e4);
          Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readdir);
        }

      pdirent[cpt].cookie.data = piter_entry->cookie;
      /* Link the entries together */
      pdirent[cpt].nextentry = NULL;    /* Will be overwritten if there is an entry behind, stay NULL if not */
      if(cpt != 0)
        pdirent[cpt - 1].nextentry = &pdirent[cpt];

      /* Set end position */
      ((proxyfsal_cookie_t *)end_position)->data = piter_entry->cookie;

      /* Get ready for next pdirent */
      cpt += 1;

      if(cpt >= nbreaddir)
        break;
    }

  /* The number of entries to be returned */
  *nb_entries = cpt;

  gsh_free(pxy_e4);
  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readdir);

}

fsal_status_t PROXYFSAL_closedir(fsal_dir_t * dir_descriptor       /* IN */
    )
{

  /* sanity checks */
  if(!dir_descriptor)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_closedir);

  ((proxyfsal_dir_t *)dir_descriptor)->pcontext = NULL;

  Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_closedir);

}