XrdOfsFile Class Reference

#include <XrdOfs.hh>

Inheritance diagram for XrdOfsFile:

Collaboration diagram for XrdOfsFile:

Public Member Functions
	XrdOfsFile (XrdOucErrInfo &eInfo, const char *user)
	~XrdOfsFile ()
int	checkpoint (XrdSfsFile::cpAct act, struct iov *range=0, int n=0)
int	Clone (const std::vector< XrdOucCloneSeg > &cVec)
int	Clone (XrdSfsFile &srcFile)
int	close ()
int	fctl (const int cmd, const char *args, XrdOucErrInfo &out_error)
int	fctl (const int cmd, int alen, const char *args, const XrdSecEntity *client=0)
const char *	FName ()
int	getCXinfo (char cxtype[4], int &cxrsz)
int	getMmap (void **Addr, off_t &Size)
int	open (const char *fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity *client, const char *opaque=0)
int	pgRead (XrdSfsAio *aioparm, uint64_t opts=0)
XrdSfsXferSize	pgRead (XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize rdlen, uint32_t *csvec, uint64_t opts=0)
int	pgWrite (XrdSfsAio *aioparm, uint64_t opts=0)
XrdSfsXferSize	pgWrite (XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize wrlen, uint32_t *csvec, uint64_t opts=0)
int	read (XrdSfsAio *aioparm)
XrdSfsXferSize	read (XrdSfsFileOffset fileOffset, char *buffer, XrdSfsXferSize buffer_size)
int	read (XrdSfsFileOffset fileOffset, XrdSfsXferSize amount)
XrdSfsXferSize	readv (XrdOucIOVec *readV, int readCount)
int	stat (struct stat *buf)
int	sync ()
int	sync (XrdSfsAio *aiop)
int	truncate (XrdSfsFileOffset fileOffset)
int	write (XrdSfsAio *aioparm)
XrdSfsXferSize	write (XrdSfsFileOffset fileOffset, const char *buffer, XrdSfsXferSize buffer_size)
Public Member Functions inherited from XrdSfsFile
	XrdSfsFile (const char *user=0, int MonID=0)
	XrdSfsFile (XrdOucErrInfo &eInfo)
	XrdSfsFile (XrdSfsFile &wrapF)
virtual	~XrdSfsFile ()
	Destructor.
virtual XrdSfsXferSize	read (XrdOucRangeList &rlist)
virtual int	SendData (XrdSfsDio *sfDio, XrdSfsFileOffset offset, XrdSfsXferSize size)
virtual void	setXio (XrdSfsXio *xioP)
virtual XrdSfsXferSize	writev (XrdOucIOVec *writeV, int wdvCnt)

Static Public Attributes
static bool	ocFsync = false
Static Public Attributes inherited from XrdSfsFile
static const uint64_t	Verify = 0x8000000000000000ULL
	Options for pgRead() and pgWrite() as noted below.

Protected Attributes
bool	ckpBad
int	dorawio
XrdOucChkPnt *	myCKP
XrdOfsTPC *	myTPC
XrdOfsHandle *	oh
const char *	tident
bool	viaDel

Additional Inherited Members
Public Types inherited from XrdSfsFile
enum	cpAct {   cpCreate =0 ,   cpDelete ,   cpRestore ,   cpQuery ,   cpTrunc ,   cpWrite }
Public Attributes inherited from XrdSfsFile
XrdOucErrInfo &	error

Detailed Description

Definition at line 115 of file XrdOfs.hh.

Constructor & Destructor Documentation

XrdOfsFile()

XrdOfsFile::XrdOfsFile	(	XrdOucErrInfo &	eInfo,
		const char *	user )

Definition at line 462 of file XrdOfs.cc.

                      : XrdSfsFile(eInfo), tident(user ? user : ""),
                        oh(XrdOfs::dummyHandle), myTPC(0), myCKP(0),
                        dorawio(0), viaDel(false), ckpBad(false) {}

References XrdSfsFile::XrdSfsFile(), ckpBad, dorawio, myCKP, myTPC, oh, tident, and viaDel.

Referenced by XrdOfsFileFull::XrdOfsFileFull(), and Clone().

Here is the call graph for this function:

Here is the caller graph for this function:

~XrdOfsFile()

XrdOfsFile::~XrdOfsFile ( )

inline

Definition at line 197 of file XrdOfs.hh.

{viaDel = true; if (oh) close();}

References close(), oh, and viaDel.

Here is the call graph for this function:

Member Function Documentation

checkpoint()

int XrdOfsFile::checkpoint ( XrdSfsFile::cpAct act, struct iov * range = 0, int n = 0 )

virtual

Reimplemented from XrdSfsFile.

Definition at line 1010 of file XrdOfs.cc.

{
   EPNAME("chkpnt");
   const char *ckpName;
   int rc;
   bool readok;
 
// Make sure we are active
//
   if (oh->Inactive()) return XrdOfsFS->Emsg(epname, error, EBADF,
                                        "handle checkpoint", (const char *)0);
 
// If checkpointing is disabled, the don't accept this request.
//
   if (!XrdOfsConfigCP::Enabled) return XrdOfsFS->Emsg(epname, error, ENOTSUP,
                        "handle disabled checkpoint", (const char *)0);
 
// If this checkpoint is bad then only a delete, query or restore is allowed.
//
   if (ckpBad && (act == XrdSfsFile::cpTrunc || act == XrdSfsFile::cpWrite))
      return XrdOfsFS->Emsg(epname, error, EIDRM, "extend checkpoint "
             "(only delete or restore possible) for", oh->Name());
 
// Handle the request
//
   switch(act)
         {case XrdSfsFile::cpCreate:
               ckpName = "create checkpoint for";
               if ((rc = CreateCKP())) return rc;
               if ((rc = myCKP->Create())) {myCKP->Finished(); myCKP = 0;}
               break;
          case XrdSfsFile::cpDelete:
               ckpName = "delete checkpoint for";
               if (!myCKP) rc = ENOENT;
                  else {rc = myCKP->Delete();
                        myCKP->Finished();
                        myCKP = 0;
                        ckpBad = false;
                       }
               break;
          case XrdSfsFile::cpQuery:
               ckpName = "query checkpoint for";
               if (!range || n <= 0)
                  return XrdOfsFS->Emsg(epname, error, EINVAL,
                                   "query checkpoint limits for", oh->Name());
               rc = (myCKP ? myCKP->Query(*range) : ENOENT);
               break;
          case XrdSfsFile::cpRestore:
               ckpName = "restore checkpoint for";
               if (!myCKP) rc = ENOENT;
                  else {if (!(rc = myCKP->Restore(&readok)))
                           {myCKP->Finished();
                            myCKP  = 0;
                            ckpBad = false;
                           } else {
                            if (!(oh->Select().DFType() & XrdOssDF::DF_isProxy))
                               oh->Suppress((readok ? 0 : -EDOM));
                            ckpBad = true;
                           }
                       }
               break;
          case XrdSfsFile::cpTrunc:
               ckpName = "checkpoint truncate";
                    if (!range) rc = EINVAL;
               else if (!myCKP) rc = ENOENT;
               else if ((rc = myCKP->Truncate(range))) ckpBad = true;
               break;
          case XrdSfsFile::cpWrite:
               ckpName = "checkpoint write";
                    if (!range || n <= 0) rc = EINVAL;
               else if (!myCKP)           rc = ENOENT;
               else if ((rc = myCKP->Write(range, n))) ckpBad = true;
               break;
 
          default: return XrdOfsFS->Emsg(epname, error, EINVAL,
                                  "decode checkpoint request for", oh->Name());
         };
 
// Complete as needed
//
   if (rc) return XrdOfsFS->Emsg(epname, error, rc, ckpName, oh->Name());
 
// Trace success and return
//
   FTRACE(chkpnt, ckpName);
   return SFS_OK;
}

