XrdOfsCksFile Class Reference

#include <XrdOfsCksFile.hh>

Inheritance diagram for XrdOfsCksFile:

Collaboration diagram for XrdOfsCksFile:

Public Member Functions
	XrdOfsCksFile (const char *tid, const char *path, XrdOssDF *df, XrdCksCalc *cP, bool &delFlag)
virtual	~XrdOfsCksFile ()
int	Close (long long *retsz=0) override
int	Ftruncate (unsigned long long flen) override
int	Open (const char *path, int Oflag, mode_t Mode, XrdOucEnv &env) override
ssize_t	pgWrite (void *buffer, off_t offset, size_t wrlen, uint32_t *csvec, uint64_t opts) override
int	pgWrite (XrdSfsAio *aioparm, uint64_t opts) override
ssize_t	Write (const void *buffer, off_t offset, size_t size) override
int	Write (XrdSfsAio *aiop) override
ssize_t	WriteV (XrdOucIOVec *writeV, int wrvcnt) override
Public Member Functions inherited from XrdOssWrapDF
	XrdOssWrapDF (XrdOssDF &df2Wrap)
virtual	~XrdOssWrapDF ()
virtual int	Clone (const std::vector< XrdOucCloneSeg > &cVec)
virtual int	Clone (XrdOssDF &srcFile)
uint16_t	DFType ()
virtual int	Fchmod (mode_t mode)
virtual int	Fctl (int cmd, int alen, const char *args, char **resp=0)
virtual void	Flush ()
	Flush filesystem cached pages for this file (used for checksums). More...
virtual int	Fstat (struct stat *buf)
virtual int	Fsync ()
virtual int	Fsync (XrdSfsAio *aiop)
virtual bool	getErrMsg (std::string &eText)
virtual int	getFD ()
virtual off_t	getMmap (void **addr)
virtual const char *	getTID ()
virtual int	isCompressed (char *cxidp=0)
virtual int	Opendir (const char *path, XrdOucEnv &env)
virtual ssize_t	pgRead (void *buffer, off_t offset, size_t rdlen, uint32_t *csvec, uint64_t opts)
virtual int	pgRead (XrdSfsAio *aioparm, uint64_t opts)
virtual ssize_t	Read (off_t offset, size_t size)
virtual ssize_t	Read (void *buffer, off_t offset, size_t size)
virtual ssize_t	Read (XrdOucRangeList &rlist)
virtual int	Read (XrdSfsAio *aiop)
virtual int	Readdir (char *buff, int blen)
virtual ssize_t	ReadRaw (void *buffer, off_t offset, size_t size)
virtual ssize_t	ReadV (XrdOucIOVec *readV, int rdvcnt)
virtual int	StatRet (struct stat *Stat)
Public Member Functions inherited from XrdOssDF
	XrdOssDF (const char *tid="", uint16_t dftype=0, int fdnum=-1)
virtual	~XrdOssDF ()
uint16_t	DFType ()

Static Public Member Functions
static void	Init (XrdCks *cp, XrdOucEnv *ep)
static void	setRDSZ (int sz)

Additional Inherited Members
Static Public Attributes inherited from XrdOssDF
static const uint16_t	DF_isDir = 0x0001
	Object is for a directory. More...
static const uint16_t	DF_isFile = 0x0002
	Object is for a file. More...
static const uint16_t	DF_isProxy = 0x0010
	Object is a proxy object. More...
static const uint64_t	doCalc = 0x4000000000000000ULL
	pgw: Calculate checksums More...
static const int	Fctl_ckpObj = 0
static const int	Fctl_QFinfo = 3
static const int	Fctl_setFD = 2
static const int	Fctl_utimes = 1
static const uint64_t	Verify = 0x8000000000000000ULL
	all: Verify checksums More...
Protected Attributes inherited from XrdOssWrapDF
XrdOssDF &	wrapDF
Protected Attributes inherited from XrdOssDF
uint16_t	dfType
int	fd
off_t	pgwEOF
short	rsvd
const char *	tident

Detailed Description

Definition at line 45 of file XrdOfsCksFile.hh.

Constructor & Destructor Documentation

XrdOfsCksFile()

XrdOfsCksFile::XrdOfsCksFile	(	const char *	tid,
		const char *	path,
		XrdOssDF *	df,
		XrdCksCalc *	cP,
		bool &	delFlag
	)

