XrdPosixExtra Class Reference

Extended POSIX interface to XRootD. More...

#include <XrdPosixExtra.hh>

Collaboration diagram for XrdPosixExtra:

Public Member Functions
	XrdPosixExtra ()
	~XrdPosixExtra ()

Static Public Member Functions
static int	Fctl (int fildes, XrdOucCacheOp::Code opc, const std::string &args, std::string &resp)
static int	FSctl (XrdOucCacheOp::Code opc, const std::string &args, std::string &resp, bool viaCache=false, bool viaRedir=false)
static ssize_t	pgRead (int fildes, void *buffer, off_t offset, size_t rdlen, std::vector< uint32_t > &csvec, uint64_t opts=0, XrdPosixCallBackIO *cbp=0)
static ssize_t	pgWrite (int fildes, void *buffer, off_t offset, size_t wrlen, std::vector< uint32_t > &csvec, uint64_t opts=0, XrdPosixCallBackIO *cbp=0)
static int	PreRead (int fildes, off_t offs, int size)
static int	PreRead (int fildes, XrdOucRangeList &rlist)

Static Public Attributes
static const uint64_t	forceCS = 0x0000000000000001ULL

Detailed Description

Extended POSIX interface to XRootD.

Definition at line 49 of file XrdPosixExtra.hh.

Constructor & Destructor Documentation

XrdPosixExtra()

XrdPosixExtra::XrdPosixExtra ( )

inline

Definition at line 171 of file XrdPosixExtra.hh.

{}

~XrdPosixExtra()

XrdPosixExtra::~XrdPosixExtra ( )

inline

Definition at line 172 of file XrdPosixExtra.hh.

{}

Member Function Documentation

Fctl()

int XrdPosixExtra::Fctl ( int fildes, XrdOucCacheOp::Code opc, const std::string & args, std::string & resp )

static

Perform file oriented control operation (i.e. a query).

Parameters

fildes	- Posix file descriptor of associated file.
opc	- The requested operation (e.g. QFinfo).
args	- The arguments (this is not necessarily a URL)
resp	- Where the result is to be placed.

Returns

>= 0 - Success, resp holds the response data.

< 0 errno hold reason for failure.

Note

This call is routed via the cache if file is cache enabled using the associated CacheIO object returned by the cache attach call..

Definition at line 62 of file XrdPosixExtra.cc.

{
   XrdPosixFile *fp;
 
// Make s
 
// Execute the request (this handles simple cases)
//
   switch(opc)
         {case XrdOucCacheOp::Code::QFinfo:
               if (!(fp = XrdPosixObject::File(fildes)))
                  {resp = "Invalid file descriptor.";
                   return -1;
                  }
               break;
          default:
               resp = "File operation not supported.";
               errno = ENOTSUP;
               return -1;
         }
 
// Execute the operation which may first hit the cache if we have one.
//
   return fp->XCio->Fcntl(XrdOucCacheOp::Code::QFinfo, args, resp);
}

References XrdOucCacheIO::Fcntl(), XrdPosixObject::File(), XrdOucCacheOp::QFinfo, and XrdPosixFile::XCio.

Referenced by XrdPssFile::Fctl().

Here is the call graph for this function:

Here is the caller graph for this function:

FSctl()

int XrdPosixExtra::FSctl ( XrdOucCacheOp::Code opc, const std::string & args, std::string & resp, bool viaCache = false, bool viaRedir = false )

static

Perform file system oriented control operation (i.e. a query).

Parameters

opc	- The requested operation (e.g. QFSinfo).
args	- The arguments (this should be a URL).
resp	- Where the result is to be placed.
viaCache-	False -> Bypass calling any cache using URL in args. True -> Use Cache object API if cache enabled. Otherwise, assume viaCache is false;
viaRedir-	False -> Send request directly to endpoint. True -> If endpoint is a redirector, send request to the redirected endpoint (i.e. via redirect)

Returns

>= 0 - Success, resp holds the response data.

< 0 errno hold reason for failure.

Definition at line 93 of file XrdPosixExtra.cc.

