XRootD
Loading...
Searching...
No Matches
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()
 
static int Close (int fildes)
 Close() conforms to POSIX.1-2001 close()
 
static int Closedir (DIR *dirp)
 Closedir() conforms to POSIX.1-2001 closedir()
 
static int endPoint (int FD, char *Buff, int Blen)
 
static int Fstat (int fildes, struct stat *buf)
 Fstat() conforms to POSIX.1-2001 fstat()
 
static int Fsync (int fildes)
 Fsync() conforms to POSIX.1-2001 fsync()
 
static void Fsync (int fildes, XrdPosixCallBackIO *cbp)
 
static int Ftruncate (int fildes, off_t offset)
 Ftruncate() conforms to POSIX.1-2001 ftruncate()
 
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()
 
static int Mkdir (const char *path, mode_t mode)
 Mkdir() conforms to POSIX.1-2001 mkdir()
 
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()
 
static ssize_t Pread (int fildes, void *buf, size_t nbyte, off_t offset)
 Pread() conforms to POSIX.1-2001 pread()
 
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()
 
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()
 
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()
 
static int Rename (const char *oldpath, const char *newpath)
 Rename() conforms to POSIX.1-2001 rename()
 
static void Rewinddir (DIR *dirp)
 Rewinddir() conforms to POSIX.1-2001 rewinddir()
 
static int Rmdir (const char *path)
 Rmdir() conforms to POSIX.1-2001 rmdir()
 
static void Seekdir (DIR *dirp, long loc)
 Seekdir() conforms to POSIX.1-2001 seekdir()
 
static int Stat (const char *path, struct stat *buf)
 Stat() conforms to POSIX.1-2001 stat()
 
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()
 
static long Telldir (DIR *dirp)
 Telldir() conforms to POSIX.1-2001 telldir()
 
static int Truncate (const char *path, off_t offset)
 Telldir() conforms to POSIX.1-2001 telldir()
 
static int Unlink (const char *path)
 Unlink() conforms to POSIX.1-2001 unlink()
 
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()
 
static ssize_t Writev (int fildes, const struct iovec *iov, int iovcnt)
 Writev() conforms to POSIX.1-2001 writev()
 

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)
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//
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)
#define EPNAME(x)
#define DEBUGON
virtual bool Detach(XrdOucCacheIOCD &iocd)=0
XrdOucCacheIO * XCio
static void * DelayedDestroy(void *)
static XrdPosixFile * ReleaseFile(int fildes)
std::string ToString() const
Create a string representation.

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)
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
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)
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(), 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{
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
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)
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 int Result(const XrdCl::XRootDStatus &Status, XrdOucECMsg &ecMsg, bool retneg1=false)
static XrdCl::Access::Mode Mode2Access(mode_t mode)
@ 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)

References Open().

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

+ Here is the call graph for this function:
+ 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()
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(), 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(), 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)
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)

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{
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()),
1093}
virtual int Rename(const char *oldp, const char *newp)
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()

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;
1130 }
1131
1132// Issue the rmdir
1133//
1134 return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1136}
virtual int Rmdir(const char *dirp)

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()
void setOffset(long offset)
long getEntries()

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)

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}
#define statvfs(a, b)
Definition XrdPosix.hh:100
#define statfs(a, b)
Definition XrdPosix.hh:98
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()

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),
1347}
virtual int Truncate(const char *path, off_t size)

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;
1367 }
1368
1369// Issue the UnLink
1370//
1372 return EcUnlink(path, admin);
1373
1374 return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1376}
virtual int Unlink(const char *path)

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)

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 Symbol 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: