XrdOssDir Class Reference

#include <XrdOssApi.hh>

Inheritance diagram for XrdOssDir:

Collaboration diagram for XrdOssDir:

Public Member Functions
	XrdOssDir (const char *tid, DIR *dP=0)
	~XrdOssDir ()
int	Close (long long *retsz=0)
int	getFD ()
int	Opendir (const char *, XrdOucEnv &)
int	Readdir (char *buff, int blen)
int	StatRet (struct stat *buff)
Public Member Functions inherited from XrdOssDF
	XrdOssDF (const char *tid="", uint16_t dftype=0, int fdnum=-1)
virtual	~XrdOssDF ()
uint16_t	DFType ()
virtual int	Fchmod (mode_t mode)
virtual int	Fctl (int cmd, int alen, const char *args, char **resp=0)
virtual void	Flush ()
	Flush filesystem cached pages for this file (used for checksums).
virtual int	Fstat (struct stat *buf)
virtual int	Fsync ()
virtual int	Fsync (XrdSfsAio *aiop)
virtual int	Ftruncate (unsigned long long flen)
virtual off_t	getMmap (void **addr)
virtual const char *	getTID ()
virtual int	isCompressed (char *cxidp=0)
virtual int	Open (const char *path, int Oflag, mode_t Mode, XrdOucEnv &env)
virtual ssize_t	pgRead (void *buffer, off_t offset, size_t rdlen, uint32_t *csvec, uint64_t opts)
virtual int	pgRead (XrdSfsAio *aioparm, uint64_t opts)
virtual ssize_t	pgWrite (void *buffer, off_t offset, size_t wrlen, uint32_t *csvec, uint64_t opts)
virtual int	pgWrite (XrdSfsAio *aioparm, uint64_t opts)
virtual ssize_t	Read (off_t offset, size_t size)
virtual ssize_t	Read (void *buffer, off_t offset, size_t size)
virtual int	Read (XrdSfsAio *aiop)
virtual ssize_t	ReadRaw (void *buffer, off_t offset, size_t size)
virtual ssize_t	ReadV (XrdOucIOVec *readV, int rdvcnt)
virtual ssize_t	Write (const void *buffer, off_t offset, size_t size)
virtual int	Write (XrdSfsAio *aiop)
virtual ssize_t	WriteV (XrdOucIOVec *writeV, int wrvcnt)

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

Detailed Description

Definition at line 51 of file XrdOssApi.hh.

Constructor & Destructor Documentation

XrdOssDir()

XrdOssDir::XrdOssDir ( const char * tid, DIR * dP = 0 )

inline

Definition at line 61 of file XrdOssApi.hh.

                 : XrdOssDF(tid, DF_isDir),
                   lclfd(dP), mssfd(0), Stat(0), ateof(false),
                   isopen(dP != 0), dOpts(0) {if (dP) fd = dirfd(dP);}

References XrdOssDF::XrdOssDF(), XrdOssDF::DF_isDir, dirfd, and XrdOssDF::fd.

Here is the call graph for this function:

~XrdOssDir()

XrdOssDir::~XrdOssDir ( )

inline

Definition at line 66 of file XrdOssApi.hh.

{if (isopen) Close();}

References Close().

Here is the call graph for this function:

Member Function Documentation

Close()

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

virtual

Close a directory or file.

Parameters

retsz

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

Returns

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

Implements XrdOssDF.

Definition at line 671 of file XrdOssApi.cc.

{
    int retc;
 
// We do not support returing a size
//
   if (retsz) *retsz = 0;
 
// Make sure this object is open
//
    if (!isopen) return -XRDOSS_E8002;
 
// Close whichever handle is open
//
    if (lclfd)
       {if (!(retc = closedir(lclfd)))
           {lclfd = 0;
            isopen = false;
           }
       } else {
        if (mssfd) { if (!(retc = XrdOssSS->MSS_Closedir(mssfd))) mssfd = 0;}
           else retc = 0;
       }
 
// Indicate whether or not we really closed this object
//
   return retc;
}

References closedir, XRDOSS_E8002, and XrdOssSS.

Referenced by ~XrdOssDir().

Here is the caller graph for this function:

getFD()

int XrdOssDir::getFD ( )

inlinevirtual

Return the underlying file descriptor.

Returns

-1 if there is no file descriptor or a non-negative FD number.

Reimplemented from XrdOssDF.

Definition at line 58 of file XrdOssApi.hh.

{return fd;}

References XrdOssDF::fd.

Opendir()

int XrdOssDir::Opendir ( const char * path, XrdOucEnv & env )

virtual

Open a directory.

Parameters

path	- Pointer to the path of the directory to be opened.
env	- Reference to environmental information.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 497 of file XrdOssApi.cc.

{
   EPNAME("Opendir");
   char actual_path[MAXPATHLEN+1], *local_path, *remote_path;
   int retc;
 
// Return an error if this object is already open
//
   if (isopen) return -XRDOSS_E8001;
 
// Get the processing flags for this directory
//
   unsigned long long pflags = XrdOssSS->PathOpts(dir_path);
   if (pflags & XRDEXP_STAGE)   dOpts |= isStage;
   if (pflags & XRDEXP_NODREAD) dOpts |= noDread;
   if (pflags & XRDEXP_NOCHECK) dOpts |= noCheck;
   ateof = false;
 
// Generate local path
//
   if (XrdOssSS->lcl_N2N)
      if ((retc = XrdOssSS->lcl_N2N->lfn2pfn(dir_path, actual_path, sizeof(actual_path))))
         return retc;
         else local_path = actual_path;
      else local_path = (char *)dir_path;
 
// If this is a local filesystem request, open locally. We also obtian the
// underlying file descriptor.
//
   if (!(dOpts & isStage) || (dOpts & noDread))
      {TRACE(Opendir, "lcl path " <<local_path <<" (" <<dir_path <<")");
       if (!(lclfd = XrdSysFD_OpenDir(local_path))) return -errno;
       fd = dirfd(lclfd);
       isopen = true;
       return XrdOssOK;
      }
 
// Generate remote path
//
   if (XrdOssSS->rmt_N2N)
      if ((retc = XrdOssSS->rmt_N2N->lfn2rfn(dir_path, actual_path, sizeof(actual_path))))
         return retc;
         else remote_path = actual_path;
      else remote_path = (char *)dir_path;
 
   TRACE(Opendir, "rmt path " << remote_path <<" (" << dir_path <<")");
 
// Originally, if MSS directories were not to be read, we ould simply check
// if the path was a directory and return an error if not. That was superceeded
// by making NODREAD mean to read the local directory only (which is not always
// ideal). So, we keep the code below but comment it out for now.
//
// if ((dOpts & noDread) && !(dOpts & noCheck))
//    {struct stat fstat;
//     if ((retc = XrdOssSS->MSS_Stat(remote_path,&fstat))) return retc;
//     if (!(S_ISDIR(fstat.st_mode))) return -ENOTDIR;
//     isopen = true;
//     return XrdOssOK;
//    }
 
// Open the directory at the remote location.
//
   if (!(mssfd = XrdOssSS->MSS_Opendir(remote_path, retc))) return retc;
   isopen = true;
   return XrdOssOK;
}

References dirfd, EPNAME, XrdOssDF::fd, Opendir(), TRACE, XRDEXP_NOCHECK, XRDEXP_NODREAD, XRDEXP_STAGE, XRDOSS_E8001, XrdOssOK, and XrdOssSS.

Referenced by Opendir().

Here is the call graph for this function:

Here is the caller graph for this function:

Readdir()

int XrdOssDir::Readdir ( char * buff, int blen )

virtual

Get the next directory entry.

Parameters

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.
blen	- Length of the buffer.

Returns

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

Reimplemented from XrdOssDF.

Definition at line 583 of file XrdOssApi.cc.

{
   struct dirent *rp;
 
// Check if this object is actually open
//
   if (!isopen) return -XRDOSS_E8002;
 
// Perform local reads if this is a local directory
//
   if (lclfd)
      {errno = 0;
       while((rp = readdir(lclfd)))
            {strlcpy(buff, rp->d_name, blen);
#ifdef HAVE_FSTATAT
             if (Stat && fstatat(fd, rp->d_name, Stat, 0))
                {if (errno != ENOENT) return -errno;
                 errno = 0;
                 continue;
                }
#endif
             return XrdOssOK;
            }
       *buff = '\0'; ateof = true;
       return -errno;
      }
 
// Simulate the read operation, if need be.
//
   if (dOpts & noDread)
      {if (ateof) *buff = '\0';
          else   {*buff = '.'; ateof = true;}
       return XrdOssOK;
      }
 
// Perform a remote read
//
   return XrdOssSS->MSS_Readdir(mssfd, buff, blen);
}

References XrdOssDF::fd, readdir, strlcpy(), XRDOSS_E8002, XrdOssOK, and XrdOssSS.

Here is the call graph for this function:

StatRet()

int XrdOssDir::StatRet ( struct stat * buff )

virtual

Set the stat() buffer where stat information is to be placed corresponding to the directory entry returned by Readdir().

Parameters

buff	- Pointer to stat structure to be used.

Returns

0 upon success or -ENOTSUP if not supported.

Note

This is a one-time call as stat structure is reused for each Readdir.

When StatRet() is in effect, directory entries that have been deleted from the target directory are quietly skipped.

Reimplemented from XrdOssDF.

Definition at line 637 of file XrdOssApi.cc.

{
 
// Check if this object is actually open
//
   if (!isopen) return -XRDOSS_E8002;
 
// We only support autostat for local directories
//
   if (!lclfd) return -ENOTSUP;
 
// We do not support autostat unless we have the fstatat function
//
#ifndef HAVE_FSTATAT
   return -ENOTSUP;
#endif
 
// All is well
//
   Stat = buff;
   return 0;
}

References stat, and XRDOSS_E8002.

---

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

• XrdOssApi.hh
• XrdOssApi.cc