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 StatRet (DIR *dirp, struct stat *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 180 of file XrdPosixXrootd.cc.

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

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

+ Here is the call graph for this function:

◆ ~XrdPosixXrootd()

XrdPosixXrootd::~XrdPosixXrootd ( )

Definition at line 229 of file XrdPosixXrootd.cc.

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

References XrdPosixObject::Shutdown().

+ Here is the call graph for this function:

Member Function Documentation

◆ Access()

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

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

Definition at line 242 of file XrdPosixXrootd.cc.

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

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

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

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

◆ Closedir()

int XrdPosixXrootd::Closedir ( DIR * dirp)
static

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

Definition at line 311 of file XrdPosixXrootd.cc.

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

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

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

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

◆ endPoint()

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

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

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

Definition at line 331 of file XrdPosixXrootd.cc.

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

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

+ Here is the call graph for this function:

◆ fdOrigin()

int XrdPosixXrootd::fdOrigin ( )
inline

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

Definition at line 371 of file XrdPosixXrootd.hh.

371{return baseFD;}

Referenced by xrootdfs_init().

+ Here is the caller graph for this function:

◆ Fstat()

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

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

Definition at line 369 of file XrdPosixXrootd.cc.

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

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

◆ Fsync() [1/2]

int XrdPosixXrootd::Fsync ( int fildes)
static

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

Definition at line 405 of file XrdPosixXrootd.cc.

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

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

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

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

◆ Fsync() [2/2]

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

Definition at line 423 of file XrdPosixXrootd.cc.

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

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

+ Here is the call graph for this function:

◆ Ftruncate()

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

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

Definition at line 440 of file XrdPosixXrootd.cc.

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

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

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

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

◆ Getxattr()

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

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

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

is set to indicate the reason.

Definition at line 464 of file XrdPosixXrootd.cc.

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

1463{
1464 XrdPosixDir *dP;
1465 int fildes;
1466
1467 if (!dirp) return false;
1468 fildes = XrdPosixDir::dirNo(dirp);
1469
1470 if (!myFD(fildes) || !(dP = XrdPosixObject::Dir(fildes))) return false;
1471
1472 dP->UnLock();
1473 return true;
1474}
static XrdPosixDir * Dir(int fildes, bool glk=false)
static bool myFD(int fd)

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

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

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

◆ Lseek()

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

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

Definition at line 497 of file XrdPosixXrootd.cc.

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

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

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

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

◆ Mkdir()

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

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

Definition at line 528 of file XrdPosixXrootd.cc.

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

1481{
1482 return XrdPosixObject::Valid(fd);
1483}
static bool Valid(int fd)

References XrdPosixObject::Valid().

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

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

◆ Open()

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

Definition at line 555 of file XrdPosixXrootd.cc.

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

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

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

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

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

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

◆ Pread() [1/2]

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

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

Definition at line 742 of file XrdPosixXrootd.cc.

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

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

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

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

◆ Pread() [2/2]

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

Definition at line 773 of file XrdPosixXrootd.cc.

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

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

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

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

1491{
1493
1494// Stat the file first to allow vectoring of the request to the right server
1495//
1496 if (!admin.Stat(0, &Mtime)) return -1;
1497
1498// Now we can get the checksum as we have landed on the right server
1499//
1500 return admin.Query(XrdCl::QueryCode::Checksum, value, vsize);
1501}

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

1527{
1528 XrdPosixDir *dP;
1529 int fildes = XrdPosixDir::dirNo(dirP);
1530
1531// Find the object
1532//
1533 if (!(dP = XrdPosixObject::Dir(fildes)))
1534 return XrdPosixGlobals::ecMsg.SetErrno(EBADF);
1535
1536// Return result
1537//
1538 return dP->getECMsg()->Get(emsg, reset);
1539}
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 1507 of file XrdPosixXrootd.cc.

1508{
1509 XrdOucECMsg* ecmP;
1510
1511// If global wanted then use that one otherwise find the object specific one
1512//
1513 if (fd < 0) ecmP = &XrdPosixGlobals::ecMsg;
1514 else {XrdPosixFile *fp;
1515 if (!(fp = XrdPosixObject::File(fd))) return -1;
1516 ecmP = fp->getECMsg();
1517 }
1518
1519// Return the message information
1520//
1521 return ecmP->Get(emsg, reset);
1522}

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

1546{
1548
1549// Stat the file first to allow vectoring of the request to the right server
1550//
1551 if (!admin.Stat()) return -1;
1552
1553// Now we can get the checksum as we have landed on the right server
1554//
1555 return admin.Query(XrdCl::QueryCode::OpaqueFile, value, size);
1556}
@ 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 876 of file XrdPosixXrootd.cc.

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

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

992{
993 XrdPosixDir *dP;
994 dirent64 *dentP;
995 int rc, fildes = XrdPosixDir::dirNo(dirp);
996
997// Find the object
998//
999 if (!(dP = XrdPosixObject::Dir(fildes)))
1001 return (dirent64*)0;
1002 }
1003
1004// Get the next directory entry
1005//
1006 if (!(dentP = dP->nextEntry())) rc = dP->Status();
1007 else rc = 0;
1008
1009// Return the appropriate result
1010//
1011 dP->UnLock();
1012 if (rc) errno = rc;
1013 return dentP;
1014}
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 1042 of file XrdPosixXrootd.cc.

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

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

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

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

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