Definition at line 59 of file XrdOfsCksFile.cc.

                            : XrdOssWrapDF(*df),
                              tident(tid), fPath(strdup(path)), ossDF(df),
                              calcP(cP), altcP(0), viaDel(delF), nextOff(0),
                              ioBuff(0)
{
// Obtain information about the chacksum we are to use. It should have been
// pre-screened for viability, but we check it again just to make sure and
// to setup the proper execution path.
//
   int rc, sz;
   char eBuff[128];
 
// Set the name and get the size of the checksum
//
   cksName = cP->Type(sz);
   Dirty = false;
 
 
// Determine how we will compute the real-time checksum. It will either be
// either combinable via a re-read computation.
//
   if (cP->Combinable() && (sz == (int)sizeof(uint32_t)))
      {ProcessRTC = &XrdOfsCksFile::RTC_CB32;
       altcP = calcP->New();
      } else {
       ProcessRTC = &XrdOfsCksFile::RTC_NCXX;
       if ((rc = posix_memalign(&ioBuff, 4096, ioBlen)))
          {snprintf(eBuff, sizeof(eBuff),
                    "get buffer for real-time %s checksum for", cksName);
           eLog.Emsg("ckscon", rc, eBuff, path);
           Dirty = true;
          }
      }
}

References XrdCksCalc::Combinable(), XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdCksCalc::New(), and XrdCksCalc::Type().

Here is the call graph for this function:

~XrdOfsCksFile()

XrdOfsCksFile::~XrdOfsCksFile ( )

virtual

Definition at line 100 of file XrdOfsCksFile.cc.

{
// Cleanup
//
   if (ossDF)   delete ossDF;
   if (calcP)   calcP->Recycle();
   if (altcP)   altcP->Recycle();
   if (fPath)   free(fPath);
   if (ioBuff)  free(ioBuff);
}

References XrdCksCalc::Recycle().

Here is the call graph for this function:

Member Function Documentation

Close()

int XrdOfsCksFile::Close ( long long *  retsz = 0 )

overridevirtual

Close file.

Parameters

retsz

If not nil, where the size of the file is to be returned.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 122 of file XrdOfsCksFile.cc.

{
   XrdCksData cksData;
   struct stat Stat;
   int csSize, rc;;
 
// Process checksum if it is valid
//
   cksMtx.Lock();
   while(!Dirty) // This is not a loop but avoids deeply next if's.
        {char  eBuff[256];
 
         // If we are here vecause of a delete, skip setting checksum
         //
         if (viaDel)
            {snprintf(eBuff, sizeof(eBuff), "File not properly closed; "
                      "real-time %s checksum was not set for", cksName);
             eLog.Emsg("ckscls", eBuff, fPath);
             break;
            }
 
         // Verify that checksum was fully calculated
         //
 
         // Verify that all data has been written for this checksum
         //
         if (segMap.size())
            {auto it = segMap.begin();
             snprintf(eBuff, sizeof(eBuff),
                             "%lld bytes missing at offset %lld; real-time %s",
                             (long long)(it->second.segBeg - nextOff),
                             (long long)nextOff, cksName);
             eLog.Emsg("ckcls", eBuff, "checksum was not set for", fPath);
             break;
            }
 
         // Fill out the checksum information
         //
         memset((void*)&cksData, 0, sizeof(cksData));
         cksData.Set(calcP->Type(csSize));
         cksData.Length = csSize;
         memcpy(cksData.Value, calcP->Final(), csSize);
 
         if ((rc = ossDF->Fstat(&Stat)))
            {eLog.Emsg("clscls", rc, "get real-time checksum mtime for", fPath);
             break;
            }
 
         cksData.fmTime = static_cast<long long>(Stat.st_mtime);
         cksData.csTime = static_cast<int>(time(0) - Stat.st_mtime);
 
         if ((rc = cksP->Set(fPath, cksData, 1)))
            eLog.Emsg("ckscls", rc, "set real-time checksum for", fPath);
 
         break;
        }
 
// Issue close to the underlying object
//
   Dirty = true; // Prevent re-entry processing
   cksMtx.UnLock();
   return wrapDF.Close(retsz);
}

References XrdOssDF::Close(), XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdCksCalc::Final(), XrdOssDF::Fstat(), XrdSysMutex::Lock(), Stat, stat, XrdCksCalc::Type(), XrdSysMutex::UnLock(), and XrdOssWrapDF::wrapDF.

Here is the call graph for this function:

Ftruncate()

int XrdOfsCksFile::Ftruncate ( unsigned long long  flen )

overridevirtual

Set the size of the associated file.

Parameters

flen	- The new size of the file.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 196 of file XrdOfsCksFile.cc.

{
 
// Execute the truncate
//
   int rc = wrapDF.Ftruncate(flen);
 
// We support streaming checksum only when the truncate makes the file 0 length
//
   if (!Dirty)
      {if (rc < 0)
          {eLog.Emsg("ckstrunc", rc, "continue real-time checksum for", fPath);
           Dirty = true;
          } else {
           if (flen)
              {eLog.Emsg("ckstrunc","Unable to continue real-time checksum for",
                         fPath, "; truncate arg not 0.");
               Dirty = true;
              } else {
               nextOff = 0;
               segMap.clear();
               calcP->Init();
              }
          }
      }
 
// All done
//
   return rc;
}

References XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdOssDF::Ftruncate(), XrdCksCalc::Init(), and XrdOssWrapDF::wrapDF.

Here is the call graph for this function:

Init()

void XrdOfsCksFile::Init ( XrdCks *  cp, XrdOucEnv *  ep  )

static

Definition at line 231 of file XrdOfsCksFile.cc.

{
// Record the checksum manager
//
   cksP = cp;
}

Open()

int XrdOfsCksFile::Open ( const char *  path, int  Oflag, mode_t  Mode, XrdOucEnv &  env  )

overridevirtual

Open a file.

Parameters

path	- Pointer to the path of the file to be opened.
Oflag	- Standard open flags.
Mode	- File open mode (ignored unless creating a file).
env	- Reference to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 242 of file XrdOfsCksFile.cc.

{
// Make sure we have a clean setup. If not return an error.
//
   if (Dirty) return -ENOTSUP;
 
// We intercept open because for non-combinable checksums we need to make
// sure the file is open in r/w mode. Since we don't support such checksums
// yet, the code below is commented out.
//
/* if (!(calcp->Combinable()))
      {Oflag &= ~O_ACCMODE;
       Oflag |= O_RDWR;
      }
*/
// Issue open and if unsuccessful, mark this as a dirty object
//
   int rc = wrapDF.Open(path, Oflag, Mode, env);
   if (rc) Dirty = true;
   return rc;
}

References Mode, XrdOssDF::Open(), and XrdOssWrapDF::wrapDF.

Here is the call graph for this function:

pgWrite() [1/2]

ssize_t XrdOfsCksFile::pgWrite ( void *  buffer, off_t  offset, size_t  wrlen, uint32_t *  csvec, uint64_t  opts  )

overridevirtual

Write file pages into a file with corresponding checksums.

Parameters

buffer	- pointer to buffer containing the bytes to write.
offset	- The offset where the write is to start. It must be page aligned.
wrlen	- The number of bytes to write. If amount is not an integral number of XrdSys::PageSize bytes, then this must be the last write to the file at or above the offset.
csvec	- A vector which contains the corresponding CRC32 checksum for each page. It must be size to wrlen/XrdSys::PageSize + (wrlenXrdSys::PageSize != 0)
opts	- Processing options (see above).

Returns

>= 0 The number of bytes written upon success. or -errno or -osserr upon failure. (see XrdOssError.hh).

< 0 -errno or -osserr upon failure. (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 269 of file XrdOfsCksFile.cc.

{
   const char* eText;
 
// We will only continue the checksum if the underlying write succeeds
//
  ssize_t retval = wrapDF.pgWrite(buffer, offset, wrlen, csvec, opts);
 
// Continue the streaming checksum if at all possible
//
   if (!Dirty)
      {if (retval < 0)
          {eLog.Emsg("ckspgw", retval, "continue real-time checksum for",fPath);
           Dirty = true;
          } else {
           if ((eText = (this->*ProcessRTC)(buffer, offset, wrlen)))
              {eLog.Emsg("ckspgw","unable to continue real-time checksum for",
                                 fPath, eText);
              }
          }
      }
 
// Return actual result
//
   return retval;
}

References XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), opts, XrdOssDF::pgWrite(), and XrdOssWrapDF::wrapDF.

Here is the call graph for this function:

pgWrite() [2/2]

int XrdOfsCksFile::pgWrite ( XrdSfsAio *  aioparm, uint64_t  opts  )

overridevirtual

Write file pages and checksums using asynchronous I/O.

Parameters

aioparm	- Pointer to async I/O object controlling the I/O.
opts	- Processing options (see above).

Returns

0 upon if request started success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 302 of file XrdOfsCksFile.cc.

{
   const char* eText;
 
// It is too complicated to do the async I/O before doing the checksum
//
   if (!Dirty)
      {if ((eText = (this->*ProcessRTC)((void *)aioparm->sfsAio.aio_buf,
                                        (off_t) aioparm->sfsAio.aio_offset,
                                        (size_t)aioparm->sfsAio.aio_nbytes)))
          {eLog.Emsg("cksaiopw", "Unable to continue real-time checksum for",
                               fPath, eText);
           Dirty = true;
          }
      }
 
// Now do the I/O
//
   return wrapDF.pgWrite(aioparm, opts);
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), opts, XrdOssDF::pgWrite(), XrdSfsAio::sfsAio, and XrdOssWrapDF::wrapDF.

Here is the call graph for this function:

setRDSZ()

static void XrdOfsCksFile::setRDSZ ( int  sz )

inlinestatic

Definition at line 134 of file XrdOfsCksFile.hh.

                        {sz = ((sz/65536) + (sz%65536 != 0)) * 65536;
                         if (sz > 2*1024*1024) ioBlen = 2*1024*1024;
                            else ioBlen = sz;
                        }

Write() [1/2]

ssize_t XrdOfsCksFile::Write ( const void *  buffer, off_t  offset, size_t  size  )

overridevirtual

Write file bytes from a buffer.

Parameters

buffer	- pointer to buffer where the bytes reside.
offset	- The offset where the write is to start.
size	- The number of bytes to write.

Returns

>= 0 The number of bytes that were written.

< 0 -errno or -osserr upon failure (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 338 of file XrdOfsCksFile.cc.

{
   const char* eText;
 
// We will only continue the checksum if the underlying write succeeds
//
  ssize_t retval = wrapDF.Write(buff, offset, blen);
 
// Continue the streaming checksum if at all possible
//
   if (!Dirty)
      {if (retval < 0)
          {eLog.Emsg("cksw", retval, "continue streaming checksum for", fPath);
           Dirty = true;
          } else {
           if ((eText = (this->*ProcessRTC)(buff, offset, blen)))
              {eLog.Emsg("cksw", "Unable to continue real-time checksum for",
                               fPath, eText);
               Dirty = true;
              }
          }
      }
 
// Return actual result
//
   return retval;
}

References XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdOssWrapDF::wrapDF, and XrdOssDF::Write().

Here is the call graph for this function:

Write() [2/2]

int XrdOfsCksFile::Write ( XrdSfsAio *  aiop )

overridevirtual

Write file bytes using asynchronous I/O.

Parameters

aiop	- Pointer to async I/O object controlling the I/O.

Returns

0 upon if request started success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 368 of file XrdOfsCksFile.cc.

{
   const char* eText;
 
// It is too complicated to do the async I/O before doing the checksum
//
   if (!Dirty)
      {if ((eText = (this->*ProcessRTC)((void *)aioparm->sfsAio.aio_buf,
                                        (off_t) aioparm->sfsAio.aio_offset,
                                        (size_t)aioparm->sfsAio.aio_nbytes)))
          {eLog.Emsg("cksaiopw", "Unable to continue real-time checksum for",
                               fPath, eText);
           Dirty = true;
          }
      }
 
// Now do the I/O
//
   return wrapDF.Write(aioparm);
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdSfsAio::sfsAio, XrdOssWrapDF::wrapDF, and XrdOssDF::Write().

Here is the call graph for this function:

WriteV()

ssize_t XrdOfsCksFile::WriteV ( XrdOucIOVec *  writeV, int  wrvcnt  )

overridevirtual

Write file bytes as directed by the write vector.

Parameters

writeV	pointer to the array of write requests.
wrvcnt	the number of elements in writeV.

Returns

>=0 The numbe of bytes read.

< 0 -errno or -osserr upon failure (see XrdOssError.hh).

Reimplemented from XrdOssWrapDF.

Definition at line 393 of file XrdOfsCksFile.cc.

{
 
// We do not support streaming checksums when WriteV is used
//
   if (!Dirty)
      {eLog.Emsg("ckswv", "Unable to continue streaming checksum for",
                         fPath, "; WriteV() conflict.");
       Dirty = true;
      }
 
// We still handle the actual write
//
   return wrapDF.WriteV(writeV, n);
}

References XrdOfsPrepGPIReal::eLog, XrdSysError::Emsg(), XrdOssWrapDF::wrapDF, and XrdOssDF::WriteV().

Here is the call graph for this function:

---

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

• XrdOfsCksFile.hh
• XrdOfsCksFile.cc