XrdOssCsiTagstoreFile Class Reference

#include <XrdOssCsiTagstoreFile.hh>

Inheritance diagram for XrdOssCsiTagstoreFile:

Collaboration diagram for XrdOssCsiTagstoreFile:

Public Member Functions
	XrdOssCsiTagstoreFile (const std::string &fn, std::unique_ptr< XrdOssDF > fd, const char *tid)
virtual	~XrdOssCsiTagstoreFile ()
virtual int	Close ()
virtual void	Flush ()
virtual int	Fsync ()
virtual off_t	GetTrackedDataSize () const
virtual off_t	GetTrackedTagSize () const
virtual bool	IsVerified () const
virtual int	Open (const char *, off_t, int, XrdOucEnv &)
virtual ssize_t	ReadTags (uint32_t *, off_t, size_t)
virtual int	ResetSizes (const off_t size)
virtual int	SetTrackedSize (const off_t size)
virtual int	SetUnverified ()
virtual int	Truncate (off_t, bool)
virtual ssize_t	WriteTags (const uint32_t *, off_t, size_t)
Public Member Functions inherited from XrdOssCsiTagstore
virtual	~XrdOssCsiTagstore ()

Static Public Member Functions
static ssize_t	fullread (XrdOssDF &fd, void *buff, const off_t off, const size_t sz)
static ssize_t	fullwrite (XrdOssDF &fd, const void *buff, const off_t off, const size_t sz)

Additional Inherited Members
Static Public Attributes inherited from XrdOssCsiTagstore
static const uint32_t	csVer = 0x00000001

Detailed Description

Definition at line 42 of file XrdOssCsiTagstoreFile.hh.

Constructor & Destructor Documentation

XrdOssCsiTagstoreFile()

XrdOssCsiTagstoreFile::XrdOssCsiTagstoreFile ( const std::string & fn, std::unique_ptr< XrdOssDF > fd, const char * tid )

inline

Definition at line 45 of file XrdOssCsiTagstoreFile.hh.

: fn_(fn), fd_(std::move(fd)), trackinglen_(0), isOpen(false), tident_(tid), tident(tident_.c_str()) { }

~XrdOssCsiTagstoreFile()

virtual XrdOssCsiTagstoreFile::~XrdOssCsiTagstoreFile ( )

inlinevirtual

Definition at line 46 of file XrdOssCsiTagstoreFile.hh.

{ if (isOpen) { (void)Close(); } }

References Close().

Here is the call graph for this function:

Member Function Documentation

Close()

int XrdOssCsiTagstoreFile::Close ( )

virtual

Implements XrdOssCsiTagstore.

Definition at line 176 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen) return -EBADF;
   isOpen = false;
   return fd_->Close();
}

Referenced by ~XrdOssCsiTagstoreFile().

Here is the caller graph for this function:

Flush()

void XrdOssCsiTagstoreFile::Flush ( )

virtual

Implements XrdOssCsiTagstore.

Definition at line 170 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen) return;
   fd_->Flush();
}

Fsync()

int XrdOssCsiTagstoreFile::Fsync ( )

virtual

Implements XrdOssCsiTagstore.

Definition at line 164 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen) return -EBADF;
   return fd_->Fsync();
}

fullread()

static ssize_t XrdOssCsiTagstoreFile::fullread ( XrdOssDF & fd, void * buff, const off_t off, const size_t sz )

inlinestatic

Definition at line 106 of file XrdOssCsiTagstoreFile.hh.

   {
      size_t toread = sz, nread = 0;
      uint8_t *p = (uint8_t*)buff;
      while(toread>0)
      {
         const ssize_t rret = fd.Read(&p[nread], off+nread, toread);
         if (rret<0) return rret;
         if (rret==0) break;
         toread -= rret;
         nread += rret;
      }
      if (nread != sz) return -EDOM;
      return nread;
   }

References XrdOssDF::Read().

Referenced by Open(), and ReadTags().

Here is the call graph for this function:

Here is the caller graph for this function:

fullwrite()

static ssize_t XrdOssCsiTagstoreFile::fullwrite ( XrdOssDF & fd, const void * buff, const off_t off, const size_t sz )

inlinestatic

Definition at line 122 of file XrdOssCsiTagstoreFile.hh.

   {
      size_t towrite = sz, nwritten = 0;
      const uint8_t *p = (const uint8_t*)buff;
      while(towrite>0)
      {
         const ssize_t wret = fd.Write(&p[nwritten], off+nwritten, towrite);
         if (wret<0) return wret;
         towrite -= wret;
         nwritten += wret;
      }
      return nwritten;
   }

References XrdOssDF::Write().

