XrdOfsCPFile Class Reference

#include <XrdOfsCPFile.hh>

Collaboration diagram for XrdOfsCPFile:

Classes
class	rInfo

Public Member Functions
	XrdOfsCPFile (const char *cfn=0)
	~XrdOfsCPFile ()
	Destructor.
int	Append (const char *data, off_t offset, int dlen)
int	Create (const char *lfn, struct stat &Stat)
int	Destroy ()
int	ErrState ()
const char *	FName (bool trim=false)
bool	isActive ()
bool	Reserve (int dlen, int nseg)
int	RestoreInfo (rInfo &rinfo, const char *&ewhy)
int	Sync ()
int	Used (int nseg=0)

Static Public Member Functions
static char *	Target (const char *ckpfn)

Detailed Description

Definition at line 39 of file XrdOfsCPFile.hh.

Constructor & Destructor Documentation

XrdOfsCPFile()

XrdOfsCPFile::XrdOfsCPFile

(

const char *

cfn = 0

)

Constructor

Parameters

cfn	- Pointer to the name of the checkpoint file to use. When supplied, creates are prohibited.

Definition at line 136 of file XrdOfsCPFile.cc.

             : ckpFN(ckpfn ? strdup(ckpfn) : 0), ckpFD(-1),
               ckpDLen(0), ckpSize(0) {}

~XrdOfsCPFile()

XrdOfsCPFile::~XrdOfsCPFile

(

)

Destructor.

Definition at line 144 of file XrdOfsCPFile.cc.

{
 
// Close the file descriptor if need be
//
   if (ckpFD >= 0) close(ckpFD);
   if (ckpFN) free(ckpFN);
}

References close.

Member Function Documentation

Append()

int XrdOfsCPFile::Append	(	const char *	data,
		off_t	offset,
		int	dlen )

Append data to the checkpoint. Appends should be followed by Sync().

Parameters

data	- Pointer to the data to be recorded.
offset	- Offset in the source file where data came from.
dlen	- Length of the data.

Returns

0 upon success and -errno upon failure.

Definition at line 157 of file XrdOfsCPFile.cc.

{
   struct iovec ioV[2];
   cpSeg theSeg;
   int retval;
 
// Account for the data we will be writing
//
   ckpDLen += dlen;
   ckpSize += dlen + segSZ;
 
// Construct the next segment
//
   theSeg.dataOfs = offset;
   theSeg.dataLen = dlen;
 
// Compute checksum of the data and the segment information
//
   theSeg.crc32C = XrdOucCRC::Calc32C(((char *)&theSeg)+crcSZ, segSZ-crcSZ);
   theSeg.crc32C = XrdOucCRC::Calc32C(data, dlen, theSeg.crc32C);
 
// Construct iovec to write both pieces out
//
   ioV[0].iov_base = &theSeg;
   ioV[0].iov_len  = segSZ;
   ioV[1].iov_base = (void *)data;
   ioV[1].iov_len  = dlen;
 
// Write the data out
//
   retval = writev(ckpFD, ioV, 2);
   if (retval != (int)(dlen+segSZ)) return (retval < 0 ? -errno : -EIO);
 
// All done
//
   return 0;
}

References XrdOucCRC::Calc32C(), and writev.

Here is the call graph for this function:

Create()

int XrdOfsCPFile::Create	(	const char *	lfn,
		struct stat &	Stat )

Create a checkpoint

Parameters

lfn	- Pointer to the name of the source file being checkpointed.
Stat	- Reference to source file stat information.

Returns

0 upon success and -errno upon failure.

Definition at line 199 of file XrdOfsCPFile.cc.

