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 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 179 of file XrdPosixXrootd.cc.

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

229 {
230 
231 // Shutdown processing
232 //
234  initDone = 0;
235 }
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 241 of file XrdPosixXrootd.cc.

242 {
244  mode_t stMode;
245  bool aOK = true;
246 
247 // Issue the stat and verify that all went well
248 //
249  if (!admin.Stat(&stMode)) return -1;
250 
251 // Translate the mode bits
252 //
253  if (amode & R_OK && !(stMode & S_IRUSR)) aOK = 0;
254  if (amode & W_OK && !(stMode & S_IWUSR)) aOK = 0;
255  if (amode & X_OK && !(stMode & S_IXUSR)) aOK = 0;
256 
257 // All done
258 //
259  if (aOK) return 0;
260  return XrdPosixGlobals::ecMsg.SetErrno(EACCES);
261 }
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 267 of file XrdPosixXrootd.cc.

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

311 {
312  XrdPosixDir *dP;
313  int fildes = XrdPosixDir::dirNo(dirp);
314 
315 // Get the directory object
316 //
317  if (!(dP = XrdPosixObject::ReleaseDir(fildes)))
318  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
319 
320 // Deallocate the directory
321 //
322  delete dP;
323  return 0;
324 }
static int dirNo(DIR *dirP)
Definition: XrdPosixDir.hh:60
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 330 of file XrdPosixXrootd.cc.

331 {
332  XrdPosixFile *fp;
333  int uPort;
334 
335 // Find the file object
336 //
337  if (!(fp = XrdPosixObject::File(FD))) return 0;
338 
339 // Make sure url is valid
340 //
341  if (!(fp->clFile.IsOpen()))
342  {fp->UnLock(); return -ENOTCONN;}
343 
344 // Make sure we can fit result in the buffer
345 //
346  std::string dataServer;
347  fp->clFile.GetProperty( "DataServer", dataServer );
348  XrdCl::URL dataServerUrl = dataServer;
349 
350  if (dataServer.size() >= (uint32_t)Blen)
351  {fp->UnLock(); return -ENAMETOOLONG;}
352 
353 // Copy the data server location
354 //
355  strcpy(Buff, dataServer.c_str());
356 
357 // Get the port and return it
358 //
359  uPort = dataServerUrl.GetPort();
360  fp->UnLock();
361  return uPort;
362 }
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;}

◆ Fstat()

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

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

Definition at line 368 of file XrdPosixXrootd.cc.

369 {
370  XrdPosixFile *fp;
371  int rc;
372 
373 // Find the file object
374 //
375  if (!(fp = XrdPosixObject::File(fildes))) return -1;
376 
377 // First initialize the stat buffer
378 //
380 
381 // Check if we can get the stat information from the cache.
382 //
383  rc = fp->XCio->Fstat(*buf);
384  if (rc <= 0)
385  {fp->UnLock();
386  if (!rc) return 0;
387  errno = -rc; //???
388  return -1;
389  }
390 
391 // At this point we can call the file's Fstat() and if the file is not open
392 // it will be opened.
393 //
394  rc = fp->Fstat(*buf);
395  fp->UnLock();
396  if (rc < 0) {errno = -rc; rc = -1;}
397  return rc;
398 }
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(), and XrdPosix_Fstat().

+ 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 404 of file XrdPosixXrootd.cc.

405 {
406  XrdPosixFile *fp;
407  int rc;
408 
409 // Find the file object
410 //
411  if (!(fp = XrdPosixObject::File(fildes))) return -1;
412 
413 // Do the sync
414 //
415  if ((rc = fp->XCio->Sync()) < 0) return Fault(fp, -rc);
416  fp->UnLock();
417  return 0;
418 }
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 422 of file XrdPosixXrootd.cc.

423 {
424  XrdPosixFile *fp;
425 
426 // Find the file object and do the sync
427 //
428  if ((fp = XrdPosixObject::File(fildes)))
429  {cbp->theFile = fp;
430  fp->Ref(); fp->UnLock();
431  fp->XCio->Sync(*cbp);
432  } else cbp->Complete(-1);
433 }
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 439 of file XrdPosixXrootd.cc.

440 {
441  XrdPosixFile *fp;
442  int rc;
443 
444 // Find the file object
445 //
446  if (!(fp = XrdPosixObject::File(fildes))) return -1;
447 
448 // Do the trunc
449 //
450  if ((rc = fp->XCio->Trunc(offset)) < 0) return Fault(fp, -rc);
451  fp->UnLock();
452  return 0;
453 }
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 463 of file XrdPosixXrootd.cc.

465 {
467  XrdCl::QueryCode::Code reqCode;
468  int vsize = static_cast<int>(size);
469 
470 // Check if user just wants the maximum length needed
471 //
472  if (size == 0) return 1024;
473 
474 // Check if we support the query
475 //
476  if (name)
477  { if (!strcmp(name,"xroot.cksum")) reqCode=XrdCl::QueryCode::Checksum;
478  else if (!strcmp(name,"xroot.space")) reqCode=XrdCl::QueryCode::Space;
479  else if (!strcmp(name,"xroot.xattr")) reqCode=XrdCl::QueryCode::XAttr;
480  else {errno = ENOATTR; return -1;} //???
481  }else {errno = EINVAL; return -1;}
482 
483 // Stat the file first to allow vectoring of the request to the right server
484 //
485  if (!admin.Stat()) return -1;
486 
487 // Return the result
488 //
489  return admin.Query(reqCode, value, vsize);
490 }
#define ENOATTR
Definition: XProtocol.hh:1342
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 1434 of file XrdPosixXrootd.cc.

1435 {
1436  XrdPosixDir *dP;
1437  int fildes;
1438 
1439  if (!dirp) return false;
1440  fildes = XrdPosixDir::dirNo(dirp);
1441 
1442  if (!myFD(fildes) || !(dP = XrdPosixObject::Dir(fildes))) return false;
1443 
1444  dP->UnLock();
1445  return true;
1446 }
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 496 of file XrdPosixXrootd.cc.

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