{
   XrdCl::QueryCode::Code clOp;
 
// Make sure we support the operation
//
   switch(opc)
         {case XrdOucCacheOp::Code::QFSinfo:
               clOp = XrdCl::QueryCode::Code::FSInfo;
               break;
          default:
               resp = "Filesystem operation not supported.";
               errno = ENOTSUP;
               return -1;
         }
 
// Use cache, if possible and allowed, to handle this operation
//
   if (viaCache && XrdPosixGlobals::theCache)
      return XrdPosixGlobals::theCache->Fcntl(opc, args, resp);
 
// We need to execute this at the endpoint described by args (i.e. a URL)
//
   XrdPosixAdmin admin(args.c_str(),XrdPosixGlobals::ecMsg);
 
// Stat the file first to allow vectoring of the request to the right server
// but do so only if caller wishes to use a redirect as opposed to sending
// the request to the actual redirector.
//
   if (viaRedir && !admin.Stat()) return -1;
 
// Return the actual retult
 
   return admin.Query(clOp, resp);
}

References XrdPosixGlobals::ecMsg, XrdCl::QueryCode::FSInfo, XrdOucCacheOp::QFSinfo, XrdPosixAdmin::Query(), XrdPosixAdmin::Stat(), and XrdPosixGlobals::theCache.

Referenced by XrdPssSys::FSctl().

Here is the call graph for this function:

Here is the caller graph for this function:

pgRead()

ssize_t XrdPosixExtra::pgRead ( int fildes, void * buffer, off_t offset, size_t rdlen, std::vector< uint32_t > & csvec, uint64_t opts = 0, XrdPosixCallBackIO * cbp = 0 )

static

Definition at line 135 of file XrdPosixExtra.cc.

{
   XrdPosixFile *fp;
   long long     offs, bytes;
   uint64_t      fOpts;
   int           iosz;
 
// Find the file object
//
   if (!(fp = XrdPosixObject::File(fildes)))
      {if (!cbp) return -1;
       cbp->Complete(-1);
       return 0;
      }
 
// Make sure the size is not too large
//
   if (rdlen > (size_t)0x7fffffff)
      {fp->UnLock();
       errno = EOVERFLOW;
       if (!cbp) return -1;
       cbp->Complete(-1);
       return 0;
      }
 
// Get the parameters
//
   iosz = static_cast<int>(rdlen);
   offs = static_cast<long long>(offset);
   csvec.clear();
   fOpts= (opts & forceCS ? XrdOucCacheIO::forceCS : 0);
 
// Issue the read in the sync case
//
   if (!cbp)
      {bytes = fp->XCio->pgRead((char *)buffer, offs, (int)iosz, csvec, fOpts);
       if (bytes < 0)
          {fp->ecMsg.SetErrno(-bytes);
           fp->UnLock();
           return -1;
          }
       fp->UnLock();
       return (ssize_t)bytes;
      }
 
// Handle the read in the async case
//
   cbp->theFile = fp;
   fp->Ref(); fp->UnLock();
 
// Issue the read
//
   fp->XCio->pgRead(*cbp, (char *)buffer, offs, (int)iosz, csvec, fOpts);
   return 0;
}