{
   static const int oFlag = O_CREAT | O_EXCL  | O_WRONLY;
   static const int oMode = S_IRUSR | S_IWUSR | S_IRGRP;
   struct iovec ioV[2];
   cpHdr theHdr;
   int retval, rc = 0;
 
// Make sure we do not have an active checkpoint here
//
   if (ckpFD >= 0 || ckpFN) return -EEXIST;
 
// Generate the path to the checkpoint file
//
   ckpFN = genCkpPath();
 
// Create the checkpoint file and set its attribute
//
   if ((ckpFD = XrdSysFD_Open(ckpFN, oFlag, oMode)) < 0
   ||  XATTR.Set(attrName, srcFN, strlen(srcFN)+1, ckpFN, ckpFD) < 0)
      {rc = -errno;
       if (ckpFD >= 0) {close(ckpFD); ckpFD = -1;}
       unlink(ckpFN);
       free(ckpFN);
       ckpFN = 0;
      }
 
// Construct the header
//
   theHdr.lfnLen = strlen(srcFN) + 1;
   theHdr.hdrLen = hdrSZ + theHdr.lfnLen;
   theHdr.fSize  = Stat.st_size;
   theHdr.mTime  = Stat.st_mtime;
   memcpy(theHdr.srcUrl, " file://", sizeof(theHdr.srcUrl));
   memset(theHdr.rsvd, 0, sizeof(theHdr.rsvd));
 
// Generate CRC32C checksum for the header and source filename
//
   theHdr.crc32C = XrdOucCRC::Calc32C(((char *)&theHdr)+crcSZ, hdrSZ-crcSZ);
   theHdr.crc32C = XrdOucCRC::Calc32C(srcFN, theHdr.lfnLen, theHdr.crc32C);
 
// Construct I/O vector to write out the header
//
   ioV[0].iov_base = &theHdr;
   ioV[0].iov_len  = sizeof(theHdr);
   ioV[1].iov_base = (void *)srcFN;
   ioV[1].iov_len  = theHdr.lfnLen;
   ckpSize = sizeof(theHdr) + theHdr.lfnLen;
 
// Write out the header and make sure it gets stored
//
   retval = writev(ckpFD, ioV, 2);
   if (retval != ckpSize) rc = (retval < 0 ? -errno : -EIO);
      else if (fsync(ckpFD)) rc = -errno;
 
// Eliminate the checkpoint file if we encountered any error
//
   if (rc) {if (ftruncate(ckpFD, 0) && unlink(ckpFN)) {}}
   return rc;
}

References XrdOucCRC::Calc32C(), close, fsync, ftruncate, Stat, stat, unlink, writev, and XATTR.

Here is the call graph for this function:

Destroy()

int XrdOfsCPFile::Destroy

(

)

Destroy a checkpoint

Returns

0 upon success and -errno upon failure.

Definition at line 264 of file XrdOfsCPFile.cc.

{
   int rc;
 
// Attempt to destroy the checkpoint file
//
   if (ckpFN && unlink(ckpFN))
      {rc = errno;
       if (!truncate(ckpFN, 0) || !ErrState()) rc = 0;
      } else rc = 0;
 
// All done
//
   return rc;
}

References ErrState(), truncate, and unlink.

Here is the call graph for this function:

ErrState()

int XrdOfsCPFile::ErrState

(

)

Place checkpoint file in error state.

Returns

0 upon success and -errno upon failure.

Definition at line 284 of file XrdOfsCPFile.cc.

{
   char buff[MAXPATHLEN+8];
 
// Place checkpoint file in error state. If the rename fails, then the
// checkpoint will be applied again which should fail anyway. This just
// tries to avoid that issue and leave a trail.
//
   snprintf(buff, sizeof(buff), "%serr", ckpFN);
   return (rename(ckpFN, buff) ? -errno : 0);
}

References rename.

Referenced by Destroy().

Here is the caller graph for this function:

FName()

const char * XrdOfsCPFile::FName

(

bool

trim = false

)

Get the checkpoint file name.

Returns

pointer to the checkpoint file name. The pointer will be "???" if there is no checkpoint file established.

Definition at line 300 of file XrdOfsCPFile.cc.

{
   if (ckpFN)
      {if (trim)
          {char *slash = rindex(ckpFN, '/');
           if (slash) return slash+1;
          }
       return ckpFN;
      }
   return "???";
}

References trim().

Here is the call graph for this function:

isActive()

bool XrdOfsCPFile::isActive ( )

inline

Check if checpoint is established.

Returns

True if checkpoint has been established and false otherwise.

Definition at line 97 of file XrdOfsCPFile.hh.

{return ckpFN != 0;}

Reserve()

bool XrdOfsCPFile::Reserve	(	int	dlen,
		int	nseg )

Reserve space for a subsequent checkpoint.

Parameters

dlen	- the number of bytes that will be writen.
nseg	- the number of segements that will be written.

Returns

True upon success and false otherwise

Definition at line 353 of file XrdOfsCPFile.cc.

{
// Make sure paramenters are valid
//
   if (dlen < 0 || nseg < 0 || ckpFD < 0) return false;
 
// Calculate the amount of space to reserve
//
   dlen += nseg*segSZ;
 
// Now allocate the space
//
#ifdef __APPLE__
   fstore_t Store = {F_ALLOCATEALL, F_PEOFPOSMODE, ckpSize, dlen, 0};
   if (fcntl(ckpFD, F_PREALLOCATE, &Store) == -1
   &&  ftruncate(ckpFD, ckpSize + dlen)    == -1) return false;
#else
   if (posix_fallocate(ckpFD, ckpSize, dlen))
      {if (ftruncate(ckpFD, ckpSize)) {}
       return false;
      }
#endif
 
// All done
//
   return true;
}

References ftruncate.

RestoreInfo()

int XrdOfsCPFile::RestoreInfo	(	XrdOfsCPFile::rInfo &	rinfo,
		const char *&	ewhy )

Definition at line 385 of file XrdOfsCPFile.cc.

{
   std::vector<XrdOucIOVec> vecIO;
   struct stat Stat;
   XrdOucIOVec *ioV, ioItem;
   char *ckpRec, *ckpEnd;
   cpSeg theSeg;
   cUp cup;
   int retval;
   bool aOK;
 
// Open the file
//
   if ((cup.fd = XrdSysFD_Open(ckpFN, O_RDONLY)) < 0)
      {if (errno == ENOENT) return -ENOENT;
       eWhy = "open failed";
       return getSrcLfn(ckpFN, rinfo, cup.fd, errno);
      }
 
// Get the size of the file
//
   if (fstat(cup.fd, &Stat))
      {eWhy = "stat failed";
       return getSrcLfn(ckpFN, rinfo, cup.fd, errno);
      }
 
// If this is a zero length file, then it has not been comitted which is OK
//
   if (Stat.st_size == 0) return getSrcLfn(ckpFN, rinfo, cup.fd, ENODATA);
 
// The file must be at least the basic record size
//
   if (Stat.st_size < hdrSZ+1)
      {eWhy = "truncated header";
       return getSrcLfn(ckpFN, rinfo, cup.fd, EDOM);
      }
 
// Allocate memory to read the whole file
//
   if (!(ckpRec = (char *)malloc(Stat.st_size)))
      return getSrcLfn(ckpFN, rinfo, cup.fd, ENOMEM);
   rinfo.rBuff = ckpRec;
 
// Now read the whole file into the buffer
//
   if ((retval = read(cup.fd, ckpRec, Stat.st_size)) != Stat.st_size)
      {eWhy = "read failed";
       return getSrcLfn(ckpFN, rinfo, cup.fd, (retval < 0 ? errno : EIO));
      }
 
// We have a catch-22 as we need to use the record length to verify the checksum
// but it may have been corrupted. So, we first verify the value is reasonably
// correct relative to the value of the lfn length and the fixed header length.
//
   cpHdr &theHdr = *((cpHdr *)ckpRec);
   if (theHdr.hdrLen > Stat.st_size
   || (theHdr.hdrLen - theHdr.lfnLen) != (int)hdrSZ)
      {eWhy = "corrupted header";
       return getSrcLfn(ckpFN, rinfo, cup.fd, EDOM);
      }
 
// Verify the header checksum
//
   if (!XrdOucCRC::Ver32C(ckpRec+crcSZ, theHdr.hdrLen-crcSZ, theHdr.crc32C))
      {eWhy = "header checksum mismatch";
       return getSrcLfn(ckpFN, rinfo, cup.fd, EDOM);
      }
 
// Set the source file name and other information
//
   rinfo.srcLFN = ckpRec+hdrSZ;
   rinfo.fSize  = theHdr.fSize;
   rinfo.mTime  = theHdr.mTime;
 
// Prepare to verify and record the segments
//
   ckpEnd = ckpRec + Stat.st_size;
   ckpRec = ckpRec + theHdr.hdrLen;
   ioItem.info   = 0;
   vecIO.reserve(16);
 
// Verify all of the segments
//
   aOK = false; eWhy = 0;
   while(ckpRec+sizeof(cpSeg) < ckpEnd)
        {memcpy(&theSeg, ckpRec, segSZ);
         if (!theSeg.dataLen && !theSeg.dataOfs && !theSeg.crc32C)
            {aOK = true;
             break;
            }
         char *ckpData = ckpRec + segSZ;
         if (theSeg.dataLen <= 0 || ckpData + theSeg.dataLen > ckpEnd) break;
         int cLen = theSeg.dataLen+sizeof(cpSeg)-crcSZ;
         if (!XrdOucCRC::Ver32C(ckpRec+crcSZ, cLen, theSeg.crc32C))
            {eWhy = "data checksum mismatch";
             break;
            }
         ioItem.offset  = theSeg.dataOfs;
         ioItem.size    = theSeg.dataLen;
         ioItem.data    = ckpRec + segSZ;
         rinfo.DataLen += theSeg.dataLen;
         vecIO.push_back(ioItem);
         ckpRec += (segSZ + theSeg.dataLen);
        }
 
// Check that we ended perfectly (we accept a failed write as long as the
// space was already allocated).
//
   if (!aOK && ckpRec != ckpEnd)
      {if (!eWhy) eWhy = "truncated file";
       return -EDOM;
      }
 
// If the file had no data changed, return as only the size changed. Otherwise,
// allocate an iovec for all of the segments we need to restore.
//
   if (!vecIO.size()) return 0;
   ioV = new XrdOucIOVec[vecIO.size()];
 
// Fill in the vector in reverse order as this is the restore sequence
//
   int j = vecIO.size() - 1;
   for (int i = 0; i < (int)vecIO.size(); i++) ioV[j--] = vecIO[i];
 
// All done
//
   rinfo.DataVec = ioV;
   rinfo.DataNum = vecIO.size();
   return 0;
}

