XrdPssFile Class Reference

#include <XrdPss.hh>

Inheritance diagram for XrdPssFile:

Collaboration diagram for XrdPssFile:

Public Member Functions
	XrdPssFile (const char *tid)
virtual	~XrdPssFile ()
virtual int	Close (long long *retsz=0)
int	Fchmod (mode_t mode)
int	Fstat (struct stat *)
int	Fsync ()
int	Fsync (XrdSfsAio *aiop)
int	Ftruncate (unsigned long long)
virtual int	Open (const char *, int, mode_t, XrdOucEnv &)
ssize_t	pgRead (void *buffer, off_t offset, size_t rdlen, uint32_t *csvec, uint64_t opts)
int	pgRead (XrdSfsAio *aioparm, uint64_t opts)
ssize_t	pgWrite (void *buffer, off_t offset, size_t wrlen, uint32_t *csvec, uint64_t opts)
int	pgWrite (XrdSfsAio *aioparm, uint64_t opts)
ssize_t	Read (off_t, size_t)
ssize_t	Read (void *, off_t, size_t)
int	Read (XrdSfsAio *aiop)
ssize_t	ReadRaw (void *, off_t, size_t)
ssize_t	ReadV (XrdOucIOVec *readV, int n)
ssize_t	Write (const void *, off_t, size_t)
int	Write (XrdSfsAio *aiop)
Public Member Functions inherited from XrdOssDF
	XrdOssDF (const char *tid="", uint16_t dftype=0, int fdnum=-1)
virtual	~XrdOssDF ()
uint16_t	DFType ()
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).
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 int	Readdir (char *buff, int blen)
virtual int	StatRet (struct stat *buff)
virtual ssize_t	WriteV (XrdOucIOVec *writeV, int wrvcnt)

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

Detailed Description

Definition at line 74 of file XrdPss.hh.

Constructor & Destructor Documentation

XrdPssFile()

XrdPssFile::XrdPssFile ( const char *  tid )

inline

Definition at line 104 of file XrdPss.hh.

                   : XrdOssDF(tid, XrdOssDF::DF_isFile|XrdOssDF::DF_isProxy),
                     rpInfo(0), tpcPath(0), entity(0) {}

~XrdPssFile()

virtual XrdPssFile::~XrdPssFile ( )

inlinevirtual

Definition at line 108 of file XrdPss.hh.

                      {if (fd >= 0) Close();
                       if (rpInfo) delete(rpInfo);
                       if (tpcPath) free(tpcPath);
                      }

References Close(), and XrdOssDF::fd.

Here is the call graph for this function:

Member Function Documentation

Close()

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

virtual

Close a directory or 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).

Implements XrdOssDF.

Definition at line 907 of file XrdPss.cc.

{   int rc;
 
// We don't support returning the size (we really should fix this)
//
    if (retsz) *retsz = 0;
 
// If the file is not open, then this may be OK if it is a 3rd party copy
//
    if (fd < 0)
       {if (!tpcPath) return -XRDOSS_E8004;
        free(tpcPath);
        tpcPath = 0;
        return XrdOssOK;
       }
 
// Close the file
//
    rc = XrdPosixXrootd::Close(fd);
    fd = -1;
    return (rc == 0 ? XrdOssOK : -errno);
}

References XrdPosixXrootd::Close(), XrdOssDF::fd, XRDOSS_E8004, and XrdOssOK.

Referenced by ~XrdPssFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Fchmod()

int XrdPssFile::Fchmod ( mode_t  mode )

inlinevirtual

Change file mode settings.

Parameters

mode	- The new file mode setting.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 84 of file XrdPss.hh.

{return XrdOssOK;}

References XrdOssOK.

Fstat()

int XrdPssFile::Fstat ( struct stat *  buf )

virtual

Return state information for this file.

Parameters

buf	- Pointer to the structure where info it to be returned.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 1175 of file XrdPss.cc.

{
   EPNAME("fstat");
 
// If we have a file descriptor then return a stat for it
//
   if (fd >= 0) return (XrdPosixXrootd::Fstat(fd, buff) ? -errno : XrdOssOK);
 
// Otherwise, if this is not a tpc of any kind, return an error
//
   if (!tpcPath) return -XRDOSS_E8004;
 
// If this is a normal tpc then simply issue the stat against the origin
//
   if (!rpInfo)
      {XrdOucEnv fstatEnv(0, 0, entity);
       return XrdProxySS.Stat(tpcPath, buff, 0, &fstatEnv);
      }
 
// This is a reproxy tpc, if we have not yet dertermined the true dest, do so.
//
   struct stat Stat;
 
   if (rpInfo->dstURL == 0
   ||  !fstatat(rpFD, rpInfo->tprPath, &Stat, AT_SYMLINK_NOFOLLOW))
      {char lnkbuff[2048]; int lnklen;
       lnklen = readlinkat(rpFD, rpInfo->tprPath, lnkbuff, sizeof(lnkbuff)-1);
       if (lnklen <= 0)
          {int rc = 0;
           if (lnklen < 0) {if (errno != ENOENT) rc = -errno;}
               else rc = -EFAULT;
           if (rc)
              {unlinkat(rpFD, rpInfo->tprPath, 0);
               return rc;
              }
          } else {
            unlinkat(rpFD, rpInfo->tprPath, 0);
            lnkbuff[lnklen] = 0;
            if (rpInfo->dstURL) free(rpInfo->dstURL);
            rpInfo->dstURL = strdup(lnkbuff);
            rpInfo->fSize = 1;
            DEBUG(tident,rpInfo->tprPath<<" maps "<<tpcPath<<" -> "<<lnkbuff);
          }
      }
 
// At this point we may or may not have the final endpoint. An error here could
// be due to write error recovery, so make allowance for that.
//
   if (rpInfo->dstURL)
      {if (!XrdPosixXrootd::Stat(rpInfo->dstURL, buff))
          {if (!(rpInfo->fSize = buff->st_size)) rpInfo->fSize = 1;
           return XrdOssOK;
          }
       free(rpInfo->dstURL);
       rpInfo->dstURL = 0;
      }
 
// We don't have the final endpoint. If we ever had it before, then punt.
//
   if (rpInfo->fSize)
      {memset(buff, 0, sizeof(struct stat));
       buff->st_size = rpInfo->fSize;
       return XrdOssOK;
      }
 
// If we are here then maybe the reproxy option was the wrong config setting.
// Give stat a try on the origin we'll retry resolution on the next stat.
//
   XrdOucEnv fstatEnv(0, 0, entity);
 
   if (XrdProxySS.Stat(tpcPath, buff, 0, &fstatEnv))
       memset(buff, 0, sizeof(struct stat));
   return XrdOssOK;
}

References DEBUG, EPNAME, XrdOssDF::fd, XrdPosixXrootd::Fstat(), XrdProxy::rpFD, Stat, stat, XrdPssSys::Stat(), XrdPosixXrootd::Stat(), XrdOssDF::tident, XRDOSS_E8004, XrdOssOK, and XrdProxy::XrdProxySS.

Here is the call graph for this function:

Fsync() [1/2]

int XrdPssFile::Fsync ( void  )

virtual

Synchronize associated file with media (synchronous).

Returns

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

Reimplemented from XrdOssDF.

Definition at line 1261 of file XrdPss.cc.

{
    if (fd < 0) return -XRDOSS_E8004;
 
    return (XrdPosixXrootd::Fsync(fd) ? -errno : XrdOssOK);
}

References XrdOssDF::fd, XrdPosixXrootd::Fsync(), XRDOSS_E8004, and XrdOssOK.

Here is the call graph for this function:

Fsync() [2/2]

int XrdPssFile::Fsync ( XrdSfsAio *  aiop )

virtual

Synchronize associated file with media (asynchronous).

Parameters

aiop	- Pointer to async I/O request object.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 53 of file XrdPssAio.cc.

{
 
// Execute this request in an asynchronous fashion
//
   XrdPosixXrootd::Fsync(fd, XrdPssAioCB::Alloc(aiop, true));
   return 0;
}

References XrdPssAioCB::Alloc(), XrdOssDF::fd, and XrdPosixXrootd::Fsync().

Here is the call graph for this function:

Ftruncate()

int XrdPssFile::Ftruncate ( unsigned long long  flen )

virtual

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 XrdOssDF.

Definition at line 1290 of file XrdPss.cc.

{
    if (fd < 0) return -XRDOSS_E8004;
 
    return (XrdPosixXrootd::Ftruncate(fd, flen) ?  -errno : XrdOssOK);
}

References XrdOssDF::fd, XrdPosixXrootd::Ftruncate(), XRDOSS_E8004, and XrdOssOK.

Here is the call graph for this function:

Open()

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

virtual

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 XrdOssDF.

Definition at line 771 of file XrdPss.cc.

{
   EPNAME("Open");
   unsigned long long popts = XrdPssSys::XPList.Find(path);
   const char *Cgi = "";
   char pbuff[PBsz];
   int  rc;
   bool tpcMode = (Oflag & O_NOFOLLOW) != 0;
   bool rwMode  = (Oflag & (O_WRONLY | O_RDWR | O_APPEND)) != 0;
   bool ucgiOK  = true;
   bool ioCache = (Oflag & O_DIRECT);
 
// Record the security environment
//
   entity = Env.secEnv();
 
// Turn off direct flag if set (we record it separately
//
   if (ioCache) Oflag &= ~O_DIRECT;
 
// Return an error if the object is already open
//
   if (fd >= 0 || tpcPath) return -XRDOSS_E8003;
 
// If we are opening this in r/w mode make sure we actually can
//
   if (rwMode)
      {if (XrdPssSys::fileOrgn) return -EROFS;
       if (popts & XRDEXP_NOTRW)
          {if (popts & XRDEXP_FORCERO && !tpcMode) Oflag = O_RDONLY;
              else return -EROFS;
          }
      }
 
   // check CGI cache-control paramters
   if (cacheFSctl)
   {
      int elen;
      char *envcgi = (char *)Env.Env(elen);
 
      if (envcgi && strstr(envcgi, "only-if-cached"))
      {
         XrdOucErrInfo einfo;
         XrdSfsFSctl myData;
         myData.Arg1 = "cached";
         myData.Arg1Len = 1;
         myData.Arg2Len = 1;
         const char *myArgs[1];
         myArgs[0] = path;
         myData.ArgP = myArgs;
         int fsctlRes = cacheFSctl->FSctl(SFS_FSCTL_PLUGXC, myData, einfo);
         if (fsctlRes == SFS_ERROR)
            return -einfo.getErrInfo();
      }
   }
 
// If this is a third party copy open, then strange rules apply. If this is an
// outgoing proxy we let everything pass through as this may be a TPC request
// elsewhere.  Otherwise, if it's an open for reading, we open the file but
// strip off all CGI (technically, we should only remove the "tpc" tokens)
// because the source might not support direct TPC mode. If we are opening for
// writing, then we skip the open and mark this as a TPC handle which can only
// be used for fstat() and close(). Any other actions return an error.
//
   if (tpcMode)
      {Oflag &= ~O_NOFOLLOW;
       if (!XrdProxy::outProxy || !IS_FWDPATH(path))
          {if (rwMode)
              {tpcPath = strdup(path);
               if (XrdPssSys::reProxy)
                  {const char *rPath = Env.Get("tpc.reproxy");
                   if (!rPath || *rPath != '/') return -ENOATTR;
                   if (!(rPath = rindex(rPath, '/')) || *(rPath+1) == 0)
                      return -EFAULT;
                   rpInfo = new tprInfo(rPath+1);
                  }
               return XrdOssOK;
              }
           ucgiOK = false;
          }
      }
 
// Setup any required cgi information. Don't mess with it if it's an objectid
// or if the we are an outgoing proxy server.
//
   if (!XrdProxy::outProxy && *path == '/' && !(XRDEXP_STAGE & popts))
      Cgi = osslclCGI;
 
// Construct the url info
//
   XrdPssUrlInfo uInfo(&Env, path, Cgi, ucgiOK);
   uInfo.setID();
 
// Convert path to URL
//
   if ((rc = XrdPssSys::P2URL(pbuff, PBsz, uInfo, XrdPssSys::xLfn2Pfn)))
      return rc;
 
// Do some tracing
//
  if(DEBUGON) {
    auto urlObf = obfuscateAuth(pbuff);
    DEBUG(uInfo.Tident(),"url="<<urlObf);
  }
 
// Try to open and if we failed, return an error
//
   if (!XrdPssSys::dcaCheck || !ioCache)
      {if ((fd = XrdPosixXrootd::Open(pbuff,Oflag,Mode)) < 0) return -errno;
      } else {
       XrdPosixInfo Info;
       Info.ffReady = XrdPssSys::dcaWorld;
       if (XrdPosixConfig::OpenFC(pbuff,Oflag,Mode,Info))
          {Env.Put("FileURL", Info.cacheURL);
           return -EDESTADDRREQ;
          }
       fd = Info.fileFD;
       if (fd < 0) return -errno;
      }
 
// All done
//
   return XrdOssOK;
}

