LStoreFile.cc

Go to the documentation of this file.

#include "Utilities/LStoreAdaptor/interface/LStoreFile.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <cassert>
#include <vector>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <dlfcn.h>
#include <iostream>
#include <cstring>



// dlsym isn't reentrant, need a locak around it
pthread_mutex_t LStoreFile::m_dlopen_lock = PTHREAD_MUTEX_INITIALIZER;

LStoreFile::LStoreFile (void)
  : m_fd (nullptr),
    m_close (false),
    m_name(),
    m_library_handle(nullptr),
    m_is_loaded(false),
    redd_init(nullptr),
    redd_read(nullptr),
    redd_close(nullptr),
    redd_lseek(nullptr),
    redd_open(nullptr),
    redd_write(nullptr),
    redd_term(nullptr),
    redd_errno(nullptr),
    redd_strerror(nullptr)
{
    loadLibrary();  
}

LStoreFile::LStoreFile (void * fd)
  : m_fd (fd),
    m_close (true),
    m_name(),
    m_library_handle(nullptr),
    m_is_loaded(false),
    redd_init(nullptr),
    redd_read(nullptr),
    redd_close(nullptr),
    redd_lseek(nullptr),
    redd_open(nullptr),
    redd_write(nullptr),
    redd_term(nullptr),
    redd_errno(nullptr),
    redd_strerror(nullptr)
{
    loadLibrary();  
}

LStoreFile::LStoreFile (const char *name,
            int flags /* = IOFlags::OpenRead */,
            int perms /* = 066 */ )
  : m_fd (nullptr),
    m_close (false),
    m_is_loaded(false)
{   loadLibrary();
    open (name, flags, perms); }

LStoreFile::LStoreFile (const std::string &name,
            int flags /* = IOFlags::OpenRead*/, 
            int perms /* = 066 */)
  : m_fd (nullptr),
    m_close (false),
    m_is_loaded(false)
{   loadLibrary();
    open (name.c_str (), flags, perms); }

LStoreFile::~LStoreFile (void)
{
  if (m_close)
    edm::LogError("LStoreFileError")
      << "Destructor called on LStore file '" << m_name
      << "' but the file is still open";
  closeLibrary();
}