References XrdOfsCPFile::rInfo::DataLen, XrdOfsCPFile::rInfo::DataNum, XrdOfsCPFile::rInfo::DataVec, ENODATA, XrdOfsCPFile::rInfo::fSize, fstat, XrdOfsCPFile::rInfo::mTime, read, XrdOfsCPFile::rInfo::srcLFN, Stat, stat, and XrdOucCRC::Ver32C().

Here is the call graph for this function:

Sync()

int XrdOfsCPFile::Sync

(

)

Commit data to media.

Returns

0 upon success and -errno upon failure.

Definition at line 520 of file XrdOfsCPFile.cc.

{
   if (fsync(ckpFD)) return -errno;
   return 0;
}

References fsync.

Target()

char * XrdOfsCPFile::Target ( const char * ckpfn )

static

Get the name of the source file associated with a checkpoint file.

Parameters

ckpfn

- Pointer to the name of the checkpoint file to use.

Returns

pointer to either the source file name or reason it's not valid.

Definition at line 530 of file XrdOfsCPFile.cc.

{
   struct {cpHdr hdr; char srcfn[MAXPATHLEN+8];} ckpRec;
   cUp cup;
   const char *eMsg = "Target unknown; corrupt checkpoint file";
   int n;
 
// Try to get the name via the extended attributes first
//
   if ((n = XATTR.Get(attrName,ckpRec.srcfn,sizeof(ckpRec.srcfn)-1,ckpfn)) > 0)
      {ckpRec.srcfn[n] = 0;
       return strdup(ckpRec.srcfn);
      }
 
// Open the file
//
   if ((cup.fd = XrdSysFD_Open(ckpfn, O_RDONLY)) < 0)
      {char buff[256];
       snprintf(buff, sizeof(buff), "Target unknown; %s", XrdSysE2T(errno));
       return strdup(buff);
      }
 
// Now read the file header
//
   if ((n = read(cup.fd, &ckpRec, sizeof(ckpRec))) <= (int)sizeof(cpHdr))
      return strdup(eMsg);
 
// Make sure the length of the lfn is reasonable
//
   if (ckpRec.hdr.lfnLen <= 1 || ckpRec.hdr.lfnLen > (int)MAXPATHLEN)
      return strdup(eMsg);
 
// Return a copy of the filename
//
   ckpRec.srcfn[ckpRec.hdr.lfnLen-1] = 0;
   return strdup(ckpRec.srcfn);
}

References eMsg, read, XATTR, and XrdSysE2T().

Here is the call graph for this function:

Used()

int XrdOfsCPFile::Used

(

int

nseg = 0

)

Get the curent size of the checkpoint file.

Parameters

nseg	- the number of future segments to account for.

Returns

The size of the file in bytes.

Definition at line 572 of file XrdOfsCPFile.cc.

{return ckpSize + (nseg*segSZ);}

---

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

• XrdOfsCPFile.hh
• XrdOfsCPFile.cc