References ckpBad, XrdSfsFile::cpCreate, XrdSfsFile::cpDelete, XrdSfsFile::cpQuery, XrdSfsFile::cpRestore, XrdSfsFile::cpTrunc, XrdSfsFile::cpWrite, XrdOssDF::DF_isProxy, XrdOfsConfigCP::Enabled, EPNAME, XrdSfsFile::error, FTRACE, myCKP, oh, SFS_OK, and XrdOfsFS.

Clone() [1/2]

int XrdOfsFile::Clone ( const std::vector< XrdOucCloneSeg > & cVec )

virtual

Clone contents of a file from one or more other files.

Parameters

cVec	- A vector of struct XrdOucCloneSeg describing the action.

Returns

One of SFS_OK or SFS_ERROR.

Reimplemented from XrdSfsFile.

Definition at line 881 of file XrdOfs.cc.

{
   EPNAME("Clone");
   int rc = oh->Select().Clone(cVec);
 
   if (rc < 0)
      {char etxt[4096];
       snprintf(etxt,sizeof(etxt),"%s from file ranges",oh->Name());
       return XrdOfsFS->Emsg(epname, error, rc, "clone", etxt);
      }
 
  return SFS_OK;
}

References EPNAME, XrdSfsFile::error, oh, SFS_OK, and XrdOfsFS.

Clone() [2/2]

int XrdOfsFile::Clone ( XrdSfsFile & srcFile )

virtual

Clone contents of a file from another file.

Parameters

srcFile

- Reference to the file to used to clone contents of this file,

Returns

One of SFS_OK or SFS_ERROR.

Reimplemented from XrdSfsFile.

Definition at line 864 of file XrdOfs.cc.

{
   EPNAME("Clone");
   XrdOfsFile& ofsFile = static_cast<XrdOfsFile&>(srcFile);
   int rc = oh->Select().Clone(ofsFile.oh->Select());
 
   if (rc < 0)
      {char etxt[4096];
       snprintf(etxt,sizeof(etxt),"%s from %s",oh->Name(),ofsFile.oh->Name());
       return XrdOfsFS->Emsg(epname, error, rc, "clone", etxt);
      }
 
   return SFS_OK;
}

References XrdOfsFile(), XrdSfsFile::XrdSfsFile(), EPNAME, XrdSfsFile::error, XrdOfsHandle::Name(), oh, XrdOfsHandle::Select(), SFS_OK, and XrdOfsFS.

Here is the call graph for this function:

close()

int XrdOfsFile::close ( )

virtual

Close the file.

Returns

One of SFS_OK or SFS_ERROR.

Implements XrdSfsFile.

Definition at line 899 of file XrdOfs.cc.

{
   EPNAME("close");
 
   class  CloseFH : public XrdOfsHanCB
         {public: void Retired(XrdOfsHandle *hP) {XrdOfsFS->Unpersist(hP);}};
   static XrdOfsHanCB *hCB = static_cast<XrdOfsHanCB *>(new CloseFH);
 
   XrdOfsHandle *hP;
   int   poscNum, retc, cRetc = 0;
   short theMode;
 
// Trace the call
//
    FTRACE(close, "use=" <<oh->Usage()); // Unreliable trace, no origin lock
 
// Verify the handle (we briefly maintain a global lock)
//
    XrdOfsFS->ocMutex.Lock();
    if (oh == XrdOfs::dummyHandle)
       {XrdOfsFS->ocMutex.UnLock(); return SFS_OK;}
    if ((oh->Inactive()))
       {XrdOfsFS->ocMutex.UnLock();
        return XrdOfsFS->Emsg(epname, error, EBADF, "close file");
       }
    hP = oh; oh = XrdOfs::dummyHandle;
    XrdOfsFS->ocMutex.UnLock();
    hP->Lock();
 
// Delete the tpc object, if any
//
   if (myTPC) {myTPC->Del(); myTPC = 0;}
 
// Maintain statistics
//
   OfsStats.sdMutex.Lock();
   if (!(hP->isRW)) OfsStats.Data.numOpenR--;
      else {OfsStats.Data.numOpenW--;
            if (hP->isRW == XrdOfsHandle::opPC) OfsStats.Data.numOpenP--;
           }
   OfsStats.sdMutex.UnLock();
 
// Do an fsync() on this file prior to closing if it was open r/w
//
   if (ocFsync && hP->isRW) hP->Select().Fsync(); // Ignore errors
 
// If this file was tagged as a POSC then we need to make sure it will persist
// Note that we unpersist the file immediately when it's inactive or if no hold
// time is allowed. Also, close events occur only for active handles. If the
// entry was via delete then we ignore the close return code as there is no
// one to handle it on the other side.
//
   if ((poscNum = hP->PoscGet(theMode, !viaDel)))
      {if (viaDel)
          {if (hP->Inactive() || !XrdOfsFS->poscHold)
              {XrdOfsFS->Unpersist(hP, !hP->Inactive()); hP->Retire(cRetc);}
              else hP->Retire(hCB, XrdOfsFS->poscHold);
           return SFS_OK;
          }
       if ((retc = hP->Select().Fchmod(theMode)))
          XrdOfsFS->Emsg(epname, error, retc, "fchmod", hP->Name());
          else {XrdOfsFS->poscQ->Del(hP->Name(), poscNum);
                if (XrdOfsFS->Balancer) XrdOfsFS->Balancer->Added(hP->Name());
               }
      }
 
// Handle any oustanding checkpoint
//
   if (myCKP)
      {retc =  myCKP->Restore();
       if (retc) XrdOfsFS->Emsg(epname,error,retc,"restore chkpnt",hP->Name());
       myCKP->Finished();
       myCKP = 0;
      }
 
// We need to handle the cunudrum that an event may have to be sent upon
// the final close. However, that would cause the path name to be destroyed.
// So, we have two modes of logic where we copy out the pathname if a final
// close actually occurs. The path is not copied if it's not final and we
// don't bother with any of it if we need not generate an event.
//
   if (XrdOfsFS->evsObject && tident
   &&  XrdOfsFS->evsObject->Enabled(hP->isRW ? XrdOfsEvs::Closew
                                             : XrdOfsEvs::Closer))
      {long long FSize, *retsz;
       char pathbuff[MAXPATHLEN+8];
       XrdOfsEvs::Event theEvent;
       if (hP->isRW) {theEvent = XrdOfsEvs::Closew; retsz = &FSize;}
          else {      theEvent = XrdOfsEvs::Closer; retsz = 0; FSize=0;}
       if (!(hP->Retire(cRetc, retsz, pathbuff, sizeof(pathbuff))))
          {XrdOfsEvsInfo evInfo(tident, pathbuff, "" , 0, 0, FSize);
           XrdOfsFS->evsObject->Notify(theEvent, evInfo);
          }
      } else hP->Retire(cRetc);
 
// All done
//
  return (cRetc ? XrdOfsFS->Emsg(epname, error, cRetc, "close file") : SFS_OK);
}

References close(), XrdOfsEvs::Closer, XrdOfsEvs::Closew, EPNAME, XrdSfsFile::error, XrdOssDF::Fchmod(), XrdOssDF::Fsync(), FTRACE, XrdOfsHandle::Inactive(), XrdOfsHandle::isRW, XrdOfsHandle::Lock(), myCKP, myTPC, XrdOfsHandle::Name(), ocFsync, OfsStats, oh, XrdOfsHandle::opPC, XrdOfsHandle::PoscGet(), XrdOfsHandle::Retire(), XrdOfsHandle::Select(), SFS_OK, tident, viaDel, and XrdOfsFS.

Referenced by ~XrdOfsFile(), and close().

Here is the call graph for this function:

Here is the caller graph for this function:

fctl() [1/2]

int XrdOfsFile::fctl ( const int cmd, const char * args, XrdOucErrInfo & eInfo )

virtual

Execute a special operation on the file (version 1)

Parameters

cmd	- The operation to be performed (see below). SFS_FCTL_GETFD Return file descriptor if possible SFS_FCTL_STATV Reserved for future use.
args	- specific arguments to cmd SFS_FCTL_GETFD Set to zero.
eInfo	- The object where error info or results are to be returned. This is legacy and the error onject may be used as well.

Returns

