LStoreFile Class Reference

#include <LStoreFile.h>

Inheritance diagram for LStoreFile:

Classes
class	MutexWrapper

Public Member Functions
virtual void	abort (void)
void	close (void) override
virtual void	create (const char *name, bool exclusive=false, int perms=0666)
virtual void	create (const std::string &name, bool exclusive=false, int perms=0666)
	LStoreFile (const char *name, int flags=IOFlags::OpenRead, int perms=0666)
	LStoreFile (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)
	LStoreFile (void *fd)
	LStoreFile (void)
virtual void	open (const char *name, int flags=IOFlags::OpenRead, int perms=0666)
virtual void	open (const std::string &name, int flags=IOFlags::OpenRead, int perms=0666)
IOOffset	position (IOOffset offset, Relative whence=SET) override
virtual IOOffset	position (IOOffset offset, Relative whence=SET)=0
virtual IOOffset	position (void) const
IOSize	read (IOBuffer into, IOOffset pos)
IOSize	read (void *into, IOSize n) override
virtual IOSize	read (void *into, IOSize n, IOOffset pos)
void	resize (IOOffset size) override
IOSize	write (const void *from, IOSize n) override
virtual IOSize	write (const void *from, IOSize n, IOOffset pos)
IOSize	write (IOBuffer from, IOOffset pos)
	~LStoreFile (void) override
Public Member Functions inherited from Storage
virtual bool	eof (void) const
virtual void	flush (void)
virtual IOOffset	position (void) const
virtual bool	prefetch (const IOPosBuffer *what, IOSize n)
IOSize	read (IOBuffer into)
IOSize	read (IOBuffer into, IOOffset pos)
virtual IOSize	read (void *into, IOSize n)=0
virtual IOSize	read (void *into, IOSize n, IOOffset pos)
int	read (void)
virtual IOSize	readv (IOBuffer *into, IOSize buffers)
virtual IOSize	readv (IOPosBuffer *into, IOSize buffers)
virtual void	rewind (void)
virtual IOOffset	size (void) const
	Storage (void)
virtual IOSize	write (const void *from, IOSize n)=0
virtual IOSize	write (const void *from, IOSize n, IOOffset pos)
IOSize	write (IOBuffer from)
IOSize	write (IOBuffer from, IOOffset pos)
IOSize	write (unsigned char byte)
virtual IOSize	writev (const IOBuffer *from, IOSize buffers)
virtual IOSize	writev (const IOPosBuffer *from, IOSize buffers)
	~Storage (void) override
Public Member Functions inherited from IOInput
IOSize	read (IOBuffer into)
int	read (void)
virtual IOSize	readv (IOBuffer *into, IOSize buffers)
IOSize	xread (IOBuffer into)
IOSize	xread (void *into, IOSize n)
IOSize	xreadv (IOBuffer *into, IOSize buffers)
virtual	~IOInput (void)
	Destruct the stream. A no-op. More...
Public Member Functions inherited from IOOutput
IOSize	write (IOBuffer from)
IOSize	write (unsigned char byte)
virtual IOSize	writev (const IOBuffer *from, IOSize buffers)
IOSize	xwrite (const void *from, IOSize n)
IOSize	xwrite (IOBuffer from)
IOSize	xwritev (const IOBuffer *from, IOSize buffers)
virtual	~IOOutput (void)
	Destruct the stream. A no-op. More...

Static Public Attributes
static pthread_mutex_t	m_dlopen_lock = PTHREAD_MUTEX_INITIALIZER

Private Member Functions
void	closeLibrary ()
void	loadLibrary ()

Private Attributes
bool	m_close
void *	m_fd
bool	m_is_loaded
void *	m_library_handle
std::string	m_name
int32_t(*	redd_close )(void *)
int32_t(*	redd_errno )()
int32_t(*	redd_init )()
int64_t(*	redd_lseek )(void *, int64_t, uint32_t)
void *(*	redd_open )(const char *, int32_t, int32_t)
int64_t(*	redd_read )(void *, char *, int64_t)
const std::string &(*	redd_strerror )()
int32_t(*	redd_term )()
int64_t(*	redd_write )(void *, const char *, int64_t)

