EIC code displayed by LXR master/​include/​xrootd/​XrdOss/​XrdOssWrapper.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-01-08 10:33:37

 #ifndef _XRDOSSWRAPPER_H
 #define _XRDOSSWRAPPER_H
 /******************************************************************************/
 /*                                                                            */
 /*                      X r d O s s W r a p p e r . h h                       */
 /*                                                                            */
 /* (c) 2020 by the Board of Trustees of the Leland Stanford, Jr., University  */
 /*                            All Rights Reserved                             */
 /*   Produced by Andrew Hanushevsky for Stanford University under contract    */
 /*              DE-AC02-76-SFO0515 with the Department of Energy              */
 /*                                                                            */
 /* This file is part of the XRootD software suite.                            */
 /*                                                                            */
 /* XRootD is free software: you can redistribute it and/or modify it under    */
 /* the terms of the GNU Lesser General Public License as published by the     */
 /* Free Software Foundation, either version 3 of the License, or (at your     */
 /* option) any later version.                                                 */
 /*                                                                            */
 /* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
 /* License for more details.                                                  */
 /*                                                                            */
 /* You should have received a copy of the GNU Lesser General Public License   */
 /* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
 /* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
 /*                                                                            */
 /* The copyright holder's institutional names and contributor's names may not */
 /* be used to endorse or promote products derived from this software without  */
 /* specific prior written permission of the institution or contributor.       */
 /******************************************************************************/
 
 #include "XrdOss/XrdOss.hh"
 
 /******************************************************************************/
 //! This class defines a wrapper around the three basic XrdOss classes that
 //! defines the Oss interface. It is meant to be used by pushed XrdOss plugins
 //! that wish to intercept certain XrdOss method for an underlying Oss plugin.
 //! Inheriting this class and providing it the underlying wrapped object
 //! allows the derived class to easily intercept certain methods while
 //! allow non-intercepted methods to pass through.
 /******************************************************************************/
 
 /******************************************************************************/
 /*                    C l a s s   X r d O s s W r a p D F                     */
 /******************************************************************************/
 
 //! This class wraps the object that handles directory as well as file
 //! oriented requests. It is used by the derived class to wrap the object
 //! obtained by calling newDir() or newFile() in class XrdOss.
   
 class XrdOssWrapDF : public XrdOssDF
 {
 public:
 
 /******************************************************************************/
 /*            D i r e c t o r y   O r i e n t e d   M e t h o d s             */
 /******************************************************************************/
 
 //-----------------------------------------------------------------------------
 //! Open a directory.
 //!
 //! @param  path   - Pointer to the path of the directory to be opened.
 //! @param  env    - Reference to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Opendir(const char *path, XrdOucEnv &env)
                        {return wrapDF.Opendir(path, env);}
 
 //-----------------------------------------------------------------------------
 //! Get the next directory entry.
 //!
 //! @param  buff   - Pointer to buffer where a null terminated string of the
 //!                  entry name is to be returned. If no more entries exist,
 //!                  a null string is returned.
 //! @param  blen   - Length of the buffer.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Readdir(char *buff, int blen)
                        {return wrapDF.Readdir(buff, blen);}
 
 //-----------------------------------------------------------------------------
 //! Set the stat() buffer where stat information is to be placed corresponding
 //! to the directory entry returned by Readdir().
 //!
 //! @param  Stat   - Pointer to stat structure to be used.
 //!
 //! @return 0 upon success or -ENOTSUP if not supported.
 //!
 //! @note This is a one-time call as stat structure is reused for each Readdir.
 //-----------------------------------------------------------------------------
 
 virtual int     StatRet(struct stat *Stat) {return wrapDF.StatRet(Stat);}
 
 /******************************************************************************/
 /*                 F i l e   O r i e n t e d   M e t h o d s                  */
 /******************************************************************************/
 //-----------------------------------------------------------------------------
 //! Change file mode settings.
 //!
 //! @param  mode   - The new file mode setting.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Fchmod(mode_t mode) {return wrapDF.Fchmod(mode);}
 
 //-----------------------------------------------------------------------------
 //! Flush filesystem cached pages for this file (used for checksums).
 //-----------------------------------------------------------------------------
 
 virtual void    Flush() {wrapDF.Flush();}
 
 //-----------------------------------------------------------------------------
 //! Return state information for this file.
 //!
 //! @param  buf    - Pointer to the structure where info it to be returned.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Fstat(struct stat *buf) {return wrapDF.Fstat(buf);}
 
 //-----------------------------------------------------------------------------
 //! Synchronize associated file with media (synchronous).
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Fsync() {return wrapDF.Fsync();}
 
 //-----------------------------------------------------------------------------
 //! Synchronize associated file with media (asynchronous).
 //!
 //! @param  aiop   - Pointer to async I/O request object.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Fsync(XrdSfsAio *aiop) {return wrapDF.Fsync(aiop);}
 
 //-----------------------------------------------------------------------------
 //! Set the size of the associated file.
 //!
 //! @param  flen   - The new size of the file.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Ftruncate(unsigned long long flen)
                          {return wrapDF.Ftruncate(flen);}
 
 //-----------------------------------------------------------------------------
 //! Return the memory mapped characteristics of the file.
 //!
 //! @param  addr   - Pointer to where the memory mapped address is to be returned.
 //!
 //! @return If mapped, the size of the file is returned and it memory location
 //!         is placed in addr. Otherwise, addr is set to zero and zero is
 //!         returned. Note that zero length files cannot be memory mapped.
 //-----------------------------------------------------------------------------
 
 virtual off_t   getMmap(void **addr) {return wrapDF.getMmap(addr);}
 
 //-----------------------------------------------------------------------------
 //! Return file compression charectistics.
 //!
 //! @param  cxidp  - Pointer to where the compression algorithm name returned.
 //!
 //! @return If the file is compressed, the region size if returned. Otherwise,
 //!         zero is returned (file not compressed).
 //-----------------------------------------------------------------------------
 
 virtual int     isCompressed(char *cxidp=0) {return wrapDF.isCompressed(cxidp);}
 
 //-----------------------------------------------------------------------------
 //! Open a file.
 //!
 //! @param  path   - Pointer to the path of the file to be opened.
 //! @param  Oflag  - Standard open flags.
 //! @param  Mode   - File open mode (ignored unless creating a file).
 //! @param  env    - Reference to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Open(const char *path, int Oflag, mode_t Mode, XrdOucEnv &env)
                     {return wrapDF.Open(path, Oflag, Mode, env);}
 
 //-----------------------------------------------------------------------------
 //! Read file pages into a buffer and return corresponding checksums.
 //!
 //! @param  buffer  - pointer to buffer where the bytes are to be placed.
 //! @param  offset  - The offset where the read is to start. It must be
 //!                   page aligned.
 //! @param  rdlen   - The number of bytes to read. The amount must be an
 //!                   integral number of XrdSfsPage::Size bytes.
 //! @param  csvec   - A vector of entries to be filled with the cooresponding
 //!                   CRC32C checksum for each page. It must be size to
 //!                   rdlen/XrdSys::PageSize + (rdlen%XrdSys::PageSize != 0)
 //! @param  opts    - Processing options (see below).
 //!
 //! @return >= 0      The number of bytes that placed in buffer upon success.
 //! @return  < 0       -errno or -osserr upon failure. (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t pgRead (void* buffer, off_t offset, size_t rdlen,
                         uint32_t* csvec, uint64_t opts)
                        {return wrapDF.pgRead(buffer,offset,rdlen,csvec,opts);}
 
 //-----------------------------------------------------------------------------
 //! Read file pages and checksums using asynchronous I/O.
 //!
 //! @param  aioparm - Pointer to async I/O object controlling the I/O.
 //! @param  opts    - Processing options (see above).
 //!
 //! @return 0 upon if request started success or -errno or -osserr
 //!         (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     pgRead (XrdSfsAio* aioparm, uint64_t opts)
                        {return wrapDF.pgRead(aioparm, opts);}
 
 //-----------------------------------------------------------------------------
 //! Write file pages into a file with corresponding checksums.
 //!
 //! @param  buffer  - pointer to buffer containing the bytes to write.
 //! @param  offset  - The offset where the write is to start. It must be
 //!                   page aligned.
 //! @param  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.
 //! @param  csvec   - A vector which contains the corresponding CRC32 checksum
 //!                   for each page. It must be size to
 //!                   wrlen/XrdSys::PageSize + (wrlen%XrdSys::PageSize != 0)
 //! @param  opts    - Processing options (see above).
 //!
 //! @return >= 0      The number of bytes written upon success.
 //!                   or -errno or -osserr upon failure. (see XrdOssError.hh).
 //! @return  < 0      -errno or -osserr upon failure. (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t pgWrite(void* buffer, off_t offset, size_t wrlen,
                         uint32_t* csvec, uint64_t opts)
                        {return wrapDF.pgWrite(buffer,offset,wrlen,csvec,opts);}
 
 //-----------------------------------------------------------------------------
 //! Write file pages and checksums using asynchronous I/O.
 //!
 //! @param  aioparm - Pointer to async I/O object controlling the I/O.
 //! @param  opts    - Processing options (see above).
 //!
 //! @return 0 upon if request started success or -errno or -osserr
 //!         (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     pgWrite(XrdSfsAio* aioparm, uint64_t opts)
                        {return wrapDF.pgWrite(aioparm, opts);}
 
 //-----------------------------------------------------------------------------
 //! Preread file blocks into the file system cache.
 //!
 //! @param  offset  - The offset where the read is to start.
 //! @param  size    - The number of bytes to pre-read.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t Read(off_t offset, size_t size)
                     {return wrapDF.Read(offset, size);}
 
 //-----------------------------------------------------------------------------
 //! Read file bytes into a buffer.
 //!
 //! @param  buffer  - pointer to buffer where the bytes are to be placed.
 //! @param  offset  - The offset where the read is to start.
 //! @param  size    - The number of bytes to read.
 //!
 //! @return >= 0      The number of bytes that placed in buffer.
 //! @return  < 0      -errno or -osserr upon failure (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t Read(void *buffer, off_t offset, size_t size)
                     {return wrapDF.Read(buffer, offset, size);}
 
 //-----------------------------------------------------------------------------
 //! Read file bytes using asynchronous I/O.
 //!
 //! @param  aiop    - Pointer to async I/O object controlling the I/O.
 //!
 //! @return 0 upon if request started success or -errno or -osserr
 //!         (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Read(XrdSfsAio *aiop) {return wrapDF.Read(aiop);}
 
 //-----------------------------------------------------------------------------
 //! Read uncompressed file bytes into a buffer.
 //!
 //! @param  buffer  - pointer to buffer where the bytes are to be placed.
 //! @param  offset  - The offset where the read is to start.
 //! @param  size    - The number of bytes to read.
 //!
 //! @return >= 0      The number of bytes that placed in buffer.
 //! @return  < 0      -errno or -osserr upon failure (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t ReadRaw(void *buffer, off_t offset, size_t size)
                        {return wrapDF.ReadRaw(buffer, offset, size);}
 
 //-----------------------------------------------------------------------------
 //! Read file bytes as directed by the read vector.
 //!
 //! @param  readV     pointer to the array of read requests.
 //! @param  rdvcnt    the number of elements in readV.
 //!
 //! @return >=0       The numbe of bytes read.
 //! @return < 0       -errno or -osserr upon failure (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t ReadV(XrdOucIOVec *readV, int rdvcnt)
                      {return wrapDF.ReadV(readV, rdvcnt);}
 
 //-----------------------------------------------------------------------------
 //! Write file bytes from a buffer.
 //!
 //! @param  buffer  - pointer to buffer where the bytes reside.
 //! @param  offset  - The offset where the write is to start.
 //! @param  size    - The number of bytes to write.
 //!
 //! @return >= 0      The number of bytes that were written.
 //! @return <  0      -errno or -osserr upon failure (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t Write(const void *buffer, off_t offset, size_t size)
                      {return wrapDF.Write(buffer, offset, size);}
 
 //-----------------------------------------------------------------------------
 //! Write file bytes using asynchronous I/O.
 //!
 //! @param  aiop    - Pointer to async I/O object controlling the I/O.
 //!
 //! @return 0 upon if request started success or -errno or -osserr
 //!         (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Write(XrdSfsAio *aiop) {return wrapDF.Write(aiop);}
 
 //-----------------------------------------------------------------------------
 //! Write file bytes as directed by the write vector.
 //!
 //! @param  writeV    pointer to the array of write requests.
 //! @param  wrvcnt    the number of elements in writeV.
 //!
 //! @return >=0       The numbe of bytes read.
 //! @return < 0       -errno or -osserr upon failure (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual ssize_t WriteV(XrdOucIOVec *writeV, int wrvcnt)
                       {return wrapDF.WriteV(writeV, wrvcnt);}
 
 /******************************************************************************/
 /*     C o m m o n   D i r e c t o r y   a n d   F i l e   M e t h o d s      */
 /******************************************************************************/
 //-----------------------------------------------------------------------------
 //! Close a directory or file.
 //!
 //! @param  retsz     If not nil, where the size of the file is to be returned.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Close(long long *retsz=0) {return wrapDF.Close(retsz);}
 
 //-----------------------------------------------------------------------------
 //! Return the underlying object type.
 //!
 //! @return Type of object.
 //-----------------------------------------------------------------------------
 
 uint16_t        DFType() {return wrapDF.DFType();}
 
 //-----------------------------------------------------------------------------
 //! Execute a special operation on the directory or file.
 //!
 //! @param  cmd    - The operation to be performed:
 //!                  Fctl_ckpObj - Obtain checkpoint object for proxy file.
 //!                                Argument: None.
 //!                                Response: Pointer to XrdOucChkPnt object.
 //!                  Fctl_utimes - Set atime and mtime (no response).
 //!                                Argument: struct timeval tv[2]
 //! @param  alen   - Length of data pointed to by args.
 //! @param  args   - Data sent with request, zero if alen is zero.
 //! @param  resp   - Where the response is to be set. The caller must call
 //!                  delete on the returned object.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int     Fctl(int cmd, int alen, const char *args, char **resp=0)
                     {return wrapDF.Fctl(cmd, alen, args, resp);}
 
 //-----------------------------------------------------------------------------
 //! Return the underlying file descriptor.
 //!
 //! @return -1 if there is no file descriptor or a non-negative FD number.
 //-----------------------------------------------------------------------------
 
 virtual int     getFD() {return wrapDF.getFD();}
 
 //-----------------------------------------------------------------------------
 //! Return trace identifier associated with this object.
 //!
 //! @return Pointer to trace identifier
 //-----------------------------------------------------------------------------
 virtual
 const char     *getTID() {return wrapDF.getTID();}
 
 //-----------------------------------------------------------------------------
 //! Constructor and Destructor
 //!
 //! @param  df2Wrap- Reference to the newFile or newDir object being wrapped.
 //!
 //! @note: The object creator is responsible for deleting the df2Wrap object.
 //!        The ref to this object is stored here and is accessible.
 //-----------------------------------------------------------------------------
 
                 XrdOssWrapDF(XrdOssDF &df2Wrap) : wrapDF(df2Wrap) {}
 
 virtual        ~XrdOssWrapDF() {}
 
 
 protected:
 
 XrdOssDF   &wrapDF;  // Object being wrapped
 };
   
 /******************************************************************************/
 /*                   C l a s s   X r d O s s W r a p p e r                    */
 /******************************************************************************/
   
 class XrdOssWrapper : public XrdOss
 {
 public:
 
 //-----------------------------------------------------------------------------
 //! Obtain a new director object to be used for future directory requests.
 //!
 //! @param  tident - The trace identifier.
 //!
 //! @return pointer- Pointer to a possibly wrapped XrdOssDF object.
 //! @return nil    - Insufficient memory to allocate an object.
 //-----------------------------------------------------------------------------
 
 virtual XrdOssDF     *newDir(const char *tident)
                             {return wrapPI.newDir(tident);}
 
 //-----------------------------------------------------------------------------
 //! Obtain a new file object to be used for a future file requests.
 //!
 //! @param  tident - The trace identifier.
 //!
 //! @return pointer- Pointer to a possibly wrapped XrdOssDF object.
 //! @return nil    - Insufficient memory to allocate an object.
 //-----------------------------------------------------------------------------
 
 virtual XrdOssDF     *newFile(const char *tident)
                              {return wrapPI.newFile(tident);}
 
 //-----------------------------------------------------------------------------
 //! Change file mode settings.
 //!
 //! @param  path   - Pointer to the path of the file in question.
 //! @param  mode   - The new file mode setting.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Chmod(const char * path, mode_t mode, XrdOucEnv *envP=0)
                        {return wrapPI.Chmod(path, mode, envP);}
 
 //-----------------------------------------------------------------------------
 //! Notify storage system that a client has connected.
 //!
 //! @param  env    - Reference to environmental information.
 //-----------------------------------------------------------------------------
 
 virtual void      Connect(XrdOucEnv &env) {wrapPI.Connect(env);}
 
 //-----------------------------------------------------------------------------
 //! Create file.
 //!
 //! @param  tid    - Pointer to the trace identifier.
 //! @param  path   - Pointer to the path of the file to create.
 //! @param  mode   - The new file mode setting.
 //! @param  env    - Reference to environmental information.
 //! @param  opts   - Create options:
 //!                  XRDOSS_mkpath - create dir path if it does not exist.
 //!                  XRDOSS_new    - the file must not already exist.
 //!                  oflags<<8     - open flags shifted 8 bits to the left/
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Create(const char *tid, const char *path, mode_t mode,
                          XrdOucEnv &env, int opts=0)
                         {return wrapPI.Create(tid, path, mode, env, opts);}
 
 //-----------------------------------------------------------------------------
 //! Notify storage system that a client has disconnected.
 //!
 //! @param  env    - Reference to environmental information.
 //-----------------------------------------------------------------------------
 
 virtual void      Disc(XrdOucEnv &env) {wrapPI.Disc(env);}
 
 //-----------------------------------------------------------------------------
 //! Notify storage system of initialization information (deprecated).
 //!
 //! @param  envP   - Pointer to environmental information.
 //-----------------------------------------------------------------------------
 
 virtual void      EnvInfo(XrdOucEnv *envP) {wrapPI.EnvInfo(envP);}
 
 //-----------------------------------------------------------------------------
 //! Return storage system features.
 //!
 //! @return Storage system features (see XRDOSS_HASxxx flags).
 //-----------------------------------------------------------------------------
 
 virtual uint64_t  Features() {return wrapPI.Features();}
 
 //-----------------------------------------------------------------------------
 //! Execute a special storage system operation.
 //!
 //! @param  cmd    - The operation to be performed:
 //!                  XRDOSS_FSCTLFA - Perform proxy file attribute operation
 //! @param  alen   - Length of data pointed to by args.
 //! @param  args   - Data sent with request, zero if alen is zero.
 //! @param  resp   - Where the response is to be set, if any.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       FSctl(int cmd, int alen, const char *args, char **resp=0)
                        {return wrapPI.FSctl(cmd, alen, args, resp);}
 
 //-----------------------------------------------------------------------------
 //! Initialize the storage system V1 (deprecated).
 //!
 //! @param  lp     - Pointer to the message logging object.
 //! @param  cfn    - Pointer to the configuration file.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Init(XrdSysLogger *lp, const char *cfn)
                       {return wrapPI.Init(lp, cfn);}
 
 //-----------------------------------------------------------------------------
 //! Initialize the storage system V2.
 //!
 //! @param  lp     - Pointer to the message logging object.
 //! @param  cfn    - Pointer to the configuration file.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Init(XrdSysLogger *lp, const char *cfn, XrdOucEnv *envP)
                       {return wrapPI.Init(lp, cfn, envP);}
 
 //-----------------------------------------------------------------------------
 //! Create a directory.
 //!
 //! @param  path   - Pointer to the path of the directory to be created.
 //! @param  mode   - The directory mode setting.
 //! @param  mkpath - When true the path is created if it does not exist.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Mkdir(const char *path, mode_t mode, int mkpath=0,
                         XrdOucEnv  *envP=0)
                        {return wrapPI.Mkdir(path, mode, mkpath, envP);}
 
 //-----------------------------------------------------------------------------
 //! Relocate/Copy the file at `path' to a new location.
 //!
 //! @param  tident - -> trace identifier for this operation.
 //! @param  path   - -> fully qualified name of the file to relocate.
 //! @param  cgName - -> target space name[:path]
 //! @param  anchor - Processing directions (see XrdOssReloc.cc example).
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Reloc(const char *tident, const char *path,
                         const char *cgName, const char *anchor=0)
                        {return wrapPI.Reloc(tident,path,cgName,anchor);}
 
 //-----------------------------------------------------------------------------
 //! Remove a directory.
 //!
 //! @param  path   - Pointer to the path of the directory to be removed.
 //! @param  Opts   - The processing options:
 //!                  XRDOSS_Online   - only remove online copy
 //!                  XRDOSS_isPFN    - path is already translated.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Remdir(const char *path, int Opts=0, XrdOucEnv *envP=0)
                         {return wrapPI.Remdir(path, Opts, envP);}
 
 //-----------------------------------------------------------------------------
 //! Rename a file or directory.
 //!
 //! @param  oPath   - Pointer to the path to be renamed.
 //! @param  nPath   - Pointer to the path oPath is to have.
 //! @param  oEnvP   - Environmental information for oPath.
 //! @param  nEnvP   - Environmental information for nPath.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Rename(const char *oPath, const char *nPath,
                          XrdOucEnv  *oEnvP=0, XrdOucEnv *nEnvP=0)
                         {return wrapPI.Rename(oPath, nPath, oEnvP, nEnvP);}
 
 //-----------------------------------------------------------------------------
 //! Return state information on a file or directory.
 //!
 //! @param  path   - Pointer to the path in question.
 //! @param  buff   - Pointer to the structure where info it to be returned.
 //! @param  opts   - Options:
 //!                  XRDOSS_preop    - this is a stat prior to open.
 //!                  XRDOSS_resonly  - only look for resident files.
 //!                  XRDOSS_updtatm  - update file access time.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Stat(const char *path, struct stat *buff,
                        int opts=0, XrdOucEnv *envP=0)
                       {return wrapPI.Stat(path, buff, opts, envP);}
 
 //-----------------------------------------------------------------------------
 //! Return statistics.
 //!
 //! @param  buff   - Pointer to the buffer to hold statistics.
 //! @param  blen   - Length of the buffer.
 //!
 //! @return The number of bytes placed in the buffer excluding null byte.
 //-----------------------------------------------------------------------------
 
 virtual int       Stats(char *buff, int blen)
                        {return wrapPI.Stats(buff, blen);}
 
 //-----------------------------------------------------------------------------
 //! Return filesystem physical space information associated with a path.
 //!
 //! @param  path   - Path in the partition in question.
 //! @param  buff   - Pointer to the buffer to hold the information.
 //! @param  blen   - Length of the buffer. This is updated with the actual
 //!                  number of bytes placed in the buffer as in snprintf().
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return "<wval> <fsp> <utl> <sval> <fsp> <utl>"
 //!         where: <wval> is "0" if XRDEXP_NOTRW specified, otherwise "1"
 //!                <fsp>  is free space in megabytes.
 //!                <utl>  is percentage utilization (i.e. allocated space)
 //!                <sval> is "1' if XRDEXP_STAGE specified, otherwise "0"
 //!         Upon failure -errno or -osserr (see XrdOssError.hh) returned.
 //-----------------------------------------------------------------------------
 
 virtual int       StatFS(const char *path, char *buff, int &blen,
                          XrdOucEnv  *envP=0)
                         {return wrapPI.StatFS(path, buff, blen, envP);}
 
 //-----------------------------------------------------------------------------
 //! Return filesystem physical space information associated with a space name.
 //!
 //! @param  env    - Ref to environmental information. If the environment
 //!                  has the key oss.cgroup defined, the associated value is
 //!                  used as the space name and the path is ignored.
 //! @param  path   - Path in the name space in question. The space name
 //!                  associated with gthe path is used unless overridden.
 //! @param  buff   - Pointer to the buffer to hold the information.
 //! @param  blen   - Length of the buffer. This is updated with the actual
 //!                  number of bytes placed in the buffer as in snprintf().
 //!
 //! @return "oss.cgroup=<name>&oss.space=<totbytes>&oss.free=<freebytes>
 //!          &oss.maxf=<maxcontigbytes>&oss.used=<bytesused>
 //!          &oss.quota=<quotabytes>" in buff upon success.
 //!         Upon failure -errno or -osserr (see XrdOssError.hh) returned.
 //-----------------------------------------------------------------------------
 
 virtual int       StatLS(XrdOucEnv &env, const char *path,
                          char *buff, int &blen)
                         {return wrapPI.StatLS(env, path, buff, blen);}
 
 //-----------------------------------------------------------------------------
 //! Return state information on a resident physical file or directory.
 //!
 //! @param  path   - Pointer to the path in question.
 //! @param  buff   - Pointer to the structure where info it to be returned.
 //! @param  opts   - Options:
 //!                  PF_dInfo - provide bdevID in st_rdev and partID in st_dev
 //!                             based on path. If path is nil then the contents
 //!                             of the of buff is used as the input source.
 //!                  PF_dNums - provide number of bdev's in st_rdev and the
 //!                             number of partitions in st_dev. The path
 //!                             argument is ignored. This superceeds PF_dInfo.
 //!                  PF_dStat - provide file state flags in st_rdev as shown
 //!                             below. Path may not be nil. This supercedes
 //!                             PF_dInfo and PF_dNums.
 //!                  PF_isLFN - Do N2N translation on path (default is none).
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       StatPF(const char *path, struct stat *buff, int opts)
                         {return wrapPI.StatPF(path, buff, opts);}
 
 virtual int       StatPF(const char *path, struct stat *buff)
                         {return wrapPI.StatPF(path, buff);}
 
 //-----------------------------------------------------------------------------
 //! Return space information for a space name.
 //!
 //! @param  vsP    - Pointer to the XrdOssVSInfo object to hold results.
 //!                  It should be fully initialized (i.e. a new copy).
 //! @param  sname  - Pointer to the space name. If the name starts with a
 //!                  plus (e.g. "+public"), partition information is
 //!                  returned, should it exist. If nil, space information for
 //!                  all spaces is returned. See, XrdOssVS.hh for more info.
 //! @param  updt   - When true, a space update occurrs prior to a query.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       StatVS(XrdOssVSInfo *vsP, const char *sname=0, int updt=0)
                         {return wrapPI.StatVS(vsP, sname, updt);}
 
 //-----------------------------------------------------------------------------
 //! Return logical extended attributes associated with a path.
 //!
 //! @param  path   - Path in whose information is wanted.
 //! @param  buff   - Pointer to the buffer to hold the information.
 //! @param  blen   - Length of the buffer. This is updated with the actual
 //!                  number of bytes placed in the buffer as in snprintf().
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return "oss.cgroup=<name>&oss.type={'f'|'d'|'o'}&oss.used=<totbytes>
 //!          &oss.mt=<mtime>&oss.ct=<ctime>&oss.at=<atime>&oss.u=*&oss.g=*
 //!          &oss.fs={'w'|'r'}"
 //!         Upon failure -errno or -osserr (see XrdOssError.hh) returned.
 //-----------------------------------------------------------------------------
 
 virtual int       StatXA(const char *path, char *buff, int &blen,
                          XrdOucEnv *envP=0)
                         {return wrapPI.StatXA(path, buff, blen, envP);}
 
 //-----------------------------------------------------------------------------
 //! Return export attributes associated with a path.
 //!
 //! @param  path   - Path in whose information is wanted.
 //! @param  attr   - Reference to where the inforamation is to be stored.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       StatXP(const char *path, unsigned long long &attr,
                          XrdOucEnv  *envP=0)
                         {return wrapPI.StatXP(path, attr, envP);}
 
 //-----------------------------------------------------------------------------
 //! Truncate a file.
 //!
 //! @param  path   - Pointer to the path of the file to be truncated.
 //! @param  fsize  - The size that the file is to have.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Truncate(const char *path, unsigned long long fsize,
                            XrdOucEnv *envP=0)
                           {return wrapPI.Truncate(path, fsize, envP);}
 
 //-----------------------------------------------------------------------------
 //! Remove a file.
 //!
 //! @param  path   - Pointer to the path of the file to be removed.
 //! @param  Opts   - Options:
 //!                  XRDOSS_isMIG  - this is a migratable path.
 //!                  XRDOSS_isPFN  - do not apply name2name to path.
 //!                  XRDOSS_Online - remove only the online copy.
 //! @param  envP   - Pointer to environmental information.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Unlink(const char *path, int Opts=0, XrdOucEnv *envP=0)
                         {return wrapPI.Unlink(path, Opts, envP);}
 
                   // Default Name-to-Name Methods
 
 //-----------------------------------------------------------------------------
 //! Translate logical name to physical name V1 (deprecated).
 //!
 //! @param  Path   - Path in whose information is wanted.
 //! @param  buff   - Pointer to the buffer to hold the new path.
 //! @param  blen   - Length of the buffer.
 //!
 //! @return 0 upon success or -errno or -osserr (see XrdOssError.hh).
 //-----------------------------------------------------------------------------
 
 virtual int       Lfn2Pfn(const char *Path, char *buff, int blen)
                          {return wrapPI.Lfn2Pfn(Path, buff, blen);}
 
 //-----------------------------------------------------------------------------
 //! Translate logical name to physical name V2.
 //!
 //! @param  Path   - Path in whose information is wanted.
 //! @param  buff   - Pointer to the buffer to hold the new path.
 //! @param  blen   - Length of the buffer.
 //! @param  rc     - Place where failure return code is to be returned:
 //!                  -errno or -osserr (see XrdOssError.hh).
 //!
 //! @return Pointer to the translated path upon success or nil on failure.
 //-----------------------------------------------------------------------------
 virtual
 const char       *Lfn2Pfn(const char *Path, char *buff, int blen, int &rc)
                          {return wrapPI.Lfn2Pfn(Path, buff, blen, rc);}
 
 //-----------------------------------------------------------------------------
 //! Constructor and Destructor.
 //!
 //! @param  ossRef - Reference to the Oss object being wrapped.
 //!
 //! @note: The object creator is responsible for deleting the ossRef object.
 //!        The ref to this object is stored here and is accessible.
 //-----------------------------------------------------------------------------
 
                 XrdOssWrapper(XrdOss &ossRef) : wrapPI(ossRef) {}
 virtual        ~XrdOssWrapper() {}
 
 protected:
 
 XrdOss &wrapPI;
 };
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team