If an error occurs or the operation is not support, SFS_ERROR should be returned with error.code set to errno. Otherwise, SFS_FCTL_GETFD error.code holds the real file descriptor number If the value is negative, sendfile() is not used. If the value is SFS_SFIO_FDVAL then the SendData() method is used for future read requests.

Implements XrdSfsFile.

Definition at line 1142 of file XrdOfs.cc.

{
// See if we can do this
//
   if (cmd == SFS_FCTL_GETFD)
      {out_error.setErrCode(oh->Select().getFD());
       return SFS_OK;
      }
 
// We don't support this
//
   out_error.setErrInfo(ENOTSUP, "fctl operation not supported");
 
// Return
//
   return SFS_ERROR;
}

References oh, XrdOucErrInfo::setErrCode(), XrdOucErrInfo::setErrInfo(), SFS_ERROR, SFS_FCTL_GETFD, and SFS_OK.

Here is the call graph for this function:

fctl() [2/2]

int XrdOfsFile::fctl ( const int cmd, int alen, const char * args, const XrdSecEntity * client = 0 )

virtual

Execute a special operation on the file (version 2)

Parameters

cmd	- The operation to be performed: SFS_FCTL_SPEC1 Perform implementation defined action V1 SFS_FCTL_SPEC2 Perform implementation defined action V2
alen	- Length of data pointed to by args.
args	- Data sent with request, zero if alen is zero.
client	- Client's identify (see common description).

Returns

SFS_OK a null response is sent.

SFS_DATA error.code length of the data to be sent. error.message contains the data to be sent. o/w one of SFS_ERROR, SFS_REDIRECT, or SFS_STALL.

Reimplemented from XrdSfsFile.

Definition at line 1164 of file XrdOfs.cc.

{                             // 12345678901234
   EPNAME("fctl");
   static const char *fctlArg = "ofs.tpc cancel";
   static const int   fctlAsz = 15;
 
// For QFINFO we simply pass it to the Oss layer
//
   if (cmd == SFS_FCTL_QFINFO)
      {char* resp = 0;;
       int rc = oh->Select().Fctl(XrdOssDF::Fctl_QFinfo, alen, args, &resp);
       if (rc < 0)
          {if (resp) delete[] resp;
           return XrdOfsFS->Emsg(epname,error,rc,"fctl",oh,false,false);
          }
       if (resp)
          {if ((rc = strlen(resp)))
              {error.setErrInfo(rc, resp);
               delete[] resp;
               return SFS_DATA;
              }
           delete[] resp;
          }
       return SFS_OK;
      }
 
// See if the is a tpc cancellation (the only thing we support here)
//
   if (cmd != SFS_FCTL_SPEC1 || !args || alen < fctlAsz || strcmp(fctlArg,args))
      return XrdOfsFS->FSctl(*this, cmd, alen, args, client);
 
// Check if we have a tpc operation in progress
//
   if (!myTPC)
      {error.setErrInfo(ESRCH, "tpc operation not found");
       return SFS_ERROR;
      }
 
// Cancel the tpc
//
   myTPC->Del();
   myTPC = 0;
   return SFS_OK;
}

References EPNAME, XrdSfsFile::error, XrdOssDF::Fctl_QFinfo, myTPC, oh, SFS_DATA, SFS_ERROR, SFS_FCTL_QFINFO, SFS_FCTL_SPEC1, SFS_OK, and XrdOfsFS.

FName()

const char * XrdOfsFile::FName ( )

inlinevirtual

Get the file path.

Returns

Null terminated string of the path used in open().

Implements XrdSfsFile.

Definition at line 145 of file XrdOfs.hh.

{return (oh ? oh->Name() : "?");}

References oh.

getCXinfo()

int XrdOfsFile::getCXinfo ( char cxtype[4], int & cxrsz )

virtual

Get compression information for the file.

Parameters

cxtype	- Place where the compression algorithm name is to be placed
cxrsz	- Place where the compression page size is to be returned

Returns

One of the valid SFS return codes described above. If the file is not compressed or an error is returned, cxrsz must be set to 0.

Implements XrdSfsFile.

Definition at line 1854 of file XrdOfs.cc.

{
 
// Copy out the info
//
   cxrsz = oh->Select().isCompressed(cxtype);
   return SFS_OK;
}

References oh, and SFS_OK.

getMmap()

int XrdOfsFile::getMmap ( void ** Addr, off_t & Size )

virtual

Get file's memory mapping if one exists (memory mapped files only).

Parameters

Addr	- Place where the starting memory address is returned.
Size	- Place where the file's size is returned.

Returns

SFS_OK when the file is memory mapped or any other code otherwise.

Implements XrdSfsFile.

Definition at line 1697 of file XrdOfs.cc.

{
 
// Perform the function
//
   Size = oh->Select().getMmap(Addr);
 
   return SFS_OK;
}

References oh, and SFS_OK.

open()

int XrdOfsFile::open ( const char * fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity * client, const char * opaque = 0 )

virtual

Open a file.

Parameters

fileName	- Pointer to the path of the file to be opened.
openMode	- Flags indicating how the open is to be handled. SFS_O_CREAT create the file SFS_O_CREATAT create the file in a perticular FS SFS_O_MKPTH Make directory path if missing SFS_O_NOWAIT do not impose operational delays SFS_O_NOTPC do not allow TPC operation SFS_O_POSC persist only on successful close SFS_O_RAWIO allow client-side decompression SFS_O_RDONLY open read/only SFS_O_RDWR open read/write SFS_O_REPLICA Open for replication SFS_O_RESET Reset any cached information SFS_O_TRUNC truncate existing file to zero length SFS_O_WRONLY open write/only
createMode	- The file's mode if it will be created.
client	- Client's identify (see common description).
opaque	- path's CGI information (see common description).

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED

Note

When SFS_O_CREATAT is specified, the CGI should contain an element oss.coloc=<path> where <path> is URL encoded and determines the filesystem in which the new file should be created.

Implements XrdSfsFile.

Definition at line 471 of file XrdOfs.cc.