Referenced by WriteTags().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTrackedDataSize()

virtual off_t XrdOssCsiTagstoreFile::GetTrackedDataSize ( ) const

inlinevirtual

Implements XrdOssCsiTagstore.

Definition at line 65 of file XrdOssCsiTagstoreFile.hh.

   {
      if (!isOpen) return 0;
      return actualsize_;
   }

GetTrackedTagSize()

virtual off_t XrdOssCsiTagstoreFile::GetTrackedTagSize ( ) const

inlinevirtual

Implements XrdOssCsiTagstore.

Definition at line 59 of file XrdOssCsiTagstoreFile.hh.

   {
      if (!isOpen) return 0;
      return trackinglen_;
   }

IsVerified()

virtual bool XrdOssCsiTagstoreFile::IsVerified ( ) const

inlinevirtual

Implements XrdOssCsiTagstore.

Definition at line 88 of file XrdOssCsiTagstoreFile.hh.

   {
      if (!isOpen) return false;
     if ((hflags_ & XrdOssCsiTagstore::csVer)) return true;
     return false;
   }

References XrdOssCsiTagstore::csVer.

Open()

int XrdOssCsiTagstoreFile::Open ( const char * path, off_t dsize, int Oflag, XrdOucEnv & Env )

virtual

Implements XrdOssCsiTagstore.

Definition at line 41 of file XrdOssCsiTagstoreFile.cc.

{
   EPNAME("TagstoreFile::Open");
 
   const int ret = fd_->Open(path, Oflag, 0666, Env);
   if (ret<0)
   {
      return ret;
   }
   isOpen = true;
 
   struct guard_s
   {
      guard_s(XrdOssDF *fd, bool &isopen) : fd_(fd), isopen_(isopen) { }
      ~guard_s() { if (fd_) { fd_->Close(); isopen_ = false; } }
      void disarm() { fd_ = NULL; }
 
      XrdOssDF *fd_;
      bool &isopen_;
   } fdguard(fd_.get(),isOpen);
 
   const static int little = 1;
   if (*(char const *)&little)
   {
      machineIsBige_ = false;
   }
   else
   {
      machineIsBige_ = true;
   }
 
   uint32_t magic;
 
   const ssize_t mread = XrdOssCsiTagstoreFile::fullread(*fd_, header_, 0, 20);
   bool mok = false;
   if (mread >= 0)
   {
      memcpy(&magic, header_, 4);
      if (magic == cmagic_)
      {
         fileIsBige_ = machineIsBige_;
         mok = true;
      }
      else if (magic == bswap_32(cmagic_))
      {
         fileIsBige_ = !machineIsBige_;
         mok = true;
      }
   }
 
   if (!mok)
   {
      fileIsBige_ = machineIsBige_;
      hflags_ = (dsize==0) ? XrdOssCsiTagstore::csVer : 0;
      trackinglen_ = 0;
      const int stret = MarshallAndWriteHeader();
      if (stret<0) return stret;
   }
   else
   {
      memcpy(&trackinglen_, &header_[4], 8);
      if (fileIsBige_ != machineIsBige_)
      {
         trackinglen_ = bswap_64(trackinglen_);
      }
      memcpy(&hflags_,&header_[12], 4);
      if (fileIsBige_ != machineIsBige_)
      {
         hflags_ = bswap_32(hflags_);
      }
      const uint32_t cv = XrdOucCRC::Calc32C(header_, 16, 0U);
      uint32_t rv;
      memcpy(&rv, &header_[16], 4);
      if (fileIsBige_ != machineIsBige_) rv = bswap_32(rv);
      if (rv != cv)
      {
         return -EDOM;
      }
   }
 
   if (trackinglen_ != dsize)
   {
      TRACE(Warn, "Tagfile disagrees with actual filelength for " << fn_ << " expected " << trackinglen_ << " actual " << dsize);
   }
 
   const int rsret = ResetSizes(dsize);
   if (rsret<0) return rsret;
 
   fdguard.disarm();
   return 0;
}

References XrdOucCRC::Calc32C(), XrdOssCsiTagstore::csVer, EPNAME, fullread(), ResetSizes(), and TRACE.

Here is the call graph for this function:

ReadTags()

ssize_t XrdOssCsiTagstoreFile::ReadTags ( uint32_t * buf, off_t off, size_t n )

virtual

Implements XrdOssCsiTagstore.

Definition at line 193 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen) return -EBADF;
   if (machineIsBige_ != fileIsBige_) return ReadTags_swap(buf, off, n);
 
   const ssize_t nread = XrdOssCsiTagstoreFile::fullread(*fd_, buf, 20LL+4*off, 4*n);
   if (nread<0) return nread;
   return nread/4;
}