// Helper macro to perform dlsym()
// Double cast is supposed to be more compliant
// otherwise, GCC complains with the pointer conversion
#define REDD_LOAD_SYMBOL( NAME, TYPE )  dlerror();\
    NAME = reinterpret_cast<TYPE>(reinterpret_cast<size_t>( \
                dlsym(m_library_handle, #NAME))); \
    if ( (retval = dlerror()) ) {\
        throw cms::Exception("LStoreFile::loadLibrary()") <<\
            "Failed to load dlsym LStore library: " << retval;\
    }\
    if ( NAME == NULL) {\
        throw cms::Exception("LStoreFile::loadLibrary()") <<\
            "Got a null pointer back from dlsym()\n";\
    }

void LStoreFile::loadLibrary() {
    edm::LogError("LStoreFile::loadLibrary()") << "Loading library\n";
    LStoreFile::MutexWrapper lockObj( & this->m_dlopen_lock );
    // until ACCRE removes the java dependency from their client libs,
    // we'll dlopen() them so they don't need to be brought along with cmssw
    // if you're running LStore at your site, you will have the libs anyway
    // TODO add wrappers to make this work in OSX as well (CMSSW's getting ported?)
    // TODO   should be easy, just need to know the "proper" way to do #if OSX
    // -Melo

    m_library_handle =
         dlopen("libreddnet.so", RTLD_LAZY);
    if (m_library_handle == nullptr) {
        throw cms::Exception("LStoreFile::loadLibrary()")
            << "Can't dlopen() LStore libraries: " << dlerror();
    }

    char * retval = nullptr;
    // Explicitly state the size of these values, keeps weird 64/32 bit stuff away
    REDD_LOAD_SYMBOL( redd_init, int32_t(*)()); 
    REDD_LOAD_SYMBOL( redd_read, int64_t(*)(void *, char*, int64_t));
    REDD_LOAD_SYMBOL( redd_lseek, int64_t(*)(void*, int64_t, uint32_t));
    REDD_LOAD_SYMBOL( redd_open, void*(*)(const char*,int,int));
    REDD_LOAD_SYMBOL( redd_write, int64_t(*)(void *, const char *, int64_t));
    REDD_LOAD_SYMBOL( redd_term, int32_t(*)());
    REDD_LOAD_SYMBOL( redd_errno,  int32_t(*)());
    REDD_LOAD_SYMBOL( redd_strerror, const std::string & (*)());

    if ( (*redd_init)() ) {
        throw cms::Exception("LStoreFile::loadLibrary()")
            << "Error in redd_init: " << (*redd_strerror)();
    }
    m_is_loaded = true;

}

void LStoreFile::closeLibrary() {
    try {
        LStoreFile::MutexWrapper lockObj( & this->m_dlopen_lock );
        
        // What is the correct idiom for propagating error messages 
        // in functions that are exclusively called in destructors?
        // Seriously. I have no idea
        // melo
        if ( m_is_loaded ) {
            if ( (*redd_term)() ) {
                throw cms::Exception("LStoreFile::closeLibrary()")
                    << "Error in redd_term: " << (*redd_strerror)();
            }
        }
        if ( m_library_handle != nullptr ) {
            if ( dlclose( m_library_handle ) ) {
                throw cms::Exception("LStoreFile::closeLibrary()")
                    << "Error on dlclose(): " << dlerror();
            }
        }
    } catch (cms::Exception & e) {
        edm::LogError("LStoreFileError")
          << "LStoreFile had an error in its destructor: " << e;
    }
    m_is_loaded = false;
}


void
LStoreFile::create (const char *name,
            bool exclusive /* = false */,
            int perms /* = 066 */)
{
  open (name,
        (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate
         | (exclusive ? IOFlags::OpenExclusive : 0)),
        perms);
}

void
LStoreFile::create (const std::string &name,
                    bool exclusive /* = false */,
                    int perms /* = 066 */)
{
  open (name.c_str (),
        (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate
         | (exclusive ? IOFlags::OpenExclusive : 0)),
        perms);
}

void
LStoreFile::open (const std::string &name,
                  int flags /* = IOFlags::OpenRead */,
                  int perms /* = 066 */)
{ open (name.c_str (), flags, perms); }

void
LStoreFile::open (const char *name,
                  int flags /* = IOFlags::OpenRead */,
                  int perms /* = 066 */)
{
  // Actual open
  if ((name == nullptr) || (*name == 0))
    throw cms::Exception("LStoreFile::open()")
      << "Cannot open a file without a name";

  if ((flags & (IOFlags::OpenRead | IOFlags::OpenWrite)) == 0)
    throw cms::Exception("LStoreFile::open()")
      << "Must open file '" << name << "' at least for read or write";

  // If I am already open, close old file first
  if (m_fd != nullptr && m_close)
    close ();

  // Translate our flags to system flags
  int openflags = 0;

  if ((flags & IOFlags::OpenRead) && (flags & IOFlags::OpenWrite))
    openflags |= O_RDWR;
  else if (flags & IOFlags::OpenRead)
    openflags |= O_RDONLY;
  else if (flags & IOFlags::OpenWrite)
    openflags |= O_WRONLY;

  if (flags & IOFlags::OpenNonBlock)
    openflags |= O_NONBLOCK;

  if (flags & IOFlags::OpenAppend)
    openflags |= O_APPEND;

  if (flags & IOFlags::OpenCreate)
    openflags |= O_CREAT;

  if (flags & IOFlags::OpenExclusive)
    openflags |= O_EXCL;

  if (flags & IOFlags::OpenTruncate)
    openflags |= O_TRUNC;

  void * newfd = nullptr;
  if ((newfd = (*redd_open) (name, openflags, perms)) == nullptr)
    throw cms::Exception("LStoreFile::open()")
      << "redd_open(name='" << name
      << "', flags=0x" << std::hex << openflags
      << ", permissions=0" << std::oct << perms << std::dec
      << ") => error '" << (*redd_strerror)()
      << "' (redd_errno=" << (*redd_errno)() << ")";

  m_name = name;
  m_fd = newfd;

  m_close = true;

  edm::LogInfo("LStoreFileInfo") << "Opened " << m_name;
}

void
LStoreFile::close (void)
{
  if (m_fd == nullptr)
  {
    edm::LogError("LStoreFileError")
      << "LStoreFile::close(name='" << m_name
      << "') called but the file is not open";
    m_close = false;
    return;
  }
  edm::LogInfo("LStoreFile::close()") << "closing " << m_name << std::endl;
  if ((*redd_close) (m_fd) == -1)
    edm::LogWarning("LStoreFileWarning")
      << "redd_close(name='" << m_name
      << "') failed with error '" << (*redd_strerror) ()
      << "' (redd_errno=" << (*redd_errno)() << ")";

  m_close = false;
  m_fd = nullptr;

  // Caused hang.  Will be added back after problem is fixed.
  // edm::LogInfo("LStoreFileInfo") << "Closed " << m_name;
}

void
LStoreFile::abort (void)
{
  if (m_fd != nullptr)
    (*redd_close) (m_fd);

  m_close = false;
  m_fd = nullptr;
}


IOSize
LStoreFile::read (void *into, IOSize n)
{
  IOSize done = 0;
  while (done < n)
  {
    ssize_t s = (*redd_read) (m_fd, (char *) into + done, n - done);
    if (s == -1)
      throw cms::Exception("LStoreFile::read()")
        << "redd_read(name='" << m_name << "', n=" << (n-done)
        << ") failed with error '" << (*redd_strerror)()
        << "' (redd_errno=" << (*redd_errno)() << ")";
   done += s;
  }
  return done;
}

IOSize
LStoreFile::write (const void *from, IOSize n)
{
  IOSize done = 0;
  while (done < n)
  {
    ssize_t s = (*redd_write) (m_fd, (const char *) from + done, n - done);
    if (s == -1)
      throw cms::Exception("LStoreFile::write()")
        << "redd_write(name='" << m_name << "', n=" << (n-done)
        << ") failed with error '" << (*redd_strerror)()
        << "' (redd_errno=" << (*redd_errno)() << ")";
    done += s;
  }

  return done;
}
IOOffset
LStoreFile::position (IOOffset offset, Relative whence /* = SET */)
{
  if (m_fd == nullptr)
    throw cms::Exception("LStoreFile::position()")
      << "LStoreFile::position() called on a closed file";
  if (whence != CURRENT && whence != SET && whence != END)
    throw cms::Exception("LStoreFile::position()")
      << "LStoreFile::position() called with incorrect 'whence' parameter";

  IOOffset  result;
  uint32_t      mywhence = (whence == SET ? SEEK_SET
                    : whence == CURRENT ? SEEK_CUR
                : SEEK_END);
  if ((result = (*redd_lseek) (m_fd, (off_t) offset, (uint32_t)mywhence)) == -1)
    throw cms::Exception("LStoreFile::position()")
      << "redd_lseek64(name='" << m_name << "', offset=" << offset
      << ", whence=" << mywhence << ") failed with error '"
      << (*redd_strerror) () << "' (redd_errno=" << (*redd_errno)() << ")";
  return result;
}

void
LStoreFile::resize (IOOffset /* size */)
{
  throw cms::Exception("LStoreFile::resize()")
    << "LStoreFile::resize(name='" << m_name << "') not implemented";
}



LStoreFile::MutexWrapper::MutexWrapper( pthread_mutex_t * target ) 
{
    m_lock = target;
    pthread_mutex_lock( m_lock ); // never fails
}

LStoreFile::MutexWrapper::~MutexWrapper()
{
    int retval;
    if ( (retval = pthread_mutex_unlock( m_lock )) ) {
        // congrats. pthread_mutex_lock failed and we're in a destructor
        // I don't know what to do here
        // Then again, if the mutex is jammed, things are already boned
        // Cry for a second, then continue with life, I guess
        // melo

        char buf[1024];
        edm::LogError("LStoreFileError")
          << "LStoreFile couldn't unlock a mutex. Not good." 
          << strerror_r( retval, buf, 1024 );
    }
}