References XrdSfsFSctl::Arg1, XrdSfsFSctl::Arg1Len, XrdSfsFSctl::Arg2Len, XrdProxy::cacheFSctl, XrdPssSys::dcaCheck, XrdPssSys::dcaWorld, DEBUG, DEBUGON, ENOATTR, XrdOucEnv::Env(), EPNAME, XrdOssDF::fd, XrdPssSys::fileOrgn, XrdOucPListAnchor::Find(), XrdOfsFSctl_PI::FSctl(), XrdOucEnv::Get(), XrdOucErrInfo::getErrInfo(), IS_FWDPATH, Mode, O_DIRECT, obfuscateAuth(), XrdPosixXrootd::Open(), XrdPosixConfig::OpenFC(), XrdProxy::osslclCGI, XrdProxy::outProxy, XrdPssSys::P2URL(), XrdProxy::PBsz, XrdOucEnv::Put(), XrdPssSys::reProxy, XrdOucEnv::secEnv(), XrdPssUrlInfo::setID(), SFS_ERROR, SFS_FSCTL_PLUGXC, XrdPssUrlInfo::Tident(), XrdPssSys::xLfn2Pfn, XrdPssSys::XPList, XRDEXP_FORCERO, XRDEXP_NOTRW, XRDEXP_STAGE, XRDOSS_E8003, and XrdOssOK.

Here is the call graph for this function:

pgRead() [1/2]

ssize_t XrdPssFile::pgRead ( void *  buffer, off_t  offset, size_t  rdlen, uint32_t *  csvec, uint64_t  opts  )

virtual

Reimplemented from XrdOssDF.

Definition at line 948 of file XrdPss.cc.

{
   std::vector<uint32_t> vecCS;
   uint64_t psxOpts;
   ssize_t bytes;
 
// Make sure file is open
//
   if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
// Set options as needed
//
   psxOpts = (csvec ? XrdPosixExtra::forceCS : 0);
 
// Issue the pgread
//
   if ((bytes = XrdPosixExtra::pgRead(fd,buffer,offset,rdlen,vecCS,psxOpts)) < 0)
      return (ssize_t)-errno;
 
// Copy out the checksum vector
//
   if (vecCS.size() && csvec)
       memcpy(csvec, vecCS.data(), vecCS.size()*sizeof(uint32_t));
 
// All done
//
   return bytes;
}

References XrdOssDF::fd, XrdPosixExtra::forceCS, XrdPosixExtra::pgRead(), and XRDOSS_E8004.

Here is the call graph for this function:

pgRead() [2/2]

int XrdPssFile::pgRead ( XrdSfsAio *  aioparm, uint64_t  opts  )

virtual

Read 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 XrdOssDF.

Definition at line 77 of file XrdPssAio.cc.

{
   XrdPssAioCB *aioCB = XrdPssAioCB::Alloc(aiop, false, true);
   uint64_t psxOpts = (aiop->cksVec ? XrdPosixExtra::forceCS : 0);
 
// Execute this request in an asynchronous fashion
//
   XrdPosixExtra::pgRead(fd, (void *)aiop->sfsAio.aio_buf,
                             (off_t)aiop->sfsAio.aio_offset,
                             (size_t)aiop->sfsAio.aio_nbytes,
                             aioCB->csVec, psxOpts, aioCB);
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdPssAioCB::Alloc(), XrdSfsAio::cksVec, XrdPssAioCB::csVec, XrdOssDF::fd, XrdPosixExtra::forceCS, XrdPosixExtra::pgRead(), and XrdSfsAio::sfsAio.

Here is the call graph for this function:

pgWrite() [1/2]

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

virtual

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.
wrlen	- The number of bytes to write.
csvec	- A vector which contains the corresponding CRC32 checksum for each page. See XrdOucPgrwUtils::csNum() for sizing.
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 XrdOssDF.

Definition at line 1001 of file XrdPss.cc.

{
   std::vector<uint32_t> vecCS;
   ssize_t bytes;
 
// Make sure we have an open file
//
   if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
// Check if caller wants to verify the checksums before writing
//
   if (csvec && (opts & XrdOssDF::Verify))
      {XrdOucPgrwUtils::dataInfo dInfo((const char*)buffer,csvec,offset,wrlen);
       off_t bado;
       int   badc;
       if (!XrdOucPgrwUtils::csVer(dInfo, bado, badc)) return -EDOM;
      }
 
// Check if caller want checksum generated and possibly returned
//
   if ((opts & XrdOssDF::doCalc) || csvec == 0)
      {XrdOucPgrwUtils::csCalc((const char *)buffer, offset, wrlen, vecCS);
       if (csvec) memcpy(csvec, vecCS.data(), vecCS.size()*sizeof(uint32_t));
      } else {
       int n = XrdOucPgrwUtils::csNum(offset, wrlen);
       vecCS.resize(n);
       vecCS.assign(n, 0);
       memcpy(vecCS.data(), csvec, n*sizeof(uint32_t));
      }
 
// Issue the pgwrite
//
   bytes = XrdPosixExtra::pgWrite(fd, buffer, offset, wrlen, vecCS);
 
// Return result
//
   return (bytes < 0 ? (ssize_t)-errno : bytes);
}

References XrdOucPgrwUtils::csCalc(), XrdOucPgrwUtils::csNum(), XrdOucPgrwUtils::csVer(), XrdOssDF::doCalc, XrdOssDF::fd, opts, XrdPosixExtra::pgWrite(), XrdOssDF::Verify, and XRDOSS_E8004.

Here is the call graph for this function:

pgWrite() [2/2]

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

virtual

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 XrdOssDF.

Definition at line 106 of file XrdPssAio.cc.

{
 
// Check if caller wants to verify the checksums before writing
//
   if (aiop->cksVec && (opts & XrdOssDF::Verify))
      {XrdOucPgrwUtils::dataInfo dInfo((const char *)(aiop->sfsAio.aio_buf),
                                       aiop->cksVec, aiop->sfsAio.aio_offset,
                                       aiop->sfsAio.aio_nbytes);
       off_t bado;
       int   badc;
       if (!XrdOucPgrwUtils::csVer(dInfo, bado, badc)) return -EDOM;
      }
 
// Get a callback object as no errors can error here
//
   XrdPssAioCB *aioCB = XrdPssAioCB::Alloc(aiop, true, true);
 
// Check if caller want checksum generated and possibly returned
//
   if ((opts & XrdOssDF::doCalc) || aiop->cksVec == 0)
      {XrdOucPgrwUtils::csCalc((const char *)(aiop->sfsAio.aio_buf),
                               (off_t)(aiop->sfsAio.aio_offset),
                               (size_t)(aiop->sfsAio.aio_nbytes),
                               aioCB->csVec);
       if (aiop->cksVec) memcpy(aiop->cksVec, aioCB->csVec.data(),
                                aioCB->csVec.size()*sizeof(uint32_t));
      } else {
       int n = XrdOucPgrwUtils::csNum(aiop->sfsAio.aio_offset,
                                      aiop->sfsAio.aio_nbytes);
       aioCB->csVec.resize(n);
       aioCB->csVec.assign(n, 0);
       memcpy(aioCB->csVec.data(), aiop->cksVec, n*sizeof(uint32_t));
      }
 
// Issue the pgWrite
//
   XrdPosixExtra::pgWrite(fd, (void *)aiop->sfsAio.aio_buf,
                              (off_t)aiop->sfsAio.aio_offset,
                              (size_t)aiop->sfsAio.aio_nbytes,
                              aioCB->csVec, 0, aioCB);
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdPssAioCB::Alloc(), XrdSfsAio::cksVec, XrdOucPgrwUtils::csCalc(), XrdOucPgrwUtils::csNum(), XrdPssAioCB::csVec, XrdOucPgrwUtils::csVer(), XrdOssDF::doCalc, XrdOssDF::fd, opts, XrdPosixExtra::pgWrite(), XrdSfsAio::sfsAio, and XrdOssDF::Verify.

Here is the call graph for this function:

Read() [1/3]

ssize_t XrdPssFile::Read ( off_t  offset, size_t  size  )

virtual

Preread file blocks into the file system cache.

Parameters

offset	- The offset where the read is to start.
size	- The number of bytes to pre-read.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 1057 of file XrdPss.cc.

{
     if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
     return 0;  // We haven't implemented this yet!
}

References XrdOssDF::fd, and XRDOSS_E8004.

Referenced by ReadRaw().

Here is the caller graph for this function:

Read() [2/3]

ssize_t XrdPssFile::Read ( void *  buffer, off_t  offset, size_t  size  )

virtual

Read file bytes into a buffer.

Parameters

buffer	- pointer to buffer where the bytes are to be placed.
offset	- The offset where the read is to start.
size	- The number of bytes to read.

Returns

>= 0 The number of bytes that placed in buffer.

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

Reimplemented from XrdOssDF.

Definition at line 1081 of file XrdPss.cc.

{
     ssize_t retval;
 
     if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
     return (retval = XrdPosixXrootd::Pread(fd, buff, blen, offset)) < 0
            ? (ssize_t)-errno : retval;
}

References XrdOssDF::fd, XrdPosixXrootd::Pread(), and XRDOSS_E8004.

Here is the call graph for this function:

Read() [3/3]

int XrdPssFile::Read ( XrdSfsAio *  aiop )

virtual

Read 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 XrdOssDF.

Definition at line 165 of file XrdPssAio.cc.

{
 
// Execute this request in an asynchronous fashion
//
   XrdPosixXrootd::Pread(fd, (void *)aiop->sfsAio.aio_buf,
                             (size_t)aiop->sfsAio.aio_nbytes,
                             (off_t)aiop->sfsAio.aio_offset,
                             XrdPssAioCB::Alloc(aiop, false));
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdPssAioCB::Alloc(), XrdOssDF::fd, XrdPosixXrootd::Pread(), and XrdSfsAio::sfsAio.

Here is the call graph for this function:

ReadRaw()

ssize_t XrdPssFile::ReadRaw ( void *  buffer, off_t  offset, size_t  size  )

virtual

Read uncompressed file bytes into a buffer.

Parameters

buffer	- pointer to buffer where the bytes are to be placed.
offset	- The offset where the read is to start.
size	- The number of bytes to read.

Returns

>= 0 The number of bytes that placed in buffer.

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

Reimplemented from XrdOssDF.

Definition at line 1133 of file XrdPss.cc.

{
     return Read(buff, offset, blen);
}

References Read().

Here is the call graph for this function:

ReadV()

ssize_t XrdPssFile::ReadV ( XrdOucIOVec *  readV, int  rdvcnt  )

virtual

Read file bytes as directed by the read vector.

Parameters

readV	pointer to the array of read requests.
rdvcnt	the number of elements in readV.

Returns

>=0 The numbe of bytes read.

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

Reimplemented from XrdOssDF.

Definition at line 1095 of file XrdPss.cc.

{
    ssize_t retval;
 
    if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
    return (retval = XrdPosixXrootd::VRead(fd, readV, readCount)) < 0 ? (ssize_t)-errno : retval;;
}

References XrdOssDF::fd, XrdPosixXrootd::VRead(), and XRDOSS_E8004.

Here is the call graph for this function:

Write() [1/2]

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

virtual

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 XrdOssDF.

Definition at line 1153 of file XrdPss.cc.

{
     ssize_t retval;
 
     if (fd < 0) return (ssize_t)-XRDOSS_E8004;
 
     return (retval = XrdPosixXrootd::Pwrite(fd, buff, blen, offset)) < 0
            ? (ssize_t)-errno : retval;
}

References XrdOssDF::fd, XrdPosixXrootd::Pwrite(), and XRDOSS_E8004.

Here is the call graph for this function:

Write() [2/2]

int XrdPssFile::Write ( XrdSfsAio *  aiop )

virtual

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 XrdOssDF.

Definition at line 192 of file XrdPssAio.cc.

{
 
// Execute this request in an asynchronous fashion
//
   XrdPosixXrootd::Pwrite(fd, (const void *)aiop->sfsAio.aio_buf,
                              (size_t)aiop->sfsAio.aio_nbytes,
                              (off_t)aiop->sfsAio.aio_offset,
                              XrdPssAioCB::Alloc(aiop, true));
   return 0;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdPssAioCB::Alloc(), XrdOssDF::fd, XrdPosixXrootd::Pwrite(), and XrdSfsAio::sfsAio.

Here is the call graph for this function:

---

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

• XrdPss.hh
• XrdPss.cc
• XrdPssAio.cc