References fullread().

Here is the call graph for this function:

ResetSizes()

int XrdOssCsiTagstoreFile::ResetSizes ( const off_t size )

virtual

Implements XrdOssCsiTagstore.

Definition at line 133 of file XrdOssCsiTagstoreFile.cc.

{
   EPNAME("ResetSizes");
   if (!isOpen) return -EBADF;
   actualsize_ = size;
   struct stat sb;
   const int ssret = fd_->Fstat(&sb);
   if (ssret<0) return ssret;
   const off_t expected_tagfile_size = 20LL + 4*((trackinglen_+XrdSys::PageSize-1)/XrdSys::PageSize);
   // truncate can be relatively slow
   if (expected_tagfile_size < sb.st_size)
   {
      TRACE(Warn, "Truncating tagfile to " << expected_tagfile_size <<
         ", from current size " << sb.st_size << " for " << fn_);
      const int tret = fd_->Ftruncate(expected_tagfile_size);
      if (tret<0) return tret;
   }
   else if (expected_tagfile_size > sb.st_size)
   {
      off_t nb = 0;
      if (sb.st_size>20) nb = (sb.st_size - 20)/4;
      TRACE(Warn, "Reducing tracked size to " << (nb*XrdSys::PageSize) <<
         " instead of " << trackinglen_ << ", because of short tagfile for " << fn_);
      const int stret = WriteTrackedTagSize(nb*XrdSys::PageSize);
      if (stret<0) return stret;
      const int tret = fd_->Ftruncate(20LL + 4*nb);
      if (tret<0) return tret;
   }
   return 0;
}

References EPNAME, XrdSys::PageSize, stat, and TRACE.

Referenced by Open().

Here is the caller graph for this function:

SetTrackedSize()

virtual int XrdOssCsiTagstoreFile::SetTrackedSize ( const off_t size )

inlinevirtual

Implements XrdOssCsiTagstore.

Definition at line 73 of file XrdOssCsiTagstoreFile.hh.

   {
      if (!isOpen) return -EBADF;
      if (size > actualsize_)
      {
         actualsize_ = size;
      }
      if (size != trackinglen_)
      {
         const int wtt = WriteTrackedTagSize(size);
         if (wtt<0) return wtt;
      }
      return 0;
   }

SetUnverified()

virtual int XrdOssCsiTagstoreFile::SetUnverified ( )

inlinevirtual

Implements XrdOssCsiTagstore.

Definition at line 95 of file XrdOssCsiTagstoreFile.hh.

   {
      if (!isOpen) return -EBADF;
     if ((hflags_ & XrdOssCsiTagstore::csVer))
     {
       hflags_ &= ~XrdOssCsiTagstore::csVer;
       return MarshallAndWriteHeader();
     }
     return 0;
   }

References XrdOssCsiTagstore::csVer.

Truncate()

int XrdOssCsiTagstoreFile::Truncate ( off_t size, bool datatoo )

virtual

Implements XrdOssCsiTagstore.

Definition at line 203 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen)
   {
      return -EBADF;
   }
 
   // set tag file to correct length for value of size
   const off_t expected_tagfile_size = 20LL + 4*((size+XrdSys::PageSize-1)/XrdSys::PageSize);
   const int tret = fd_->Ftruncate(expected_tagfile_size);
 
   // if failed to set the tagfile length return error before updating header
   if (tret != XrdOssOK) return tret;
 
   // truncating down to zero, so reset to content verified
   if (datatoo && size==0) hflags_ |= XrdOssCsiTagstore::csVer;
 
   int wtt = WriteTrackedTagSize(size);
   if (wtt<0) return wtt;
 
   if (datatoo) actualsize_ = size;
   return 0;
}

References XrdOssCsiTagstore::csVer, XrdSys::PageSize, and XrdOssOK.

WriteTags()

ssize_t XrdOssCsiTagstoreFile::WriteTags ( const uint32_t * buf, off_t off, size_t n )

virtual

Implements XrdOssCsiTagstore.

Definition at line 183 of file XrdOssCsiTagstoreFile.cc.

{
   if (!isOpen) return -EBADF;
   if (machineIsBige_ != fileIsBige_) return WriteTags_swap(buf, off, n);
 
   const ssize_t nwritten = XrdOssCsiTagstoreFile::fullwrite(*fd_, buf, 20LL+4*off, 4*n);
   if (nwritten<0) return nwritten;
   return nwritten/4;
}

References fullwrite().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• XrdOssCsiTagstoreFile.hh
• XrdOssCsiTagstoreFile.cc