1101{
1102 XrdPosixDir *dP;
1103 int fildes = XrdPosixDir::dirNo(dirp);
1104
1105// Find the object and rewind it
1106//
1107 if ((dP = XrdPosixObject::Dir(fildes)))
1108 {dP->rewind();
1109 dP->UnLock();
1110 }
1111}
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 1117 of file XrdPosixXrootd.cc.

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

1144{
1145 XrdPosixDir *dP;
1146 int fildes = XrdPosixDir::dirNo(dirp);
1147
1148// Find the object
1149//
1150 if (!(dP = XrdPosixObject::Dir(fildes))) return;
1151
1152// Sets the current directory position
1153//
1154 if (dP->Unread() && !(dP->Open()))
1155 {if (loc >= dP->getEntries()) loc = dP->getEntries();
1156 else if (loc < 0) loc = 0;
1157 dP->setOffset(loc);
1158 }
1159 dP->UnLock();
1160}
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 1166 of file XrdPosixXrootd.cc.

1167{
1169 bool cacheChk = false;
1170
1171// Make sure the admin is OK
1172//
1173 if (!admin.isOK()) return -1;
1174
1175// Initialize the stat buffer
1176//
1178
1179// Check if we can get the stat informatation from the cache
1180//
1182 {LfnPath statX("stat", path, false);
1183 if (!statX.path) return -1;
1184 int rc = XrdPosixGlobals::theCache->Stat(statX.path, *buf);
1185 if (!rc) return 0;
1186 if (rc < 0) {errno = -rc; return -1;} // does the cache set this???
1187 cacheChk = true;
1188 }
1189
1190// Issue the stat and verify that all went well
1191//
1193 return EcStat(path, buf, admin);
1194
1195 if (!admin.Stat(*buf)) return -1;
1196
1197// If we are here and the cache was checked then the file was not in the cache.
1198// We informally tell the caller this is the case by setting atime to zero.
1199// Normally, atime will never be zero in any other case.
1200//
1201 if (cacheChk) buf->st_atime = 0;
1202 return 0;
1203}
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 1209 of file XrdPosixXrootd.cc.

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

References statfs, Statvfs(), and statvfs.

Referenced by XrdPosix_Statfs().

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

◆ StatRet()

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

Definition at line 1246 of file XrdPosixXrootd.cc.

1247{
1248// Find the object
1249//
1250 auto fildes = XrdPosixDir::dirNo(dirp);
1251 auto dP = XrdPosixObject::Dir(fildes);
1252 if (!dP) return EBADF;
1253
1254// Get the stat info
1255 auto rc = dP->StatRet(buf);
1256
1257 dP->UnLock();
1258 return rc;
1259}

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

Referenced by XrdPssDir::StatRet().

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

◆ Statvfs()

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

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

Definition at line 1265 of file XrdPosixXrootd.cc.