References XrdPosixCallBackIO::Complete(), XrdPosixObject::ecMsg, XrdPosixObject::File(), XrdOucCacheIO::forceCS, forceCS, opts, XrdOucCacheIO::pgRead(), XrdPosixObject::Ref(), XrdOucECMsg::SetErrno(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::pgRead(), and XrdPssFile::pgRead().

Here is the call graph for this function:

Here is the caller graph for this function:

pgWrite()

ssize_t XrdPosixExtra::pgWrite ( int fildes, void * buffer, off_t offset, size_t wrlen, std::vector< uint32_t > & csvec, uint64_t opts = 0, XrdPosixCallBackIO * cbp = 0 )

static

Write file pages into a file with corresponding checksums.

Parameters

fildes	- File descriptor
buffer	- pointer to buffer containing the bytes to write.
offset	- The offset where the write is to start.
wrlen	- The number of bytes to write. 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 segment. If size is 0, then checksums are calculated. If not zero, the size must equal the required number of checksums for offset/wrlen.
opts	- Options as noted.
cbp	- When supplied, return is made via callback.

Returns

>= 0 Sync: The number of bytes written upon success. Async: Always returns 0.

< 0 errno hold reason for failure.

Definition at line 199 of file XrdPosixExtra.cc.

{
   XrdPosixFile *fp;
   long long     offs;
   int           iosz, bytes;
 
// Find the file object
//
   if (!(fp = XrdPosixObject::File(fildes)))
      {if (!cbp) return -1;
       cbp->Complete(-1);
       return 0;
      }
 
// Make sure the size is not too large
//
   if (wrlen > (size_t)0x7fffffff)
      {fp->UnLock();
       errno = EOVERFLOW;
       if (!cbp) return -1;
       cbp->Complete(-1);
       return 0;
      }
 
// Check if we need to generate checksums or verify that we have the right num.
//
   if (csvec.size() == 0)
      XrdOucPgrwUtils::csCalc((const char *)buffer, offset, wrlen, csvec);
      else if (XrdOucPgrwUtils::csNum(offset, wrlen) != (int)csvec.size())
              {fp->UnLock();
               errno = EINVAL;
               if (!cbp) return -1;
               cbp->Complete(-1);
               return 0;
              }
 
// Get the parameters
//
   iosz = static_cast<int>(wrlen);
   offs = static_cast<long long>(offset);
 
// Sync: Issue the write
//
   if (!cbp)
      {bytes = fp->XCio->pgWrite((char *)buffer, offs, (int)iosz, csvec);
       if (bytes < 0)
          {fp->ecMsg.SetErrno(-bytes);
           fp->UnLock();
           return -1;
          }
       fp->UpdtSize(offs + iosz);
       fp->UnLock();
       return (ssize_t)bytes;
      }
 
// Async: Prepare for writing
//
   cbp->theFile = fp;
   fp->Ref(); fp->UnLock();
 
// Issue the write
//
   fp->XCio->pgWrite(*cbp, (char *)buffer, offs, (int)iosz, csvec);
   return 0;
}

References XrdPosixCallBackIO::Complete(), XrdOucPgrwUtils::csCalc(), XrdOucPgrwUtils::csNum(), XrdPosixObject::ecMsg, XrdPosixObject::File(), opts, XrdOucCacheIO::pgWrite(), XrdPosixObject::Ref(), XrdOucECMsg::SetErrno(), XrdPosixObject::UnLock(), XrdPosixFile::UpdtSize(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::pgWrite(), and XrdPssFile::pgWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

PreRead() [1/2]

int XrdPosixExtra::PreRead ( int fildes, off_t offs, int size )

static

Preread a range of bytes.

Parameters

fildes	- File descriptor The file descriptor must refer to an open file.
offs	- The offset at which to start the preread.
size	- The numbert of bytes to preread.

Returns

0 Request accepted.

< 0 Request rejected, errno hold reason for failure.

Definition at line 273 of file XrdPosixExtra.cc.

{
   XrdPosixFile *fp;
 
// Find the file object
//
   if (!(fp = XrdPosixObject::File(fildes))) return -1;
 
// We need to implement this
//
   return 0;
}

References XrdPosixObject::File().

Here is the call graph for this function:

PreRead() [2/2]

int XrdPosixExtra::PreRead ( int fildes, XrdOucRangeList & rlist )

static

Preread a list of byte ranges in one operation

Parameters

fildes	- File descriptor The file descriptor must refer to an open file.
rlist	- list of the byte ranges to preread. The default maximum size is 2097136 bytes and the default maximum number of request is 1024. Be aware the the server may support a different combination and may be queried for its defaults.

Returns

0 Request accepted.

< 0 Request rejected, errno hold reason for failure.

Definition at line 286 of file XrdPosixExtra.cc.

{
   XrdPosixFile *fp;
 
// Find the file object
//
   if (!(fp = XrdPosixObject::File(fildes))) return -1;
 
// We need to implement this so for now we just pretend this worked
//
   return 0;
}

References XrdPosixObject::File().

Here is the call graph for this function:

Member Data Documentation

forceCS

const uint64_t XrdPosixExtra::forceCS = 0x0000000000000001ULL

static

Read file pages into a buffer and return corresponding checksums.

Parameters

fildes	- File descriptor
buffer	- pointer to buffer where the bytes are to be placed.
offset	- The offset where the read is to start.
rdlen	- The number of bytes to read.
csvec	- A vector to be filled with the corresponding CRC32C checksums for each page or page segment, if available.
opts	- Options as noted.
cbp	- Async version: return is made via callback.

Returns

>= 0 Sync: Number of bytes that placed in buffer upon success; Async: Always returns 0.

< 0 errno hold reason for failure.

Definition at line 109 of file XrdPosixExtra.hh.

Referenced by pgRead(), XrdPssFile::pgRead(), and XrdPssFile::pgRead().

---

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

• XrdPosixExtra.hh
• XrdPosixExtra.cc