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:183
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:1339
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 1419 of file XrdPosixXrootd.cc.

1420 {
1421  XrdPosixDir *dP;
1422  int fildes;
1423 
1424  if (!dirp) return false;
1425  fildes = XrdPosixDir::dirNo(dirp);
1426 
1427  if (!myFD(fildes) || !(dP = XrdPosixObject::Dir(fildes))) return false;
1428 
1429  dP->UnLock();
1430  return true;
1431 }
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 1437 of file XrdPosixXrootd.cc.

1438 {
1439  return XrdPosixObject::Valid(fd);
1440 }
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 689 of file XrdPosixXrootd.cc.

690 {
691  XrdPosixDir *dP;
692  DIR *dirP;
693  int rc;
694 
695 // Get a new directory object
696 //
697  if (!(dP = new XrdPosixDir(path)))
699  return (DIR*)0;
700  }
701 
702 // Assign a file descriptor to this file
703 //
704  if (!(dP->AssignFD()))
705  {delete dP;
707  return (DIR*)0;
708  }
709 
710 // Open the directory
711 //
712  if ((dirP = dP->Open())) return dirP;
713 
714 // We failed
715 //
716  rc = errno;
717  delete dP;
718  errno = rc; // Restore saved errno
719  return (DIR *)0;
720 }
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 726 of file XrdPosixXrootd.cc.

727 {
728  XrdPosixFile *fp;
729  long long offs, bytes;
730  int iosz;
731 
732 // Find the file object
733 //
734  if (!(fp = XrdPosixObject::File(fildes)))
735  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
736 
737 // Make sure the size is not too large
738 //
739  if (nbyte > (size_t)0x7fffffff)
740  return Fault(fp, EOVERFLOW, "read size too large");
741  else iosz = static_cast<int>(nbyte);
742 
743 // Issue the read
744 //
745  offs = static_cast<long long>(offset);
746  bytes = fp->XCio->Read((char *)buf, offs, (int)iosz);
747  if (bytes < 0) return Fault(fp,-bytes,"*");
748 
749 // All went well
750 //
751  fp->UnLock();
752  return (ssize_t)bytes;
753 }
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 757 of file XrdPosixXrootd.cc.

759 {
760  XrdPosixFile *fp;
761  long long offs;
762  int iosz;
763 
764 // Find the file object
765 //
766  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
767 
768 // Make sure the size is not too large
769 //
770  if (nbyte > (size_t)0x7fffffff)
771  {fp->UnLock();
772  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
773  cbp->Complete(-1);
774  return;
775  }
776 
777 // Prepare for the read
778 //
779  cbp->theFile = fp;
780  fp->Ref(); fp->UnLock();
781  iosz = static_cast<int>(nbyte);
782  offs = static_cast<long long>(offset);
783 
784 // Issue the read
785 //
786  fp->XCio->Read(*cbp, (char *)buf, offs, (int)iosz);
787 }
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 793 of file XrdPosixXrootd.cc.

794 {
795  XrdPosixFile *fp;
796  long long offs;
797  int iosz, bytes;
798 
799 // Find the file object
800 //
801  if (!(fp = XrdPosixObject::File(fildes))) return -1;
802 
803 // Make sure the size is not too large
804 //
805  if (nbyte > (size_t)0x7fffffff)
806  return Fault(fp,EOVERFLOW,"write size too large");
807  else iosz = static_cast<int>(nbyte);
808 
809 // Issue the write
810 //
811  offs = static_cast<long long>(offset);
812  bytes = fp->XCio->Write((char *)buf, offs, (int)iosz);
813  if (bytes < 0) return Fault(fp,-bytes,"*");
814 
815 // All went well
816 //
817  fp->UpdtSize(offs + iosz);
818  fp->UnLock();
819  return (ssize_t)iosz;
820 }
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 824 of file XrdPosixXrootd.cc.

826 {
827  XrdPosixFile *fp;
828  long long offs;
829  int iosz;
830 
831 // Find the file object
832 //
833  if (!(fp = XrdPosixObject::File(fildes))) {cbp->Complete(-1); return;}
834 
835 // Make sure the size is not too large
836 //
837  if (nbyte > (size_t)0x7fffffff)
838  {fp->UnLock();
839  fp->ecMsg.SetErrno(EOVERFLOW,0,"read size too large");
840  cbp->Complete(-1);
841  return;
842  }
843 
844 // Prepare for the writing
845 //
846  cbp->theFile = fp;
847  fp->Ref(); fp->UnLock();
848  iosz = static_cast<int>(nbyte);
849  offs = static_cast<long long>(offset);
850 
851 // Issue the read
852 //
853  fp->XCio->Write(*cbp, (char *)buf, offs, (int)iosz);
854 }

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

1448 {
1450 
1451 // Stat the file first to allow vectoring of the request to the right server
1452 //
1453  if (!admin.Stat(0, &Mtime)) return -1;
1454 
1455 // Now we can get the checksum as we have landed on the right server
1456 //
1457  return admin.Query(XrdCl::QueryCode::Checksum, value, vsize);
1458 }

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

1484 {
1485  XrdPosixDir *dP;
1486  int fildes = XrdPosixDir::dirNo(dirP);
1487 
1488 // Find the object
1489 //
1490  if (!(dP = XrdPosixObject::Dir(fildes)))
1491  return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
1492 
1493 // Return result
1494 //
1495  return dP->getECMsg()->Get(emsg, reset);
1496 }
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 1464 of file XrdPosixXrootd.cc.

1465 {
1466  XrdOucECMsg* ecmP;
1467 
1468 // If global wanted then use that one otherwise find the object specific one
1469 //
1470  if (fd < 0) ecmP = &XrdPosixGlobals::ecMsg;
1471  else {XrdPosixFile *fp;
1472  if (!(fp = XrdPosixObject::File(fd))) return -1;
1473  ecmP = fp->getECMsg();
1474  }
1475 
1476 // Return the message information
1477 //
1478  return ecmP->Get(emsg, reset);
1479 }

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

1503 {
1505 
1506 // Stat the file first to allow vectoring of the request to the right server
1507 //
1508  if (!admin.Stat()) return -1;
1509 
1510 // Now we can get the checksum as we have landed on the right server
1511 //
1512  return admin.Query(XrdCl::QueryCode::OpaqueFile, value, size);
1513 }
@ 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 860 of file XrdPosixXrootd.cc.

861 {
862  XrdPosixFile *fp;
863  long long bytes;
864  int iosz;
865 
866 // Find the file object
867 //
868  if (!(fp = XrdPosixObject::File(fildes))) return -1;
869 
870 // Make sure the size is not too large
871 //
872  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
873  else iosz = static_cast<int>(nbyte);
874 
875 // Issue the read
876 //
877  bytes = fp->XCio->Read((char *)buf,fp->Offset(),(int)iosz);
878  if (bytes < 0) return Fault(fp,-bytes);
879 
880 // All went well
881 //
882  fp->addOffset(bytes);
883  fp->UnLock();
884  return (ssize_t)bytes;
885 }
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 953 of file XrdPosixXrootd.cc.

954 {
955  dirent64 *dp64;
956  dirent *dp32; // Could be the same as dp64
957 
958  if (!(dp64 = Readdir64(dirp))) return 0;
959 
960  dp32 = (struct dirent *)dp64;
961  if ((char*)dp32->d_name != (char*)dp64->d_name)
962  {dp32->d_ino = dp64->d_ino;
963 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
964  dp32->d_off = dp64->d_off;
965 #endif
966 #ifndef __solaris__
967  dp32->d_type = dp64->d_type;
968 #endif
969  dp32->d_reclen = dp64->d_reclen;
970  strcpy(dp32->d_name, dp64->d_name);
971  }
972  return dp32;
973 }
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 975 of file XrdPosixXrootd.cc.

976 {
977  XrdPosixDir *dP;
978  dirent64 *dentP;
979  int rc, fildes = XrdPosixDir::dirNo(dirp);
980 
981 // Find the object
982 //
983  if (!(dP = XrdPosixObject::Dir(fildes)))
985  return (dirent64*)0;
986  }
987 
988 // Get the next directory entry
989 //
990  if (!(dentP = dP->nextEntry())) rc = dP->Status();
991  else rc = 0;
992 
993 // Return the appropriate result
994 //
995  dP->UnLock();
996  if (rc) errno = rc;
997  return dentP;
998 }
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 1026 of file XrdPosixXrootd.cc.

1028 {
1029  XrdPosixDir *dP;
1030  int rc, fildes = XrdPosixDir::dirNo(dirp);
1031 
1032 // Find the object
1033 //
1034  if (!(dP = XrdPosixObject::Dir(fildes))) return EBADF;
1035 
1036 // Get the next entry
1037 //
1038  if (!(*result = dP->nextEntry(entry))) {rc = dP->Status(); *result = 0;}
1039  else {rc = 0; *result = entry;}
1040 
1041 // Return the appropriate result
1042 //
1043  dP->UnLock();
1044  return rc;
1045 }

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