1266{
1267 static const int szVFS = sizeof(buf->f_bfree);
1268 static const long long max32 = 0x7fffffffLL;
1269
1271 XrdCl::StatInfoVFS *vfsStat;
1272
1273 long long rwFree, ssFree, rwBlks;
1274 int rwNum, ssNum, rwUtil, ssUtil;
1275
1276// Make sure we connected
1277//
1278 if (!admin.isOK()) return -1;
1279
1280// Issue the statfvs call
1281//
1282 if (XrdPosixMap::Result(admin.Xrd.StatVFS(admin.Url.GetPathWithParams(),
1283 vfsStat),
1284 XrdPosixGlobals::ecMsg) < 0) return -1;
1285
1286// Extract out the information
1287//
1288 rwNum = static_cast<int>(vfsStat->GetNodesRW());
1289 rwFree = (long long)vfsStat->GetFreeRW();
1290 rwUtil = static_cast<int>(vfsStat->GetUtilizationRW());
1291 ssNum = static_cast<int>(vfsStat->GetNodesStaging());
1292 ssFree = (long long)vfsStat->GetFreeStaging();
1293 ssUtil = static_cast<int>(vfsStat->GetUtilizationStaging());
1294 delete vfsStat;
1295
1296// Calculate number of blocks
1297//
1298 if (rwUtil == 0) rwBlks = rwFree;
1299 else if (rwUtil >= 100) rwBlks = 0;
1300 else rwBlks = rwFree * (100 / (100 - rwUtil));
1301 if (ssUtil == 0) rwBlks += ssFree;
1302 else if (ssUtil < 100) rwBlks += ssFree * (100 / (100 - ssUtil));
1303
1304// Scale units to what will fit here (we can have a 32-bit or 64-bit struct)
1305//
1306 if (szVFS < 8)
1307 {if (rwBlks > max32) rwBlks = max32;
1308 if (rwFree > max32) rwFree = max32;
1309 if (ssFree > max32) ssFree = max32;
1310 }
1311
1312// Return what little we can
1313//
1314 memset(buf, 0, sizeof(struct statvfs));
1315 buf->f_bsize = 1024*1024;
1316 buf->f_frsize = 1024*1024;
1317 buf->f_blocks = static_cast<fsblkcnt_t>(rwBlks);
1318 buf->f_bfree = static_cast<fsblkcnt_t>(rwFree + ssFree);
1319 buf->f_bavail = static_cast<fsblkcnt_t>(rwFree);
1320 buf->f_ffree = rwNum + ssNum;
1321 buf->f_favail = rwNum;
1322 buf->f_namemax = 255; // The best we are going to do here
1323 buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1324 return 0;
1325}
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 1331 of file XrdPosixXrootd.cc.

1332{
1333 XrdPosixDir *dP;
1334 long pos;
1335 int fildes = XrdPosixDir::dirNo(dirp);
1336
1337// Find the object
1338//
1339 if (!(dP = XrdPosixObject::Dir(fildes)))
1340 return XrdPosixGlobals::ecMsg.SetErrno(EBADF,0);
1341
1342// Tell the current directory location
1343//
1344 pos = dP->getOffset();
1345 dP->UnLock();
1346 return pos;
1347}
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 1353 of file XrdPosixXrootd.cc.

1354{
1356 uint64_t tSize = static_cast<uint64_t>(Size);
1357
1358// Make sure the admin is OK
1359//
1360 if (!admin.isOK()) return -1;
1361
1362// Truncate in the cache first
1363//
1365 {LfnPath trunc("truncate", path);
1366 if (!trunc.path) return -1;
1367 XrdPosixGlobals::theCache->Truncate(trunc.path, tSize);
1368 }
1369
1370// Issue the truncate to the origin
1371//
1372 std::string urlp = admin.Url.GetPathWithParams();
1373 return XrdPosixMap::Result(admin.Xrd.Truncate(urlp,tSize),
1375}
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 1381 of file XrdPosixXrootd.cc.

1382{
1384
1385// Make sure the admin is OK
1386//
1387 if (!admin.isOK()) return -1;
1388
1389// Unlink the cache first
1390//
1392 {LfnPath remf("unlink", path);
1393 if (!remf.path) return -1;
1395 }
1396
1397// Issue the UnLink
1398//
1400 return EcUnlink(path, admin);
1401
1402 return XrdPosixMap::Result(admin.Xrd.Rm(admin.Url.GetPathWithParams()),
1404}
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 930 of file XrdPosixXrootd.cc.

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

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

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

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

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

1441{
1442 ssize_t totbytes = 0;
1443 int i;
1444
1445// Return the results of the write for each iov segment
1446//
1447 for (i = 0; i < iovcnt; i++)
1448 {if (!Write(fildes,(void *)iov[i].iov_base,(size_t)iov[i].iov_len))
1449 return -1;
1450 totbytes += iov[i].iov_len;
1451 }
1452
1453// All done
1454//
1455 return totbytes;
1456}
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: