XRootD
XrdPosixXrootd Class Reference

POSIX interface to XRootD with some extensions, as noted. More...

#include <XrdPosixXrootd.hh>

+ Collaboration diagram for XrdPosixXrootd:

Public Member Functions

 XrdPosixXrootd (int maxfd=255, int maxdir=0, int maxthr=0)
 
 ~XrdPosixXrootd ()
 
int fdOrigin ()
 

Static Public Member Functions

static int Access (const char *path, int amode)
 Access() conforms to POSIX.1-2001 access() More...
 
static int Close (int fildes)
 Close() conforms to POSIX.1-2001 close() More...
 
static int Closedir (DIR *dirp)
 Closedir() conforms to POSIX.1-2001 closedir() More...
 
static int endPoint (int FD, char *Buff, int Blen)
 
static int Fstat (int fildes, struct stat *buf)
 Fstat() conforms to POSIX.1-2001 fstat() More...
 
static int Fsync (int fildes)
 Fsync() conforms to POSIX.1-2001 fsync() More...
 
static void Fsync (int fildes, XrdPosixCallBackIO *cbp)
 
static int Ftruncate (int fildes, off_t offset)
 Ftruncate() conforms to POSIX.1-2001 ftruncate() More...
 
static long long Getxattr (const char *path, const char *name, void *value, unsigned long long size)
 
static bool isXrootdDir (DIR *dirp)
 
static off_t Lseek (int fildes, off_t offset, int whence)
 Lseek() conforms to POSIX.1-2001 lseek() More...
 
static int Mkdir (const char *path, mode_t mode)
 Mkdir() conforms to POSIX.1-2001 mkdir() More...
 
static bool myFD (int fd)
 
static int Open (const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)
 
static DIR * Opendir (const char *path)
 Opendir() conforms to POSIX.1-2001 opendir() More...
 
static ssize_t Pread (int fildes, void *buf, size_t nbyte, off_t offset)
 Pread() conforms to POSIX.1-2001 pread() More...
 
static void Pread (int fildes, void *buf, size_t nbyte, off_t offset, XrdPosixCallBackIO *cbp)
 
static ssize_t Pwrite (int fildes, const void *buf, size_t nbyte, off_t offset)
 Pwrite() conforms to POSIX.1-2001 pwrite() More...
 
static void Pwrite (int fildes, const void *buf, size_t nbyte, off_t offset, XrdPosixCallBackIO *cbp)
 
static int QueryChksum (const char *path, time_t &mtime, char *buff, int blen)
 
static int QueryError (std::string &emsg, DIR *dirP, bool reset=true)
 
static int QueryError (std::string &emsg, int fd=-1, bool reset=true)
 
static long long QueryOpaque (const char *path, char *buff, int blen)
 
static ssize_t Read (int fildes, void *buf, size_t nbyte)
 Read() conforms to POSIX.1-2001 read() More...
 
static struct dirent * Readdir (DIR *dirp)
 
static struct dirent64 * Readdir64 (DIR *dirp)
 
static int Readdir64_r (DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
 
static int Readdir_r (DIR *dirp, struct dirent *entry, struct dirent **result)
 
static ssize_t Readv (int fildes, const struct iovec *iov, int iovcnt)
 Readv() conforms to POSIX.1-2001 readv() More...
 
static int Rename (const char *oldpath, const char *newpath)
 Rename() conforms to POSIX.1-2001 rename() More...
 
static void Rewinddir (DIR *dirp)
 Rewinddir() conforms to POSIX.1-2001 rewinddir() More...
 
static int Rmdir (const char *path)
 Rmdir() conforms to POSIX.1-2001 rmdir() More...
 
static void Seekdir (DIR *dirp, long loc)
 Seekdir() conforms to POSIX.1-2001 seekdir() More...
 
static int Stat (const char *path, struct stat *buf)
 Stat() conforms to POSIX.1-2001 stat() More...
 
static int Statfs (const char *path, struct statfs *buf)
 
static int StatRet (DIR *dirp, struct stat *buf)
 
static int Statvfs (const char *path, struct statvfs *buf)
 Statvfs() conforms to POSIX.1-2001 statvfs() More...
 
static long Telldir (DIR *dirp)
 Telldir() conforms to POSIX.1-2001 telldir() More...
 
static int Truncate (const char *path, off_t offset)
 Telldir() conforms to POSIX.1-2001 telldir() More...
 
static int Unlink (const char *path)
 Unlink() conforms to POSIX.1-2001 unlink() More...
 
static ssize_t VRead (int fildes, const XrdOucIOVec *readV, int n)
 
static void VRead (int fildes, const XrdOucIOVec *readV, int n, XrdPosixCallBackIO *cbp)
 
static ssize_t Write (int fildes, const void *buf, size_t nbyte)
 Write() conforms to POSIX.1-2001 write() More...
 
static ssize_t Writev (int fildes, const struct iovec *iov, int iovcnt)
 Writev() conforms to POSIX.1-2001 writev() More...
 

Static Public Attributes

static const int isStream = 0x40000000
 

Friends

class XrdPosixConfig
 
class XrdPosixExtra
 

Detailed Description

POSIX interface to XRootD with some extensions, as noted.

Definition at line 63 of file XrdPosixXrootd.hh.

Constructor & Destructor Documentation

◆ XrdPosixXrootd()

XrdPosixXrootd::XrdPosixXrootd ( int  maxfd = 255,
int  maxdir = 0,
int  maxthr = 0 
)

Definition at line 180 of file XrdPosixXrootd.cc.

181 {
182  static XrdSysMutex myMutex;
183  char *cfn;
184 
185 // Test if XRDCL_EC is set. That env var. is set at XrdCl::PlugInManager::LoadFactory
186 // in XrdClPlugInManager.cc, which is called (by XrdOssGetSS while loading
187 // libXrdPss.so) before this function.
188 // Note: some standalone programs will call this constructor directly.
189  XrdPosixGlobals::usingEC = getenv("XRDCL_EC")? true : false;
190 
191 // Only static fields are initialized here. We need to do this only once!
192 //
193  myMutex.Lock();
194  if (initDone) {myMutex.UnLock(); return;}
195  initDone = 1;
196  myMutex.UnLock();
197 
198 // Initialize environment as a client or a server (it differs somewhat).
199 // Note that we create a permanent Env since some plugins rely on it. We
200 // leave the logger handling to OucPsx as we do not want to enable messages
201 // because this is likely a client application that doesn't understand noise.
202 //
203  if (!XrdPosixGlobals::theLogger && (cfn=getenv("XRDPOSIX_CONFIG")) && *cfn)
204  {bool hush;
205  if (*cfn == '+') {hush = false; cfn++;}
206  else hush = (getenv("XRDPOSIX_DEBUG") == 0);
207  if (*cfn)
208  {XrdOucEnv *psxEnv = new XrdOucEnv;
209  psxEnv->Put("psx.Client", "1");
210  XrdOucPsx psxConfig(&XrdVERSIONINFOVAR(XrdPosix), cfn, 0, psxEnv);
211  if (!psxConfig.ClientConfig("posix.", hush)
212  || !XrdPosixConfig::SetConfig(psxConfig))
213  {std::cerr <<"Posix: Unable to instantiate specified "
214  "configuration; program exiting!" <<std::endl;
215  exit(16);
216  }
217  }
218  }
219 
220 // Initialize file tracking
221 //
222  baseFD = XrdPosixObject::Init(fdnum);
223 }
void Put(const char *varname, const char *value)
Definition: XrdOucEnv.hh:85
static bool SetConfig(XrdOucPsx &parms)
static int Init(int numfd)
XrdSysLogger * theLogger

References XrdOucPsx::ClientConfig(), XrdPosixObject::Init(), XrdSysMutex::Lock(), XrdOucEnv::Put(), XrdPosixConfig::SetConfig(), XrdPosixGlobals::theLogger, XrdSysMutex::UnLock(), and XrdPosixGlobals::usingEC.

+ Here is the call graph for this function:

◆ ~XrdPosixXrootd()

XrdPosixXrootd::~XrdPosixXrootd ( )

Definition at line 229 of file XrdPosixXrootd.cc.

230 {
231 
232 // Shutdown processing
233 //
235  initDone = 0;
236 }
static void Shutdown()

References XrdPosixObject::Shutdown().

+ Here is the call graph for this function:

Member Function Documentation

◆ Access()

int XrdPosixXrootd::Access ( const char *  path,
int  amode 
)
static

Access() conforms to POSIX.1-2001 access()

Definition at line 242 of file XrdPosixXrootd.cc.

243 {
244  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
245  mode_t stMode;
246  bool aOK = true;
247 
248 // Issue the stat and verify that all went well
249 //
250  if (!admin.Stat(&stMode)) return -1;
251 
252 // Translate the mode bits
253 //
254  if (amode & R_OK && !(stMode & S_IRUSR)) aOK = 0;
255  if (amode & W_OK && !(stMode & S_IWUSR)) aOK = 0;
256  if (amode & X_OK && !(stMode & S_IXUSR)) aOK = 0;
257 
258 // All done
259 //
260  if (aOK) return 0;
261  return XrdPosixGlobals::ecMsg.SetErrno(EACCES);
262 }
int SetErrno(int ecc, int retval=-1, const char *alt=0)
Definition: XrdOucECMsg.cc:144
thread_local XrdOucECMsg ecMsg

References XrdPosixGlobals::ecMsg, XrdOucECMsg::SetErrno(), and XrdPosixAdmin::Stat().

Referenced by XrdPosix_Access().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Close()

int XrdPosixXrootd::Close ( int  fildes)
static

Close() conforms to POSIX.1-2001 close()

Definition at line 268 of file XrdPosixXrootd.cc.

269 {
270  EPNAME("Close");
271  XrdCl::XRootDStatus Status;
272  XrdPosixFile *fP;
273  bool ret;
274 
275 // Map the file number to the file object. In the prcess we relese the file
276 // number so no one can reference this file again.
277 //
278  if (!(fP = XrdPosixObject::ReleaseFile(fildes)))
279  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
280 
281 // Detach the file from a possible cache. We need to up the reference count
282 // to synchrnoize with any possible callback as we may need to place this
283 // object in he delayed destroy queue if it is stil being used. Note that
284 // the caller will get a zero return code should we delay the close.
285 //
286  fP->Ref();
287  if (fP->XCio->Detach((XrdOucCacheIOCD&)*fP) && fP->Refs() < 2)
288  {if ((ret = fP->Close(Status))) {delete fP; fP = 0;}
289  else if (DEBUGON)
290  {std::string eTxt = Status.ToString();
291  DEBUG(eTxt <<" closing " << obfuscateAuth(fP->Origin()));
292  }
293  } else {
294  ret = true;
295  }
296 
297 // If we still have a handle then we need to do a delayed delete on this
298 // object because either the close failed or there is still active I/O
299 //
300  if (fP) XrdPosixFile::DelayedDestroy(fP);
301 
302 // Return final result. Note: close errors are recorded in global thread status
303 //
304  return (ret ? 0 : XrdPosixMap::Result(Status,XrdPosixGlobals::ecMsg,true));
305 }
#define DEBUG(x)
Definition: XrdBwmTrace.hh:54
#define EPNAME(x)
Definition: XrdBwmTrace.hh:56
std::string obfuscateAuth(const std::string &input)
#define DEBUGON
virtual bool Detach(XrdOucCacheIOCD &iocd)=0
XrdOucCacheIO * XCio
Definition: XrdPosixFile.hh:65
static void * DelayedDestroy(void *)
static int Result(const XrdCl::XRootDStatus &Status, XrdOucECMsg &ecMsg, bool retneg1=false)
Definition: XrdPosixMap.cc:188
static XrdPosixFile * ReleaseFile(int fildes)
std::string ToString() const
Create a string representation.
Definition: XrdClStatus.cc:97

References XrdPosixFile::Close(), DEBUG, DEBUGON, XrdPosixFile::DelayedDestroy(), XrdOucCacheIO::Detach(), XrdPosixGlobals::ecMsg, EPNAME, obfuscateAuth(), XrdPosixFile::Origin(), XrdPosixObject::Ref(), XrdPosixObject::Refs(), XrdPosixObject::ReleaseFile(), XrdPosixMap::Result(), XrdOucECMsg::SetErrno(), XrdCl::Status::ToString(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Close(), main(), XrdFfsPosix_close(), XrdPosix_Close(), XrdPosix_Fclose(), and XrdPosix_Fopen().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Closedir()

int XrdPosixXrootd::Closedir ( DIR *  dirp)
static

Closedir() conforms to POSIX.1-2001 closedir()

Definition at line 311 of file XrdPosixXrootd.cc.

312 {
313  XrdPosixDir *dP;
314  int fildes = XrdPosixDir::dirNo(dirp);
315 
316 // Get the directory object
317 //
318  if (!(dP = XrdPosixObject::ReleaseDir(fildes)))
319  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
320 
321 // Deallocate the directory
322 //
323  delete dP;
324  return 0;
325 }
static int dirNo(DIR *dirP)
Definition: XrdPosixDir.hh:63
static XrdPosixDir * ReleaseDir(int fildes)

References XrdPosixDir::dirNo(), XrdPosixGlobals::ecMsg, XrdPosixObject::ReleaseDir(), and XrdOucECMsg::SetErrno().

Referenced by XrdPssDir::Close(), XrdFfsPosix_closedir(), and XrdPosix_Closedir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ endPoint()

int XrdPosixXrootd::endPoint ( int  FD,
char *  Buff,
int  Blen 
)
static

endPoint() is a POSIX extension and returns the location of an open file.

Parameters
FDFile descriptor of an open file in question.
BuffPointer to the buffer to receive '<host>:<port>' of the server.
BlenSize of the buffer, it must be big enough for the result.
Returns
>= 0 The numeric port number of the data server.
-1 Call failed, errno has the reason.

Definition at line 331 of file XrdPosixXrootd.cc.

332 {
333  XrdPosixFile *fp;
334  int uPort;
335 
336 // Find the file object
337 //
338  if (!(fp = XrdPosixObject::File(FD))) return 0;
339 
340 // Make sure url is valid
341 //
342  if (!(fp->clFile.IsOpen()))
343  {fp->UnLock(); return -ENOTCONN;}
344 
345 // Make sure we can fit result in the buffer
346 //
347  std::string dataServer;
348  fp->clFile.GetProperty( "DataServer", dataServer );
349  XrdCl::URL dataServerUrl = dataServer;
350 
351  if (dataServer.size() >= (uint32_t)Blen)
352  {fp->UnLock(); return -ENAMETOOLONG;}
353 
354 // Copy the data server location
355 //
356  strcpy(Buff, dataServer.c_str());
357 
358 // Get the port and return it
359 //
360  uPort = dataServerUrl.GetPort();
361  fp->UnLock();
362  return uPort;
363 }
bool IsOpen() const
Check if the file is open.
Definition: XrdClFile.cc:846
bool GetProperty(const std::string &name, std::string &value) const
Definition: XrdClFile.cc:878
URL representation.
Definition: XrdClURL.hh:31
int GetPort() const
Get the target port.
Definition: XrdClURL.hh:188
XrdCl::File clFile
Definition: XrdPosixFile.hh:67
static XrdPosixFile * File(int fildes, bool glk=false)

References XrdPosixFile::clFile, XrdPosixObject::File(), XrdCl::URL::GetPort(), XrdCl::File::GetProperty(), XrdCl::File::IsOpen(), and XrdPosixObject::UnLock().

+ Here is the call graph for this function:

◆ fdOrigin()

int XrdPosixXrootd::fdOrigin ( )
inline

The following methods are considered private but defined as public to allow XrdPosix 'C' functions and XrdPss classes access private members.

Definition at line 371 of file XrdPosixXrootd.hh.

371 {return baseFD;}

Referenced by xrootdfs_init().

+ Here is the caller graph for this function:

◆ Fstat()

int XrdPosixXrootd::Fstat ( int  fildes,
struct stat buf 
)
static

Fstat() conforms to POSIX.1-2001 fstat()

Definition at line 369 of file XrdPosixXrootd.cc.

370 {
371  XrdPosixFile *fp;
372  int rc;
373 
374 // Find the file object
375 //
376  if (!(fp = XrdPosixObject::File(fildes))) return -1;
377 
378 // First initialize the stat buffer
379 //
381 
382 // Check if we can get the stat information from the cache.
383 //
384  rc = fp->XCio->Fstat(*buf);
385  if (rc <= 0)
386  {fp->UnLock();
387  if (!rc) return 0;
388  errno = -rc; //???
389  return -1;
390  }
391 
392 // At this point we can call the file's Fstat() and if the file is not open
393 // it will be opened.
394 //
395  rc = fp->Fstat(*buf);
396  fp->UnLock();
397  if (rc < 0) {errno = -rc; rc = -1;}
398  return rc;
399 }
virtual int Fstat(struct stat &sbuff)
Definition: XrdOucCache.hh:148
static void initStat(struct stat *buf)
int Fstat(struct stat &buf) override

References XrdPosixObject::File(), XrdPosixFile::Fstat(), XrdOucCacheIO::Fstat(), XrdPosixConfig::initStat(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Fstat(), XrdPosix_Fstat(), and xrootdfs_read().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Fsync() [1/2]

int XrdPosixXrootd::Fsync ( int  fildes)
static

Fsync() conforms to POSIX.1-2001 fsync()

Definition at line 405 of file XrdPosixXrootd.cc.

406 {
407  XrdPosixFile *fp;
408  int rc;
409 
410 // Find the file object
411 //
412  if (!(fp = XrdPosixObject::File(fildes))) return -1;
413 
414 // Do the sync
415 //
416  if ((rc = fp->XCio->Sync()) < 0) return Fault(fp, -rc);
417  fp->UnLock();
418  return 0;
419 }
virtual int Sync()=0

References XrdPosixObject::File(), XrdOucCacheIO::Sync(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Fsync(), XrdFfsPosix_fsync(), XrdPosix_Fdatasync(), XrdPosix_Fflush(), and XrdPosix_Fsync().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Fsync() [2/2]

void XrdPosixXrootd::Fsync ( int  fildes,
XrdPosixCallBackIO cbp 
)
static

Definition at line 423 of file XrdPosixXrootd.cc.

424 {
425  XrdPosixFile *fp;
426 
427 // Find the file object and do the sync
428 //
429  if ((fp = XrdPosixObject::File(fildes)))
430  {cbp->theFile = fp;
431  fp->Ref(); fp->UnLock();
432  fp->XCio->Sync(*cbp);
433  } else cbp->Complete(-1);
434 }
virtual void Complete(ssize_t Result)=0

References XrdPosixCallBackIO::Complete(), XrdPosixObject::File(), XrdPosixObject::Ref(), XrdOucCacheIO::Sync(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

+ Here is the call graph for this function:

◆ Ftruncate()

int XrdPosixXrootd::Ftruncate ( int  fildes,
off_t  offset 
)
static

Ftruncate() conforms to POSIX.1-2001 ftruncate()

Definition at line 440 of file XrdPosixXrootd.cc.

441 {
442  XrdPosixFile *fp;
443  int rc;
444 
445 // Find the file object
446 //
447  if (!(fp = XrdPosixObject::File(fildes))) return -1;
448 
449 // Do the trunc
450 //
451  if ((rc = fp->XCio->Trunc(offset)) < 0) return Fault(fp, -rc);
452  fp->UnLock();
453  return 0;
454 }
virtual int Trunc(long long offs)=0

References XrdPosixObject::File(), XrdOucCacheIO::Trunc(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Ftruncate(), XrdFfsPosix_ftruncate(), and XrdPosix_Ftruncate().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Getxattr()

long long XrdPosixXrootd::Getxattr ( const char *  path,
const char *  name,
void *  value,
unsigned long long  size 
)
static

Getxattr() is a POSIX extension and conforms to Linux 2.4 getxattr(). This method returns attributes associated with a file. The format does not correspond to information returned by Linux. Refer to the XRootD protocol reference for the detailed description of the information returned.

Parameters
pathpointer to the path whose attributes are to be returned
namename of the attribute to be returned. Valid attributes are xrootd.cksum - file's checksum xrootd.space - space associated with the path xrootd.xattr - server specific extended attributes for path
valuepointer to the buffer to receive the attribute values.
sizesize of the buffer (value). If size is zero, only the maximum length of the attribute value is returned.
Returns
On success, a positive number is returned indicating the size of is extended attribute value. On failure, -1 is returned and errno

is set to indicate the reason.

Definition at line 464 of file XrdPosixXrootd.cc.

466 {
467  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
468  XrdCl::QueryCode::Code reqCode;
469  int vsize = static_cast<int>(size);
470 
471 // Check if user just wants the maximum length needed
472 //
473  if (size == 0) return 1024;
474 
475 // Check if we support the query
476 //
477  if (name)
478  { if (!strcmp(name,"xroot.cksum")) reqCode=XrdCl::QueryCode::Checksum;
479  else if (!strcmp(name,"xroot.space")) reqCode=XrdCl::QueryCode::Space;
480  else if (!strcmp(name,"xroot.xattr")) reqCode=XrdCl::QueryCode::XAttr;
481  else {errno = ENOATTR; return -1;} //???
482  }else {errno = EINVAL; return -1;}
483 
484 // Stat the file first to allow vectoring of the request to the right server
485 //
486  if (!admin.Stat()) return -1;
487 
488 // Return the result
489 //
490  return admin.Query(reqCode, value, vsize);
491 }
#define ENOATTR
Definition: XProtocol.hh:1343
Code
XRootD query request codes.
@ XAttr
Query file extended attributes.
@ Checksum
Query file checksum.
@ Space
Query logical space stats.

References XrdCl::QueryCode::Checksum, XrdPosixGlobals::ecMsg, ENOATTR, XrdPosixAdmin::Query(), XrdCl::QueryCode::Space, XrdPosixAdmin::Stat(), and XrdCl::QueryCode::XAttr.

Referenced by getchksum(), and XrdFfsPosix_getxattr().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ isXrootdDir()

bool XrdPosixXrootd::isXrootdDir ( DIR *  dirp)
static

Definition at line 1468 of file XrdPosixXrootd.cc.

1469 {
1470  XrdPosixDir *dP;
1471  int fildes;
1472 
1473  if (!dirp) return false;
1474  fildes = XrdPosixDir::dirNo(dirp);
1475 
1476  if (!myFD(fildes) || !(dP = XrdPosixObject::Dir(fildes))) return false;
1477 
1478  dP->UnLock();
1479  return true;
1480 }
static XrdPosixDir * Dir(int fildes, bool glk=false)
static bool myFD(int fd)

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), myFD(), and XrdPosixObject::UnLock().

Referenced by XrdPosix_Closedir(), XrdPosix_Readdir(), XrdPosix_Readdir64(), XrdPosix_Readdir64_r(), XrdPosix_Readdir_r(), XrdPosix_Rewinddir(), XrdPosix_Seekdir(), and XrdPosix_Telldir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Lseek()

off_t XrdPosixXrootd::Lseek ( int  fildes,
off_t  offset,
int  whence 
)
static

Lseek() conforms to POSIX.1-2001 lseek()

Definition at line 497 of file XrdPosixXrootd.cc.

498 {
499  XrdPosixFile *fp;
500  long long curroffset;
501 
502 // Find the file object
503 //
504  if (!(fp = XrdPosixObject::File(fildes))) return -1;
505 
506 // Set the new offset. Note that SEEK_END requires that the file be opened.
507 // An open may occur by calling the FSize() method via the cache pointer.
508 //
509  if (whence == SEEK_SET) curroffset = fp->setOffset(offset);
510  else if (whence == SEEK_CUR) curroffset = fp->addOffset(offset);
511  else if (whence == SEEK_END)
512  {curroffset = fp->XCio->FSize();
513  if (curroffset < 0) return Fault(fp,static_cast<int>(-curroffset));
514  curroffset = fp->setOffset(curroffset+offset);
515  }
516  else return Fault(fp, EINVAL);
517 
518 // All done
519 //
520  fp->UnLock();
521  return curroffset;
522 }
virtual long long FSize()=0
long long addOffset(long long offs, int updtSz=0)
Definition: XrdPosixFile.hh:69
long long setOffset(long long offs)

References XrdPosixFile::addOffset(), XrdPosixObject::File(), XrdOucCacheIO::FSize(), XrdPosixFile::setOffset(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdFfsPosix_lseek(), XrdPosix_Fseek(), XrdPosix_Fseeko(), XrdPosix_Ftell(), XrdPosix_Ftello(), and XrdPosix_Lseek().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Mkdir()

int XrdPosixXrootd::Mkdir ( const char *  path,
mode_t  mode 
)
static

Mkdir() conforms to POSIX.1-2001 mkdir()

Definition at line 528 of file XrdPosixXrootd.cc.

529 {
530  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
532 
533 // Preferentially make the whole path unless told otherwise
534 //
535  flags = (mode & S_ISUID ? XrdCl::MkDirFlags::None
537 
538 // Make sure the admin is OK
539 //
540  if (!admin.isOK()) return -1;
541 
542 // Issue the mkdir
543 //
544  return XrdPosixMap::Result(admin.Xrd.MkDir(admin.Url.GetPathWithParams(),
545  flags,
548  );
549 }
static XrdCl::Access::Mode Mode2Access(mode_t mode)
Definition: XrdPosixMap.cc:168
@ None
Nothing special.
@ MakePath
create the entire directory tree if it doesn't exist

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdCl::MkDirFlags::MakePath, XrdCl::FileSystem::MkDir(), XrdPosixMap::Mode2Access(), XrdCl::MkDirFlags::None, XrdPosixMap::Result(), XrdPosixAdmin::Url, and XrdPosixAdmin::Xrd.

Referenced by XrdPssSys::Mkdir(), XrdFfsPosix_mkdir(), and XrdPosix_Mkdir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ myFD()

bool XrdPosixXrootd::myFD ( int  fd)
static

Definition at line 1486 of file XrdPosixXrootd.cc.

1487 {
1488  return XrdPosixObject::Valid(fd);
1489 }
static bool Valid(int fd)

References XrdPosixObject::Valid().

Referenced by fcntl(), fstat(), isXrootdDir(), XrdPosix_Close(), XrdPosix_Fclose(), XrdPosix_Fcntl(), XrdPosix_Fdatasync(), XrdPosix_Fflush(), XrdPosix_Fread(), XrdPosix_Fseek(), XrdPosix_Fseeko(), XrdPosix_Fstat(), XrdPosix_Fsync(), XrdPosix_Ftell(), XrdPosix_Ftello(), XrdPosix_Ftruncate(), XrdPosix_Fwrite(), XrdPosix_Lseek(), XrdPosix_Pread(), XrdPosix_Pwrite(), XrdPosix_Read(), XrdPosix_Readv(), XrdPosix_Write(), and XrdPosix_Writev().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Open()

int XrdPosixXrootd::Open ( const char *  path,
int  oflag,
mode_t  mode = 0,
XrdPosixCallBack cbP = 0 
)
static

Definition at line 555 of file XrdPosixXrootd.cc.

557 {
558  return Open(path, oflags, mode, cbP, 0);
559 }
static int Open(const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)

Referenced by main(), XrdPssFile::Open(), XrdPosixConfig::OpenFC(), XrdFfsPosix_open(), XrdPosix_Fopen(), and XrdPosix_Open().

+ Here is the caller graph for this function:

◆ Opendir()

DIR * XrdPosixXrootd::Opendir ( const char *  path)
static

Opendir() conforms to POSIX.1-2001 opendir()

Definition at line 705 of file XrdPosixXrootd.cc.

706 {
707  XrdPosixDir *dP;
708  DIR *dirP;
709  int rc;
710 
711 // Get a new directory object
712 //
713  if (!(dP = new XrdPosixDir(path)))
715  return (DIR*)0;
716  }
717 
718 // Assign a file descriptor to this file
719 //
720  if (!(dP->AssignFD()))
721  {delete dP;
723  return (DIR*)0;
724  }
725 
726 // Open the directory
727 //
728  if ((dirP = dP->Open())) return dirP;
729 
730 // We failed
731 //
732  rc = errno;
733  delete dP;
734  errno = rc; // Restore saved errno
735  return (DIR *)0;
736 }
DIR * Open()
Definition: XrdPosixDir.cc:116
bool AssignFD(bool isStream=false)

References XrdPosixObject::AssignFD(), XrdPosixGlobals::ecMsg, XrdPosixDir::Open(), and XrdOucECMsg::SetErrno().

Referenced by XrdPssDir::Opendir(), XrdFfsPosix_opendir(), and XrdPosix_Opendir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Pread() [1/2]

ssize_t XrdPosixXrootd::Pread ( int  fildes,
void *  buf,
size_t  nbyte,
off_t  offset 
)
static

Pread() conforms to POSIX.1-2001 pread()

Definition at line 742 of file XrdPosixXrootd.cc.

743 {
744  XrdPosixFile *fp;
745  long long offs, bytes;
746  int iosz;
747 
748 // Find the file object
749 //
750  if (!(fp = XrdPosixObject::File(fildes)))
751  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
752 
753 // Make sure the size is not too large
754 //
755  if (nbyte > (size_t)0x7fffffff)
756  return Fault(fp, EOVERFLOW, "read size too large");
757  else iosz = static_cast<int>(nbyte);
758 
759 // Issue the read
760 //
761  offs = static_cast<long long>(offset);
762  bytes = fp->XCio->Read((char *)buf, offs, (int)iosz);
763  if (bytes < 0) return Fault(fp,-bytes,"*");
764 
765 // All went well
766 //
767  fp->UnLock();
768  return (ssize_t)bytes;
769 }
virtual int Read(char *buff, long long offs, int rlen)=0

References XrdPosixGlobals::ecMsg, XrdPosixObject::File(), XrdOucCacheIO::Read(), XrdOucECMsg::SetErrno(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Read(), XrdFfsPosix_pread(), and XrdPosix_Pread().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Pread() [2/2]

void XrdPosixXrootd::Pread ( int  fildes,
void *  buf,
size_t  nbyte,
off_t  offset,
XrdPosixCallBackIO cbp 
)
static

Definition at line 773 of file XrdPosixXrootd.cc.

775 {
776  XrdPosixFile *fp;
777  long long offs;
778  int iosz;
779 
780 // Find the file object
781 //
782  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
783 
784 // Make sure the size is not too large
785 //
786  if (nbyte > (size_t)0x7fffffff)
787  {fp->UnLock();
788  {
789  std::unique_lock lock(fp->ecMutex);
790  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
791  }
792  cbp->Complete(-1);
793  return;
794  }
795 
796 // Prepare for the read
797 //
798  cbp->theFile = fp;
799  fp->Ref(); fp->UnLock();
800  iosz = static_cast<int>(nbyte);
801  offs = static_cast<long long>(offset);
802 
803 // Issue the read
804 //
805  fp->XCio->Read(*cbp, (char *)buf, offs, (int)iosz);
806 }
std::mutex ecMutex
XrdOucECMsg ecMsg

References XrdPosixCallBackIO::Complete(), XrdPosixObject::ecMsg, XrdPosixObject::ecMutex, XrdPosixObject::File(), XrdOucCacheIO::Read(), XrdPosixObject::Ref(), XrdOucECMsg::SetErrno(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

+ Here is the call graph for this function:

◆ Pwrite() [1/2]

ssize_t XrdPosixXrootd::Pwrite ( int  fildes,
const void *  buf,
size_t  nbyte,
off_t  offset 
)
static

Pwrite() conforms to POSIX.1-2001 pwrite()

Definition at line 812 of file XrdPosixXrootd.cc.

813 {
814  XrdPosixFile *fp;
815  long long offs;
816  int iosz, bytes;
817 
818 // Find the file object
819 //
820  if (!(fp = XrdPosixObject::File(fildes))) return -1;
821 
822 // Make sure the size is not too large
823 //
824  if (nbyte > (size_t)0x7fffffff)
825  return Fault(fp,EOVERFLOW,"write size too large");
826  else iosz = static_cast<int>(nbyte);
827 
828 // Issue the write
829 //
830  offs = static_cast<long long>(offset);
831  bytes = fp->XCio->Write((char *)buf, offs, (int)iosz);
832  if (bytes < 0) return Fault(fp,-bytes,"*");
833 
834 // All went well
835 //
836  fp->UpdtSize(offs + iosz);
837  fp->UnLock();
838  return (ssize_t)iosz;
839 }
virtual int Write(char *buff, long long offs, int wlen)=0
void UpdtSize(size_t newsz)

References XrdPosixObject::File(), XrdPosixObject::UnLock(), XrdPosixFile::UpdtSize(), XrdOucCacheIO::Write(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::Write(), XrdFfsPosix_pwrite(), and XrdPosix_Pwrite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Pwrite() [2/2]

void XrdPosixXrootd::Pwrite ( int  fildes,
const void *  buf,
size_t  nbyte,
off_t  offset,
XrdPosixCallBackIO cbp 
)
static

Definition at line 843 of file XrdPosixXrootd.cc.

845 {
846  XrdPosixFile *fp;
847  long long offs;
848  int iosz;
849 
850 // Find the file object
851 //
852  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
853 
854 // Make sure the size is not too large
855 //
856  if (nbyte > (size_t)0x7fffffff)
857  {fp->UnLock();
858  {
859  std::unique_lock lock(fp->ecMutex);
860  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
861  }
862  cbp->Complete(-1);
863  return;
864  }
865 
866 // Prepare for the writing
867 //
868  cbp->theFile = fp;
869  fp->Ref(); fp->UnLock();
870  iosz = static_cast<int>(nbyte);
871  offs = static_cast<long long>(offset);
872 
873 // Issue the read
874 //
875  fp->XCio->Write(*cbp, (char *)buf, offs, (int)iosz);
876 }

References XrdPosixCallBackIO::Complete(), XrdPosixObject::ecMsg, XrdPosixObject::ecMutex, XrdPosixObject::File(), XrdPosixObject::Ref(), XrdOucECMsg::SetErrno(), XrdPosixObject::UnLock(), XrdOucCacheIO::Write(), and XrdPosixFile::XCio.

+ Here is the call graph for this function:

◆ QueryChksum()

int XrdPosixXrootd::QueryChksum ( const char *  path,
time_t &  mtime,
char *  buff,
int  blen 
)
static

QueryChksum() is a POSIX extension and returns a file's modification time and its associated checksum value.

Parameters
pathpath associated with the file whose checksum is wanted.
mtimewhere the file's modification time (st_mtime) is placed.
buffpointer to the buffer to hold the checksum value.
blenthe length of the buffer.
Returns
Upon success returns the length of the checksum response placed in buff. Otherwise, -1 is returned and errno appropriately set.

Definition at line 1495 of file XrdPosixXrootd.cc.

1497 {
1498  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1499 
1500 // Stat the file first to allow vectoring of the request to the right server
1501 //
1502  if (!admin.Stat(0, &Mtime)) return -1;
1503 
1504 // Now we can get the checksum as we have landed on the right server
1505 //
1506  return admin.Query(XrdCl::QueryCode::Checksum, value, vsize);
1507 }

References XrdCl::QueryCode::Checksum, XrdPosixGlobals::ecMsg, XrdPosixAdmin::Query(), and XrdPosixAdmin::Stat().

Referenced by XrdPssCks::Get().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ QueryError() [1/2]

int XrdPosixXrootd::QueryError ( std::string &  emsg,
DIR *  dirP,
bool  reset = true 
)
static

Definition at line 1527 of file XrdPosixXrootd.cc.

1528 {
1529  XrdPosixDir *dP;
1530  int fildes = XrdPosixDir::dirNo(dirP);
1531 
1532 // Find the object
1533 //
1534  if (!(dP = XrdPosixObject::Dir(fildes)))
1535  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
1536 
1537 // Return result
1538 //
1539  return dP->getECMsg().Get(emsg, reset);
1540 }
int emsg(int rc, char *msg)
int Get(std::string &ecm, bool rst=true)
Definition: XrdOucECMsg.cc:41
XrdOucECMsg getECMsg() const

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixGlobals::ecMsg, emsg(), XrdOucECMsg::Get(), XrdPosixObject::getECMsg(), and XrdOucECMsg::SetErrno().

+ Here is the call graph for this function:

◆ QueryError() [2/2]

int XrdPosixXrootd::QueryError ( std::string &  emsg,
int  fd = -1,
bool  reset = true 
)
static

QueryError() is a POSIX extension and returns extended information about the last error returned from a call to a POSIX function.

Parameters
emsgReference to a string to hold the retruned message text.
fdThe file descriptor associated with the error. A negative value returns the last error encountered on the calling thread for the last function not releated to a file descritor. dirP Get the error associated with the last directory operation.
resetWhen true (the default) clears the error information.
Returns
The error code and the associated message via parameter emsg. A zero return indicates that no error information is available. A -1 return indicates the call was bad itself because either the fd or dirP was invalid.

Definition at line 1513 of file XrdPosixXrootd.cc.

1514 {
1515 // If global wanted then use that one otherwise find the object specific one
1516 //
1517  if (fd < 0) return XrdPosixGlobals::ecMsg.Get(emsg, reset);
1518  else {XrdPosixFile *fp;
1519  if (!(fp = XrdPosixObject::File(fd))) return -1;
1520  std::unique_lock lock(fp->ecMutex);
1521  return fp->ecMsg.Get(emsg, reset);
1522  }
1523 }

References XrdPosixGlobals::ecMsg, XrdPosixObject::ecMsg, XrdPosixObject::ecMutex, emsg(), XrdPosixObject::File(), and XrdOucECMsg::Get().

Referenced by XrdPssSys::Info().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ QueryOpaque()

long long XrdPosixXrootd::QueryOpaque ( const char *  path,
char *  buff,
int  blen 
)
static

QueryOpaque() is a POSIX extension and returns a file's implementation specific information.

Parameters
pathpath associated with the file whose information is wanted.
buffpointer to the buffer to hold the information.
blenthe length of the buffer.
Returns
Upon success returns the length of the checksum response placed in buff. Otherwise, -1 is returned and errno appropriately set.

Definition at line 1546 of file XrdPosixXrootd.cc.

1547 {
1548  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1549 
1550 // Stat the file first to allow vectoring of the request to the right server
1551 //
1552  if (!admin.Stat()) return -1;
1553 
1554 // Now we can get the checksum as we have landed on the right server
1555 //
1556  return admin.Query(XrdCl::QueryCode::OpaqueFile, value, size);
1557 }
@ OpaqueFile
Implementation dependent.

References XrdPosixGlobals::ecMsg, XrdCl::QueryCode::OpaqueFile, XrdPosixAdmin::Query(), and XrdPosixAdmin::Stat().

+ Here is the call graph for this function:

◆ Read()

ssize_t XrdPosixXrootd::Read ( int  fildes,
void *  buf,
size_t  nbyte 
)
static

Read() conforms to POSIX.1-2001 read()

Definition at line 882 of file XrdPosixXrootd.cc.

883 {
884  XrdPosixFile *fp;
885  long long bytes;
886  int iosz;
887 
888 // Find the file object
889 //
890  if (!(fp = XrdPosixObject::File(fildes))) return -1;
891 
892 // Make sure the size is not too large
893 //
894  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
895  else iosz = static_cast<int>(nbyte);
896 
897 // Issue the read
898 //
899  bytes = fp->XCio->Read((char *)buf,fp->Offset(),(int)iosz);
900  if (bytes < 0) return Fault(fp,-bytes);
901 
902 // All went well
903 //
904  fp->addOffset(bytes);
905  fp->UnLock();
906  return (ssize_t)bytes;
907 }
long long Offset()

References XrdPosixFile::addOffset(), XrdPosixObject::File(), XrdPosixFile::Offset(), XrdOucCacheIO::Read(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by main(), Readv(), XrdFfsPosix_read(), XrdPosix_Fread(), and XrdPosix_Read().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Readdir()

struct dirent * XrdPosixXrootd::Readdir ( DIR *  dirp)
static

readdir() conforms to POSIX.1-2001 readdir() and is normally equivalent to readdir64(). The latter is provided for those platforms that require a specific 64-bit interface to directory information, which is now rare.

Definition at line 975 of file XrdPosixXrootd.cc.

976 {
977  dirent64 *dp64;
978  dirent *dp32; // Could be the same as dp64
979 
980  if (!(dp64 = Readdir64(dirp))) return 0;
981 
982  dp32 = (struct dirent *)dp64;
983  if ((char*)dp32->d_name != (char*)dp64->d_name)
984  {dp32->d_ino = dp64->d_ino;
985 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
986  dp32->d_off = dp64->d_off;
987 #endif
988 #ifndef __solaris__
989  dp32->d_type = dp64->d_type;
990 #endif
991  dp32->d_reclen = dp64->d_reclen;
992  strcpy(dp32->d_name, dp64->d_name);
993  }
994  return dp32;
995 }
static struct dirent64 * Readdir64(DIR *dirp)

References Readdir64().

Referenced by XrdFfsPosix_readdir(), and XrdPosix_Readdir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Readdir64()

struct dirent64 * XrdPosixXrootd::Readdir64 ( DIR *  dirp)
static

Definition at line 997 of file XrdPosixXrootd.cc.

998 {
999  XrdPosixDir *dP;
1000  dirent64 *dentP;
1001  int rc, fildes = XrdPosixDir::dirNo(dirp);
1002 
1003 // Find the object
1004 //
1005  if (!(dP = XrdPosixObject::Dir(fildes)))
1007  return (dirent64*)0;
1008  }
1009 
1010 // Get the next directory entry
1011 //
1012  if (!(dentP = dP->nextEntry())) rc = dP->Status();
1013  else rc = 0;
1014 
1015 // Return the appropriate result
1016 //
1017  dP->UnLock();
1018  if (rc) errno = rc;
1019  return dentP;
1020 }
dirent64 * nextEntry(dirent64 *dp=0)
Definition: XrdPosixDir.cc:48
int Status()
Definition: XrdPosixDir.hh:84

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixGlobals::ecMsg, XrdPosixDir::nextEntry(), XrdOucECMsg::SetErrno(), XrdPosixDir::Status(), and XrdPosixObject::UnLock().

Referenced by Readdir(), and XrdPosix_Readdir64().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Readdir64_r()

int XrdPosixXrootd::Readdir64_r ( DIR *  dirp,
struct dirent64 *  entry,
struct dirent64 **  result 
)
static

Definition at line 1048 of file XrdPosixXrootd.cc.

1050 {
1051  XrdPosixDir *dP;
1052  int rc, fildes = XrdPosixDir::dirNo(dirp);
1053 
1054 // Find the object
1055 //
1056  if (!(dP = XrdPosixObject::Dir(fildes))) return EBADF;
1057 
1058 // Get the next entry
1059 //
1060  if (!(*result = dP->nextEntry(entry))) {rc = dP->Status(); *result = 0;}
1061  else {rc = 0; *result = entry;}
1062 
1063 // Return the appropriate result
1064 //
1065  dP->UnLock();
1066  return rc;
1067 }

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixDir::nextEntry(), XrdPosixDir::Status(), and XrdPosixObject::UnLock().

Referenced by Readdir_r(), and XrdPosix_Readdir64_r().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Readdir_r()

int XrdPosixXrootd::Readdir_r ( DIR *  dirp,
struct dirent *  entry,
struct dirent **  result 
)
static

readdir_r() conforms to POSIX.1-2001 readdir_r() and is normally equivalent to readdir64_r(). The latter is provided for those platforms that require a specific 64-bit interface to directory information, which is now rare.

Definition at line 1026 of file XrdPosixXrootd.cc.

1028 {
1029  dirent64 *dp64 = 0, d64ent;
1030  int rc;
1031 
1032  if ((rc = Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1033  {*result = 0; return rc;}
1034 
1035  entry->d_ino = dp64->d_ino;
1036 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1037  entry->d_off = dp64->d_off;
1038 #endif
1039 #ifndef __solaris__
1040  entry->d_type = dp64->d_type;
1041 #endif
1042  entry->d_reclen = dp64->d_reclen;
1043  strcpy(entry->d_name, dp64->d_name);
1044  *result = entry;
1045  return rc;
1046 }
static int Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)

References Readdir64_r().

Referenced by XrdPssDir::Readdir(), and XrdPosix_Readdir_r().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Readv()

ssize_t XrdPosixXrootd::Readv ( int  fildes,
const struct iovec *  iov,
int  iovcnt 
)
static

Readv() conforms to POSIX.1-2001 readv()

Definition at line 913 of file XrdPosixXrootd.cc.

914 {
915  ssize_t bytes, totbytes = 0;
916  int i;
917 
918 // Return the results of the read for each iov segment
919 //
920  for (i = 0; i < iovcnt; i++)
921  {bytes = Read(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len);
922  if (bytes > 0) totbytes += bytes;
923  else if (bytes < 0) return -1;
924  else break;
925  }
926 
927 // All done
928 //
929  return totbytes;
930 }
static ssize_t Read(int fildes, void *buf, size_t nbyte)
Read() conforms to POSIX.1-2001 read()

References Read().

Referenced by XrdPosix_Readv().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Rename()

int XrdPosixXrootd::Rename ( const char *  oldpath,
const char *  newpath 
)
static

Rename() conforms to POSIX.1-2001 rename()

Definition at line 1073 of file XrdPosixXrootd.cc.

1074 {
1075  XrdPosixAdmin admin(oldpath,XrdPosixGlobals::ecMsg,nullptr);
1076  XrdCl::URL newUrl((std::string)newpath);
1077 
1078 // Make sure the admin is OK and the new url is valid
1079 //
1080  if (!admin.isOK() || !newUrl.IsValid())
1081  return XrdPosixGlobals::ecMsg.SetErrno(EINVAL);
1082 
1083 // Issue rename to he cache (it really should just deep-six both files)
1084 //
1086  {LfnPath oldF("rename", oldpath);
1087  LfnPath newF("rename", newpath);
1088  if (!oldF.path || !newF.path) return -1;
1089  XrdPosixGlobals::theCache->Rename(oldF.path, newF.path);
1090  }
1091 
1092 // Issue the rename
1093 //
1095  return EcRename(oldpath, newpath, admin);
1096 
1097  return XrdPosixMap::Result(admin.Xrd.Mv(admin.Url.GetPathWithParams(),
1098  newUrl.GetPathWithParams()),
1099  XrdPosixGlobals::ecMsg, true);
1100 }
virtual int Rename(const char *oldp, const char *newp)
Definition: XrdOucCache.hh:610
XrdOucCache * theCache

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdCl::URL::IsValid(), XrdCl::FileSystem::Mv(), XrdOucCache::Rename(), XrdPosixMap::Result(), XrdOucECMsg::SetErrno(), XrdPosixGlobals::theCache, XrdPosixAdmin::Url, XrdPosixGlobals::usingEC, and XrdPosixAdmin::Xrd.

Referenced by XrdPssSys::Rename(), XrdFfsPosix_rename(), and XrdPosix_Rename().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Rewinddir()

void XrdPosixXrootd::Rewinddir ( DIR *  dirp)
static

Rewinddir() conforms to POSIX.1-2001 rewinddir()

Definition at line 1106 of file XrdPosixXrootd.cc.

1107 {
1108  XrdPosixDir *dP;
1109  int fildes = XrdPosixDir::dirNo(dirp);
1110 
1111 // Find the object and rewind it
1112 //
1113  if ((dP = XrdPosixObject::Dir(fildes)))
1114  {dP->rewind();
1115  dP->UnLock();
1116  }
1117 }
void rewind()
Definition: XrdPosixDir.hh:80

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixDir::rewind(), and XrdPosixObject::UnLock().

Referenced by XrdPosix_Rewinddir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Rmdir()

int XrdPosixXrootd::Rmdir ( const char *  path)
static

Rmdir() conforms to POSIX.1-2001 rmdir()

Definition at line 1123 of file XrdPosixXrootd.cc.

1124 {
1125  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1126 
1127 // Make sure the admin is OK
1128 //
1129  if (!admin.isOK()) return -1;
1130 
1131 // Remove directory from the cache first
1132 //
1134  {LfnPath rmd("rmdir", path);
1135  if (!rmd.path) return -1;
1136  XrdPosixGlobals::theCache->Rmdir(rmd.path);
1137  }
1138 
1139 // Issue the rmdir
1140 //
1141  return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1142  XrdPosixGlobals::ecMsg, true);
1143 }
virtual int Rmdir(const char *dirp)
Definition: XrdOucCache.hh:622

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), XrdOucCache::Rmdir(), XrdCl::FileSystem::RmDir(), XrdPosixGlobals::theCache, XrdPosixAdmin::Url, and XrdPosixAdmin::Xrd.

Referenced by XrdPssSys::Remdir(), XrdFfsPosix_rmdir(), and XrdPosix_Rmdir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Seekdir()

void XrdPosixXrootd::Seekdir ( DIR *  dirp,
long  loc 
)
static

Seekdir() conforms to POSIX.1-2001 seekdir()

Definition at line 1149 of file XrdPosixXrootd.cc.

1150 {
1151  XrdPosixDir *dP;
1152  int fildes = XrdPosixDir::dirNo(dirp);
1153 
1154 // Find the object
1155 //
1156  if (!(dP = XrdPosixObject::Dir(fildes))) return;
1157 
1158 // Sets the current directory position
1159 //
1160  if (dP->Unread() && !(dP->Open()))
1161  {if (loc >= dP->getEntries()) loc = dP->getEntries();
1162  else if (loc < 0) loc = 0;
1163  dP->setOffset(loc);
1164  }
1165  dP->UnLock();
1166 }
bool Unread()
Definition: XrdPosixDir.hh:86
void setOffset(long offset)
Definition: XrdPosixDir.hh:69
long getEntries()
Definition: XrdPosixDir.hh:65

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixDir::getEntries(), XrdPosixDir::Open(), XrdPosixDir::setOffset(), XrdPosixObject::UnLock(), and XrdPosixDir::Unread().

Referenced by XrdPosix_Seekdir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Stat()

int XrdPosixXrootd::Stat ( const char *  path,
struct stat buf 
)
static

Stat() conforms to POSIX.1-2001 stat()

Definition at line 1172 of file XrdPosixXrootd.cc.

1173 {
1174  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1175  bool cacheChk = false;
1176 
1177 // Make sure the admin is OK
1178 //
1179  if (!admin.isOK()) return -1;
1180 
1181 // Initialize the stat buffer
1182 //
1184 
1185 // Check if we can get the stat informatation from the cache
1186 //
1188  {LfnPath statX("stat", path, false);
1189  if (!statX.path) return -1;
1190  int rc = XrdPosixGlobals::theCache->Stat(statX.path, *buf);
1191  if (!rc) return 0;
1192  if (rc < 0) {errno = -rc; return -1;} // does the cache set this???
1193  cacheChk = true;
1194  }
1195 
1196 // Issue the stat and verify that all went well
1197 //
1199  return EcStat(path, buf, admin);
1200 
1201  if (!admin.Stat(*buf)) return -1;
1202 
1203 // If we are here and the cache was checked then the file was not in the cache.
1204 // We informally tell the caller this is the case by setting atime to zero.
1205 // Normally, atime will never be zero in any other case.
1206 //
1207  if (cacheChk) buf->st_atime = 0;
1208  return 0;
1209 }
virtual int Stat(const char *url, struct stat &sbuff)
Definition: XrdOucCache.hh:638

References XrdPosixGlobals::ecMsg, XrdPosixConfig::initStat(), XrdPosixAdmin::isOK(), XrdOucCache::Stat(), XrdPosixAdmin::Stat(), XrdPosixGlobals::theCache, and XrdPosixGlobals::usingEC.

Referenced by XrdPssFile::Fstat(), main(), XrdPssSys::Stat(), XrdFfsPosix_stat(), XrdPosix_Lstat(), and XrdPosix_Stat().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Statfs()

int XrdPosixXrootd::Statfs ( const char *  path,
struct statfs buf 
)
static

Statfs() generally conforms to the platform-specific definition of statfs(). There is no specific POSIX specification for this call.

Definition at line 1215 of file XrdPosixXrootd.cc.

1216 {
1217  struct statvfs myVfs;
1218  int rc;
1219 
1220 // Issue a statvfs() call and transcribe the results
1221 //
1222  if ((rc = Statvfs(path, &myVfs))) return rc;
1223 
1224 // The vfs structure and fs structures should be size compatible (not really)
1225 //
1226  memset(buf, 0, sizeof(struct statfs));
1227  buf->f_bsize = myVfs.f_bsize;
1228  buf->f_blocks = myVfs.f_blocks;
1229  buf->f_bfree = myVfs.f_bfree;
1230  buf->f_files = myVfs.f_files;
1231  buf->f_ffree = myVfs.f_ffree;
1232 #if defined(__APPLE__) || defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1233  buf->f_iosize = myVfs.f_frsize;
1234 #else
1235  buf->f_frsize = myVfs.f_frsize;
1236 #endif
1237 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1238  buf->f_bavail = myVfs.f_bavail;
1239 #endif
1240 #if defined(__linux__) || defined(__GNU__)
1241  buf->f_namelen = myVfs.f_namemax;
1242 #elif defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1243  buf->f_namemax = myVfs.f_namemax;
1244 #endif
1245  return 0;
1246 }
int statvfs(const char *path, struct statvfs *buf)
int statfs(const char *path, struct statfs *buf)
static int Statvfs(const char *path, struct statvfs *buf)
Statvfs() conforms to POSIX.1-2001 statvfs()

References statfs(), statvfs(), and Statvfs().

Referenced by XrdPosix_Statfs().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ StatRet()

int XrdPosixXrootd::StatRet ( DIR *  dirp,
struct stat buf 
)
static

Definition at line 1252 of file XrdPosixXrootd.cc.

1253 {
1254 // Find the object
1255 //
1256  auto fildes = XrdPosixDir::dirNo(dirp);
1257  auto dP = XrdPosixObject::Dir(fildes);
1258  if (!dP) return EBADF;
1259 
1260 // Get the stat info
1261  auto rc = dP->StatRet(buf);
1262 
1263  dP->UnLock();
1264  return rc;
1265 }

References XrdPosixObject::Dir(), and XrdPosixDir::dirNo().

Referenced by XrdPssDir::StatRet().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Statvfs()

int XrdPosixXrootd::Statvfs ( const char *  path,
struct statvfs buf 
)
static

Statvfs() conforms to POSIX.1-2001 statvfs()

Definition at line 1271 of file XrdPosixXrootd.cc.

1272 {
1273  static const int szVFS = sizeof(buf->f_bfree);
1274  static const long long max32 = 0x7fffffffLL;
1275 
1276  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1277  XrdCl::StatInfoVFS *vfsStat;
1278 
1279  long long rwFree, ssFree, rwBlks;
1280  int rwNum, ssNum, rwUtil, ssUtil;
1281 
1282 // Make sure we connected
1283 //
1284  if (!admin.isOK()) return -1;
1285 
1286 // Issue the statfvs call
1287 //
1288  if (XrdPosixMap::Result(admin.Xrd.StatVFS(admin.Url.GetPathWithParams(),
1289  vfsStat),
1290  XrdPosixGlobals::ecMsg) < 0) return -1;
1291 
1292 // Extract out the information
1293 //
1294  rwNum = static_cast<int>(vfsStat->GetNodesRW());
1295  rwFree = (long long)vfsStat->GetFreeRW();
1296  rwUtil = static_cast<int>(vfsStat->GetUtilizationRW());
1297  ssNum = static_cast<int>(vfsStat->GetNodesStaging());
1298  ssFree = (long long)vfsStat->GetFreeStaging();
1299  ssUtil = static_cast<int>(vfsStat->GetUtilizationStaging());
1300  delete vfsStat;
1301 
1302 // Calculate number of blocks
1303 //
1304  if (rwUtil == 0) rwBlks = rwFree;
1305  else if (rwUtil >= 100) rwBlks = 0;
1306  else rwBlks = rwFree * (100 / (100 - rwUtil));
1307  if (ssUtil == 0) rwBlks += ssFree;
1308  else if (ssUtil < 100) rwBlks += ssFree * (100 / (100 - ssUtil));
1309 
1310 // Scale units to what will fit here (we can have a 32-bit or 64-bit struct)
1311 //
1312  if (szVFS < 8)
1313  {if (rwBlks > max32) rwBlks = max32;
1314  if (rwFree > max32) rwFree = max32;
1315  if (ssFree > max32) ssFree = max32;
1316  }
1317 
1318 // Return what little we can
1319 //
1320  memset(buf, 0, sizeof(struct statvfs));
1321  buf->f_bsize = 1024*1024;
1322  buf->f_frsize = 1024*1024;
1323  buf->f_blocks = static_cast<fsblkcnt_t>(rwBlks);
1324  buf->f_bfree = static_cast<fsblkcnt_t>(rwFree + ssFree);
1325  buf->f_bavail = static_cast<fsblkcnt_t>(rwFree);
1326  buf->f_ffree = rwNum + ssNum;
1327  buf->f_favail = rwNum;
1328  buf->f_namemax = 255; // The best we are going to do here
1329  buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1330  return 0;
1331 }
uint64_t GetFreeRW() const
Get size of the largest contiguous area of free r/w space (in MB)
uint64_t GetNodesStaging() const
Get number of nodes that can provide staging space.
uint8_t GetUtilizationStaging() const
Get percentage of the partition utilization represented by FreeStaging.
uint64_t GetFreeStaging() const
Get size of the largest contiguous area of free staging space (in MB)
uint8_t GetUtilizationRW() const
Get percentage of the partition utilization represented by FreeRW.
uint64_t GetNodesRW() const
Get number of nodes that can provide read/write space.

References XrdPosixGlobals::ecMsg, XrdCl::StatInfoVFS::GetFreeRW(), XrdCl::StatInfoVFS::GetFreeStaging(), XrdCl::StatInfoVFS::GetNodesRW(), XrdCl::StatInfoVFS::GetNodesStaging(), XrdCl::URL::GetPathWithParams(), XrdCl::StatInfoVFS::GetUtilizationRW(), XrdCl::StatInfoVFS::GetUtilizationStaging(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), statvfs(), XrdCl::FileSystem::StatVFS(), XrdPosixAdmin::Url, and XrdPosixAdmin::Xrd.

Referenced by Statfs(), and XrdPosix_Statvfs().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Telldir()

long XrdPosixXrootd::Telldir ( DIR *  dirp)
static

Telldir() conforms to POSIX.1-2001 telldir()

Definition at line 1337 of file XrdPosixXrootd.cc.

1338 {
1339  XrdPosixDir *dP;
1340  long pos;
1341  int fildes = XrdPosixDir::dirNo(dirp);
1342 
1343 // Find the object
1344 //
1345  if (!(dP = XrdPosixObject::Dir(fildes)))
1346  return XrdPosixGlobals::ecMsg.SetErrno(EBADF,0);
1347 
1348 // Tell the current directory location
1349 //
1350  pos = dP->getOffset();
1351  dP->UnLock();
1352  return pos;
1353 }
long getOffset()
Definition: XrdPosixDir.hh:67

References XrdPosixObject::Dir(), XrdPosixDir::dirNo(), XrdPosixGlobals::ecMsg, XrdPosixDir::getOffset(), XrdOucECMsg::SetErrno(), and XrdPosixObject::UnLock().

Referenced by XrdPosix_Telldir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Truncate()

int XrdPosixXrootd::Truncate ( const char *  path,
off_t  offset 
)
static

Telldir() conforms to POSIX.1-2001 telldir()

Definition at line 1359 of file XrdPosixXrootd.cc.

1360 {
1361  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1362  uint64_t tSize = static_cast<uint64_t>(Size);
1363 
1364 // Make sure the admin is OK
1365 //
1366  if (!admin.isOK()) return -1;
1367 
1368 // Truncate in the cache first
1369 //
1371  {LfnPath trunc("truncate", path);
1372  if (!trunc.path) return -1;
1373  XrdPosixGlobals::theCache->Truncate(trunc.path, tSize);
1374  }
1375 
1376 // Issue the truncate to the origin
1377 //
1378  std::string urlp = admin.Url.GetPathWithParams();
1379  return XrdPosixMap::Result(admin.Xrd.Truncate(urlp,tSize),
1380  XrdPosixGlobals::ecMsg,true);
1381 }
virtual int Truncate(const char *path, off_t size)
Definition: XrdOucCache.hh:651

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), XrdPosixGlobals::theCache, XrdOucCache::Truncate(), XrdCl::FileSystem::Truncate(), XrdPosixAdmin::Url, and XrdPosixAdmin::Xrd.

Referenced by XrdPssSys::Truncate(), XrdFfsPosix_truncate(), and XrdPosix_Truncate().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Unlink()

int XrdPosixXrootd::Unlink ( const char *  path)
static

Unlink() conforms to POSIX.1-2001 unlink()

Definition at line 1387 of file XrdPosixXrootd.cc.

1388 {
1389  XrdPosixAdmin admin(path,XrdPosixGlobals::ecMsg,nullptr);
1390 
1391 // Make sure the admin is OK
1392 //
1393  if (!admin.isOK()) return -1;
1394 
1395 // Unlink the cache first
1396 //
1398  {LfnPath remf("unlink", path);
1399  if (!remf.path) return -1;
1400  XrdPosixGlobals::theCache->Unlink(remf.path);
1401  }
1402 
1403 // Issue the UnLink
1404 //
1406  return EcUnlink(path, admin);
1407 
1408  return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1409  XrdPosixGlobals::ecMsg, true);
1410 }
virtual int Unlink(const char *path)
Definition: XrdOucCache.hh:663

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), XrdCl::FileSystem::Rm(), XrdPosixGlobals::theCache, XrdOucCache::Unlink(), XrdPosixAdmin::Url, XrdPosixGlobals::usingEC, and XrdPosixAdmin::Xrd.

Referenced by XrdPssSys::Unlink(), XrdFfsPosix_unlink(), and XrdPosix_Unlink().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VRead() [1/2]

ssize_t XrdPosixXrootd::VRead ( int  fildes,
const XrdOucIOVec readV,
int  n 
)
static

Definition at line 936 of file XrdPosixXrootd.cc.

937 {
938  XrdPosixFile *fp;
939  ssize_t bytes;
940 
941 // Find the file object
942 //
943  if (!(fp = XrdPosixObject::File(fildes))) return -1;
944 
945 // Issue the read
946 //
947  if ((bytes = fp->XCio->ReadV(readV, n)) < 0) return Fault(fp,-bytes);
948 
949 // Return bytes read
950 //
951  fp->UnLock();
952  return bytes;
953 }
virtual int ReadV(const XrdOucIOVec *readV, int rnum)
Definition: XrdOucCache.cc:86

References XrdPosixObject::File(), XrdOucCacheIO::ReadV(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

+ Here is the call graph for this function:

◆ VRead() [2/2]

void XrdPosixXrootd::VRead ( int  fildes,
const XrdOucIOVec readV,
int  n,
XrdPosixCallBackIO cbp 
)
static

VRead() is a POSIX extension and allows one to read multiple chunks of a file in one operation.

Parameters
fildesfile descriptor of a file opened for reading.
readVthe read vector of offset/length/buffer triplets. Data at each offset of the specifiued length is placed in buffer.
nthe number of elements in the readV vector.
cbppointer to the callback object for async execution.

Definition at line 957 of file XrdPosixXrootd.cc.

959 {
960  XrdPosixFile *fp;
961 
962 // Find the file object and issue read
963 //
964  if ((fp = XrdPosixObject::File(fildes)))
965  {cbp->theFile = fp;
966  fp->Ref(); fp->UnLock();
967  fp->XCio->ReadV(*cbp, readV, n);
968  } else cbp->Complete(-1);
969 }

References XrdPosixCallBackIO::Complete(), XrdPosixObject::File(), XrdOucCacheIO::ReadV(), XrdPosixObject::Ref(), XrdPosixObject::UnLock(), and XrdPosixFile::XCio.

Referenced by XrdPssFile::ReadV().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Write()

ssize_t XrdPosixXrootd::Write ( int  fildes,
const void *  buf,
size_t  nbyte 
)
static

Write() conforms to POSIX.1-2001 write()

Definition at line 1416 of file XrdPosixXrootd.cc.

1417 {
1418  XrdPosixFile *fp;
1419  int iosz, bytes;
1420 
1421 // Find the file object
1422 //
1423  if (!(fp = XrdPosixObject::File(fildes))) return -1;
1424 
1425 // Make sure the size is not too large
1426 //
1427  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
1428  else iosz = static_cast<int>(nbyte);
1429 
1430 // Issue the write
1431 //
1432  bytes = fp->XCio->Write((char *)buf,fp->Offset(),(int)iosz);
1433  if (bytes < 0) return Fault(fp,-bytes);
1434 
1435 // All went well
1436 //
1437  fp->addOffset(iosz, 1);
1438  fp->UnLock();
1439  return (ssize_t)iosz;
1440 }

References XrdPosixFile::addOffset(), XrdPosixObject::File(), XrdPosixFile::Offset(), XrdPosixObject::UnLock(), XrdOucCacheIO::Write(), and XrdPosixFile::XCio.

Referenced by Writev(), XrdFfsPosix_write(), XrdPosix_Fwrite(), and XrdPosix_Write().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Writev()

ssize_t XrdPosixXrootd::Writev ( int  fildes,
const struct iovec *  iov,
int  iovcnt 
)
static

Writev() conforms to POSIX.1-2001 writev()

Definition at line 1446 of file XrdPosixXrootd.cc.

1447 {
1448  ssize_t totbytes = 0;
1449  int i;
1450 
1451 // Return the results of the write for each iov segment
1452 //
1453  for (i = 0; i < iovcnt; i++)
1454  {if (!Write(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len))
1455  return -1;
1456  totbytes += iov[i].iov_len;
1457  }
1458 
1459 // All done
1460 //
1461  return totbytes;
1462 }
static ssize_t Write(int fildes, const void *buf, size_t nbyte)
Write() conforms to POSIX.1-2001 write()

References Write().

Referenced by XrdPosix_Writev().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Friends And Related Function Documentation

◆ XrdPosixConfig

friend class XrdPosixConfig
friend

Definition at line 66 of file XrdPosixXrootd.hh.

◆ XrdPosixExtra

friend class XrdPosixExtra
friend

Definition at line 67 of file XrdPosixXrootd.hh.

Member Data Documentation

◆ isStream

const int XrdPosixXrootd::isStream = 0x40000000
static

Open() conforms to POSIX.1-2001 open() when extensions are not used.

Extensions:

Parameters
cbPPointer to a callback object. When specified, the open is performed in the background and the Comp[lete() is called when the Open() completes. See XrdPosixCallBack.hh for complete details.
Returns
-1 is always returned when cbP is specified. If the Open() was actually scheduled then errno will contain EINPROGRESS. Otherwise, the Open() immediately failed and errno contains the reason.

Definition at line 166 of file XrdPosixXrootd.hh.

Referenced by XrdPosix_Fopen().


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