1006 {
1007  dirent64 *dp64 = 0, d64ent;
1008  int rc;
1009 
1010  if ((rc = Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1011  {*result = 0; return rc;}
1012 
1013  entry->d_ino = dp64->d_ino;
1014 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__GNU__) && !(defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1015  entry->d_off = dp64->d_off;
1016 #endif
1017 #ifndef __solaris__
1018  entry->d_type = dp64->d_type;
1019 #endif
1020  entry->d_reclen = dp64->d_reclen;
1021  strcpy(entry->d_name, dp64->d_name);
1022  *result = entry;
1023  return rc;
1024 }
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 891 of file XrdPosixXrootd.cc.

892 {
893  ssize_t bytes, totbytes = 0;
894  int i;
895 
896 // Return the results of the read for each iov segment
897 //
898  for (i = 0; i < iovcnt; i++)
899  {bytes = Read(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len);
900  if (bytes > 0) totbytes += bytes;
901  else if (bytes < 0) return -1;
902  else break;
903  }
904 
905 // All done
906 //
907  return totbytes;
908 }
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 1051 of file XrdPosixXrootd.cc.

1052 {
1053  XrdPosixAdmin admin(oldpath,XrdPosixGlobals::ecMsg);
1054  XrdCl::URL newUrl((std::string)newpath);
1055 
1056 // Make sure the admin is OK and the new url is valid
1057 //
1058  if (!admin.isOK() || !newUrl.IsValid())
1059  return XrdPosixGlobals::ecMsg.SetErrno(EINVAL);
1060 
1061 // Issue rename to he cache (it really should just deep-six both files)
1062 //
1064  {LfnPath oldF("rename", oldpath);
1065  LfnPath newF("rename", newpath);
1066  if (!oldF.path || !newF.path) return -1;
1067  XrdPosixGlobals::theCache->Rename(oldF.path, newF.path);
1068  }
1069 
1070 // Issue the rename
1071 //
1073  return EcRename(oldpath, newpath, admin);
1074 
1075  return XrdPosixMap::Result(admin.Xrd.Mv(admin.Url.GetPathWithParams(),
1076  newUrl.GetPathWithParams()),
1077  XrdPosixGlobals::ecMsg, true);
1078 }
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 1084 of file XrdPosixXrootd.cc.

1085 {
1086  XrdPosixDir *dP;
1087  int fildes = XrdPosixDir::dirNo(dirp);
1088 
1089 // Find the object and rewind it
1090 //
1091  if ((dP = XrdPosixObject::Dir(fildes)))
1092  {dP->rewind();
1093  dP->UnLock();
1094  }
1095 }
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 1101 of file XrdPosixXrootd.cc.

1102 {
1104 
1105 // Make sure the admin is OK
1106 //
1107  if (!admin.isOK()) return -1;
1108 
1109 // Remove directory from the cache first
1110 //
1112  {LfnPath rmd("rmdir", path);
1113  if (!rmd.path) return -1;
1114  XrdPosixGlobals::theCache->Rmdir(rmd.path);
1115  }
1116 
1117 // Issue the rmdir
1118 //
1119  return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1120  XrdPosixGlobals::ecMsg, true);
1121 }
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 1127 of file XrdPosixXrootd.cc.

1128 {
1129  XrdPosixDir *dP;
1130  int fildes = XrdPosixDir::dirNo(dirp);
1131 
1132 // Find the object
1133 //
1134  if (!(dP = XrdPosixObject::Dir(fildes))) return;
1135 
1136 // Sets the current directory position
1137 //
1138  if (dP->Unread() && !(dP->Open()))
1139  {if (loc >= dP->getEntries()) loc = dP->getEntries();
1140  else if (loc < 0) loc = 0;
1141  dP->setOffset(loc);
1142  }
1143  dP->UnLock();
1144 }
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 1150 of file XrdPosixXrootd.cc.

1151 {
1153 
1154 // Make sure the admin is OK
1155 //
1156  if (!admin.isOK()) return -1;
1157 
1158 // Initialize the stat buffer
1159 //
1161 
1162 // Check if we can get the stat informatation from the cache
1163 //
1165  {LfnPath statX("stat", path, false);
1166  if (!statX.path) return -1;
1167  int rc = XrdPosixGlobals::theCache->Stat(statX.path, *buf);
1168  if (!rc) return 0;
1169  if (rc < 0) {errno = -rc; return -1;} // does the cache set this???
1170  }
1171 
1172 // Issue the stat and verify that all went well
1173 //
1175  return EcStat(path, buf, admin);
1176 
1177  if (!admin.Stat(*buf)) return -1;
1178  return 0;
1179 }
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 1185 of file XrdPosixXrootd.cc.

1186 {
1187  struct statvfs myVfs;
1188  int rc;
1189 
1190 // Issue a statvfs() call and transcribe the results
1191 //
1192  if ((rc = Statvfs(path, &myVfs))) return rc;
1193 
1194 // The vfs structure and fs structures should be size compatible (not really)
1195 //
1196  memset(buf, 0, sizeof(struct statfs));
1197  buf->f_bsize = myVfs.f_bsize;
1198  buf->f_blocks = myVfs.f_blocks;
1199  buf->f_bfree = myVfs.f_bfree;
1200  buf->f_files = myVfs.f_files;
1201  buf->f_ffree = myVfs.f_ffree;
1202 #if defined(__APPLE__) || defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1203  buf->f_iosize = myVfs.f_frsize;
1204 #else
1205  buf->f_frsize = myVfs.f_frsize;
1206 #endif
1207 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1208  buf->f_bavail = myVfs.f_bavail;
1209 #endif
1210 #if defined(__linux__) || defined(__GNU__)
1211  buf->f_namelen = myVfs.f_namemax;
1212 #elif defined(__FreeBSD__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1213  buf->f_namemax = myVfs.f_namemax;
1214 #endif
1215  return 0;
1216 }
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 1222 of file XrdPosixXrootd.cc.

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

1289 {
1290  XrdPosixDir *dP;
1291  long pos;
1292  int fildes = XrdPosixDir::dirNo(dirp);
1293 
1294 // Find the object
1295 //
1296  if (!(dP = XrdPosixObject::Dir(fildes)))
1297  return XrdPosixGlobals::ecMsg.SetErrno(EBADF,0);
1298 
1299 // Tell the current directory location
1300 //
1301  pos = dP->getOffset();
1302  dP->UnLock();
1303  return pos;
1304 }
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 1310 of file XrdPosixXrootd.cc.

1311 {
1313  uint64_t tSize = static_cast<uint64_t>(Size);
1314 
1315 // Make sure the admin is OK
1316 //
1317  if (!admin.isOK()) return -1;
1318 
1319 // Truncate in the cache first
1320 //
1322  {LfnPath trunc("truncate", path);
1323  if (!trunc.path) return -1;
1324  XrdPosixGlobals::theCache->Truncate(trunc.path, tSize);
1325  }
1326 
1327 // Issue the truncate to the origin
1328 //
1329  std::string urlp = admin.Url.GetPathWithParams();
1330  return XrdPosixMap::Result(admin.Xrd.Truncate(urlp,tSize),
1331  XrdPosixGlobals::ecMsg,true);
1332 }
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 1338 of file XrdPosixXrootd.cc.

1339 {
1341 
1342 // Make sure the admin is OK
1343 //
1344  if (!admin.isOK()) return -1;
1345 
1346 // Unlink the cache first
1347 //
1349  {LfnPath remf("unlink", path);
1350  if (!remf.path) return -1;
1351  XrdPosixGlobals::theCache->Unlink(remf.path);
1352  }
1353 
1354 // Issue the UnLink
1355 //
1357  return EcUnlink(path, admin);
1358 
1359  return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1360  XrdPosixGlobals::ecMsg, true);
1361 }
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 914 of file XrdPosixXrootd.cc.

915 {
916  XrdPosixFile *fp;
917  ssize_t bytes;
918 
919 // Find the file object
920 //
921  if (!(fp = XrdPosixObject::File(fildes))) return -1;
922 
923 // Issue the read
924 //
925  if ((bytes = fp->XCio->ReadV(readV, n)) < 0) return Fault(fp,-bytes);
926 
927 // Return bytes read
928 //
929  fp->UnLock();
930  return bytes;
931 }
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 935 of file XrdPosixXrootd.cc.

937 {
938  XrdPosixFile *fp;
939 
940 // Find the file object and issue read
941 //
942  if ((fp = XrdPosixObject::File(fildes)))
943  {cbp->theFile = fp;
944  fp->Ref(); fp->UnLock();
945  fp->XCio->ReadV(*cbp, readV, n);
946  } else cbp->Complete(-1);
947 }

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

1368 {
1369  XrdPosixFile *fp;
1370  int iosz, bytes;
1371 
1372 // Find the file object
1373 //
1374  if (!(fp = XrdPosixObject::File(fildes))) return -1;
1375 
1376 // Make sure the size is not too large
1377 //
1378  if (nbyte > (size_t)0x7fffffff) return Fault(fp,EOVERFLOW);
1379  else iosz = static_cast<int>(nbyte);
1380 
1381 // Issue the write
1382 //
1383  bytes = fp->XCio->Write((char *)buf,fp->Offset(),(int)iosz);
1384  if (bytes < 0) return Fault(fp,-bytes);
1385 
1386 // All went well
1387 //
1388  fp->addOffset(iosz, 1);
1389  fp->UnLock();
1390  return (ssize_t)iosz;
1391 }

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

1398 {
1399  ssize_t totbytes = 0;
1400  int i;
1401 
1402 // Return the results of the write for each iov segment
1403 //
1404  for (i = 0; i < iovcnt; i++)
1405  {if (!Write(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len))
1406  return -1;
1407  totbytes += iov[i].iov_len;
1408  }
1409 
1410 // All done
1411 //
1412  return totbytes;
1413 }
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: