cache_inode_open_close.c

Go to the documentation of this file.

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

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

#include "fsal.h"

#include "abstract_atomic.h"
#include "log.h"
#include "HashData.h"
#include "HashTable.h"
#include "cache_inode.h"
#include "cache_inode_lru.h"

#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <time.h>
#include <pthread.h>
#include <strings.h>
#include <assert.h>

fsal_file_t *
cache_inode_fd(cache_entry_t *entry)
{
     if (entry == NULL) {
          return NULL;
     }

     if (entry->type != REGULAR_FILE) {
          return NULL;
     }

     if (entry->object.file.open_fd.openflags != FSAL_O_CLOSED) {
          return &entry->object.file.open_fd.fd;
     }

     return NULL;
}

bool_t
is_open_for_write(cache_entry_t *entry)
{
     return
          (entry &&
           (entry->type == REGULAR_FILE) &&
           ((entry->object.file.open_fd.openflags == FSAL_O_RDWR) ||
            (entry->object.file.open_fd.openflags == FSAL_O_WRONLY)));
}

bool_t
is_open_for_read(cache_entry_t *entry)
{
     return
          (entry &&
           (entry->type == REGULAR_FILE) &&
           ((entry->object.file.open_fd.openflags == FSAL_O_RDWR) ||
            (entry->object.file.open_fd.openflags == FSAL_O_RDONLY)));
}

cache_inode_status_t
cache_inode_open(cache_entry_t *entry,
                 fsal_openflags_t openflags,
                 fsal_op_context_t *context,
                 uint32_t flags,
                 cache_inode_status_t *status)
{
     /* Error return from FSAL */
     fsal_status_t fsal_status = {0, 0};

     if ((entry == NULL) || (context == NULL) ||
         (status == NULL)) {
          *status = CACHE_INODE_INVALID_ARGUMENT;
          goto out;
     }

     if (entry->type != REGULAR_FILE) {
          *status = CACHE_INODE_BAD_TYPE;
          goto out;
     }

     if (!cache_inode_lru_fds_available()) {
          /* This seems the best idea, let the client try again later
             after the reap. */
          *status = CACHE_INODE_DELAY;
          goto out;
     }

     if (!(flags & CACHE_INODE_FLAG_CONTENT_HAVE)) {
          pthread_rwlock_wrlock(&entry->content_lock);
     }

     /* Open file need to be closed, unless it is already open as read/write */
     if ((entry->object.file.open_fd.openflags != FSAL_O_RDWR) &&
         (entry->object.file.open_fd.openflags != 0) &&
         (entry->object.file.open_fd.openflags != openflags)) {
          fsal_status = FSAL_close(&(entry->object.file.open_fd.fd));
          if (FSAL_IS_ERROR(fsal_status) &&
              (fsal_status.major != ERR_FSAL_NOT_OPENED)) {
               *status = cache_inode_error_convert(fsal_status);
               if (fsal_status.major == ERR_FSAL_STALE) {
                    cache_inode_kill_entry(entry);
               }

               LogDebug(COMPONENT_CACHE_INODE,
                        "cache_inode_open: returning %d(%s) from FSAL_close",
                        *status, cache_inode_err_str(*status));

               goto unlock;
          }

          if (!FSAL_IS_ERROR(fsal_status))
              atomic_dec_size_t(&open_fd_count);

          /* Force re-openning */
          entry->object.file.open_fd.openflags = FSAL_O_CLOSED;
     }

     if ((entry->object.file.open_fd.openflags == FSAL_O_CLOSED)) {
          fsal_status = FSAL_open(&(entry->handle),
                                  context,
                                  openflags,
                                  &entry->object.file.open_fd.fd,
                                  NULL);
          if (FSAL_IS_ERROR(fsal_status)) {
               *status = cache_inode_error_convert(fsal_status);
               LogDebug(COMPONENT_CACHE_INODE,
                        "cache_inode_open: returning %d(%s) from FSAL_open",
                        *status, cache_inode_err_str(*status));
               if (fsal_status.major == ERR_FSAL_STALE) {
                    cache_inode_kill_entry(entry);
               }
               goto unlock;
          }

          entry->object.file.open_fd.openflags = openflags;
          /* This is temporary code, until Jim Lieb makes FSALs cache
             their own file descriptors.  Under that regime, the LRU
             thread will interrogate FSALs for their FD use. */
          atomic_inc_size_t(&open_fd_count);

          LogDebug(COMPONENT_CACHE_INODE,
                   "cache_inode_open: pentry %p: openflags = %d, "
                   "open_fd_count = %zd", entry, openflags,
                   open_fd_count);
     }

     *status = CACHE_INODE_SUCCESS;

unlock:

     if (!(flags & CACHE_INODE_FLAG_CONTENT_HOLD)) {
          pthread_rwlock_unlock(&entry->content_lock);
     }

out:

     return *status;

} /* cache_inode_open */

cache_inode_status_t
cache_inode_close(cache_entry_t *entry,
                  uint32_t flags,
                  cache_inode_status_t *status)
{
     /* Error return from the FSAL */
     fsal_status_t fsal_status;

     if ((entry == NULL) || (status == NULL)) {
          *status = CACHE_INODE_INVALID_ARGUMENT;
          goto out;
     }

     if (entry->type != REGULAR_FILE) {
          *status = CACHE_INODE_BAD_TYPE;
          goto out;
     }

     if (!(flags & CACHE_INODE_FLAG_CONTENT_HAVE)) {
          pthread_rwlock_wrlock(&entry->content_lock);
     }

     /* If nothing is opened, do nothing */
     if (entry->object.file.open_fd.openflags == FSAL_O_CLOSED) {
          if (!(flags & CACHE_INODE_FLAG_CONTENT_HOLD)) {
               pthread_rwlock_unlock(&entry->content_lock);
          }
          *status = CACHE_INODE_SUCCESS;
          return *status;
     }

     /* If state is held in the file, do not close it.  This should
        be refined.  (A non return_on_close layout should not prevent
        the file from closing.)  The caller should hold the state
        lock. */
     if (cache_inode_file_holds_state(entry)) {
          *status = CACHE_INODE_SUCCESS;
          goto unlock;
     }

     if (!cache_inode_lru_caching_fds() ||
         (flags & CACHE_INODE_FLAG_REALLYCLOSE)) {
          LogDebug(COMPONENT_CACHE_INODE,
                   "cache_inode_close: entry %p", entry);
          fsal_status = FSAL_close(&(entry->object.file.open_fd.fd));

          entry->object.file.open_fd.openflags = FSAL_O_CLOSED;
          if (FSAL_IS_ERROR(fsal_status) &&
              (fsal_status.major != ERR_FSAL_NOT_OPENED)) {
               *status = cache_inode_error_convert(fsal_status);
               if (fsal_status.major == ERR_FSAL_STALE) {
                    cache_inode_kill_entry(entry);
               }
               LogCrit(COMPONENT_CACHE_INODE,
                       "cache_inode_close: returning %d(%s) from FSAL_close",
                       *status, cache_inode_err_str(*status));
               goto unlock;
          }
          if (!FSAL_IS_ERROR(fsal_status))
              atomic_dec_size_t(&open_fd_count);
     }

     *status = CACHE_INODE_SUCCESS;

unlock:

     if (!(flags & CACHE_INODE_FLAG_CONTENT_HOLD)) {
          pthread_rwlock_unlock(&entry->content_lock);
     }

out:

     return *status;
}