{
   EPNAME("open");
   static const int crMask = (SFS_O_CREAT  | SFS_O_TRUNC);
   static const int opMask = (SFS_O_RDONLY | SFS_O_WRONLY | SFS_O_RDWR);
 
   struct OpenHelper
         {const char   *Path;
          XrdOfsHandle *hP;
          XrdOssDF     *fP;
          XrdCksCalc   *cP;
          int           poscNum;
 
          int           OK() {hP=0; fP=0; cP=0; poscNum=0; return SFS_OK;}
 
                        OpenHelper(const char *path)
                       : Path(path), hP(0), fP(0), cP(0), poscNum(0) {}
 
                       ~OpenHelper()
                       {int retc;
                        if (hP) hP->Retire(retc);
                        if (fP) delete fP;
                        if (cP) cP->Recycle();
                        if (poscNum > 0) XrdOfsFS->poscQ->Del(Path, poscNum, 1);
                       }
         } oP(path);
 
   mode_t theMode = (Mode | XrdOfsFS->fMask[0]) & XrdOfsFS->fMask[1];
   const char *tpcKey;
   int retc, isPosc = 0, crOpts = 0, isRW = 0, open_flag = 0;
   int find_flag = open_mode & (SFS_O_NOWAIT | SFS_O_RESET | SFS_O_MULTIW);
   XrdOucEnv Open_Env(info,0,client);
 
// Trace entry
//
   ZTRACE(open, Xrd::hex1 <<open_mode <<"-" <<Xrd::oct1 <<Mode <<" ("
              <<Xrd::oct1 <<theMode <<") fn=" <<path);
 
// Verify that this object is not already associated with an open file
//
   XrdOfsFS->ocMutex.Lock();
   if (oh != XrdOfs::dummyHandle)
      {XrdOfsFS->ocMutex.UnLock();
       return XrdOfsFS->Emsg(epname,error,EADDRINUSE,"open file",path);
      }
   XrdOfsFS->ocMutex.UnLock();
 
// Handle the open mode options
//
   if (open_mode & crMask)
      {crOpts = (Mode & SFS_O_MKPTH ? XRDOSS_mkpath : 0);
       if (XrdOfsFS->poscQ && ((open_mode & SFS_O_POSC) ||
           XrdOfsFS->poscAuto || Open_Env.Get("ofs.posc")))
           {isPosc = 1; isRW = XrdOfsHandle::opPC;}
          else isRW = XrdOfsHandle::opRW;
       if (open_mode & SFS_O_CREAT)
          {open_flag   = O_RDWR     | O_CREAT  | O_EXCL;
           find_flag  |= SFS_O_RDWR | SFS_O_CREAT | (open_mode & SFS_O_REPLICA);
           crOpts     |= XRDOSS_new;
          } else {
           open_flag  |= O_RDWR     | O_CREAT  | O_TRUNC;
           find_flag  |= SFS_O_RDWR | SFS_O_TRUNC;
          }
       if (XrdOfsFS->WantCksRT())
          {const char* cipher = 0;
           if ((retc = XrdOfsFS->SetupCksRT(oP.cP, Open_Env, cipher)))
              {char eBuff[80];
               snprintf(eBuff, sizeof(eBuff), "setup real-time %s checksum",
                        (cipher ? cipher : "unknown"));
               return XrdOfsFS->Emsg(epname, error, retc, eBuff, path);
              }
          }
      }
   else
   switch(open_mode & opMask)
  {case SFS_O_RDONLY: open_flag = O_RDONLY; find_flag |= SFS_O_RDONLY;
                      break;
   case SFS_O_WRONLY: open_flag = O_WRONLY; find_flag |= SFS_O_WRONLY;
                      isRW = XrdOfsHandle::opRW;
                      if (XrdOfsFS->poscQ && ((open_mode & SFS_O_POSC) ||
                          Open_Env.Get("ofs.posc"))) oP.poscNum = -1;
                      break;
   case SFS_O_RDWR:   open_flag = O_RDWR;   find_flag |= SFS_O_RDWR;
                      isRW = XrdOfsHandle::opRW;
                      if (XrdOfsFS->poscQ && ((open_mode & SFS_O_POSC) ||
                          Open_Env.Get("ofs.posc"))) oP.poscNum = -1;
                      break;
   default:           open_flag = O_RDONLY; find_flag |= SFS_O_RDONLY;
                      break;
  }
 
// Preset TPC handling
//
   tpcKey = Open_Env.Get(XrdOucTPC::tpcKey);
 
// Check if we will be redirecting the tpc request
//
   if (tpcKey && isRW && (XrdOfsFS->Options & XrdOfs::RdrTPC))
      {const char *dOn = Open_Env.Get(XrdOucTPC::tpcDlgOn);
       int k = ((dOn && *dOn == '1') || strcmp(tpcKey, "delegate") ? 1 : 0);
       if (XrdOfsFS->tpcRdrHost[k])
          {error.setErrInfo(XrdOfsFS->tpcRdrPort[k], XrdOfsFS->tpcRdrHost[k]);
           return SFS_REDIRECT;
          }
      }
 
// If we have a finder object, use it to direct the client. The final
// destination will apply the security that is needed
//
   if (XrdOfsFS->Finder && (retc = XrdOfsFS->Finder->Locate(error, path,
                                                   find_flag, &Open_Env)))
      return XrdOfsFS->fsError(error, retc);
 
// Preset TPC handling and if not allowed, complain
//
   if (tpcKey && (open_mode & SFS_O_NOTPC))
      return XrdOfsFS->Emsg(epname, error, EPROTOTYPE, "tpc", path,
                            "+TPC prohibited due to security configuration");
 
// Create the file if so requested o/w try to attach the file
//
   if (open_flag & O_CREAT)
      {// Apply security, as needed
       //
       // If we aren't requesting O_EXCL, one needs AOP_Create
       bool overwrite_permitted = true;
       if (!(open_flag & O_EXCL))
          {if (client && XrdOfsFS->Authorization &&
               !XrdOfsFS->Authorization->Access(client, path, AOP_Create, &Open_Env))
              { // We don't have the ability to create a file without O_EXCL.  If we have AOP_Excl_Create,
                // then manipulate the open flags and see if we're successful with it.
                AUTHORIZE(client,&Open_Env,AOP_Excl_Create,"create",path,error);
                overwrite_permitted = false;
                open_flag |= O_EXCL;
                open_flag &= ~O_TRUNC;
              }
          }
       // If we are in O_EXCL mode, then we accept either AOP_Excl_Create or AOP_Create
       else if (client && XrdOfsFS->Authorization &&
            !XrdOfsFS->Authorization->Access(client, path, AOP_Create, &Open_Env))
          {AUTHORIZE(client,&Open_Env,AOP_Excl_Create,"create",path,error);
           // In this case, we don't have AOP_Create but we do have AOP_Excl_Create; note that
           // overwrites are not permitted (this is later used to correct an error code).
           overwrite_permitted = false;
          }
 
       OOIDENTENV(client, Open_Env);
 
       // For ephemeral file, we must enter the file into the queue
       //
       if (isPosc)
          {bool isNew = (open_mode & SFS_O_TRUNC) == 0;
           if ((oP.poscNum = XrdOfsFS->poscQ->Add(tident, path, isNew)) < 0)
              return XrdOfsFS->Emsg(epname, error, oP.poscNum, "pcreate", path,
                     "+ofs_open: failed to enter file into posc queue");
          }
 
       // If placement information is present provide a hint to the oss plugin
       //
       if ((open_mode & ~SFS_O_CREAT) & SFS_O_CREATAT) crOpts |= XRDOSS_coloc;
 
       // Create the file. If ENOTSUP is returned, promote the creation to
       // the subsequent open. This is to accomodate proxy support.
       //
       if ((retc = XrdOfsOss->Create(tident, path, theMode, Open_Env,
                                     ((open_flag << 8) | crOpts))))
          {if (retc > 0) return XrdOfsFS->Stall(error, retc, path);
           if (retc == -EINPROGRESS)
              {XrdOfsFS->evrObject.Wait4Event(path,&error);
               return XrdOfsFS->fsError(error, SFS_STARTED);
              }
           if (retc != -ENOTSUP)
              {// If we tried to overwrite an existing file but do not have the AOP_Create
               // privilege, then ensure we generate a 'permission denied' instead of 'exists'
               if ((open_flag & O_EXCL) && retc == -EEXIST && !overwrite_permitted)
                  {retc = -EACCES;}
               if (XrdOfsFS->Balancer) XrdOfsFS->Balancer->Removed(path);
               return XrdOfsFS->Emsg(epname, error, retc, "create", path);
              }
          } else {
            if (XrdOfsFS->Balancer) XrdOfsFS->Balancer->Added(path, isPosc);
            open_flag  = O_RDWR|O_TRUNC;
            if (XrdOfsFS->evsObject
            &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Create))
               {XrdOfsEvsInfo evInfo(tident,path,info,&Open_Env,Mode);
                XrdOfsFS->evsObject->Notify(XrdOfsEvs::Create, evInfo);
               }
          }
 
      } else {
 
       // Apply security, as needed
       //
          if (tpcKey && !isRW)
             {XrdOfsTPC::Facts Args(client, &error, &Open_Env, tpcKey, path);
              if ((retc = XrdOfsTPC::Authorize(&myTPC, Args))) return retc;
             } else {AUTHORIZE(client, &Open_Env, (isRW?AOP_Update:AOP_Read),
                               "open", path, error);
                    }
       OOIDENTENV(client, Open_Env);
      }
 
// Get a handle for this file.
//
   if ((retc = XrdOfsHandle::Alloc(path, isRW, &oP.hP)))
      {if (retc > 0) return XrdOfsFS->Stall(error, retc, path);
       return XrdOfsFS->Emsg(epname, error, retc, "attach", path);
      }
 