Additional Inherited Members
Public Types inherited from Storage
enum	Relative { SET, CURRENT, END }

Detailed Description

Definition at line 8 of file LStoreFile.h.

Constructor & Destructor Documentation

LStoreFile() [1/4]

LStoreFile::LStoreFile

(

void

)

Definition at line 16 of file LStoreFile.cc.

    : 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();
}

References loadLibrary().

LStoreFile() [2/4]

LStoreFile::LStoreFile

(

void *

fd

)

Definition at line 34 of file LStoreFile.cc.

    : 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();
}

References loadLibrary().

LStoreFile() [3/4]

LStoreFile::LStoreFile	(	const char *	name,
		int	flags = IOFlags::OpenRead,
		int	perms = 0666
	)

Definition at line 52 of file LStoreFile.cc.

    : m_fd(nullptr), m_close(false), m_is_loaded(false) {
  loadLibrary();
  open(name, flags, perms);
}

References HLT_FULL_cff::flags, loadLibrary(), Skims_PA_cff::name, and open().

LStoreFile() [4/4]

LStoreFile::LStoreFile	(	const std::string &	name,
		int	flags = IOFlags::OpenRead,
		int	perms = 0666
	)

Definition at line 58 of file LStoreFile.cc.

    : m_fd(nullptr), m_close(false), m_is_loaded(false) {
  loadLibrary();
  open(name.c_str(), flags, perms);
}

References HLT_FULL_cff::flags, loadLibrary(), Skims_PA_cff::name, and open().

~LStoreFile()

LStoreFile::~LStoreFile ( void  )

override

Definition at line 64 of file LStoreFile.cc.

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

References closeLibrary(), m_close, and m_name.

Member Function Documentation

abort()

void LStoreFile::abort ( void  )

virtual

Definition at line 226 of file LStoreFile.cc.

                           {
  if (m_fd != nullptr)
    (*redd_close)(m_fd);
 
  m_close = false;
  m_fd = nullptr;
}

References m_close, and m_fd.

close()

void LStoreFile::close ( void  )

overridevirtual

Reimplemented from Storage.

Definition at line 208 of file LStoreFile.cc.

                           {
  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;
}

References m_close, m_fd, m_name, redd_close, and redd_errno.

Referenced by esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), and open().

closeLibrary()

void LStoreFile::closeLibrary ( )

private

Definition at line 116 of file LStoreFile.cc.

                              {
  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;
}

References MillePedeFileConverter_cfg::e, Exception, m_dlopen_lock, m_is_loaded, m_library_handle, and redd_term.

Referenced by ~LStoreFile().

create() [1/2]

void LStoreFile::create ( const char *  name, bool  exclusive = false, int  perms = 0666  )

virtual

Definition at line 141 of file LStoreFile.cc.

                                                                       {
  open(name,
       (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate | (exclusive ? IOFlags::OpenExclusive : 0)),
       perms);
}

References generator_cfi::exclusive, Skims_PA_cff::name, open(), IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

create() [2/2]

void LStoreFile::create ( const std::string &  name, bool  exclusive = false, int  perms = 0666  )

virtual

Definition at line 147 of file LStoreFile.cc.

                                                                            {
  open(name.c_str(),
       (IOFlags::OpenCreate | IOFlags::OpenWrite | IOFlags::OpenTruncate | (exclusive ? IOFlags::OpenExclusive : 0)),
       perms);
}

References generator_cfi::exclusive, Skims_PA_cff::name, open(), IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenTruncate, and IOFlags::OpenWrite.

loadLibrary()

void LStoreFile::loadLibrary ( )

private

Definition at line 84 of file LStoreFile.cc.

                             {
  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;
}

References Exception, m_dlopen_lock, m_is_loaded, m_library_handle, redd_errno, redd_init, REDD_LOAD_SYMBOL, redd_lseek, redd_open, redd_read, redd_strerror, redd_term, redd_write, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by LStoreFile().

open() [1/2]

void LStoreFile::open ( const char *  name, int  flags = IOFlags::OpenRead, int  perms = 0666  )

virtual

Definition at line 157 of file LStoreFile.cc.

                                                                {
  // 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;
}

References close(), TauDecayModes::dec, Exception, HLT_FULL_cff::flags, m_close, m_fd, m_name, Skims_PA_cff::name, O_NONBLOCK, IOFlags::OpenAppend, IOFlags::OpenCreate, IOFlags::OpenExclusive, IOFlags::OpenNonBlock, IOFlags::OpenRead, IOFlags::OpenTruncate, IOFlags::OpenWrite, redd_errno, and redd_open.

Referenced by create(), LStoreFile(), and open().

open() [2/2]

void LStoreFile::open ( const std::string &  name, int  flags = IOFlags::OpenRead, int  perms = 0666  )

virtual

Definition at line 153 of file LStoreFile.cc.

                                                                     {
  open(name.c_str(), flags, perms);
}

References HLT_FULL_cff::flags, Skims_PA_cff::name, and open().

position() [1/3]

IOOffset LStoreFile::position ( IOOffset  offset, Relative  whence = SET  )

overridevirtual

Implements Storage.

Definition at line 263 of file LStoreFile.cc.

                                                                {
  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;
}

References Storage::CURRENT, Storage::END, Exception, m_fd, m_name, hltrates_dqm_sourceclient-live_cfg::offset, redd_errno, redd_lseek, mps_fire::result, and Storage::SET.

Referenced by LStoreStorageMaker::check().

position() [2/3]

virtual IOOffset Storage::position

position() [3/3]

IOOffset Storage::position

Definition at line 72 of file Storage.cc.

                                     {
  Storage *self = const_cast<Storage *>(this);
  return self->position(0, CURRENT);
}

read() [1/3]

IOSize Storage::read

Definition at line 10 of file Storage.cc.

{ return read(into.data(), into.size(), pos); }

read() [2/3]

IOSize LStoreFile::read ( void *  into, IOSize  n  )

overridevirtual

Read into into at most n number of bytes.

If this is a blocking stream, the call will block until some data can be read, end of input is reached, or an exception is thrown. For a non-blocking stream the available input is returned. If none is available, an exception is thrown.

Returns

The number of bytes actually read. This is less or equal to the size of the buffer. Zero indicates that the end of the input has been reached: end of file, or remote end closing for a connected channel like a pipe or a socket. Otherwise the value can be less than requested if limited amount of input is currently available for platform or implementation reasons.

Exceptions

In	case of error, a #IOError exception is thrown. This includes the situation where the input stream is in non-blocking mode and no input is currently available (FIXME: make this simpler; clarify which exception).

Implements IOInput.

Definition at line 234 of file LStoreFile.cc.

                                            {
  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;
}

References fileCollector::done, Exception, m_fd, m_name, dqmiodumpmetadata::n, redd_errno, redd_strerror, and alignCSCRings::s.

read() [3/3]

IOSize Storage::read

Definition at line 12 of file Storage.cc.

                                                       {
  // FIXME: this is not thread safe!  split into separate interface
  // that a particular storage can choose to support or not?  make
  // sure that throw semantics are correct here!
  // FIXME: use saveposition object in case exceptions are thrown?
  IOOffset here = position();
  position(pos);
  n = read(into, n);
  position(here);
  return n;
}

resize()

void LStoreFile::resize ( IOOffset  size )

overridevirtual

Implements Storage.

Definition at line 278 of file LStoreFile.cc.

                                  {
  throw cms::Exception("LStoreFile::resize()") << "LStoreFile::resize(name='" << m_name << "') not implemented";
}

References Exception, and m_name.

write() [1/3]

IOSize LStoreFile::write ( const void *  from, IOSize  n  )

overridevirtual

Write n bytes of data starting at address from.

Returns

The number of bytes written. Normally this will be n, but can be less, even zero, for example if the stream is non-blocking mode and cannot accept input at this time.

Exceptions

In	case of error, an exception is thrown. However if the stream is in non-blocking mode and cannot accept output, it will not throw an exception – the return value will be less than requested.

Implements IOOutput.

Definition at line 247 of file LStoreFile.cc.

                                                   {
  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;
}

References fileCollector::done, Exception, m_fd, m_name, dqmiodumpmetadata::n, redd_errno, redd_strerror, and alignCSCRings::s.

write() [2/3]

IOSize Storage::write

Definition at line 44 of file Storage.cc.

                                                              {
  // FIXME: this is not thread safe!  split into separate interface
  // that a particular storage can choose to support or not?  make
  // sure that throw semantics are correct here!
 
  // FIXME: use saveposition object in case exceptions are thrown?
  IOOffset here = position();
  position(pos);
  n = write(from, n);
  position(here);
  return n;
}

write() [3/3]

IOSize Storage::write

Definition at line 42 of file Storage.cc.

{ return write(from.data(), from.size(), pos); }

Member Data Documentation

m_close

bool LStoreFile::m_close

private

Definition at line 52 of file LStoreFile.h.

Referenced by abort(), close(), open(), and ~LStoreFile().

m_dlopen_lock

pthread_mutex_t LStoreFile::m_dlopen_lock = PTHREAD_MUTEX_INITIALIZER

static

Definition at line 41 of file LStoreFile.h.

Referenced by closeLibrary(), and loadLibrary().

m_fd

void* LStoreFile::m_fd

private

Definition at line 51 of file LStoreFile.h.

Referenced by abort(), close(), open(), position(), read(), and write().

m_is_loaded

bool LStoreFile::m_is_loaded

private

Definition at line 55 of file LStoreFile.h.

Referenced by closeLibrary(), and loadLibrary().

m_library_handle

void* LStoreFile::m_library_handle

private

Definition at line 54 of file LStoreFile.h.

Referenced by closeLibrary(), and loadLibrary().

m_name

std::string LStoreFile::m_name

private

Definition at line 53 of file LStoreFile.h.

Referenced by close(), open(), position(), read(), resize(), write(), and ~LStoreFile().

redd_close

int32_t(* LStoreFile::redd_close) (void *)

private

Definition at line 62 of file LStoreFile.h.

Referenced by close().

redd_errno

int32_t(* LStoreFile::redd_errno) ()

private

Definition at line 67 of file LStoreFile.h.

Referenced by close(), loadLibrary(), open(), position(), read(), and write().

redd_init

int32_t(* LStoreFile::redd_init) ()

private

Definition at line 60 of file LStoreFile.h.

Referenced by loadLibrary().

redd_lseek

int64_t(* LStoreFile::redd_lseek) (void *, int64_t, uint32_t)

private

Definition at line 63 of file LStoreFile.h.

Referenced by loadLibrary(), and position().

redd_open

void*(* LStoreFile::redd_open) (const char *, int32_t, int32_t)

private

Definition at line 64 of file LStoreFile.h.

Referenced by loadLibrary(), and open().

redd_read

int64_t(* LStoreFile::redd_read) (void *, char *, int64_t)

private

Definition at line 61 of file LStoreFile.h.

Referenced by loadLibrary().

redd_strerror

const std::string&(* LStoreFile::redd_strerror) ()

private

Definition at line 68 of file LStoreFile.h.

Referenced by loadLibrary(), read(), and write().

redd_term

int32_t(* LStoreFile::redd_term) ()

private

Definition at line 66 of file LStoreFile.h.

Referenced by closeLibrary(), and loadLibrary().

redd_write

int64_t(* LStoreFile::redd_write) (void *, const char *, int64_t)

private

Definition at line 65 of file LStoreFile.h.

Referenced by loadLibrary().