37#include <sys/resource.h>
40#include "XrdVersion.hh"
103int XrdPosixXrootd::baseFD = 0;
104int XrdPosixXrootd::initDone = 0;
122 LfnPath(
const char *who,
const char *pURL,
bool ponly=
true)
125 ~LfnPath() {
if (relURL) free(relURL);}
165 if (!cbP)
return fp->
FDNum();
193 if (initDone) {myMutex.
UnLock();
return;}
204 if (*cfn ==
'+') {hush =
false; cfn++;}
205 else hush = (getenv(
"XRDPOSIX_DEBUG") == 0);
208 psxEnv->
Put(
"psx.Client",
"1");
209 XrdOucPsx psxConfig(&XrdVERSIONINFOVAR(XrdPosix), cfn, 0, psxEnv);
212 {std::cerr <<
"Posix: Unable to instantiate specified "
213 "configuration; program exiting!" <<std::endl;
249 if (!admin.
Stat(&stMode))
return -1;
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;
287 {
if ((ret = fP->
Close(Status))) {
delete fP; fP = 0;}
289 {std::string eTxt = Status.
ToString();
342 {fp->
UnLock();
return -ENOTCONN;}
346 std::string dataServer;
350 if (dataServer.size() >= (uint32_t)Blen)
351 {fp->
UnLock();
return -ENAMETOOLONG;}
355 strcpy(Buff, dataServer.c_str());
359 uPort = dataServerUrl.
GetPort();
394 rc = fp->
Fstat(*buf);
396 if (rc < 0) {errno = -rc; rc = -1;}
415 if ((rc = fp->
XCio->
Sync()) < 0)
return Fault(fp, -rc);
450 if ((rc = fp->
XCio->
Trunc(offset)) < 0)
return Fault(fp, -rc);
460#define ENOATTR ENOTSUP
464 void *value,
unsigned long long size)
468 int vsize =
static_cast<int>(size);
472 if (size == 0)
return 1024;
480 else {errno =
ENOATTR;
return -1;}
481 }
else {errno = EINVAL;
return -1;}
485 if (!admin.
Stat())
return -1;
489 return admin.
Query(reqCode, value, vsize);
499 long long curroffset;
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)
512 if (curroffset < 0)
return Fault(fp,
static_cast<int>(-curroffset));
513 curroffset = fp->
setOffset(curroffset+offset);
515 else return Fault(fp, EINVAL);
539 if (!admin.
isOK())
return -1;
557 return Open(path, oflags, mode, cbP, 0);
569 bool aOK, isRO =
false;
573 if (oflags & (O_WRONLY | O_RDWR))
591 if (oflags & O_CREAT)
607 if (!aOK) {
delete fp;
return -1;}
614 if (infoP && isRO && OpenCache(*fp, *infoP))
620 if (rc > 0)
return OpenDefer(fp, cbP, XOflags, XOmode, oflags&
isStream);
627 if (!cbP) Status = fp->
clFile.
Open((std::string)path, XOflags, XOmode);
628 else Status = fp->
clFile.
Open((std::string)path, XOflags, XOmode,
636 if (
DEBUGON && rc != -ENOENT && rc != -ELOOP)
645 if (!(fp->AssignFD(oflags &
isStream)))
653 if (cbP) {errno = EINPROGRESS;
return -1;}
654 if (fp->Finalize(&Status))
return fp->FDNum();
670 (
int)
sizeof(
Info.cachePath),
674 {
Info.ffReady =
true;
675 DEBUG(
"File in cache url=" <<
Info.cacheURL);
681 Info.ffReady =
false;
712 if ((dirP = dP->
Open()))
return dirP;
729 long long offs, bytes;
739 if (nbyte > (
size_t)0x7fffffff)
740 return Fault(fp, EOVERFLOW,
"read size too large");
741 else iosz =
static_cast<int>(nbyte);
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,
"*");
752 return (ssize_t)bytes;
770 if (nbyte > (
size_t)0x7fffffff)
781 iosz =
static_cast<int>(nbyte);
782 offs =
static_cast<long long>(offset);
786 fp->
XCio->
Read(*cbp, (
char *)buf, offs, (int)iosz);
805 if (nbyte > (
size_t)0x7fffffff)
806 return Fault(fp,EOVERFLOW,
"write size too large");
807 else iosz =
static_cast<int>(nbyte);
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,
"*");
819 return (ssize_t)iosz;
837 if (nbyte > (
size_t)0x7fffffff)
848 iosz =
static_cast<int>(nbyte);
849 offs =
static_cast<long long>(offset);
853 fp->
XCio->
Write(*cbp, (
char *)buf, offs, (int)iosz);
872 if (nbyte > (
size_t)0x7fffffff)
return Fault(fp,EOVERFLOW);
873 else iosz =
static_cast<int>(nbyte);
878 if (bytes < 0)
return Fault(fp,-bytes);
884 return (ssize_t)bytes;
893 ssize_t bytes, totbytes = 0;
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;
925 if ((bytes = fp->
XCio->
ReadV(readV, n)) < 0)
return Fault(fp,-bytes);
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;
967 dp32->d_type = dp64->d_type;
969 dp32->d_reclen = dp64->d_reclen;
970 strcpy(dp32->d_name, dp64->d_name);
1005 struct dirent **result)
1007 dirent64 *dp64 = 0, d64ent;
1010 if ((rc =
Readdir64_r(dirp, &d64ent, &dp64)) || !dp64)
1011 {*result = 0;
return rc;}
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;
1018 entry->d_type = dp64->d_type;
1020 entry->d_reclen = dp64->d_reclen;
1021 strcpy(entry->d_name, dp64->d_name);
1027 struct dirent64 **result)
1038 if (!(*result = dP->
nextEntry(entry))) {rc = dP->
Status(); *result = 0;}
1039 else {rc = 0; *result = entry;}
1064 {LfnPath oldF(
"rename", oldpath);
1065 LfnPath newF(
"rename", newpath);
1066 if (!oldF.path || !newF.path)
return -1;
1073 return EcRename(oldpath, newpath, admin);
1107 if (!admin.
isOK())
return -1;
1112 {LfnPath rmd(
"rmdir", path);
1113 if (!rmd.path)
return -1;
1140 else if (loc < 0) loc = 0;
1156 if (!admin.
isOK())
return -1;
1165 {LfnPath statX(
"stat", path,
false);
1166 if (!statX.path)
return -1;
1169 if (rc < 0) {errno = -rc;
return -1;}
1175 return EcStat(path, buf, admin);
1177 if (!admin.
Stat(*buf))
return -1;
1192 if ((rc =
Statvfs(path, &myVfs)))
return rc;
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;
1205 buf->f_frsize = myVfs.f_frsize;
1207#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
1208 buf->f_bavail = myVfs.f_bavail;
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;
1224 static const int szVFS =
sizeof(buf->f_bfree);
1225 static const long long max32 = 0x7fffffffLL;
1230 long long rwFree, ssFree, rwBlks;
1231 int rwNum, ssNum, rwUtil, ssUtil;
1235 if (!admin.
isOK())
return -1;
1245 rwNum =
static_cast<int>(vfsStat->
GetNodesRW());
1246 rwFree = (
long long)vfsStat->
GetFreeRW();
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));
1264 {
if (rwBlks > max32) rwBlks = max32;
1265 if (rwFree > max32) rwFree = max32;
1266 if (ssFree > max32) ssFree = max32;
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;
1280 buf->f_flag = (rwNum == 0 ? ST_RDONLY|ST_NOSUID : ST_NOSUID);
1313 uint64_t tSize =
static_cast<uint64_t
>(Size);
1317 if (!admin.
isOK())
return -1;
1322 {LfnPath trunc(
"truncate", path);
1323 if (!trunc.path)
return -1;
1344 if (!admin.
isOK())
return -1;
1349 {LfnPath remf(
"unlink", path);
1350 if (!remf.path)
return -1;
1357 return EcUnlink(path, admin);
1378 if (nbyte > (
size_t)0x7fffffff)
return Fault(fp,EOVERFLOW);
1379 else iosz =
static_cast<int>(nbyte);
1384 if (bytes < 0)
return Fault(fp,-bytes);
1390 return (ssize_t)iosz;
1399 ssize_t totbytes = 0;
1404 for (i = 0; i < iovcnt; i++)
1405 {
if (!
Write(fildes,(
void *)
iov[i].iov_base,(
size_t)
iov[i].iov_len))
1407 totbytes +=
iov[i].iov_len;
1424 if (!dirp)
return false;
1447 char *value,
int vsize)
1453 if (!admin.
Stat(0, &Mtime))
return -1;
1478 return ecmP->
Get(
emsg, reset);
1508 if (!admin.
Stat())
return -1;
1522int XrdPosixXrootd::Fault(
XrdPosixFile *fp,
int ecode,
const char *msg)
1532int XrdPosixXrootd::EcRename(
const char *oldpath,
const char *newpath,
1538 std::string file = url.GetPath();
1549 || queryResp->
ToString() ==
"server\n")
1551 if (queryResp)
delete queryResp;
1553 newUrl.GetPathWithParams()),
1557 if (queryResp)
delete queryResp;
1560 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1569 if ( ! S_ISREG(buf.st_mode))
1576 for(
size_t i = 0; i < info->
GetSize(); ++i )
1578 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1581 newUrl.GetPathWithParams()),
1583 if (x != -ENOENT && rc != 0)
1585 if (admin_i)
delete admin_i;
1594int XrdPosixXrootd::EcStat(
const char *path,
struct stat *buf,
1598 std::string file = url.GetPath();
1602 std::vector<std::string> xattrkeys;
1603 std::vector<XrdCl::XAttr> xattrvals;
1604 xattrkeys.push_back(
"xrdec.strpver");
1605 xattrkeys.push_back(
"xrdec.filesize");
1613 || queryResp->
ToString() ==
"server\n")
1615 if (queryResp)
delete queryResp;
1616 if (!admin.
Stat(*buf))
1620 st = fs.GetXAttr(file, xattrkeys, xattrvals, 0);
1621 if (! xattrvals[0].value.empty())
1623 std::stringstream sstream0(xattrvals[0].value);
1624 sstream0 >> buf->st_mtime;
1625 std::stringstream sstream1(xattrvals[1].value);
1626 sstream1 >> buf->st_size;
1627 buf->st_blocks = (buf->st_size + 512)/512;
1633 if (queryResp)
delete queryResp;
1636 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1644 uint64_t verNumMax = 0;
1647 for(
size_t i = 0; i < info->
GetSize(); ++i )
1649 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1652 if (admin_i->
Stat(buf_i))
1654 if (! S_ISREG(buf_i.st_mode))
1656 memcpy(buf, &buf_i,
sizeof(
struct stat));
1657 if (admin_i)
delete admin_i;
1662 if (verNumMax == 0) memcpy(buf, &buf_i,
sizeof(
struct stat));
1668 st = fs_i->
GetXAttr(file, xattrkeys, xattrvals, 0);
1669 if (! xattrvals[0].value.empty())
1671 std::stringstream sstream(xattrvals[0].value);
1674 if ( verNum > verNumMax )
1677 memcpy(buf, &buf_i,
sizeof(
struct stat));
1678 buf->st_mtime = verNumMax;
1679 std::stringstream sstream(xattrvals[1].value);
1680 sstream >> buf->st_size;
1681 buf->st_blocks = (buf->st_size + 512)/512;
1684 if (fs_i)
delete fs_i;
1686 if (admin_i)
delete admin_i;
1700int XrdPosixXrootd::EcUnlink(
const char *path,
XrdPosixAdmin &admin)
1703 std::string file = url.GetPath();
1713 || queryResp->
ToString() ==
"server\n")
1715 if (queryResp)
delete queryResp;
1720 if (queryResp)
delete queryResp;
1723 std::unique_ptr<XrdCl::LocationInfo> ptr( info );
1728 for(
size_t i = 0; i < info->
GetSize(); ++i )
1730 std::string url_i =
"root://" + info->
At(i).
GetAddress() +
"/" + file;
1735 if (x != -ENOENT && rc != 0)
1737 if (admin_i)
delete admin_i;
XrdVERSIONINFO(XrdPosix, XrdPosix)
int emsg(int rc, char *msg)
Binary blob representation.
void FromString(const std::string str)
Fill the buffer from a string.
std::string ToString() const
Convert the buffer to a string.
Send file/filesystem queries to an XRootD cluster.
XRootDStatus RmDir(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Mv(const std::string &source, const std::string &dest, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus Rm(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus GetXAttr(const std::string &path, const std::vector< std::string > &attrs, ResponseHandler *handler, uint16_t timeout=0)
XRootDStatus Truncate(const std::string &path, uint64_t size, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus MkDir(const std::string &path, MkDirFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
XRootDStatus StatVFS(const std::string &path, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
bool IsOpen() const
Check if the file is open.
XRootDStatus Open(const std::string &url, OpenFlags::Flags flags, Access::Mode mode, ResponseHandler *handler, uint16_t timeout=0) XRD_WARN_UNUSED_RESULT
bool GetProperty(const std::string &name, std::string &value) const
const std::string & GetAddress() const
Get address.
uint32_t GetSize() const
Get number of locations.
Location & At(uint32_t index)
Get the location at index.
Handle an async response.
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.
std::string GetPathWithParams() const
Get the path with params.
bool IsValid() const
Is the url valid.
int GetPort() const
Get the target port.
virtual int Read(char *buff, long long offs, int rlen)=0
virtual int Fstat(struct stat &sbuff)
virtual int Write(char *buff, long long offs, int wlen)=0
virtual long long FSize()=0
virtual bool Detach(XrdOucCacheIOCD &iocd)=0
virtual int Trunc(long long offs)=0
virtual int ReadV(const XrdOucIOVec *readV, int rnum)
virtual int Rename(const char *oldp, const char *newp)
virtual int Stat(const char *url, struct stat &sbuff)
virtual int Truncate(const char *path, off_t size)
virtual int Unlink(const char *path)
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
virtual int Prepare(const char *url, int oflags, mode_t mode)
virtual int Rmdir(const char *dirp)
int Get(std::string &ecm, bool rst=true)
int SetErrno(int ecc, int retval=-1, const char *alt=0)
void Put(const char *varname, const char *value)
bool ClientConfig(const char *pfx, bool hush=false)
bool Stat(mode_t *flags=0, time_t *mtime=0)
int Query(XrdCl::QueryCode::Code reqCode, void *buff, int bsz)
virtual void Complete(ssize_t Result)=0
An abstract class to define a callback for Open() call.
virtual void Complete(int Result)=0
static void initStat(struct stat *buf)
static bool SetConfig(XrdOucPsx &parms)
static int dirNo(DIR *dirP)
dirent64 * nextEntry(dirent64 *dp=0)
void setOffset(long offset)
void UpdtSize(size_t newsz)
long long addOffset(long long offs, int updtSz=0)
int Fstat(struct stat &buf) override
bool Close(XrdCl::XRootDStatus &Status)
const char * Path() override
bool Finalize(XrdCl::XRootDStatus *Status)
long long setOffset(long long offs)
static void * DelayedDestroy(void *)
static int Result(const XrdCl::XRootDStatus &Status, XrdOucECMsg &ecMsg, bool retneg1=false)
static XrdCl::Access::Mode Mode2Access(mode_t mode)
bool AssignFD(bool isStream=false)
static XrdPosixDir * Dir(int fildes, bool glk=false)
static XrdPosixDir * ReleaseDir(int fildes)
static int Init(int numfd)
static XrdPosixFile * ReleaseFile(int fildes)
static bool Valid(int fd)
static XrdPosixFile * File(int fildes, bool glk=false)
void Count(long long &Dest)
static const char * P2L(const char *who, const char *inP, char *&relP, bool ponly=false)
static ssize_t Readv(int fildes, const struct iovec *iov, int iovcnt)
Readv() conforms to POSIX.1-2001 readv()
static ssize_t Pread(int fildes, void *buf, size_t nbyte, off_t offset)
Pread() conforms to POSIX.1-2001 pread()
static int Closedir(DIR *dirp)
Closedir() conforms to POSIX.1-2001 closedir()
static void Seekdir(DIR *dirp, long loc)
Seekdir() conforms to POSIX.1-2001 seekdir()
static const int isStream
static int Stat(const char *path, struct stat *buf)
Stat() conforms to POSIX.1-2001 stat()
static int QueryChksum(const char *path, time_t &mtime, char *buff, int blen)
static int Mkdir(const char *path, mode_t mode)
Mkdir() conforms to POSIX.1-2001 mkdir()
static int Unlink(const char *path)
Unlink() conforms to POSIX.1-2001 unlink()
static int Rmdir(const char *path)
Rmdir() conforms to POSIX.1-2001 rmdir()
static void Rewinddir(DIR *dirp)
Rewinddir() conforms to POSIX.1-2001 rewinddir()
static void VRead(int fildes, const XrdOucIOVec *readV, int n, XrdPosixCallBackIO *cbp)
static int Rename(const char *oldpath, const char *newpath)
Rename() conforms to POSIX.1-2001 rename()
static int Close(int fildes)
Close() conforms to POSIX.1-2001 close()
static int Statvfs(const char *path, struct statvfs *buf)
Statvfs() conforms to POSIX.1-2001 statvfs()
static int endPoint(int FD, char *Buff, int Blen)
static ssize_t Write(int fildes, const void *buf, size_t nbyte)
Write() conforms to POSIX.1-2001 write()
static struct dirent * Readdir(DIR *dirp)
static int Readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
static ssize_t Writev(int fildes, const struct iovec *iov, int iovcnt)
Writev() conforms to POSIX.1-2001 writev()
static int QueryError(std::string &emsg, int fd=-1, bool reset=true)
static struct dirent64 * Readdir64(DIR *dirp)
XrdPosixXrootd(int maxfd=255, int maxdir=0, int maxthr=0)
static int Ftruncate(int fildes, off_t offset)
Ftruncate() conforms to POSIX.1-2001 ftruncate()
static long Telldir(DIR *dirp)
Telldir() conforms to POSIX.1-2001 telldir()
static bool isXrootdDir(DIR *dirp)
static int Access(const char *path, int amode)
Access() conforms to POSIX.1-2001 access()
static DIR * Opendir(const char *path)
Opendir() conforms to POSIX.1-2001 opendir()
static int Fsync(int fildes)
Fsync() conforms to POSIX.1-2001 fsync()
static long long Getxattr(const char *path, const char *name, void *value, unsigned long long size)
static long long QueryOpaque(const char *path, char *buff, int blen)
static int Statfs(const char *path, struct statfs *buf)
static int Readdir64_r(DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
static ssize_t Read(int fildes, void *buf, size_t nbyte)
Read() conforms to POSIX.1-2001 read()
static int Fstat(int fildes, struct stat *buf)
Fstat() conforms to POSIX.1-2001 fstat()
static off_t Lseek(int fildes, off_t offset, int whence)
Lseek() conforms to POSIX.1-2001 lseek()
static int Open(const char *path, int oflag, mode_t mode=0, XrdPosixCallBack *cbP=0)
static ssize_t Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset)
Pwrite() conforms to POSIX.1-2001 pwrite()
static int Truncate(const char *path, off_t offset)
Telldir() conforms to POSIX.1-2001 telldir()
thread_local XrdOucECMsg ecMsg
XrdCl::DirListFlags::Flags dlFlag
@ MakePath
create the entire directory tree if it doesn't exist
Flags
Open flags, may be or'd when appropriate.
@ Read
Open only for reading.
@ Update
Open for reading and writing.
Code
XRootD query request codes.
@ OpaqueFile
Implementation dependent.
@ XAttr
Query file extended attributes.
@ Config
Query server configuration.
@ Checksum
Query file checksum.
@ Space
Query logical space stats.
bool IsOK() const
We're fine.
std::string ToString() const
Create a string representation.