// If this is a third party copy and we are the destination, then validate
// specification at this point and setup to transfer. Note that if the
// call fails and auto removal is enabled, the file we created will be deleted.
//
   if (tpcKey && isRW)
      {char pfnbuff[MAXPATHLEN+8]; const char *pfnP;
       if (!(pfnP = XrdOfsOss->Lfn2Pfn(path, pfnbuff, MAXPATHLEN, retc)))
          return XrdOfsFS->Emsg(epname, error, retc, "open", path,
                           "+ofs_open: mapping tpc target lfn to pfn failed");
       XrdOfsTPC::Facts Args(client, &error, &Open_Env, tpcKey, path, pfnP);
       if ((retc = XrdOfsTPC::Validate(&myTPC, Args))) return retc;
      }
 
// Assign/transfer posc ownership. We may need to delay the client if the
// file create ownership does not match and this is not a create request.
//
   if (oP.hP->isRW == XrdOfsHandle::opPC)
      {if (!isRW) return XrdOfsFS->Stall(error, -1, path);
       if ((retc = oP.hP->PoscSet(tident, oP.poscNum, theMode)))
          {if (retc > 0) XrdOfsFS->poscQ->Del(path, retc);
              else return XrdOfsFS->Emsg(epname, error, retc, "access", path,
                                    "+ofs_open: posc mode initiation failed");
          }
      }
 
// If this is a previously existing handle, we are almost done. If this is
// the target of a third party copy request, fail it now. We don't support
// multiple writers in tpc mode (this should really never happen).
//
   if (!(oP.hP->Inactive()))
      {dorawio = (oh->isCompressed && open_mode & SFS_O_RAWIO ? 1 : 0);
       if (tpcKey && isRW)
          return XrdOfsFS->Emsg(epname, error, EALREADY, "tpc", path,
                           "+ofs_open: this tpc is already in progress");
       XrdOfsFS->ocMutex.Lock(); oh = oP.hP; XrdOfsFS->ocMutex.UnLock();
       FTRACE(open, "attach use=" <<oh->Usage());
       if (oP.poscNum > 0) XrdOfsFS->poscQ->Commit(path, oP.poscNum);
       oP.hP->UnLock();
       OfsStats.sdMutex.Lock();
       isRW ? OfsStats.Data.numOpenW++ : OfsStats.Data.numOpenR++;
       if (oP.poscNum > 0) OfsStats.Data.numOpenP++;
       OfsStats.sdMutex.UnLock();
       return oP.OK();
      }
 
// Get a storage system object
//
   if (!(oP.fP = XrdOfsOss->newFile(tident)))
      return XrdOfsFS->Emsg(epname, error, ENOMEM, "open", path);
 
// We need to make special provisions for proxy servers in the presence of
// the TPC option and possibly cache as it's handled differently in this case.
//
   if (XrdOfsFS->OssIsProxy)
      {if (myTPC) open_flag |= O_NOFOLLOW;
       if (error.getUCap() & XrdOucEI::uUrlOK &&
           error.getUCap() & XrdOucEI::uLclF) open_flag |= O_DIRECT;
      }
 
// If we are doing real-time checksums, wrap the Oss file with a Cks file
//
   if (oP.cP)
      {XrdOfsCksFile* cfP = new XrdOfsCksFile(tident,path,oP.fP,oP.cP,viaDel);
       oP.fP = static_cast<XrdOssDF*>(cfP);
       oP.cP = 0;
      }
 
// Open the file
//
   if ((retc = oP.fP->Open(path, open_flag, theMode, Open_Env)))
      {if (retc > 0) return XrdOfsFS->Stall(error, retc, path);
       if (retc == -EINPROGRESS)
          {XrdOfsFS->evrObject.Wait4Event(path,&error);
           return XrdOfsFS->fsError(error, SFS_STARTED);
          }
       if (retc == -ETXTBSY) return XrdOfsFS->Stall(error, -1, path);
       if (retc == -EDESTADDRREQ)
          {char *url = Open_Env.Get("FileURL");
           if (url) {error.setErrInfo(-1, url); return SFS_REDIRECT;}
          }
       if (XrdOfsFS->Balancer && retc == -ENOENT)
          XrdOfsFS->Balancer->Removed(path);
       const char* etP = 0;
       std::string eText;
       if (XrdOfsFS->tryXERT && oP.fP->getErrMsg(eText)) etP = eText.c_str();
       return XrdOfsFS->Emsg(epname, error, retc, "open", path, etP);
      }
 
// Verify that we can actually use this file
//
   if (oP.poscNum > 0)
      {if ((retc = oP.fP->Fchmod(static_cast<mode_t>(theMode|XRDSFS_POSCPEND))))
          return XrdOfsFS->Emsg(epname, error, retc, "fchmod", path,
                                "+ofs_open: POSC file designation failed");
       XrdOfsFS->poscQ->Commit(path, oP.poscNum);
      }
 
// Set compression values and activate the handle
//
   if (oP.fP->isCompressed() > 0)
      {oP.hP->isCompressed = 1;
       dorawio = (open_mode & SFS_O_RAWIO ? 1 : 0);
      }
   oP.hP->Activate(oP.fP);
   oP.hP->UnLock();
 
// If this is being opened for sequential I/O advise the filesystem about it.
//
#if defined(__linux__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
   if (!(XrdOfsFS->OssIsProxy) && open_mode & SFS_O_SEQIO)
      {static RAtomic_int fadFails(0);
       int theFD =  oP.fP->getFD();
       if (theFD >= 0 && fadFails < 4096)
          if (posix_fadvise(theFD, 0, 0, POSIX_FADV_SEQUENTIAL) < 0)
             {OfsEroute.Emsg(epname, errno, "fadvise for sequential I/O.");
              fadFails++;
             }
      }
#endif
 
// Send an open event if we must
//
   if (XrdOfsFS->evsObject)
      {XrdOfsEvs::Event theEvent = (isRW ? XrdOfsEvs::Openw : XrdOfsEvs::Openr);
       if (XrdOfsFS->evsObject->Enabled(theEvent))
          {XrdOfsEvsInfo evInfo(tident, path, info, &Open_Env);
           XrdOfsFS->evsObject->Notify(theEvent, evInfo);
          }
      }
 
// Maintain statistics
//
   OfsStats.sdMutex.Lock();
   isRW ? OfsStats.Data.numOpenW++ : OfsStats.Data.numOpenR++;
   if (oP.poscNum > 0) OfsStats.Data.numOpenP++;
   OfsStats.sdMutex.UnLock();
 
// All done
//
   XrdOfsFS->ocMutex.Lock(); oh = oP.hP; XrdOfsFS->ocMutex.UnLock();
   return oP.OK();
}

References XrdOfsHandle::Alloc(), AOP_Create, AOP_Excl_Create, AOP_Read, AOP_Update, AUTHORIZE, XrdOfsTPC::Authorize(), XrdOfsEvs::Create, dorawio, EPNAME, XrdSfsFile::error, FTRACE, Xrd::hex1, Mode, myTPC, O_DIRECT, Xrd::oct1, OfsEroute, OfsStats, oh, OOIDENTENV, open(), XrdOfsEvs::Openr, XrdOfsEvs::Openw, XrdOfsHandle::opPC, XrdOfsHandle::opRW, Path, XrdOfs::RdrTPC, XrdCksCalc::Recycle(), XrdOfsHandle::Retire(), SFS_O_CREAT, SFS_O_CREATAT, SFS_O_MKPTH, SFS_O_MULTIW, SFS_O_NOTPC, SFS_O_NOWAIT, SFS_O_POSC, SFS_O_RAWIO, SFS_O_RDONLY, SFS_O_RDWR, SFS_O_REPLICA, SFS_O_RESET, SFS_O_SEQIO, SFS_O_TRUNC, SFS_O_WRONLY, SFS_OK, SFS_REDIRECT, SFS_STARTED, tident, XrdOucTPC::tpcDlgOn, XrdOucTPC::tpcKey, XrdOucEI::uLclF, XrdOucEI::uUrlOK, XrdOfsTPC::Validate(), viaDel, XrdOfsFS, XrdOfsOss, XRDOSS_coloc, XRDOSS_mkpath, XRDOSS_new, XRDSFS_POSCPEND, and ZTRACE.

Referenced by open().

Here is the call graph for this function:

Here is the caller graph for this function:

pgRead() [1/2]

XrdSfsXferSize XrdOfsFile::pgRead ( XrdSfsAio * aioparm, uint64_t opts = 0 )

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

SFS_OK Request accepted and will be scheduled.

SFS_ERROR File could not be read, error holds the reason.

Reimplemented from XrdSfsFile.

Definition at line 1264 of file XrdOfs.cc.

{
   EPNAME("aiopgread");
   uint64_t pgOpts;
   int rc;
 
// If the oss plugin does not support pgRead or if we are doing rawio or the
// file is compressed then revert to using a standard async read. Note that
// the standard async read will generate checksums if a vector is present.
// Note: we set cksVec in the request to nil to indicate simulation!
//
   if (!XrdOfsFS->OssHasPGrw || dorawio || oh->isCompressed)
      {aioparm->cksVec = 0;
       return XrdOfsFile::read(aioparm);
      }
 
// Perform required tracing
//
   FTRACE(aio, aioparm->sfsAio.aio_nbytes <<"@" <<aioparm->sfsAio.aio_offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (aiop->sfsAio.aio_offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname,error,-EFBIG,"pgRead",oh->Name(),0,false);
#endif
 
// Pass through any flags of interest
//
   if (opts & XrdSfsFile::Verify) pgOpts = XrdOssDF::Verify;
      else pgOpts = 0;
 
// Issue the read. Only true errors are returned here.
//
   if ((rc = oh->Select().pgRead(aioparm, pgOpts)) < 0)
      return XrdOfsFS->Emsg(epname, error, rc, "pgRead", oh, false, false);
 
// All done
//
   return SFS_OK;
}

References aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::cksVec, dorawio, EPNAME, XrdSfsFile::error, FTRACE, oh, opts, read(), SFS_OK, XrdSfsAio::sfsAio, XrdOssDF::Verify, XrdSfsFile::Verify, and XrdOfsFS.

Here is the call graph for this function:

pgRead() [2/2]

XrdSfsXferSize XrdOfsFile::pgRead ( XrdSfsFileOffset offset, char * buffer, XrdSfsXferSize rdlen, uint32_t * csvec, uint64_t opts = 0 )

virtual

Read file pages into a buffer and return corresponding checksums.

Parameters

offset	- The offset where the read is to start. It may be unaligned with certain caveats relative to csvec.
buffer	- pointer to buffer where the bytes are to be placed.
rdlen	- The number of bytes to read. The amount must be an integral number of XrdSfsPage::Size bytes.
csvec	- A vector of entries to be filled with the cooresponding CRC32C checksum for each page. However, if the offset is unaligned, then csvec[0] contains the crc for the page fragment that brings it to alignment for csvec[1]. It must be sized to hold all aligned XrdSys::Pagesize crc's plus additional ones for leading and ending page fragments, if any.
opts	- Processing options (see above).

Returns

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

SFS_ERROR File could not be read, error holds the reason.

Reimplemented from XrdSfsFile.

Definition at line 1214 of file XrdOfs.cc.

{
   EPNAME("pgRead");
   XrdSfsXferSize nbytes;
   uint64_t pgOpts;
 
// If the oss plugin does not support pgRead and we doing rawio then simulate
// the pgread. As this is relatively common we skip the vtable. This means
// this class cannot be a inherited to override the read() method.
//
   if (!XrdOfsFS->OssHasPGrw || dorawio)
      {if ((nbytes = XrdOfsFile::read(offset, buffer, rdlen)) > 0)
          XrdOucPgrwUtils::csCalc(buffer, offset, nbytes, csvec);
       return nbytes;
      }
 
// Perform required tracing
//
   FTRACE(read, rdlen <<"@" <<offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname, error, EFBIG, "pgRead", oh->Name());
#endif
 
// Pass through any flags of interest
//
   if (opts & XrdSfsFile::Verify) pgOpts = XrdOssDF::Verify;
      else pgOpts = 0;
 
// Now read the actual number of bytes
//
   nbytes = (XrdSfsXferSize)(oh->Select().pgRead((void *)buffer,
                            (off_t)offset, (size_t)rdlen, csvec, pgOpts));
   if (nbytes < 0)
      return XrdOfsFS->Emsg(epname,error,(int)nbytes,"pgRead",oh,false,false);
 
// Return number of bytes read
//
   return nbytes;
}

References XrdOucPgrwUtils::csCalc(), dorawio, EPNAME, XrdSfsFile::error, FTRACE, oh, opts, read(), XrdOssDF::Verify, XrdSfsFile::Verify, and XrdOfsFS.

Here is the call graph for this function:

pgWrite() [1/2]

XrdSfsXferSize XrdOfsFile::pgWrite ( XrdSfsAio * aioparm, uint64_t opts = 0 )

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

SFS_OK Request accepted and will be scheduled.

SFS_ERROR File could not be read, error holds the reason.

Reimplemented from XrdSfsFile.

Definition at line 1364 of file XrdOfs.cc.

{
   EPNAME("aiopgWrite");
   uint64_t pgOpts;
   int rc;
 
// If the oss plugin does not support pgWrite revert to using a standard write.
//
   if (!XrdOfsFS->OssHasPGrw)
      {if ((opts & XrdSfsFile::Verify)
       && !VerPgw((char *)aioparm->sfsAio.aio_buf,
                          aioparm->sfsAio.aio_offset,
                          aioparm->sfsAio.aio_nbytes,
                          aioparm->cksVec, oh, error)) return SFS_ERROR;
       return XrdOfsFile::write(aioparm);
      }
 
// If this is a POSC file, we must convert the async call to a sync call as we
// must trap any errors that unpersist the file. We can't do that via aio i/f.
//
   if (oh->isRW == XrdOfsHandle::opPC)
      {aioparm->Result = XrdOfsFile::pgWrite(aioparm->sfsAio.aio_offset,
                                     (char *)aioparm->sfsAio.aio_buf,
                                             aioparm->sfsAio.aio_nbytes,
                                             aioparm->cksVec, opts);
       aioparm->doneWrite();
       return SFS_OK;
      }
 
// Perform any required tracing
//
   FTRACE(aio, aioparm->sfsAio.aio_nbytes <<"@" <<aioparm->sfsAio.aio_offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (aiop->sfsAio.aio_offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname, error, -EFBIG, "pgwrite", oh, true, false);
#endif
 
// Silly Castor stuff
//
   if (XrdOfsFS->evsObject && !(oh->isChanged)
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Fwrite)) GenFWEvent();
 
// Pass through any flags of interest
//
   if (opts & XrdSfsFile::Verify) pgOpts = XrdOssDF::Verify;
      else pgOpts = 0;
 
// Write the requested bytes
//
   oh->isPending = 1;
   if ((rc = oh->Select().pgWrite(aioparm, pgOpts)) < 0)
       return XrdOfsFS->Emsg(epname, error, rc, "pgwrite", oh, true, false);
 
// All done
//
   return SFS_OK;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::cksVec, XrdSfsAio::doneWrite(), EPNAME, XrdSfsFile::error, FTRACE, XrdOfsEvs::Fwrite, oh, XrdOfsHandle::opPC, opts, pgWrite(), XrdSfsAio::Result, SFS_ERROR, SFS_OK, XrdSfsAio::sfsAio, XrdOssDF::Verify, XrdSfsFile::Verify, write(), and XrdOfsFS.

Here is the call graph for this function:

pgWrite() [2/2]

XrdSfsXferSize XrdOfsFile::pgWrite ( XrdSfsFileOffset offset, char * buffer, XrdSfsXferSize wrlen, uint32_t * csvec, uint64_t opts = 0 )

virtual

Write file pages into a file with corresponding checksums.

Parameters

offset	- The offset where the write is to start. It may be unaligned with certain caveats relative to csvec.
buffer	- pointer to buffer containing the bytes to write.
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 or page fragment. If offset is unaligned then csvec[0] is the crc of the leading fragment to align the subsequent full page who's crc is in csvec[1]. It must be sized to hold all aligned XrdSys::Pagesize crc's plus additional ones for leading and ending page fragments, if any.
opts	- Processing options (see above).

Returns

>= 0 The number of bytes written.

SFS_ERROR File could not be read, error holds the reason.

Reimplemented from XrdSfsFile.

Definition at line 1310 of file XrdOfs.cc.

{
   EPNAME("pgWrite");
   XrdSfsXferSize nbytes;
   uint64_t pgOpts;
 
// If the oss plugin does not support pgWrite revert to using a standard write.
//
   if (!XrdOfsFS->OssHasPGrw)
      {if ((opts & XrdSfsFile::Verify)
       && !VerPgw(buffer, offset, wrlen, csvec, oh, error)) return SFS_ERROR;
       return XrdOfsFile::write(offset, buffer, wrlen);
      }
 
// Perform any required tracing
//
   FTRACE(write, wrlen <<"@" <<offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname, error, -EFBIG, "pgwrite", oh, true, false);
#endif
 
// Silly Castor stuff
//
   if (XrdOfsFS->evsObject && !(oh->isChanged)
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Fwrite)) GenFWEvent();
 
// Pass through any flags of interest
//
   if (opts & XrdSfsFile::Verify) pgOpts = XrdOssDF::Verify;
      else pgOpts = 0;
 
// Write the requested bytes
//
   oh->isPending = 1;
   nbytes = (XrdSfsXferSize)(oh->Select().pgWrite((void *)buffer,
                            (off_t)offset, (size_t)wrlen, csvec, pgOpts));
   if (nbytes < 0)
      return XrdOfsFS->Emsg(epname,error,(int)nbytes,"pgwrite",oh,true,false);
 
// Return number of bytes written
//
   return nbytes;
}

References EPNAME, XrdSfsFile::error, FTRACE, XrdOfsEvs::Fwrite, oh, opts, SFS_ERROR, XrdOssDF::Verify, XrdSfsFile::Verify, write(), and XrdOfsFS.

Referenced by pgWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

read() [1/3]

int XrdOfsFile::read ( XrdSfsAio * aioparm )

virtual

Read file bytes using asynchronous I/O.

Parameters

aioparm

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

Returns

SFS_OK Request accepted and will be scheduled.

SFS_ERROR File could not be read, error holds the reason.

Implements XrdSfsFile.

Definition at line 1554 of file XrdOfs.cc.

{
   EPNAME("aioread");
   int rc;
 
// Async mode for compressed files is not supported.
//
   if (oh->isCompressed)
      {aiop->Result = this->read((XrdSfsFileOffset)aiop->sfsAio.aio_offset,
                                           (char *)aiop->sfsAio.aio_buf,
                                   (XrdSfsXferSize)aiop->sfsAio.aio_nbytes);
       aiop->doneRead();
       return 0;
      }
 
// Perform required tracing
//
   FTRACE(aio, aiop->sfsAio.aio_nbytes <<"@" <<aiop->sfsAio.aio_offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (aiop->sfsAio.aio_offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname,error,-EFBIG,"read",oh->Name(),0,false);
#endif
 
// Issue the read. Only true errors are returned here.
//
   if ((rc = oh->Select().Read(aiop)) < 0)
      return XrdOfsFS->Emsg(epname, error, rc, "read", oh, false, false);
 
// All done
//
   return SFS_OK;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::doneRead(), EPNAME, XrdSfsFile::error, FTRACE, oh, read, XrdSfsAio::Result, SFS_OK, XrdSfsAio::sfsAio, and XrdOfsFS.

Here is the call graph for this function:

read() [2/3]

XrdSfsXferSize XrdOfsFile::read ( XrdSfsFileOffset offset, char * buffer, XrdSfsXferSize size )

virtual

Read file bytes into a buffer.

Parameters

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

Returns

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

SFS_ERROR File could not be read, error holds the reason.

Implements XrdSfsFile.

Definition at line 1468 of file XrdOfs.cc.

{
   EPNAME("read");
   XrdSfsXferSize nbytes;
 
// Perform required tracing
//
   FTRACE(read, blen <<"@" <<offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname,error,-EFBIG,"read",oh->Name(),0,false);
#endif
 
// Now read the actual number of bytes
//
   nbytes = (dorawio ?
            (XrdSfsXferSize)(oh->Select().ReadRaw((void *)buff,
                            (off_t)offset, (size_t)blen))
          : (XrdSfsXferSize)(oh->Select().Read((void *)buff,
                            (off_t)offset, (size_t)blen)));
   if (nbytes < 0)
      return XrdOfsFS->Emsg(epname, error, (int)nbytes, "read", oh, 0, false);
 
// Return number of bytes read
//
   return nbytes;
}

References dorawio, EPNAME, XrdSfsFile::error, FTRACE, oh, read(), and XrdOfsFS.

Here is the call graph for this function:

read() [3/3]

int XrdOfsFile::read ( XrdSfsFileOffset offset, XrdSfsXferSize size )

virtual

Preread a file block 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 When 0, the request was ignored; otherwise, it has been accepted.

SFS_ERROR File could not be preread, error holds the reason.

Implements XrdSfsFile.

Definition at line 1429 of file XrdOfs.cc.

{
   EPNAME("read");
   int retc;
 
// Perform required tracing
//
   FTRACE(read, "preread " <<blen <<"@" <<offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname,error,-EFBIG,"read",oh->Name(),0,false);
#endif
 
// Now preread the actual number of bytes
//
   if ((retc = oh->Select().Read((off_t)offset, (size_t)blen)) < 0)
      return XrdOfsFS->Emsg(epname, error, (int)retc, "preread", oh, 0, false);
 
// Return number of bytes read
//
   return retc;
}

References EPNAME, XrdSfsFile::error, FTRACE, oh, read(), and XrdOfsFS.

Referenced by pgRead(), pgRead(), read(), and read().

Here is the call graph for this function:

Here is the caller graph for this function:

readv()

XrdSfsXferSize XrdOfsFile::readv ( XrdOucIOVec * readV, int rdvCnt )

virtual

Given an array of read requests (size rdvCnt), read them from the file and place the contents consecutively in the provided buffer. A dumb default implementation is supplied but should be replaced to increase performance.

Parameters

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

Returns

>=0 The numbe of bytes placed into the buffer.

SFS_ERROR File could not be read, error holds the reason.

Reimplemented from XrdSfsFile.

Definition at line 1516 of file XrdOfs.cc.

{
   EPNAME("readv");
 
   XrdSfsXferSize nbytes = oh->Select().ReadV(readV, readCount);
   if (nbytes < 0)
       return XrdOfsFS->Emsg(epname,error,(int)nbytes,"readv",oh,false,false);
 
   return nbytes;
 
}

References EPNAME, XrdSfsFile::error, oh, and XrdOfsFS.

stat()

int XrdOfsFile::stat ( struct stat * buf )

virtual

Return state information on the file.

Parameters

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

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL. When SFS_OK is returned, buf must hold stat information.

Implements XrdSfsFile.

Definition at line 1718 of file XrdOfs.cc.

{
   EPNAME("fstat");
   int retc;
 
// Perform any required tracing
//
   FTRACE(stat, "");
 
// Perform the function
//
   if ((retc = oh->Select().Fstat(buf)) < 0)
      return XrdOfsFS->Emsg(epname,error,retc,"get state for",oh);
 
   return SFS_OK;
}

References EPNAME, XrdSfsFile::error, FTRACE, oh, SFS_OK, stat(), and XrdOfsFS.

Referenced by stat().

Here is the call graph for this function:

Here is the caller graph for this function:

sync() [1/2]

int XrdOfsFile::sync ( )

virtual

Make sure all outstanding data is actually written to the file (sync).

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED

Implements XrdSfsFile.

Definition at line 1746 of file XrdOfs.cc.

{
   EPNAME("sync");
   int retc;
 
// Perform any required tracing
//
   FTRACE(sync, "");
 
// If we have a tpc object hanging about, we need to dispatch that first
//
   if (myTPC && (retc = myTPC->Sync(&error))) return retc;
 
// We can test the pendio flag w/o a lock because the person doing this
// sync must have done the previous write. Causality is the synchronizer.
//
   if (!(oh->isPending)) return SFS_OK;
 
// We can also skip the sync if the file is closed. However, we need a file
// object lock in order to test the flag. We can also reset the PENDIO flag.
//
   oh->Lock();
   oh->isPending = 0;
   oh->UnLock();
 
// Perform the function
//
   if ((retc = oh->Select().Fsync()))
      {oh->isPending = 1;
       return XrdOfsFS->Emsg(epname, error, retc, "synchronize", oh, true);
      }
 
// Indicate all went well
//
   return SFS_OK;
}

References EPNAME, XrdSfsFile::error, FTRACE, myTPC, oh, SFS_OK, sync(), and XrdOfsFS.

Referenced by sync(), and sync().

Here is the call graph for this function:

Here is the caller graph for this function:

sync() [2/2]

int XrdOfsFile::sync ( XrdSfsAio * aiop )

virtual

Make sure all outstanding data is actually written to the file (async).

Returns

SFS_OK Request accepted and will be scheduled.

SFS_ERROR Request could not be accepted, return error has reason.

Implements XrdSfsFile.

Definition at line 1796 of file XrdOfs.cc.

{
   aiop->Result = this->sync();
   aiop->doneWrite();
   return 0;
}

References XrdSfsAio::doneWrite(), XrdSfsAio::Result, and sync().

Here is the call graph for this function:

truncate()

int XrdOfsFile::truncate ( XrdSfsFileOffset fsize )

virtual

Truncate the file.

Parameters

fsize

- The size that the file is to have.

Returns

One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFile.

Definition at line 1807 of file XrdOfs.cc.

{
   EPNAME("trunc");
   int retc;
 
// Lock the file handle and perform any tracing
//
   FTRACE(truncate, "len=" <<flen);
 
// Make sure the offset is not too large
//
   if (sizeof(off_t) < sizeof(flen) && flen >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname, error, EFBIG, "truncate", oh, true);
 
// Silly Castor stuff
//
   if (XrdOfsFS->evsObject && !(oh->isChanged)
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Fwrite)) GenFWEvent();
 
// Perform the function
//
   oh->isPending = 1;
   if ((retc = oh->Select().Ftruncate(flen)))
      return XrdOfsFS->Emsg(epname, error, retc, "truncate", oh, true);
 
// Indicate Success
//
   return SFS_OK;
}

References EPNAME, XrdSfsFile::error, FTRACE, XrdOfsEvs::Fwrite, oh, SFS_OK, truncate(), and XrdOfsFS.

Referenced by truncate().

Here is the call graph for this function:

Here is the caller graph for this function:

write() [1/2]

int XrdOfsFile::write ( XrdSfsAio * aioparm )

virtual

Write file bytes using asynchronous I/O.

Parameters

aioparm

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

Returns

0 Request accepted and will be scheduled.

!0 Request not accepted, returned value is errno.

Implements XrdSfsFile.

Definition at line 1650 of file XrdOfs.cc.

{
   EPNAME("aiowrite");
   int rc;
 
// Perform any required tracing
//
   FTRACE(aio, aiop->sfsAio.aio_nbytes <<"@" <<aiop->sfsAio.aio_offset);
 
// If this is a POSC file, we must convert the async call to a sync call as we
// must trap any errors that unpersist the file. We can't do that via aio i/f.
//
   if (oh->isRW == XrdOfsHandle::opPC)
      {aiop->Result = this->write(aiop->sfsAio.aio_offset,
                                  (const char *)aiop->sfsAio.aio_buf,
                                  aiop->sfsAio.aio_nbytes);
       aiop->doneWrite();
       return 0;
      }
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (aiop->sfsAio.aio_offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname, error, -EFBIG, "write", oh, true, false);
#endif
 
// Silly Castor stuff
//
   if (XrdOfsFS->evsObject && !(oh->isChanged)
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Fwrite)) GenFWEvent();
 
// Write the requested bytes
//
   oh->isPending = 1;
   if ((rc = oh->Select().Write(aiop)) < 0)
       return XrdOfsFS->Emsg(epname, error, rc, "write", oh, true, false);
 
// All done
//
   return SFS_OK;
}

References aiocb::aio_buf, aiocb::aio_nbytes, aiocb::aio_offset, XrdSfsAio::doneWrite(), EPNAME, XrdSfsFile::error, FTRACE, XrdOfsEvs::Fwrite, oh, XrdOfsHandle::opPC, XrdSfsAio::Result, SFS_OK, XrdSfsAio::sfsAio, write, and XrdOfsFS.

Here is the call graph for this function:

write() [2/2]

XrdSfsXferSize XrdOfsFile::write ( XrdSfsFileOffset offset, const char * buffer, XrdSfsXferSize size )

virtual

Write file bytes from a buffer.

Parameters

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

Returns

>= 0 The number of bytes that were written.

SFS_ERROR File could not be written, error holds the reason.

Implements XrdSfsFile.

Definition at line 1594 of file XrdOfs.cc.

{
   EPNAME("write");
   XrdSfsXferSize nbytes;
 
// Perform any required tracing
//
   FTRACE(write, blen <<"@" <<offset);
 
// Make sure the offset is not too large
//
#if _FILE_OFFSET_BITS!=64
   if (offset >  0x000000007fffffff)
      return  XrdOfsFS->Emsg(epname,error,-EFBIG,"write",oh,true,false);
#endif
 
// Silly Castor stuff
//
   if (XrdOfsFS->evsObject && !(oh->isChanged)
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Fwrite)) GenFWEvent();
 
// Write the requested bytes
//
   oh->isPending = 1;
   nbytes = (XrdSfsXferSize)(oh->Select().Write((const void *)buff,
                            (off_t)offset, (size_t)blen));
   if (nbytes < 0)
      return XrdOfsFS->Emsg(epname,error,(int)nbytes,"write",oh,true,false);
 
// Return number of bytes written
//
   return nbytes;
}

References EPNAME, XrdSfsFile::error, FTRACE, XrdOfsEvs::Fwrite, oh, write(), and XrdOfsFS.

Referenced by pgWrite(), pgWrite(), and write().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

ckpBad

bool XrdOfsFile::ckpBad

protected

Definition at line 209 of file XrdOfs.hh.

Referenced by XrdOfsFile(), and checkpoint().

dorawio

int XrdOfsFile::dorawio

protected

Definition at line 207 of file XrdOfs.hh.

Referenced by XrdOfsFile(), open(), pgRead(), pgRead(), and read().

myCKP

XrdOucChkPnt* XrdOfsFile::myCKP

protected

Definition at line 206 of file XrdOfs.hh.

Referenced by XrdOfsFile(), checkpoint(), and close().

myTPC

XrdOfsTPC* XrdOfsFile::myTPC

protected

Definition at line 205 of file XrdOfs.hh.

Referenced by XrdOfsFile(), close(), fctl(), open(), and sync().

ocFsync

bool XrdOfsFile::ocFsync = false

inlinestatic

Definition at line 199 of file XrdOfs.hh.

Referenced by close().

oh

XrdOfsHandle* XrdOfsFile::oh

protected

Definition at line 204 of file XrdOfs.hh.

Referenced by XrdOfsFile(), ~XrdOfsFile(), checkpoint(), Clone(), Clone(), close(), fctl(), fctl(), FName(), getCXinfo(), getMmap(), open(), pgRead(), pgRead(), pgWrite(), pgWrite(), read(), read(), read(), readv(), stat(), sync(), truncate(), write(), and write().

tident

const char* XrdOfsFile::tident

protected

Definition at line 203 of file XrdOfs.hh.

Referenced by XrdOfsFile(), close(), and open().

viaDel

bool XrdOfsFile::viaDel

protected

Definition at line 208 of file XrdOfs.hh.

Referenced by XrdOfsFile(), ~XrdOfsFile(), close(), and open().

---

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

• XrdOfs.hh
• XrdOfs.cc