528 {
531 
532 // Preferentially make the whole path unless told otherwise
533 //
534  flags = (mode & S_ISUID ? XrdCl::MkDirFlags::None
536 
537 // Make sure the admin is OK
538 //
539  if (!admin.isOK()) return -1;
540 
541 // Issue the mkdir
542 //
543  return XrdPosixMap::Result(admin.Xrd.MkDir(admin.Url.GetPathWithParams(),
544  flags,
547  );
548 }
static XrdCl::Access::Mode Mode2Access(mode_t mode)
Definition: XrdPosixMap.cc:130
@ 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 1452 of file XrdPosixXrootd.cc.

1453 {
1454  return XrdPosixObject::Valid(fd);
1455 }
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 554 of file XrdPosixXrootd.cc.

556 {
557  return Open(path, oflags, mode, cbP, 0);
558 }
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 704 of file XrdPosixXrootd.cc.

705 {
706  XrdPosixDir *dP;
707  DIR *dirP;
708  int rc;
709 
710 // Get a new directory object
711 //
712  if (!(dP = new XrdPosixDir(path)))
714  return (DIR*)0;
715  }
716 
717 // Assign a file descriptor to this file
718 //
719  if (!(dP->AssignFD()))
720  {delete dP;
722  return (DIR*)0;
723  }
724 
725 // Open the directory
726 //
727  if ((dirP = dP->Open())) return dirP;
728 
729 // We failed
730 //
731  rc = errno;
732  delete dP;
733  errno = rc; // Restore saved errno
734  return (DIR *)0;
735 }
DIR * Open()
Definition: XrdPosixDir.cc:94
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 741 of file XrdPosixXrootd.cc.

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

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

References XrdPosixCallBackIO::Complete(), XrdPosixObject::ecMsg, 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 808 of file XrdPosixXrootd.cc.

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

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

References XrdPosixCallBackIO::Complete(), XrdPosixObject::ecMsg, 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 1461 of file XrdPosixXrootd.cc.

1463 {
1465 
1466 // Stat the file first to allow vectoring of the request to the right server
1467 //
1468  if (!admin.Stat(0, &Mtime)) return -1;
1469 
1470 // Now we can get the checksum as we have landed on the right server
1471 //
1472  return admin.Query(XrdCl::QueryCode::Checksum, value, vsize);
1473 }

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 1498 of file XrdPosixXrootd.cc.

1499 {
1500  XrdPosixDir *dP;
1501  int fildes = XrdPosixDir::dirNo(dirP);
1502 
1503 // Find the object
1504 //
1505  if (!(dP = XrdPosixObject::Dir(fildes)))
1506  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
1507 
1508 // Return result
1509 //
1510  return dP->getECMsg()->Get(emsg, reset);
1511 }
int emsg(int rc, char *msg)
int Get(std::string &ecm, bool rst=true)
Definition: XrdOucECMsg.cc:41
XrdOucECMsg * getECMsg()

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 1479 of file XrdPosixXrootd.cc.

1480 {
1481  XrdOucECMsg* ecmP;
1482 
1483 // If global wanted then use that one otherwise find the object specific one
1484 //
1485  if (fd < 0) ecmP = &XrdPosixGlobals::ecMsg;
1486  else {XrdPosixFile *fp;
1487  if (!(fp = XrdPosixObject::File(fd))) return -1;
1488  ecmP = fp->getECMsg();
1489  }
1490 
1491 // Return the message information
1492 //
1493  return ecmP->Get(emsg, reset);
1494 }

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

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 1517 of file XrdPosixXrootd.cc.

1518 {
1520 
1521 // Stat the file first to allow vectoring of the request to the right server
1522 //
1523  if (!admin.Stat()) return -1;
1524 
1525 // Now we can get the checksum as we have landed on the right server
1526 //
1527  return admin.Query(XrdCl::QueryCode::OpaqueFile, value, size);
1528 }
@ 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 875 of file XrdPosixXrootd.cc.

876 {
877  XrdPosixFile *fp;
878  long long bytes;
879  int iosz;
880 
881 // Find the file object
882 //
883  if (!(fp = XrdPosixObject::File(fildes))) return -1;
884 
885 // Make sure the size is not too large
886 //
887  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
888  else iosz = static_cast<int>(nbyte);
889 
890 // Issue the read
891 //
892  bytes = fp->XCio->Read((char *)buf,fp->Offset(),(int)iosz);
893  if (bytes < 0) return Fault(fp,-bytes);
894 
895 // All went well
896 //
897  fp->addOffset(bytes);
898  fp->UnLock();
899  return (ssize_t)bytes;
900 }
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 968 of file XrdPosixXrootd.cc.

969 {
970  dirent64 *dp64;
971  dirent *dp32; // Could be the same as dp64
972 
973  if (!(dp64 = Readdir64(dirp))) return 0;
974 
975  dp32 = (struct dirent *)dp64;
976  if ((char*)dp32->d_name != (char*)dp64->d_name)
977  {dp32->d_ino = dp64->d_ino;
978 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
979  dp32->d_off = dp64->d_off;
980 #endif
981 #ifndef __solaris__
982  dp32->d_type = dp64->d_type;
983 #endif
984  dp32->d_reclen = dp64->d_reclen;
985  strcpy(dp32->d_name, dp64->d_name);
986  }
987  return dp32;
988 }
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 990 of file XrdPosixXrootd.cc.

991 {
992  XrdPosixDir *dP;
993  dirent64 *dentP;
994  int rc, fildes = XrdPosixDir::dirNo(dirp);
995 
996 // Find the object
997 //
998  if (!(dP = XrdPosixObject::Dir(fildes)))
1000  return (dirent64*)0;
1001  }
1002 
1003 // Get the next directory entry
1004 //
1005  if (!(dentP = dP->nextEntry())) rc = dP->Status();
1006  else rc = 0;
1007 
1008 // Return the appropriate result
1009 //
1010  dP->UnLock();
1011  if (rc) errno = rc;
1012  return dentP;
1013 }
dirent64 * nextEntry(dirent64 *dp=0)
Definition: XrdPosixDir.cc:48
int Status()
Definition: XrdPosixDir.hh:76

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 1041 of file XrdPosixXrootd.cc.

1043 {
1044  XrdPosixDir *dP;
1045  int rc, fildes = XrdPosixDir::dirNo(dirp);
1046 
1047 // Find the object
1048 //
1049  if (!(dP = XrdPosixObject::Dir(fildes))) return EBADF;
1050 
1051 // Get the next entry
1052 //
1053  if (!(*result = dP->nextEntry(entry))) {rc = dP->Status(); *result = 0;}
1054  else {rc = 0; *result = entry;}
1055 
1056 // Return the appropriate result
1057 //
1058  dP->UnLock();
1059  return rc;
1060 }

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 1019 of file XrdPosixXrootd.cc.

1021 {
1022  dirent64 *dp64 = 0, d64ent;
1023  int rc;
1024 
1025  if ((rc = Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1026  {*result = 0; return rc;}
1027 
1028  entry->d_ino = dp64->d_ino;
1029 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1030  entry->d_off = dp64->d_off;
1031 #endif
1032 #ifndef __solaris__
1033  entry->d_type = dp64->d_type;
1034 #endif
1035  entry->d_reclen = dp64->d_reclen;
1036  strcpy(entry->d_name, dp64->d_name);
1037  *result = entry;
1038  return rc;
1039 }
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 906 of file XrdPosixXrootd.cc.

907 {
908  ssize_t bytes, totbytes = 0;
909  int i;
910 
911 // Return the results of the read for each iov segment
912 //
913  for (i = 0; i < iovcnt; i++)
914  {bytes = Read(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len);
915  if (bytes > 0) totbytes += bytes;
916  else if (bytes < 0) return -1;
917  else break;
918  }
919 
920 // All done
921 //
922  return totbytes;
923 }
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 1066 of file XrdPosixXrootd.cc.

1067 {
1068  XrdPosixAdmin admin(oldpath,XrdPosixGlobals::ecMsg);
1069  XrdCl::URL newUrl((std::string)newpath);
1070 
1071 // Make sure the admin is OK and the new url is valid
1072 //
1073  if (!admin.isOK() || !newUrl.IsValid())
1074  return XrdPosixGlobals::ecMsg.SetErrno(EINVAL);
1075 
1076 // Issue rename to he cache (it really should just deep-six both files)
1077 //
1079  {LfnPath oldF("rename", oldpath);
1080  LfnPath newF("rename", newpath);
1081  if (!oldF.path || !newF.path) return -1;
1082  XrdPosixGlobals::theCache->Rename(oldF.path, newF.path);
1083  }
1084 
1085 // Issue the rename
1086 //
1088  return EcRename(oldpath, newpath, admin);
1089 
1090  return XrdPosixMap::Result(admin.Xrd.Mv(admin.Url.GetPathWithParams(),
1091  newUrl.GetPathWithParams()),
1092  XrdPosixGlobals::ecMsg, true);
1093 }
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 1099 of file XrdPosixXrootd.cc.

1100 {
1101  XrdPosixDir *dP;
1102  int fildes = XrdPosixDir::dirNo(dirp);
1103 
1104 // Find the object and rewind it
1105 //
1106  if ((dP = XrdPosixObject::Dir(fildes)))
1107  {dP->rewind();
1108  dP->UnLock();
1109  }
1110 }
void rewind()
Definition: XrdPosixDir.hh:72

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 1116 of file XrdPosixXrootd.cc.

1117 {
1119 
1120 // Make sure the admin is OK
1121 //
1122  if (!admin.isOK()) return -1;
1123 
1124 // Remove directory from the cache first
1125 //
1127  {LfnPath rmd("rmdir", path);
1128  if (!rmd.path) return -1;
1129  XrdPosixGlobals::theCache->Rmdir(rmd.path);
1130  }
1131 
1132 // Issue the rmdir
1133 //
1134  return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1135  XrdPosixGlobals::ecMsg, true);
1136 }
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 1142 of file XrdPosixXrootd.cc.

1143 {
1144  XrdPosixDir *dP;
1145  int fildes = XrdPosixDir::dirNo(dirp);
1146 
1147 // Find the object
1148 //
1149  if (!(dP = XrdPosixObject::Dir(fildes))) return;
1150 
1151 // Sets the current directory position
1152 //
1153  if (dP->Unread() && !(dP->Open()))
1154  {if (loc >= dP->getEntries()) loc = dP->getEntries();
1155  else if (loc < 0) loc = 0;
1156  dP->setOffset(loc);
1157  }
1158  dP->UnLock();
1159 }
bool Unread()
Definition: XrdPosixDir.hh:78
void setOffset(long offset)
Definition: XrdPosixDir.hh:66
long getEntries()
Definition: XrdPosixDir.hh:62

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 1165 of file XrdPosixXrootd.cc.

1166 {
1168 
1169 // Make sure the admin is OK
1170 //
1171  if (!admin.isOK()) return -1;
1172 
1173 // Initialize the stat buffer
1174 //
1176 
1177 // Check if we can get the stat informatation from the cache
1178 //
1180  {LfnPath statX("stat", path, false);
1181  if (!statX.path) return -1;
1182  int rc = XrdPosixGlobals::theCache->Stat(statX.path, *buf);
1183  if (!rc) return 0;
1184  if (rc < 0) {errno = -rc; return -1;} // does the cache set this???
1185  }
1186 
1187 // Issue the stat and verify that all went well
1188 //
1190  return EcStat(path, buf, admin);
1191 
1192  if (!admin.Stat(*buf)) return -1;
1193  return 0;
1194 }
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 1200 of file XrdPosixXrootd.cc.

1201 {
1202  struct statvfs myVfs;
1203  int rc;
1204 
1205 // Issue a statvfs() call and transcribe the results
1206 //
1207  if ((rc = Statvfs(path, &myVfs))) return rc;
1208 
1209 // The vfs structure and fs structures should be size compatible (not really)
1210 //
1211  memset(buf, 0, sizeof(struct statfs));
1212  buf->f_bsize = myVfs.f_bsize;
1213  buf->f_blocks = myVfs.f_blocks;
1214  buf->f_bfree = myVfs.f_bfree;
1215  buf->f_files = myVfs.f_files;
1216  buf->f_ffree = myVfs.f_ffree;
1217 #if defined(__APPLE__) || defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1218  buf->f_iosize = myVfs.f_frsize;
1219 #else
1220  buf->f_frsize = myVfs.f_frsize;
1221 #endif
1222 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1223  buf->f_bavail = myVfs.f_bavail;
1224 #endif
1225 #if defined(__linux__) || defined(__GNU__)
1226  buf->f_namelen = myVfs.f_namemax;
1227 #elif defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1228  buf->f_namemax = myVfs.f_namemax;
1229 #endif
1230  return 0;
1231 }
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:

◆ Statvfs()

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

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

Definition at line 1237 of file XrdPosixXrootd.cc.

1238 {
1239  static const int szVFS = sizeof(buf->f_bfree);
1240  static const long long max32 = 0x7fffffffLL;
1241 
1243  XrdCl::StatInfoVFS *vfsStat;
1244 
1245  long long rwFree, ssFree, rwBlks;
1246  int rwNum, ssNum, rwUtil, ssUtil;
1247 
1248 // Make sure we connected
1249 //
1250  if (!admin.isOK()) return -1;
1251 
1252 // Issue the statfvs call
1253 //
1254  if (XrdPosixMap::Result(admin.Xrd.StatVFS(admin.Url.GetPathWithParams(),
1255  vfsStat),
1256  XrdPosixGlobals::ecMsg) < 0) return -1;
1257 
1258 // Extract out the information
1259 //
1260  rwNum = static_cast<int>(vfsStat->GetNodesRW());
1261  rwFree = (long long)vfsStat->GetFreeRW();
1262  rwUtil = static_cast<int>(vfsStat->GetUtilizationRW());
1263  ssNum = static_cast<int>(vfsStat->GetNodesStaging());
1264  ssFree = (long long)vfsStat->GetFreeStaging();
1265  ssUtil = static_cast<int>(vfsStat->GetUtilizationStaging());
1266  delete vfsStat;
1267 
1268 // Calculate number of blocks
1269 //
1270  if (rwUtil == 0) rwBlks = rwFree;
1271  else if (rwUtil >= 100) rwBlks = 0;
1272  else rwBlks = rwFree * (100 / (100 - rwUtil));
1273  if (ssUtil == 0) rwBlks += ssFree;
1274  else if (ssUtil < 100) rwBlks += ssFree * (100 / (100 - ssUtil));
1275 
1276 // Scale units to what will fit here (we can have a 32-bit or 64-bit struct)
1277 //
1278  if (szVFS < 8)
1279  {if (rwBlks > max32) rwBlks = max32;
1280  if (rwFree > max32) rwFree = max32;
1281  if (ssFree > max32) ssFree = max32;
1282  }
1283 
1284 // Return what little we can
1285 //
1286  memset(buf, 0, sizeof(struct statvfs));
1287  buf->f_bsize = 1024*1024;
1288  buf->f_frsize = 1024*1024;
1289  buf->f_blocks = static_cast<fsblkcnt_t>(rwBlks);
1290  buf->f_bfree = static_cast<fsblkcnt_t>(rwFree + ssFree);
1291  buf->f_bavail = static_cast<fsblkcnt_t>(rwFree);
1292  buf->f_ffree = rwNum + ssNum;
1293  buf->f_favail = rwNum;
1294  buf->f_namemax = 255; // The best we are going to do here
1295  buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1296  return 0;
1297 }
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 1303 of file XrdPosixXrootd.cc.

1304 {
1305  XrdPosixDir *dP;
1306  long pos;
1307  int fildes = XrdPosixDir::dirNo(dirp);
1308 
1309 // Find the object
1310 //
1311  if (!(dP = XrdPosixObject::Dir(fildes)))
1312  return XrdPosixGlobals::ecMsg.SetErrno(EBADF,0);
1313 
1314 // Tell the current directory location
1315 //
1316  pos = dP->getOffset();
1317  dP->UnLock();
1318  return pos;
1319 }
long getOffset()
Definition: XrdPosixDir.hh:64

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 1325 of file XrdPosixXrootd.cc.

1326 {
1328  uint64_t tSize = static_cast<uint64_t>(Size);
1329 
1330 // Make sure the admin is OK
1331 //
1332  if (!admin.isOK()) return -1;
1333 
1334 // Truncate in the cache first
1335 //
1337  {LfnPath trunc("truncate", path);
1338  if (!trunc.path) return -1;
1339  XrdPosixGlobals::theCache->Truncate(trunc.path, tSize);
1340  }
1341 
1342 // Issue the truncate to the origin
1343 //
1344  std::string urlp = admin.Url.GetPathWithParams();
1345  return XrdPosixMap::Result(admin.Xrd.Truncate(urlp,tSize),
1346  XrdPosixGlobals::ecMsg,true);
1347 }
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 1353 of file XrdPosixXrootd.cc.

1354 {
1356 
1357 // Make sure the admin is OK
1358 //
1359  if (!admin.isOK()) return -1;
1360 
1361 // Unlink the cache first
1362 //
1364  {LfnPath remf("unlink", path);
1365  if (!remf.path) return -1;
1366  XrdPosixGlobals::theCache->Unlink(remf.path);
1367  }
1368 
1369 // Issue the UnLink
1370 //
1372  return EcUnlink(path, admin);
1373 
1374  return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1375  XrdPosixGlobals::ecMsg, true);
1376 }
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 929 of file XrdPosixXrootd.cc.

930 {
931  XrdPosixFile *fp;
932  ssize_t bytes;
933 
934 // Find the file object
935 //
936  if (!(fp = XrdPosixObject::File(fildes))) return -1;
937 
938 // Issue the read
939 //
940  if ((bytes = fp->XCio->ReadV(readV, n)) < 0) return Fault(fp,-bytes);
941 
942 // Return bytes read
943 //
944  fp->UnLock();
945  return bytes;
946 }
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 950 of file XrdPosixXrootd.cc.

952 {
953  XrdPosixFile *fp;
954 
955 // Find the file object and issue read
956 //
957  if ((fp = XrdPosixObject::File(fildes)))
958  {cbp->theFile = fp;
959  fp->Ref(); fp->UnLock();
960  fp->XCio->ReadV(*cbp, readV, n);
961  } else cbp->Complete(-1);
962 }

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 1382 of file XrdPosixXrootd.cc.

1383 {
1384  XrdPosixFile *fp;
1385  int iosz, bytes;
1386 
1387 // Find the file object
1388 //
1389  if (!(fp = XrdPosixObject::File(fildes))) return -1;
1390 
1391 // Make sure the size is not too large
1392 //
1393  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
1394  else iosz = static_cast<int>(nbyte);
1395 
1396 // Issue the write
1397 //
1398  bytes = fp->XCio->Write((char *)buf,fp->Offset(),(int)iosz);
1399  if (bytes < 0) return Fault(fp,-bytes);
1400 
1401 // All went well
1402 //
1403  fp->addOffset(iosz, 1);
1404  fp->UnLock();
1405  return (ssize_t)iosz;
1406 }

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 1412 of file XrdPosixXrootd.cc.

1413 {
1414  ssize_t totbytes = 0;
1415  int i;
1416 
1417 // Return the results of the write for each iov segment
1418 //
1419  for (i = 0; i < iovcnt; i++)
1420  {if (!Write(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len))
1421  return -1;
1422  totbytes += iov[i].iov_len;
1423  }
1424 
1425 // All done
1426 //
1427  return totbytes;
1428 }
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: