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:183
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(), XrdOucCacheIO::Fstat(), XrdPosixFile::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 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)
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 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)

References Open().

Referenced by main(), Open(), XrdPssFile::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 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()
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(), 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(), 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)
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)

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{
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()),
1078}
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 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()

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;
1115 }
1116
1117// Issue the rmdir
1118//
1119 return XrdPosixMap::Result(admin.Xrd.RmDir(admin.Url.GetPathWithParams()),
1121}
virtual int Rmdir(const char *dirp)

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), XrdCl::FileSystem::RmDir(), XrdOucCache::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()
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 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)

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}
#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 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(), XrdCl::FileSystem::StatVFS(), 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()

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

References XrdPosixGlobals::ecMsg, XrdCl::URL::GetPathWithParams(), XrdPosixAdmin::isOK(), XrdPosixMap::Result(), XrdPosixGlobals::theCache, XrdCl::FileSystem::Truncate(), XrdOucCache::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;
1352 }
1353
1354// Issue the UnLink
1355//
1357 return EcUnlink(path, admin);
1358
1359 return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1361}
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 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)

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