XRootD
Loading...
Searching...
No Matches
XrdOfs Class Reference

#include <XrdOfs.hh>

Inheritance diagram for XrdOfs:
Collaboration diagram for XrdOfs:

Classes

struct  fwdOpt

Public Types

enum  {
  Authorize = 0x0001 ,
  XAttrPlug = 0x0002 ,
  isPeer = 0x0050 ,
  isProxy = 0x0020 ,
  isManager = 0x0040 ,
  isServer = 0x0080 ,
  isSuper = 0x00C0 ,
  isMeta = 0x0100 ,
  haveRole = 0x01F0 ,
  Forwarding = 0x1000 ,
  ThirdPC = 0x2000 ,
  SubCluster = 0x4000 ,
  RdrTPC = 0x8000
}
Public Types inherited from XrdSfsFileSystem
enum  csFunc {
  csCalc = 0 ,
  csGet ,
  csSize
}
enum  gpfFunc {
  gpfCancel =0 ,
  gpfGet ,
  gpfPut
}

Public Member Functions

 XrdOfs ()
virtual ~XrdOfs ()
int chksum (csFunc Func, const char *csName, const char *Path, XrdOucErrInfo &out_error, const XrdSecEntity *client=0, const char *opaque=0)
int chmod (const char *Name, XrdSfsMode Mode, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
void Config_Cluster (XrdOss *)
void Config_Display (XrdSysError &)
virtual int Configure (XrdSysError &)
virtual int Configure (XrdSysError &, XrdOucEnv *)
void Connect (const XrdSecEntity *client=0)
void Disc (const XrdSecEntity *client=0)
int exists (const char *fileName, XrdSfsFileExistence &exists_flag, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
int FAttr (XrdSfsFACtl *faReq, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)
int FSctl (const int cmd, XrdSfsFSctl &args, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)
int fsctl (const int cmd, const char *args, XrdOucErrInfo &out_error, const XrdSecEntity *client=0)
int getStats (char *buff, int blen)
const char * getVersion ()
int mkdir (const char *dirName, XrdSfsMode Mode, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
XrdSfsDirectorynewDir (char *user=0, int MonID=0)
XrdSfsDirectorynewDir (XrdOucErrInfo &eInfo)
XrdSfsFilenewFile (char *user=0, int MonID=0)
XrdSfsFilenewFile (XrdOucErrInfo &eInfo)
int prepare (XrdSfsPrep &pargs, XrdOucErrInfo &out_error, const XrdSecEntity *client=0)
int rem (const char *path, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *info=0)
int remdir (const char *dirName, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *info=0)
int rename (const char *oldFileName, const char *newFileName, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *infoO=0, const char *infoN=0)
int stat (const char *Name, mode_t &mode, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
int stat (const char *Name, struct stat *buf, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
int truncate (const char *Name, XrdSfsFileOffset fileOffset, XrdOucErrInfo &out_error, const XrdSecEntity *client=0, const char *opaque=0)
Public Member Functions inherited from XrdSfsFileSystem
 XrdSfsFileSystem ()
 Constructor and Destructor.
virtual ~XrdSfsFileSystem ()
virtual void EnvInfo (XrdOucEnv *envP)
uint64_t Features ()
virtual int getChkPSize ()
virtual int gpFile (gpfFunc &gpAct, XrdSfsGPFile &gpReq, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)

Public Attributes

char * ConfigFN
mode_t dMask [2]
mode_t fMask [2]
struct fwdOpt fwdCHMOD
struct fwdOpt fwdMKDIR
struct fwdOpt fwdMKPATH
struct fwdOpt fwdMV
struct fwdOpt fwdRM
struct fwdOpt fwdRMDIR
struct fwdOpt fwdTRUNC
XrdNetIFmyIF
int myPort
int Options
char * tpcRdrHost [2]
int tpcRdrPort [2]

Static Public Attributes

static int MaxDelay = 60
static int OSSDelay = 30

Protected Member Functions

virtual int ConfigXeq (char *var, XrdOucStream &, XrdSysError &)
const char * Split (const char *Args, const char **Opq, char *Path, int Plen)
int Stall (XrdOucErrInfo &, int, const char *)
void Unpersist (XrdOfsHandle *hP, int xcev=1)
char * WaitTime (int, char *, int)

Static Protected Member Functions

static int Emsg (const char *, XrdOucErrInfo &, int, const char *x, const char *y="")
static int Emsg (const char *, XrdOucErrInfo &, int, const char *x, XrdOfsHandle *hP)
static int fsError (XrdOucErrInfo &myError, int rc)

Protected Attributes

XrdOfsEvr evrObject
XrdCmsClientFinder
Protected Attributes inherited from XrdSfsFileSystem
uint64_t FeatureSet
 Adjust features at initialization.

Friends

class XrdOfsDirectory
class XrdOfsFile

Detailed Description

Definition at line 235 of file XrdOfs.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
Authorize 
XAttrPlug 
isPeer 
isProxy 
isManager 
isServer 
isSuper 
isMeta 
haveRole 
Forwarding 
ThirdPC 
SubCluster 
RdrTPC 

Definition at line 364 of file XrdOfs.hh.

364 {Authorize = 0x0001, // Authorization wanted
365 XAttrPlug = 0x0002, // Extended Attribute Plugin
366 isPeer = 0x0050, // Role peer
367 isProxy = 0x0020, // Role proxy
368 isManager = 0x0040, // Role manager
369 isServer = 0x0080, // Role server
370 isSuper = 0x00C0, // Role supervisor
371 isMeta = 0x0100, // Role meta + above
372 haveRole = 0x01F0, // A role is present
373 Forwarding= 0x1000, // Fowarding wanted
374 ThirdPC = 0x2000, // This party copy wanted
375 SubCluster= 0x4000, // all.subcluster directive encountered
376 RdrTPC = 0x8000
377 }; // These are set in Options below
@ isProxy
Definition XrdOfs.hh:367
@ haveRole
Definition XrdOfs.hh:372
@ RdrTPC
Definition XrdOfs.hh:376
@ ThirdPC
Definition XrdOfs.hh:374
@ isMeta
Definition XrdOfs.hh:371
@ SubCluster
Definition XrdOfs.hh:375
@ isManager
Definition XrdOfs.hh:368
@ isPeer
Definition XrdOfs.hh:366
@ XAttrPlug
Definition XrdOfs.hh:365
@ isSuper
Definition XrdOfs.hh:370
@ isServer
Definition XrdOfs.hh:369
@ Authorize
Definition XrdOfs.hh:364
@ Forwarding
Definition XrdOfs.hh:373

Constructor & Destructor Documentation

◆ XrdOfs()

XrdOfs::XrdOfs ( )

Definition at line 169 of file XrdOfs.cc.

169 : dMask{0000,0775}, fMask{0000,0775}, // Legacy
171{
172 const char *bp;
173
174// Establish defaults
175//
176 ofsConfig = 0;
177 FSctl_PC = 0;
178 FSctl_PI = 0;
179 Authorization = 0;
180 Finder = 0;
181 Balancer = 0;
182 evsObject = 0;
183 ossRPList = 0;
184 myRole = strdup("server");
185 OssIsProxy = 0;
186 ossRW =' ';
187 ossFeatures = 0;
188
189// Obtain port number we will be using. Note that the constructor must occur
190// after the port number is known (i.e., this cannot be a global static).
191//
192 myPort = (bp = getenv("XRDPORT")) ? strtol(bp, (char **)NULL, 10) : 0;
193
194// Defaults for POSC
195//
196 poscQ = 0;
197 poscLog = 0;
198 poscHold= 10*60;
199 poscAuto= 0;
200 poscSync= 1;
201
202// Set the configuration file name and dummy handle
203//
204 ConfigFN = 0;
205 XrdOfsHandle::Alloc(&dummyHandle);
206
207// Set checksum pointers
208//
209 Cks = 0;
210 CksPfn = true;
211 CksRdr = true;
212
213// Prepare handling
214//
215 prepHandler = 0;
216 prepAuth = true;
217
218// Eextended attribute limits
219//
220 usxMaxNsz = kXR_faMaxNlen;
221 usxMaxVsz = kXR_faMaxVlen;
222
223// Other options
224//
225 DirRdr = false;
226 reProxy = false;
227 OssHasPGrw= false;
228}
@ kXR_faMaxVlen
Definition XProtocol.hh:282
@ kXR_faMaxNlen
Definition XProtocol.hh:281
static int Alloc(const char *thePath, int Opts, XrdOfsHandle **Handle)
mode_t dMask[2]
Definition XrdOfs.hh:384
int myPort
Definition XrdOfs.hh:380
XrdCmsClient * Finder
Definition XrdOfs.hh:429
mode_t fMask[2]
Definition XrdOfs.hh:385
char * ConfigFN
Definition XrdOfs.hh:420
int tpcRdrPort[2]
Definition XrdOfs.hh:390
char * tpcRdrHost[2]
Definition XrdOfs.hh:389

References XrdOfsHandle::Alloc(), ConfigFN, dMask, Finder, fMask, kXR_faMaxNlen, kXR_faMaxVlen, myPort, tpcRdrHost, and tpcRdrPort.

Here is the call graph for this function:

◆ ~XrdOfs()

virtual XrdOfs::~XrdOfs ( )
inlinevirtual

Definition at line 356 of file XrdOfs.hh.

356{} // Too complicate to delete :-)

Member Function Documentation

◆ chksum()

int XrdOfs::chksum ( csFunc Func,
const char * csName,
const char * Path,
XrdOucErrInfo & out_error,
const XrdSecEntity * client = 0,
const char * opaque = 0 )
virtual

Reimplemented from XrdSfsFileSystem.

Definition at line 1783 of file XrdOfs.cc.

1803{
1804 EPNAME("chksum");
1805 XrdOucEnv cksEnv(opaque,0,client);
1806 XrdCksData cksData;
1807 const char *tident = einfo.getErrUser();
1808 char buff[MAXPATHLEN+8];
1809 int rc;
1810
1811// Check if we support checksumming
1812//
1813 if (!Cks)
1814 {einfo.setErrInfo(ENOTSUP, "Checksums are not supported.");
1815 return SFS_ERROR;
1816 }
1817
1818// A csSize request is issued usually once to verify everything is working. We
1819// take this opportunity to also verify the checksum name.
1820//
1821 rc = cksData.Set(csName);
1822 if (!rc || Func == XrdSfsFileSystem::csSize)
1823 {if (rc && (rc = Cks->Size(csName)))
1824 {einfo.setErrCode(rc); return SFS_OK;}
1825 strcpy(buff, csName); strcat(buff, " checksum not supported.");
1826 einfo.setErrInfo(ENOTSUP, buff);
1827 return SFS_ERROR;
1828 }
1829
1830// Everything else requires a path
1831//
1832 if (!Path)
1833 {strcpy(buff, csName);
1834 strcat(buff, " checksum path not specified.");
1835 einfo.setErrInfo(EINVAL, buff);
1836 return SFS_ERROR;
1837 }
1838
1839// Apply security, as needed
1840//
1841 XTRACE(stat, Path, csName);
1842 AUTHORIZE(client,&cksEnv,AOP_Stat,"checksum",Path,einfo);
1843
1844// If we are a menager then we need to redirect the client to where the file is
1845//
1846 if (CksRdr && Finder && Finder->isRemote()
1847 && (rc = Finder->Locate(einfo, Path, SFS_O_RDONLY, &cksEnv)))
1848 return fsError(einfo, rc);
1849
1850// At this point we need to convert the lfn to a pfn
1851//
1852 if (CksPfn && !(Path = XrdOfsOss->Lfn2Pfn(Path, buff, MAXPATHLEN, rc)))
1853 return Emsg(epname, einfo, rc, "checksum", Path);
1854
1855// Originally we only passed he env pointer for proxy servers. Due to popular
1856// demand, we always pass the env as it points to the SecEntity object unless
1857// we don't have it then we pass the caller's environment.
1858//
1860 {if (client) cksData.envP = &cksEnv;
1861 else cksData.envP = (einfo.getEnv() ? einfo.getEnv() : &cksEnv);
1862 }
1863
1864// Now determine what to do
1865//
1866 if (Func == XrdSfsFileSystem::csCalc) rc = Cks->Calc(Path, cksData);
1867 else if (Func == XrdSfsFileSystem::csGet) rc = Cks->Get( Path, cksData);
1868 else {einfo.setErrInfo(EINVAL, "Invalid checksum function.");
1869 return SFS_ERROR;
1870 }
1871
1872// See if all went well
1873//
1874#ifdef ENOATTR
1875 if (rc >= 0 || rc == -ENOATTR || rc == -ESTALE || rc == -ESRCH)
1876#else
1877 if (rc >= 0 || rc == -ENODATA || rc == -ESTALE || rc == -ESRCH)
1878#endif
1879 {if (rc >= 0) {cksData.Get(buff, MAXPATHLEN); rc = 0;}
1880 else {*buff = 0; rc = -rc;}
1881 einfo.setErrInfo(rc, buff);
1882 return SFS_OK;
1883 }
1884
1885// We failed
1886//
1887 return Emsg(epname, einfo, rc, "checksum", Path);
1888}
#define ENOATTR
@ AOP_Stat
exists(), stat()
#define tident
#define EPNAME(x)
#define XTRACE(act, target, x)
#define ENODATA
#define AUTHORIZE(usr, env, optype, action, pathp, edata)
XrdOss * XrdOfsOss
Definition XrdOfs.cc:163
XrdOucString Path
#define SFS_ERROR
#define SFS_O_RDONLY
#define SFS_OK
int Set(const char *csName)
Definition XrdCksData.hh:81
int Get(char *Buff, int Blen)
Definition XrdCksData.hh:69
static int Emsg(const char *, XrdOucErrInfo &, int, const char *x, XrdOfsHandle *hP)
Definition XrdOfs.cc:2514
static int fsError(XrdOucErrInfo &myError, int rc)
Definition XrdOfs.cc:2629
int stat(const char *Name, struct stat *buf, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
Definition XrdOfs.cc:2362
virtual int Lfn2Pfn(const char *Path, char *buff, int blen)
Definition XrdOss.hh:873

References AOP_Stat, AUTHORIZE, XrdSfsFileSystem::csCalc, XrdSfsFileSystem::csGet, XrdSfsFileSystem::csSize, Emsg(), ENOATTR, ENODATA, EPNAME, Finder, fsError(), XrdCksData::Get(), XrdOucErrInfo::getEnv(), XrdOucErrInfo::getErrUser(), Path, XrdCksData::Set(), XrdOucErrInfo::setErrCode(), XrdOucErrInfo::setErrInfo(), SFS_ERROR, SFS_O_RDONLY, SFS_OK, stat(), tident, XrdOfsOss, and XTRACE.

Here is the call graph for this function:

◆ chmod()

int XrdOfs::chmod ( const char * path,
XrdSfsMode mode,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
virtual

Change file mode settings.

Parameters
path- Pointer to the path of the file in question.
mode- The new file mode setting.
eInfo- The object where error info or results are to be returned.
client- Client's identify (see common description).
opaque- Path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 1894 of file XrdOfs.cc.

1909{
1910 EPNAME("chmod");
1911 static const int locFlags = SFS_O_RDWR|SFS_O_META;
1912 struct stat Stat;
1913 mode_t acc_mode = Mode & S_IAMB;
1914 const char *tident = einfo.getErrUser();
1915 XrdOucEnv chmod_Env(info,0,client);
1916 int retc;
1917 XTRACE(chmod, path, "");
1918
1919// Apply security, as needed
1920//
1921 AUTHORIZE(client,&chmod_Env,AOP_Chmod,"chmod",path,einfo);
1922
1923// Find out where we should chmod this file
1924//
1925 if (Finder && Finder->isRemote())
1926 {if (fwdCHMOD.Cmd)
1927 {char buff[8];
1928 sprintf(buff, "%o", static_cast<int>(acc_mode));
1929 if (Forward(retc,einfo,fwdCHMOD,path,buff,&chmod_Env)) return retc;
1930 }
1931 else if ((retc = Finder->Locate(einfo, path, locFlags, &chmod_Env)))
1932 return fsError(einfo, retc);
1933 }
1934
1935// We need to adjust the mode based on whether this is a file or directory.
1936//
1937 if ((retc = XrdOfsOss->Stat(path, &Stat, 0, &chmod_Env)))
1938 return XrdOfsFS->Emsg(epname, einfo, retc, "change", path);
1939 if (S_ISDIR(Stat.st_mode)) acc_mode = (acc_mode | dMask[0]) & dMask[1];
1940 else acc_mode = (acc_mode | fMask[0]) & fMask[1];
1941
1942// Check if we should generate an event
1943//
1944 if (evsObject && evsObject->Enabled(XrdOfsEvs::Chmod))
1945 {XrdOfsEvsInfo evInfo(tident, path, info, &chmod_Env, acc_mode);
1946 evsObject->Notify(XrdOfsEvs::Chmod, evInfo);
1947 }
1948
1949// Now try to find the file or directory
1950//
1951 if (!(retc = XrdOfsOss->Chmod(path, acc_mode, &chmod_Env))) return SFS_OK;
1952
1953// An error occurred, return the error info
1954//
1955 return XrdOfsFS->Emsg(epname, einfo, retc, "change", path);
1956}
@ AOP_Chmod
chmod()
struct stat Stat
Definition XrdCks.cc:49
#define S_IAMB
Definition XrdConfig.cc:160
XrdOfs * XrdOfsFS
Definition XrdOfsFS.cc:47
int Mode
#define SFS_O_META
#define SFS_O_RDWR
int chmod(const char *Name, XrdSfsMode Mode, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
Definition XrdOfs.cc:1894
struct fwdOpt fwdCHMOD
Definition XrdOfs.hh:409
virtual int Chmod(const char *path, mode_t mode, XrdOucEnv *envP=0)=0
virtual int Stat(const char *path, struct stat *buff, int opts=0, XrdOucEnv *envP=0)=0

References AOP_Chmod, AUTHORIZE, XrdOfsEvs::Chmod, chmod(), dMask, EPNAME, Finder, fMask, fsError(), fwdCHMOD, XrdOucErrInfo::getErrUser(), Mode, S_IAMB, SFS_O_META, SFS_O_RDWR, SFS_OK, Stat, stat(), tident, XrdOfsFS, XrdOfsOss, and XTRACE.

Referenced by chmod().

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

◆ Config_Cluster()

void XrdOfs::Config_Cluster ( XrdOss * )

◆ Config_Display()

void XrdOfs::Config_Display ( XrdSysError & Eroute)

Definition at line 416 of file XrdOfsConfig.cc.

417{
418 const char *cloc, *pval;
419 char buff[8192], fwbuff[512], *bp;
420 int i;
421
422 if (!ConfigFN || !ConfigFN[0]) cloc = "default";
423 else cloc = ConfigFN;
424 if (!poscQ) pval = "off";
425 else pval = (poscAuto ? "auto" : "manual");
426
427 snprintf(buff, sizeof(buff), "Config effective %s ofs configuration:\n"
428 " all.role %s\n"
429 "%s"
430 " ofs.maxdelay %d\n"
431 " ofs.persist %s hold %d%s%s\n"
432 " ofs.trace %x",
433 cloc, myRole,
434 (Options & Authorize ? " ofs.authorize\n" : ""),
435 MaxDelay,
436 pval, poscHold, (poscLog ? " logdir " : ""),
437 (poscLog ? poscLog : ""), OfsTrace.What);
438
439 Eroute.Say(buff);
440 ofsConfig->Display();
441
442 if (Options & Forwarding)
443 {*fwbuff = 0;
444 if (ConfigDispFwd(buff, fwdCHMOD))
445 {Eroute.Say(buff); strcat(fwbuff, " ch");}
446 if (ConfigDispFwd(buff, fwdMKDIR))
447 {Eroute.Say(buff); strcat(fwbuff, " mk");}
448 if (ConfigDispFwd(buff, fwdMV))
449 {Eroute.Say(buff); strcat(fwbuff, " mv");}
450 if (ConfigDispFwd(buff, fwdRM))
451 {Eroute.Say(buff); strcat(fwbuff, " rm");}
452 if (ConfigDispFwd(buff, fwdRMDIR))
453 {Eroute.Say(buff); strcat(fwbuff, " rd");}
454 if (ConfigDispFwd(buff, fwdTRUNC))
455 {Eroute.Say(buff); strcat(fwbuff, " tr");}
456 if (*fwbuff) XrdOucEnv::Export("XRDOFS_FWD", fwbuff);
457 }
458
459 if (evsObject)
460 {bp = buff;
461 setBuff(" ofs.notify ", 18); // 1234567890
462 if (evsObject->Enabled(XrdOfsEvs::Chmod)) setBuff("chmod ", 6);
463 if (evsObject->Enabled(XrdOfsEvs::Closer)) setBuff("closer ", 7);
464 if (evsObject->Enabled(XrdOfsEvs::Closew)) setBuff("closew ", 7);
465 if (evsObject->Enabled(XrdOfsEvs::Create)) setBuff("create ", 7);
466 if (evsObject->Enabled(XrdOfsEvs::Mkdir)) setBuff("mkdir ", 6);
467 if (evsObject->Enabled(XrdOfsEvs::Mv)) setBuff("mv ", 3);
468 if (evsObject->Enabled(XrdOfsEvs::Openr)) setBuff("openr ", 6);
469 if (evsObject->Enabled(XrdOfsEvs::Openw)) setBuff("openw ", 6);
470 if (evsObject->Enabled(XrdOfsEvs::Rm)) setBuff("rm ", 3);
471 if (evsObject->Enabled(XrdOfsEvs::Rmdir)) setBuff("rmdir ", 6);
472 if (evsObject->Enabled(XrdOfsEvs::Trunc)) setBuff("trunc ", 6);
473 if (evsObject->Enabled(XrdOfsEvs::Fwrite)) setBuff("fwrite ", 7);
474 setBuff("msgs ", 5);
475 i=sprintf(fwbuff,"%d %d ",evsObject->maxSmsg(),evsObject->maxLmsg());
476 setBuff(fwbuff, i);
477 cloc = evsObject->Prog();
478 if (*cloc != '>') setBuff("|",1);
479 setBuff(cloc, strlen(cloc));
480 setBuff("\0", 1);
481 Eroute.Say(buff);
482 }
483}
#define setBuff(x, y)
XrdSysTrace OfsTrace("ofs")
struct fwdOpt fwdTRUNC
Definition XrdOfs.hh:415
struct fwdOpt fwdRMDIR
Definition XrdOfs.hh:414
int Options
Definition XrdOfs.hh:379
struct fwdOpt fwdMKDIR
Definition XrdOfs.hh:410
static int MaxDelay
Definition XrdOfs.hh:417
struct fwdOpt fwdMV
Definition XrdOfs.hh:412
struct fwdOpt fwdRM
Definition XrdOfs.hh:413
static int Export(const char *Var, const char *Val)
Definition XrdOucEnv.cc:170
void Say(const char *text1, const char *text2=0, const char *txt3=0, const char *text4=0, const char *text5=0, const char *txt6=0)

References Authorize, XrdOfsEvs::Chmod, XrdOfsEvs::Closer, XrdOfsEvs::Closew, ConfigFN, XrdOfsEvs::Create, XrdOucEnv::Export(), Forwarding, fwdCHMOD, fwdMKDIR, fwdMV, fwdRM, fwdRMDIR, fwdTRUNC, XrdOfsEvs::Fwrite, MaxDelay, XrdOfsEvs::Mkdir, XrdOfsEvs::Mv, OfsTrace, XrdOfsEvs::Openr, XrdOfsEvs::Openw, Options, XrdOfsEvs::Rm, XrdOfsEvs::Rmdir, XrdSysError::Say(), setBuff, and XrdOfsEvs::Trunc.

Referenced by Configure().

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

◆ Configure() [1/2]

int XrdOfs::Configure ( XrdSysError & Eroute)
virtual

Definition at line 140 of file XrdOfsConfig.cc.

140{return Configure(Eroute, 0);}
virtual int Configure(XrdSysError &)

References Configure().

Referenced by Configure().

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

◆ Configure() [2/2]

int XrdOfs::Configure ( XrdSysError & Eroute,
XrdOucEnv * EnvInfo )
virtual

Definition at line 142 of file XrdOfsConfig.cc.

142 {
143/*
144 Function: Establish default values using a configuration file.
145
146 Input: None.
147
148 Output: 0 upon success or !0 otherwise.
149*/
150 char *var;
151 const char *tmp;
152 int cfgFD, retc, NoGo = 0;
153 XrdOucEnv myEnv;
154 XrdOucStream Config(&Eroute, getenv("XRDINSTANCE"), &myEnv, "=====> ");
155
156// Print warm-up message
157//
158 Eroute.Say("++++++ File system initialization started.");
159
160// Start off with no POSC log. Note that XrdSfsGetDefaultFileSystem nakes sure
161// that we are configured only once.
162//
163 poscLog = NULL;
164
165// Establish the network interface that the caller must provide
166//
167 if (!EnvInfo || !(myIF = (XrdNetIF *)EnvInfo->GetPtr("XrdNetIF*")))
168 {Eroute.Emsg("Finder", "Network i/f undefined; unable to self-locate.");
169 NoGo = 1;
170 }
171 ofsSchedP = (XrdScheduler *)EnvInfo->GetPtr("XrdScheduler*");
172
173// Preset all variables with common defaults
174//
175 Options = 0;
176 if (getenv("XRDDEBUG")) OfsTrace.What = TRACE_MOST | TRACE_debug;
177
178// Allocate a our plugin configurator
179//
180 ofsConfig = XrdOfsConfigPI::New(ConfigFN, &Config, &Eroute, 0, this);
181
182// If there is no config file, return with the defaults sets.
183//
184 if( !ConfigFN || !*ConfigFN)
185 Eroute.Emsg("Config", "Configuration file not specified.");
186 else {
187 // Try to open the configuration file.
188 //
189 if ( (cfgFD = open(ConfigFN, O_RDONLY, 0)) < 0)
190 return Eroute.Emsg("Config", errno, "open config file",
191 ConfigFN);
192 Config.Attach(cfgFD);
193 static const char *cvec[] = {"*** ofs plugin config:",0};
194 Config.Capture(cvec);
195
196 // Now start reading records until eof.
197 //
198 while((var = Config.GetMyFirstWord()))
199 {if (!strncmp(var, "ofs.", 4)
200 || !strcmp(var, "all.role")
201 || !strcmp(var, "all.subcluster"))
202 {if (ConfigXeq(var+4,Config,Eroute)) {Config.Echo();NoGo=1;}}
203 else if (!strcmp(var, "oss.defaults")
204 || !strcmp(var, "all.export"))
205 {xexp(Config, Eroute, *var == 'a');
206 Config.noEcho();
207 }
208 }
209
210 // Now check if any errors occurred during file i/o
211 //
212 if ((retc = Config.LastError()))
213 NoGo = Eroute.Emsg("Config", -retc, "read config file",
214 ConfigFN);
215 Config.Close();
216 }
217
218// If no exports were specified, the default is that we are writable
219//
220 if (ossRW == ' ') ossRW = 'w';
221
222// Adjust the umask to correspond to the maximum mode allowed
223//
224 mode_t uMask = 0777 & (~(dMask[1] | fMask[1]));
225 umask(uMask);
226
227// Export our role if we actually have one
228//
229 if (myRole) XrdOucEnv::Export("XRDROLE", myRole);
230
231// Set the redirect option for other layers
232//
233 if (Options & isManager)
234 XrdOucEnv::Export("XRDREDIRECT", (Options & isMeta ? "M" : "R"));
235 else XrdOucEnv::Export("XRDREDIRECT", "0");
236
237// If we are a proxy, then figure out where the prosy storge system resides
238//
239 if ((Options & isProxy) && !(Options & isManager))
240 {char buff[2048], *bp, *libofs = getenv("XRDOFSLIB");
241 if (!libofs) bp = buff;
242 else {strcpy(buff, libofs); bp = buff+strlen(buff)-1;
243 while(bp != buff && *(bp-1) != '/') bp--;
244 }
245 strcpy(bp, "libXrdPss.so");
246 ofsConfig->Default(XrdOfsConfigPI::theOssLib, buff, 0);
247 ofsConfig->Default(XrdOfsConfigPI::theCksLib, buff, 0);
248 }
249
250// Configure third party copy but only if we are not a manager. Phase 1 needs
251// to be done before we load the plugins as they may need this info.
252//
253 if ((Options & ThirdPC) && !(Options & isManager))
254 NoGo |= ConfigTPC(Eroute, EnvInfo);
255
256// We need to do pre-initialization for event recording as the oss needs some
257// environmental information from that initialization to initialize the frm,
258// should it need to be used. We will do full evr initialization after the oss
259// and the finder are initialized. A bit messy in the current plug-in world.
260//
261 if (!(Options & isManager) && !evrObject.Init(&Eroute)) NoGo = 1;
262
263// Determine whether we should load authorization
264//
265 int piOpts = XrdOfsConfigPI::allXXXLib;
266 if (!(Options & Authorize)) piOpts &= ~XrdOfsConfigPI::theAutLib;
267
268// We need to export plugins to other protocols which means we need to
269// record them in the outmost environment. So get it.
270//
271 XrdOucEnv *xrdEnv = 0;
272 if (EnvInfo) xrdEnv = (XrdOucEnv*)EnvInfo->GetPtr("xrdEnv*");
273
274// Now load all of the required plugins
275//
276 if (!ofsConfig->Load(piOpts, EnvInfo)) NoGo = 1;
277 else {ofsConfig->Plugin(XrdOfsOss);
278 ossFeatures = XrdOfsOss->Features();
279 if (ossFeatures & XRDOSS_HASNOSF) FeatureSet |= XrdSfs::hasNOSF;
280 if (ossFeatures & XRDOSS_HASCACH)
282 if (xrdEnv) xrdEnv->Put("XrdCache", "T"); // Existence check
283 }
284 if (ossFeatures & XRDOSS_HASNAIO) FeatureSet |= XrdSfs::hasNAIO;
285 if (xrdEnv) xrdEnv->PutPtr("XrdOss*", XrdOfsOss);
286 ofsConfig->Plugin(Cks);
287 CksPfn = !ofsConfig->OssCks();
288 CksRdr = !ofsConfig->LclCks();
289 if (ofsConfig->Plugin(prepHandler))
290 {prepAuth = ofsConfig->PrepAuth();
292 }
293 if (Options & Authorize)
294 {ofsConfig->Plugin(Authorization);
295 XrdOfsTPC::Init(Authorization);
296 if (xrdEnv) xrdEnv->PutPtr("XrdAccAuthorize*",Authorization);
298 }
299 }
300
301// If a cache has been configured then that cache may want to interact with
302// the cache-specific FSctl() operation. We check if a plugin was provided.
303//
304 if (ossFeatures & XRDOSS_HASCACH)
305 FSctl_PC = (XrdOfsFSctl_PI*)EnvInfo->GetPtr("XrdFSCtl_PC*");
306
307// Configure third party copy phase 2, but only if we are not a manager.
308//
309 if ((Options & ThirdPC) && !(Options & isManager)) NoGo |= ConfigTPC(Eroute);
310
311// Extract out the export list should it have been supplied by the oss plugin
312//
313 ossRPList = (XrdOucPListAnchor *)EnvInfo->GetPtr("XrdOssRPList*");
314
315// Initialize redirection. We type te herald here to minimize confusion
316//
317 if (Options & haveRole)
318 {Eroute.Say("++++++ Configuring ", myRole, " role. . .");
319 if (ConfigRedir(Eroute, EnvInfo))
320 {Eroute.Emsg("Config", "Unable to create cluster management client.");
321 NoGo = 1;
322 }
323 }
324
325// Initialize the FSctl plugin if we have one. Note that we needed to defer
326// until now because we needed to configure the cms plugin first (see above).
327//
328 if (ofsConfig->Plugin(FSctl_PI) && !ofsConfig->ConfigCtl(Finder, EnvInfo))
329 {Eroute.Emsg("Config", "Unable to configure FSctl plugin.");
330 NoGo = 1;
331 }
332
333// Initialize the cache FSctl handler if we have one. The same deferal applies.
334//
335 if (FSctl_PC)
336 {struct XrdOfsFSctl_PI::Plugins thePI = {Authorization, Finder,
338 XrdOucEnv pcEnv;
339 pcEnv.PutPtr("XrdOfsHandle*", dummyHandle);
340 if (!FSctl_PC->Configure(ConfigFN, 0, &pcEnv, thePI))
341 {Eroute.Emsg("Config", "Unable to configure cache FSctl handler.");
342 NoGo = 1;
343 }
344 }
345
346// Initialize th Evr object if we are an actual server
347//
348 if (!(Options & isManager) && !evrObject.Init(Balancer)) NoGo = 1;
349
350// Turn off forwarding if we are not a pure remote redirector or a peer
351//
352 if (Options & Forwarding)
353 {const char *why = 0;
354 if (!(Options & Authorize)) why = "authorization not enabled";
355 else if (!(Options & isPeer) && (Options & (isServer | isProxy)))
356 why = "not a pure manager";
357 if (why)
358 {Eroute.Say("Config warning: forwarding turned off; ", why);
359 Options &= ~(Forwarding);
360 fwdCHMOD.Reset(); fwdMKDIR.Reset(); fwdMKPATH.Reset();
361 fwdMV.Reset(); fwdRM.Reset(); fwdRMDIR.Reset();
362 fwdTRUNC.Reset();
363 }
364 }
365
366// If we need to send notifications, initialize the interface
367//
368 if (!NoGo && evsObject) NoGo = evsObject->Start(&Eroute);
369
370// If the OSS plugin is really a proxy. If it is, it will export its origin.
371// We also suppress translating lfn to pfn (usually done via osslib +cksio).
372// Note: consulting the ENVAR below is historic and remains for compatibility
373// Otherwise we can configure checkpointing if we are a data server.
374//
375 if (ossFeatures & XRDOSS_HASPRXY || getenv("XRDXROOTD_PROXY"))
376 {OssIsProxy = 1;
377 CksPfn = false;
379 } else if (!(Options & isManager) && !XrdOfsConfigCP::Init()) NoGo = 1;
380
381// Indicate wheter oss implements pgrw or it has to be simulated
382//
383 OssHasPGrw = (ossFeatures & XRDOSS_HASPGRW) != 0;
384
385// If POSC processing is enabled (as by default) do it. Warning! This must be
386// the last item in the configuration list as we need a working filesystem.
387// Note that in proxy mode we always disable posc!
388//
389 if (OssIsProxy || getenv("XRDXROOTD_NOPOSC"))
390 {if (poscAuto != -1 && !NoGo)
391 Eroute.Say("Config POSC has been disabled by the osslib plugin.");
392 } else if (poscAuto != -1 && !NoGo) NoGo |= ConfigPosc(Eroute);
393
394// Setup statistical monitoring
395//
396 OfsStats.setRole(myRole);
397
398// Display final configuration
399//
400 if (!NoGo) Config_Display(Eroute);
401 delete ofsConfig; ofsConfig = 0;
402
403// All done
404//
405 tmp = (NoGo ? " initialization failed." : " initialization completed.");
406 Eroute.Say("------ File system ", myRole, tmp);
407 return NoGo;
408}
#define TRACE_debug
XrdScheduler * ofsSchedP
#define TRACE_MOST
XrdOfsStats OfsStats
Definition XrdOfs.cc:113
#define XRDOSS_HASCACH
Definition XrdOss.hh:479
#define XRDOSS_HASPRXY
Definition XrdOss.hh:477
#define XRDOSS_HASNOSF
Definition XrdOss.hh:478
#define XRDOSS_HASPGRW
Definition XrdOss.hh:475
#define XRDOSS_HASNAIO
Definition XrdOss.hh:480
#define open
Definition XrdPosix.hh:76
static bool Init()
static XrdOfsConfigPI * New(const char *cfn, XrdOucStream *cfgP, XrdSysError *errP, XrdVersionInfo *verP=0, XrdSfsFileSystem *sfsP=0)
@ theOssLib
Oss plugin.
@ allXXXLib
All plugins (Load() only)
@ theCksLib
Checksum manager plugin.
void setRole(const char *theRole)
static void Init()
Definition XrdOfsTPC.cc:414
XrdOfsEvr evrObject
Definition XrdOfs.hh:428
struct fwdOpt fwdMKPATH
Definition XrdOfs.hh:411
void Config_Display(XrdSysError &)
XrdNetIF * myIF
Definition XrdOfs.hh:394
virtual int ConfigXeq(char *var, XrdOucStream &, XrdSysError &)
virtual uint64_t Features()
Definition XrdOss.cc:60
void PutPtr(const char *varname, void *value)
Definition XrdOucEnv.cc:298
void Put(const char *varname, const char *value)
Definition XrdOucEnv.hh:85
virtual void EnvInfo(XrdOucEnv *envP)
uint64_t FeatureSet
Adjust features at initialization.
int Emsg(const char *esfx, int ecode, const char *text1, const char *text2=0)
XrdCmsConfig Config
static const uint64_t hasAUTZ
Feature: Authorization.
static const uint64_t hasPRP2
Feature: Prepare Handler Version 2 (different calling conventions)
static const uint64_t hasCACH
Feature: Implements a data cache.
static const uint64_t hasNOSF
Feature: Supports no sendfile.
static const uint64_t hasNAIO
Feature: Supports no async I/O.
static const uint64_t hasPRXY
Feature: Proxy Server.

References XrdOfsConfigPI::allXXXLib, Authorize, Config_Display(), ConfigFN, ConfigXeq(), dMask, XrdSysError::Emsg(), XrdSfsFileSystem::EnvInfo(), evrObject, XrdOucEnv::Export(), XrdSfsFileSystem::FeatureSet, Finder, fMask, Forwarding, fwdCHMOD, fwdMKDIR, fwdMKPATH, fwdMV, fwdRM, fwdRMDIR, fwdTRUNC, XrdSfs::hasAUTZ, XrdSfs::hasCACH, XrdSfs::hasNAIO, XrdSfs::hasNOSF, XrdSfs::hasPRP2, XrdSfs::hasPRXY, haveRole, XrdOfsConfigCP::Init(), XrdOfsTPC::Init(), isManager, isMeta, isPeer, isProxy, isServer, myIF, XrdOfsConfigPI::New(), ofsSchedP, OfsStats, OfsTrace, open, Options, XrdOucEnv::Put(), XrdOucEnv::PutPtr(), XrdSysError::Say(), XrdOfsConfigPI::theCksLib, XrdOfsConfigPI::theOssLib, ThirdPC, TRACE_debug, TRACE_MOST, XrdOfsFS, XrdOfsOss, XRDOSS_HASCACH, XRDOSS_HASNAIO, XRDOSS_HASNOSF, XRDOSS_HASPGRW, and XRDOSS_HASPRXY.

Here is the call graph for this function:

◆ ConfigXeq()

int XrdOfs::ConfigXeq ( char * var,
XrdOucStream & Config,
XrdSysError & Eroute )
protectedvirtual

Definition at line 801 of file XrdOfsConfig.cc.

803{
804 char *val, vBuff[64];
805
806 // Now assign the appropriate global variable
807 //
808 TS_Bit("authorize", Options, Authorize);
809 TS_XPI("authlib", theAutLib);
810 TS_XPI("ckslib", theCksLib);
811 TS_Xeq("cksrdsz", xcrds);
812 TS_XPI("cmslib", theCmsLib);
813 TS_Xeq("crmode", xcrm);
814 TS_XPI("ctllib", theCtlLib);
815 TS_Xeq("dirlist", xdirl);
816 TS_Xeq("forward", xforward);
817 TS_Xeq("maxdelay", xmaxd);
818 TS_Xeq("notify", xnot);
819 TS_Xeq("notifymsg", xnmsg);
820 TS_XPI("osslib", theOssLib);
821 TS_Xeq("persist", xpers);
822 TS_XPI("preplib", thePrpLib);
823 TS_Xeq("role", xrole);
824 TS_Xeq("tpc", xtpc);
825 TS_Xeq("trace", xtrace);
826 TS_Xeq("xattr", xatr);
827 TS_XPI("xattrlib", theAtrLib);
828
829 // Process miscellaneous directives handled elsemwhere
830 //
831 if (!strcmp("chkpnt", var)) return (XrdOfsConfigCP::Parse(Config) ? 0 : 1);
832
833 // Screen out the subcluster directive (we need to track that)
834 //
835 TS_Bit("subcluster",Options,SubCluster);
836
837 // Get the actual value for simple directives
838 //
839 strlcpy(vBuff, var, sizeof(vBuff)); var = vBuff;
840 if (!(val = Config.GetWord()))
841 {Eroute.Emsg("Config", "value not specified for", var); return 1;}
842
843 // No match found, complain.
844 //
845 Eroute.Say("Config warning: ignoring unknown directive '",var,"'.");
846 Config.Echo();
847 return 0;
848}
#define TS_Bit(x, m, v)
#define TS_Xeq(x, m)
Definition XrdConfig.cc:157
#define TS_XPI(x, m)
size_t strlcpy(char *dst, const char *src, size_t sz)
static bool Parse(XrdOucStream &Config)

References Authorize, XrdSysError::Emsg(), Options, XrdOfsConfigCP::Parse(), XrdSysError::Say(), strlcpy(), SubCluster, TS_Bit, TS_Xeq, and TS_XPI.

Referenced by Configure().

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

◆ Connect()

void XrdOfs::Connect ( const XrdSecEntity * client = 0)
virtual

Notify filesystem that a client has connected.

Parameters
client- Client's identify (see common description).

Reimplemented from XrdSfsFileSystem.

Definition at line 1962 of file XrdOfs.cc.

1963{
1964 XrdOucEnv myEnv(0, 0, client);
1965
1966// Pass this call along
1967//
1968 XrdOfsOss->Connect(myEnv);
1969}
virtual void Connect(XrdOucEnv &env)
Definition XrdOss.cc:42

References XrdOfsOss.

◆ Disc()

void XrdOfs::Disc ( const XrdSecEntity * client = 0)
virtual

Notify filesystem that a client has disconnected.

Parameters
client- Client's identify (see common description).

Reimplemented from XrdSfsFileSystem.

Definition at line 1975 of file XrdOfs.cc.

1976{
1977 XrdOucEnv myEnv(0, 0, client);
1978
1979// Pass this call along
1980//
1981 XrdOfsOss->Disc(myEnv);
1982}
virtual void Disc(XrdOucEnv &env)
Definition XrdOss.cc:48

References XrdOfsOss.

◆ Emsg() [1/2]

int XrdOfs::Emsg ( const char * pfx,
XrdOucErrInfo & einfo,
int ecode,
const char * x,
const char * y = "" )
staticprotected

Definition at line 2542 of file XrdOfs.cc.

2547{
2548 char buffer[MAXPATHLEN+80];
2549
2550// If the error is EBUSY then we just need to stall the client. This is
2551// a hack in order to provide for proxy support
2552//
2553// The hack unfotunately is now beinng triggered for reads and writes when
2554// it was never so before (presumably due to client changes). So do not
2555// apply the hack for these operations. This gets a better fix in R 6.0
2556//
2557if (strcmp("read", op) && strcmp("readv", op) && strcmp("pgRead", op) &&
2558 strcmp("write",op) && strcmp("pgwrite",op)) {
2559 if (ecode < 0) ecode = -ecode;
2560 if (ecode == EBUSY) return 5; // A hack for proxy support
2561
2562// Check for timeout conditions that require a client delay
2563//
2564 if (ecode == ETIMEDOUT) return OSSDelay;
2565 }
2566
2567// Format the error message
2568//
2569 XrdOucERoute::Format(buffer, sizeof(buffer), ecode, op, target);
2570
2571// Print it out if debugging is enabled
2572//
2573#ifndef NODEBUG
2574 OfsEroute.Emsg(pfx, einfo.getErrUser(), buffer);
2575#endif
2576
2577// Place the error message in the error object and return
2578//
2579 einfo.setErrInfo(ecode, buffer);
2580 return SFS_ERROR;
2581}
XrdSysError OfsEroute(0)
static int OSSDelay
Definition XrdOfs.hh:418
static int Format(char *buff, int blen, int ecode, const char *etxt1, const char *etxt2=0)
const char * getErrUser()
int setErrInfo(int code, const char *emsg)

References XrdOucERoute::Format(), XrdOucErrInfo::getErrUser(), OfsEroute, OSSDelay, XrdOucErrInfo::setErrInfo(), and SFS_ERROR.

Here is the call graph for this function:

◆ Emsg() [2/2]

int XrdOfs::Emsg ( const char * pfx,
XrdOucErrInfo & einfo,
int ecode,
const char * x,
XrdOfsHandle * hP )
staticprotected

Definition at line 2514 of file XrdOfs.cc.

2519{
2520 int rc;
2521
2522// First issue the error message so if we have to unpersist it makes sense
2523//
2524 if ((rc = Emsg(pfx, einfo, ecode, op, hP->Name())) != SFS_ERROR) return rc;
2525
2526// If this is a POSC file then we need to unpersist it. Note that we are always
2527// called with the handle **unlocked**
2528//
2529 if (hP->isRW == XrdOfsHandle::opPC)
2530 {hP->Lock();
2531 XrdOfsFS->Unpersist(hP);
2532 hP->UnLock();
2533 }
2534
2535// Now return the error
2536//
2537 return SFS_ERROR;
2538}
static const int opPC
const char * Name()
void Unpersist(XrdOfsHandle *hP, int xcev=1)
Definition XrdOfs.cc:2739

References Emsg(), XrdOfsHandle::isRW, XrdOfsHandle::Lock(), XrdOfsHandle::Name(), XrdOfsHandle::opPC, SFS_ERROR, XrdOfsHandle::UnLock(), and XrdOfsFS.

Referenced by chksum(), Emsg(), FAttr(), and fsctl().

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

◆ exists()

int XrdOfs::exists ( const char * path,
XrdSfsFileExistence & eFlag,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
virtual

Return directory/file existence information (short stat).

Parameters
path- Pointer to the path of the file/directory in question.
eFlag- Where the results are to be returned.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- Path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED When SFS_OK is returned, eFlag must be properly set, as follows: XrdSfsFileExistNo - path does not exist XrdSfsFileExistIsFile - path refers to an online file XrdSfsFileExistIsDirectory - path refers to an online directory XrdSfsFileExistIsOffline - path refers to an offline file XrdSfsFileExistIsOther - path is neither a file nor directory

Implements XrdSfsFileSystem.

Definition at line 1988 of file XrdOfs.cc.

2010{
2011 EPNAME("exists");
2012 struct stat fstat;
2013 int retc;
2014 const char *tident = einfo.getErrUser();
2015 XrdOucEnv stat_Env(info,0,client);
2016 XTRACE(exists, path, "");
2017
2018// Apply security, as needed
2019//
2020 AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
2021
2022// Find out where we should stat this file
2023//
2024 if (Finder && Finder->isRemote()
2025 && (retc = Finder->Locate(einfo, path, SFS_O_RDONLY, &stat_Env)))
2026 return fsError(einfo, retc);
2027
2028// Now try to find the file or directory
2029//
2030 retc = XrdOfsOss->Stat(path, &fstat, 0, &stat_Env);
2031 if (!retc)
2032 { if (S_ISDIR(fstat.st_mode)) file_exists=XrdSfsFileExistIsDirectory;
2033 else if (S_ISREG(fstat.st_mode)) file_exists=XrdSfsFileExistIsFile;
2034 else file_exists=XrdSfsFileExistNo;
2035 return SFS_OK;
2036 }
2037 if (retc == -ENOENT)
2038 {file_exists=XrdSfsFileExistNo;
2039 return SFS_OK;
2040 }
2041
2042// An error occurred, return the error info
2043//
2044 return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
2045}
#define fstat(a, b)
Definition XrdPosix.hh:62
@ XrdSfsFileExistIsFile
@ XrdSfsFileExistNo
@ XrdSfsFileExistIsDirectory
int exists(const char *fileName, XrdSfsFileExistence &exists_flag, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
Definition XrdOfs.cc:1988

References AOP_Stat, AUTHORIZE, EPNAME, exists(), Finder, fsError(), fstat, XrdOucErrInfo::getErrUser(), SFS_O_RDONLY, SFS_OK, stat(), tident, XrdOfsFS, XrdOfsOss, XrdSfsFileExistIsDirectory, XrdSfsFileExistIsFile, XrdSfsFileExistNo, and XTRACE.

Referenced by exists(), and rename().

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

◆ FAttr()

int XrdOfs::FAttr ( XrdSfsFACtl * faReq,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client = 0 )
virtual

Perform a filesystem extended attribute function.

Parameters
faReq- pointer to the request object (see XrdSfsFAttr.hh). If the pointer is nill, simply return whether or not extended attributes are supported.
eInfo- The object where error info or results are to be returned.
client- Client's identify (see common description).
Returns
SFS_OK a null response is sent.
SFS_DATA error.code length of the data to be sent. error.message contains the data to be sent.
SFS_STARTED Operation started result will be returned via callback. o/w one of SFS_ERROR, SFS_REDIRECT, or SFS_STALL.

Reimplemented from XrdSfsFileSystem.

Definition at line 195 of file XrdOfsFAttr.cc.

198{
199 EPNAME("FAttr");
200 const char *tident = einfo.getErrUser();
201 char pfnbuff[MAXPATHLEN+8];
202 const char *accType;
203 long long xOpts;
204
205 struct faArgs {const char *name; int fArg; Access_Operation aop;};
206
207 static faArgs faTab[] = {{ "del fattr", SFS_O_RDWR, AOP_Update}, // del
208 { "get fattr", 0, AOP_Read}, // get
209 {"list fattr", 0, AOP_Read}, // list
210 { "set fattr", SFS_O_RDWR, AOP_Update} // set
211 };
212 static const int faNum = sizeof(faTab)/sizeof(struct faArgs);
213
214 int rc;
215
216// Check if we need only return support information
217//
218 if (!faReq)
219 {XrdOucEnv *envP = einfo.getEnv();
220 ZTRACE(fsctl, "FAttr req=info");
221 if (!envP || !usxMaxNsz)
222 {einfo.setErrInfo(ENOTSUP, "Not supported.");
223 return SFS_ERROR;
224 }
225 envP->PutInt("usxMaxNsz", usxMaxNsz);
226 envP->PutInt("usxMaxVsz", usxMaxVsz);
227 return SFS_OK;
228 }
229
230// Setup for to perform attribute functions
231//
232 XrdSfsFACtl &faCtl = *faReq;
233 XrdOucEnv FAttr_Env(faCtl.pcgi,0,client);
234
235// Make sure request code is valid (we also set some options)
236//
237 if (faCtl.rqst > faNum)
238 return Emsg(epname, einfo, EINVAL, "process fattrs", faCtl.path);
239 accType = faTab[faCtl.rqst].name;
240
241// Trace this call
242//
243 ZTRACE(fsctl, "FAttr " <<accType <<' ' <<faCtl.path);
244
245// Extract the export options if we can
246//
247 xOpts = (ossRPList ? ossRPList->Find(faCtl.path) : 0);
248
249// Perform authrorization and redirection if required
250//
251 if (faCtl.opts & XrdSfsFACtl::accChk)
252 {int luFlag = faTab[faCtl.rqst].fArg;
253 Access_Operation aOP = faTab[faCtl.rqst].aop;
254
255 AUTHORIZE(client, 0, aOP, accType ,faCtl.path, einfo);
256
257 if (Finder && Finder->isRemote()
258 && (rc = Finder->Locate(einfo, faCtl.path, luFlag, &FAttr_Env)))
259 return fsError(einfo, rc);
260
261 if (aOP == AOP_Update && xOpts & XRDEXP_NOTRW)
262 return Emsg(epname, einfo, EROFS, accType, faCtl.path);
263 }
264
265// If this is a proxy server then hand this request to the storage system
266// as it will need to be executed elsewhere.
267//
268 if (OssIsProxy)
269 {faCtl.envP = &FAttr_Env;
270 rc = XrdOfsOss->FSctl(XRDOSS_FSCTLFA, 0, (const char *)&faCtl);
271 if (rc) return XrdOfsFS->Emsg(epname, einfo, rc, accType, faCtl.path);
272 return SFS_OK;
273 }
274
275// Make sure we can use xattrs on the path
276//
277 if (xOpts & XRDEXP_NOXATTR)
278 return XrdOfsFS->Emsg(epname, einfo, EPERM, accType, faCtl.path);
279
280// Convert the lfn to a pfn for actual calls to the attribute processor
281//
282 faCtl.pfnP = XrdOfsOss->Lfn2Pfn(faCtl.path, pfnbuff, sizeof(pfnbuff), rc);
283 if (!faCtl.pfnP) return XrdOfsFS->Emsg(epname,einfo,rc,accType,faCtl.path);
284
285// Fan out for processing this on the local file system
286//
287 switch(faCtl.rqst)
288 {case XrdSfsFACtl::faDel:
289 return ctlFADel(faCtl, FAttr_Env, einfo);
290 break;
292 return ctlFAGet(faCtl, FAttr_Env, einfo);
293 break;
295 return ctlFALst(faCtl, FAttr_Env, einfo);
296 break;
298 return ctlFASet(faCtl, FAttr_Env, einfo);
299 break;
300 default: break;
301 }
302
303// The request code is not one we understand
304//
305 return XrdOfsFS->Emsg(epname, einfo, EINVAL, "process fattrs", faCtl.path);
306}
Access_Operation
The following are supported operations.
@ AOP_Update
open() r/w or append
@ AOP_Read
open() r/o, prepare()
#define ZTRACE(act, x)
#define XRDOSS_FSCTLFA
Definition XrdOss.hh:492
#define XRDEXP_NOTRW
#define XRDEXP_NOXATTR
int fsctl(const int cmd, const char *args, XrdOucErrInfo &out_error, const XrdSecEntity *client=0)
virtual int FSctl(int cmd, int alen, const char *args, char **resp=0)
Definition XrdOss.cc:66
void PutInt(const char *varname, long value)
Definition XrdOucEnv.cc:250
XrdOucEnv * envP
Definition XrdPss.cc:109
const char * path
The file path to act on (logical)
unsigned char rqst
Type of file attribute request (see below)
const char * pcgi
Opaque information (null if none)
static const int accChk
Perform access check.
XrdOucEnv * envP
Optional environmental information.
unsigned char opts
Request options (see below)

References XrdSfsFACtl::accChk, AOP_Read, AOP_Update, AUTHORIZE, Emsg(), XrdSfsFACtl::envP, EPNAME, XrdSfsFACtl::faDel, XrdSfsFACtl::faGet, XrdSfsFACtl::faLst, XrdSfsFACtl::faSet, Finder, fsctl(), fsError(), XrdOucErrInfo::getEnv(), XrdOucErrInfo::getErrUser(), XrdSfsFACtl::opts, XrdSfsFACtl::path, XrdSfsFACtl::pcgi, XrdSfsFACtl::pfnP, XrdOucEnv::PutInt(), XrdSfsFACtl::rqst, XrdOucErrInfo::setErrInfo(), SFS_ERROR, SFS_O_RDWR, SFS_OK, tident, XRDEXP_NOTRW, XRDEXP_NOXATTR, XrdOfsFS, XrdOfsOss, XRDOSS_FSCTLFA, and ZTRACE.

Here is the call graph for this function:

◆ FSctl()

int XrdOfs::FSctl ( const int cmd,
XrdSfsFSctl & args,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client = 0 )
virtual

Perform a filesystem control operation (version 2)

Parameters
cmd- The operation to be performed: SFS_FSCTL_PLUGIN Return Implementation Dependent Data v1 SFS_FSCTL_PLUGIO Return Implementation Dependent Data v2
args- Arguments specific to cmd. SFS_FSCTL_PLUGIN path and opaque information. SFS_FSCTL_PLUGIO Unscreened argument string.
eInfo- The object where error info or results are to be returned.
client- Client's identify (see common description).
Returns
SFS_OK a null response is sent. SFS_DATA error.code length of the data to be sent. error.message contains the data to be sent. o/w one of SFS_ERROR, SFS_REDIRECT, or SFS_STALL.

Reimplemented from XrdSfsFileSystem.

Definition at line 263 of file XrdOfsFSctl.cc.

267{
268 EPNAME("FSctl");
269
270// If this is the cache-specfic we need to do a lot more work. Otherwise this
271// is a simple case of wheter we have a plug-in for this or not.
272//
273 if (cmd == SFS_FSCTL_PLUGXC)
274 {if (FSctl_PC)
275 {if (args.Arg2Len == -2)
276 {XrdOucEnv pc_Env(args.ArgP[1] ? args.ArgP[1] : 0, 0, client);
277 AUTHORIZE(client,&pc_Env,AOP_Read,"FSctl",args.ArgP[0],eInfo);
278 }
279 return FSctl_PC->FSctl(cmd, args, eInfo, client);
280 }
281 }
282 else if (FSctl_PI) return FSctl_PI->FSctl(cmd, args, eInfo, client);
283
284// Operation is not supported
285//
286 return XrdOfsFS->Emsg("FSctl", eInfo, ENOTSUP, "FSctl", "");
287}
int Arg2Len
Length or -count of args in extension.
#define SFS_FSCTL_PLUGXC

References AOP_Read, XrdSfsFSctl::Arg2Len, AUTHORIZE, EPNAME, SFS_FSCTL_PLUGXC, and XrdOfsFS.

◆ fsctl()

int XrdOfs::fsctl ( const int cmd,
const char * args,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client = 0 )
virtual

Perform a filesystem control operation (version 1)

Parameters
cmd- The operation to be performed: SFS_FSCTL_LOCATE Locate a file or file servers SFS_FSCTL_STATCC Return cluster config status SFS_FSCTL_STATFS Return physical filesystem information SFS_FSCTL_STATLS Return logical filesystem information SFS_FSCTL_STATXA Return extended attributes
args- Arguments specific to cmd. SFS_FSCTL_LOCATE args points to the path to be located "" path is the first exported path "*" return all current servers "*&zwj;/" return servers exporting path o/w return servers having the path SFS_FSCTL_STATFS Path in the filesystem in question. SFS_FSCTL_STATLS Path in the filesystem in question. SFS_FSCTL_STATXA Path of the file whose xattr is wanted.
eInfo- The object where error info or results are to be returned.
client- Client's identify (see common description).
Returns
SFS_OK a null response is sent.
SFS_DATA error.code length of the data to be sent. error.message contains the data to be sent.
SFS_STARTED Operation started result will be returned via callback. Valid only for for SFS_FSCTL_LOCATE, SFS_FSCTL_STATFS, and SFS_FSCTL_STATXA o/w one of SFS_ERROR, SFS_REDIRECT, or SFS_STALL.

Implements XrdSfsFileSystem.

Definition at line 93 of file XrdOfsFSctl.cc.

114{
115 EPNAME("fsctl");
116 static int PrivTab[] = {XrdAccPriv_Delete, XrdAccPriv_Insert,
120 static char PrivLet[] = {'d', 'i',
121 'k', 'l',
122 'n', 'r',
123 'w'};
124 static const int PrivNum = sizeof(PrivLet);
125
126 int retc, i, blen, privs, opcode = cmd & SFS_FSCTL_CMD;
127 const char *tident = einfo.getErrUser();
128 char *bP, *cP;
129
130// Process the LOCATE request
131//
132 if (opcode == SFS_FSCTL_LOCATE)
133 {static const int locMask = (SFS_O_FORCE|SFS_O_NOWAIT|SFS_O_RESET|
135 struct stat fstat;
136 char pbuff[1024], rType[3];
137 const char *Resp[2] = {rType, pbuff};
138 const char *locArg, *opq, *Path = Split(args,&opq,pbuff,sizeof(pbuff));
139 XrdNetIF::ifType ifType;
140 int Resp1Len;
141 int find_flag = SFS_O_LOCATE | (cmd & locMask);
142 XrdOucEnv loc_Env(opq ? opq+1 : 0,0,client);
143
144 ZTRACE(fsctl, "locate args=" <<(args ? args : "''"));
145
146 if (cmd & SFS_O_TRUNC) locArg = (char *)"*";
147 else { if (*Path == '*') {locArg = Path; Path++;}
148 else locArg = Path;
149 AUTHORIZE(client,&loc_Env,AOP_Stat,"locate",Path,einfo);
150 }
151 if (Finder && Finder->isRemote()
152 && (retc = Finder->Locate(einfo, locArg, find_flag, &loc_Env)))
153 return fsError(einfo, retc);
154
155 if (cmd & SFS_O_TRUNC) {rType[0] = 'S'; rType[1] = ossRW;}
156 else {if ((retc = XrdOfsOss->Stat(Path, &fstat, 0, &loc_Env)))
157 return XrdOfsFS->Emsg(epname, einfo, retc, "locate", Path);
158 rType[0] = ((fstat.st_mode & S_IFBLK) == S_IFBLK ? 's' : 'S');
159 rType[1] = (fstat.st_mode & S_IWUSR ? 'w' : 'r');
160 }
161 rType[2] = '\0';
162
163 ifType = XrdNetIF::GetIFType((einfo.getUCap() & XrdOucEI::uIPv4) != 0,
164 (einfo.getUCap() & XrdOucEI::uIPv64) != 0,
165 (einfo.getUCap() & XrdOucEI::uPrip) != 0);
166 bool retHN = (cmd & SFS_O_HNAME) != 0;
167 if ((Resp1Len = myIF->GetDest(pbuff, sizeof(pbuff), ifType, retHN)))
168 {einfo.setErrInfo(Resp1Len+3, (const char **)Resp, 2);
169 return SFS_DATA;
170 }
171 return Emsg(epname, einfo, ENETUNREACH, "locate", Path);
172 }
173
174// Process the STATFS request
175//
176 if (opcode == SFS_FSCTL_STATFS)
177 {char pbuff[1024];
178 const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
179 XrdOucEnv fs_Env(opq ? opq+1 : 0,0,client);
180 ZTRACE(fsctl, "statfs args=" <<(args ? args : "''"));
181 AUTHORIZE(client,&fs_Env,AOP_Stat,"statfs",Path,einfo);
182 if (Finder && Finder->isRemote()
183 && (retc = Finder->Space(einfo, Path, &fs_Env)))
184 return fsError(einfo, retc);
185 bP = einfo.getMsgBuff(blen);
186 if ((retc = XrdOfsOss->StatFS(Path, bP, blen, &fs_Env)))
187 return XrdOfsFS->Emsg(epname, einfo, retc, "statfs", args);
188 einfo.setErrCode(blen+1);
189 return SFS_DATA;
190 }
191
192// Process the STATLS request
193//
194 if (opcode == SFS_FSCTL_STATLS)
195 {char pbuff[1024];
196 const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
197 XrdOucEnv statls_Env(opq ? opq+1 : 0,0,client);
198 ZTRACE(fsctl, "statls args=" <<(args ? args : "''"));
199 AUTHORIZE(client,&statls_Env,AOP_Stat,"statfs",Path,einfo);
200 if (Finder && Finder->isRemote())
201 {statls_Env.Put("cms.qvfs", "1");
202 if ((retc = Finder->Space(einfo, Path, &statls_Env)))
203 {if (retc == SFS_DATA) retc = Reformat(einfo);
204 return fsError(einfo, retc);
205 }
206 }
207 bP = einfo.getMsgBuff(blen);
208 if ((retc = XrdOfsOss->StatLS(statls_Env, Path, bP, blen)))
209 return XrdOfsFS->Emsg(epname, einfo, retc, "statls", Path);
210 einfo.setErrCode(blen+1);
211 return SFS_DATA;
212 }
213
214// Process the STATXA request
215//
216 if (opcode == SFS_FSCTL_STATXA)
217 {char pbuff[1024];
218 const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
219 XrdOucEnv xa_Env(opq ? opq+1 : 0,0,client);
220 ZTRACE(fsctl, "statxa args=" <<(args ? args : "''"));
221 AUTHORIZE(client,&xa_Env,AOP_Stat,"statxa",Path,einfo);
222 if (Finder && Finder->isRemote()
223 && (retc = Finder->Locate(einfo,Path,SFS_O_RDONLY|SFS_O_STAT,&xa_Env)))
224 return fsError(einfo, retc);
225 bP = einfo.getMsgBuff(blen);
226 if ((retc = XrdOfsOss->StatXA(Path, bP, blen, &xa_Env)))
227 return XrdOfsFS->Emsg(epname, einfo, retc, "statxa", Path);
228 if (!client || !XrdOfsFS->Authorization) privs = XrdAccPriv_All;
229 else privs = XrdOfsFS->Authorization->Access(client, Path, AOP_Any);
230 cP = bP + blen; strcpy(cP, "&ofs.ap="); cP += 8;
231 if (privs == XrdAccPriv_All) *cP++ = 'a';
232 else {for (i = 0; i < PrivNum; i++)
233 if (PrivTab[i] & privs) *cP++ = PrivLet[i];
234 if (cP == (bP + blen + 1)) *cP++ = '?';
235 }
236 *cP++ = '\0';
237 einfo.setErrCode(cP-bP+1);
238 return SFS_DATA;
239 }
240
241// Process the STATCC request (this should always succeed)
242//
243 if (opcode == SFS_FSCTL_STATCC)
244 {static const int lcc_flag = SFS_O_LOCATE | SFS_O_LOCAL;
245 XrdOucEnv lcc_Env(0,0,client);
246 ZTRACE(fsctl, "statcc args=" <<(args ? args : "''"));
247 if (Finder) retc = Finder ->Locate(einfo,".",lcc_flag,&lcc_Env);
248 else if (Balancer) retc = Balancer->Locate(einfo,".",lcc_flag,&lcc_Env);
249 else retc = SFS_ERROR;
250 if (retc != SFS_DATA) einfo.setErrInfo(5, "none|");
251 return fsError(einfo, SFS_DATA);
252 }
253
254// Operation is not supported
255//
256 return XrdOfsFS->Emsg(epname, einfo, ENOTSUP, "fsctl", args);
257}
@ AOP_Any
Special for getting privs.
@ XrdAccPriv_Insert
@ XrdAccPriv_Lookup
@ XrdAccPriv_Rename
@ XrdAccPriv_All
@ XrdAccPriv_Read
@ XrdAccPriv_Lock
@ XrdAccPriv_Write
@ XrdAccPriv_Delete
#define SFS_O_HNAME
#define SFS_DATA
#define SFS_O_RESET
#define SFS_O_DIRLIST
#define SFS_FSCTL_STATFS
#define SFS_O_STAT
#define SFS_O_FORCE
#define SFS_FSCTL_CMD
#define SFS_FSCTL_STATLS
#define SFS_FSCTL_STATCC
#define SFS_O_LOCATE
#define SFS_FSCTL_STATXA
#define SFS_FSCTL_LOCATE
#define SFS_O_RAWIO
#define SFS_O_LOCAL
#define SFS_O_NOWAIT
#define SFS_O_TRUNC
virtual XrdAccPrivs Access(const XrdSecEntity *Entity, const char *path, const Access_Operation oper, XrdOucEnv *Env=0)=0
static ifType GetIFType(bool conIPv4, bool hasIP64, bool pvtIP)
Definition XrdNetIF.hh:204
ifType
The enum that is used to index into ifData to get appropriate interface.
Definition XrdNetIF.hh:64
const char * Split(const char *Args, const char **Opq, char *Path, int Plen)
Definition XrdOfs.cc:2686
virtual int StatLS(XrdOucEnv &env, const char *path, char *buff, int &blen)
Definition XrdOss.cc:97
virtual int StatXA(const char *path, char *buff, int &blen, XrdOucEnv *envP=0)
Definition XrdOss.cc:127
virtual int StatFS(const char *path, char *buff, int &blen, XrdOucEnv *envP=0)
Definition XrdOss.cc:87
static const int uIPv64
ucap: Supports only IPv4 info
static const int uIPv4
ucap: Supports read redirects
static const int uPrip

References AOP_Any, AOP_Stat, AUTHORIZE, Emsg(), EPNAME, Finder, fsctl(), fsError(), fstat, XrdOucErrInfo::getErrUser(), XrdNetIF::GetIFType(), XrdOucErrInfo::getMsgBuff(), XrdOucErrInfo::getUCap(), myIF, Path, XrdOucEnv::Put(), XrdOucErrInfo::setErrCode(), XrdOucErrInfo::setErrInfo(), SFS_DATA, SFS_ERROR, SFS_FSCTL_CMD, SFS_FSCTL_LOCATE, SFS_FSCTL_STATCC, SFS_FSCTL_STATFS, SFS_FSCTL_STATLS, SFS_FSCTL_STATXA, SFS_O_DIRLIST, SFS_O_FORCE, SFS_O_HNAME, SFS_O_LOCAL, SFS_O_LOCATE, SFS_O_NOWAIT, SFS_O_RAWIO, SFS_O_RDONLY, SFS_O_RESET, SFS_O_STAT, SFS_O_TRUNC, Split(), stat(), tident, XrdOucEI::uIPv4, XrdOucEI::uIPv64, XrdOucEI::uPrip, XrdAccPriv_All, XrdAccPriv_Delete, XrdAccPriv_Insert, XrdAccPriv_Lock, XrdAccPriv_Lookup, XrdAccPriv_Read, XrdAccPriv_Rename, XrdAccPriv_Write, XrdOfsFS, XrdOfsOss, and ZTRACE.

Referenced by FAttr(), and fsctl().

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

◆ fsError()

int XrdOfs::fsError ( XrdOucErrInfo & myError,
int rc )
staticprotected

Definition at line 2629 of file XrdOfs.cc.

2630{
2631
2632// Screen the error code (update statistics w/o a lock for speed!)
2633//
2634 if (rc == SFS_REDIRECT) {OfsStats.Data.numRedirect++; return SFS_REDIRECT;}
2635 if (rc == SFS_STARTED) {OfsStats.Data.numStarted++; return SFS_STARTED; }
2636 if (rc > 0) {OfsStats.Data.numDelays++; return rc; }
2637 if (rc == SFS_DATA) {OfsStats.Data.numReplies++; return SFS_DATA; }
2638 {OfsStats.Data.numErrors++; return SFS_ERROR; }
2639}
#define SFS_REDIRECT
#define SFS_STARTED
struct XrdOfsStats::StatsData Data

References OfsStats, SFS_DATA, SFS_ERROR, SFS_REDIRECT, and SFS_STARTED.

Referenced by chksum(), chmod(), exists(), FAttr(), fsctl(), mkdir(), prepare(), rename(), stat(), stat(), and truncate().

Here is the caller graph for this function:

◆ getStats()

int XrdOfs::getStats ( char * buff,
int blen )
virtual

Return statistical information.

Parameters
buff- Pointer to the buffer where results are to be returned. Statistics should be in standard XML format. If buff is nil then only maximum size information is wanted.
blen- The length available in buff.
Returns
Number of bytes placed in buff. When buff is nil, the maximum number of bytes that could have been placed in buff.

Implements XrdSfsFileSystem.

Definition at line 2051 of file XrdOfs.cc.

2052{
2053 int n;
2054
2055// See if the size just wanted
2056//
2057 if (!buff) return OfsStats.Report(0,0) + XrdOfsOss->Stats(0,0);
2058
2059// Report ofs info followed by the oss info
2060//
2061 n = OfsStats.Report(buff, blen);
2062 buff += n; blen -= n;
2063 n += XrdOfsOss->Stats(buff, blen);
2064
2065// All done
2066//
2067 return n;
2068}
int Report(char *Buff, int Blen)
virtual int Stats(char *buff, int blen)
Definition XrdOss.hh:707

References OfsStats, and XrdOfsOss.

◆ getVersion()

const char * XrdOfs::getVersion ( )
virtual

Get version string.

Returns
The version string. Normally this is the XrdVERSION value.

Implements XrdSfsFileSystem.

Definition at line 134 of file XrdOfsConfig.cc.

134{return XrdVERSION;}

◆ mkdir()

int XrdOfs::mkdir ( const char * path,
XrdSfsMode mode,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
virtual

Create a directory.

Parameters
path- Pointer to the path of the directory to be created.
mode- The directory mode setting.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- Path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 2074 of file XrdOfs.cc.

2092{
2093 EPNAME("mkdir");
2094 static const int LocOpts = SFS_O_RDWR | SFS_O_CREAT | SFS_O_META;
2095 mode_t acc_mode = (Mode | dMask[0]) & dMask[1];
2096 int retc, mkpath = Mode & SFS_O_MKPTH;
2097 const char *tident = einfo.getErrUser();
2098 XrdOucEnv mkdir_Env(info,0,client);
2099 XTRACE(mkdir, path, "");
2100
2101// Apply security, as needed
2102//
2103 AUTHORIZE(client,&mkdir_Env,AOP_Mkdir,"mkdir",path,einfo);
2104
2105// Find out where we should remove this file
2106//
2107 if (Finder && Finder->isRemote())
2108 {if (fwdMKDIR.Cmd)
2109 {char buff[8];
2110 sprintf(buff, "%o", static_cast<int>(acc_mode));
2111 if (Forward(retc, einfo, (mkpath ? fwdMKPATH:fwdMKDIR),
2112 path, buff, &mkdir_Env)) return retc;
2113 }
2114 else if ((retc = Finder->Locate(einfo,path,LocOpts,&mkdir_Env)))
2115 return fsError(einfo, retc);
2116 }
2117
2118// Perform the actual operation
2119//
2120 if ((retc = XrdOfsOss->Mkdir(path, acc_mode, mkpath, &mkdir_Env)))
2121 return XrdOfsFS->Emsg(epname, einfo, retc, "mkdir", path);
2122
2123// Check if we should generate an event
2124//
2125 if (evsObject && evsObject->Enabled(XrdOfsEvs::Mkdir))
2126 {XrdOfsEvsInfo evInfo(tident, path, info, &mkdir_Env, acc_mode);
2127 evsObject->Notify(XrdOfsEvs::Mkdir, evInfo);
2128 }
2129
2130// If we have a redirector, tell it that we now have this path
2131//
2132 if (Balancer)
2133 {if (!mkpath) Balancer->Added(path);
2134 else {char *slash, *myPath = strdup(path);
2135 do {Balancer->Added(myPath);
2136 if ((slash = rindex(myPath, '/'))) *slash = 0;
2137 } while(slash && slash != myPath);
2138 free(myPath);
2139 }
2140 }
2141
2142 return SFS_OK;
2143}
@ AOP_Mkdir
mkdir()
#define SFS_O_MKPTH
#define SFS_O_CREAT
int mkdir(const char *dirName, XrdSfsMode Mode, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *opaque=0)
Definition XrdOfs.cc:2074
virtual int Mkdir(const char *path, mode_t mode, int mkpath=0, XrdOucEnv *envP=0)=0

References AOP_Mkdir, AUTHORIZE, dMask, EPNAME, Finder, fsError(), fwdMKDIR, fwdMKPATH, XrdOucErrInfo::getErrUser(), XrdOfsEvs::Mkdir, mkdir(), Mode, SFS_O_CREAT, SFS_O_META, SFS_O_MKPTH, SFS_O_RDWR, SFS_OK, tident, XrdOfsFS, XrdOfsOss, and XTRACE.

Referenced by mkdir().

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

◆ newDir() [1/2]

XrdSfsDirectory * XrdOfs::newDir ( char * user = 0,
int MonID = 0 )
inlinevirtual

Obtain a new director object to be used for future directory requests.

Parameters
user- Text identifying the client responsible for this call. The pointer may be null if identification is missing.
MonID- The monitoring identifier assigned to this and all future requests using the returned object.
Returns
pointer- Pointer to an XrdSfsDirectory object.
nil - Insufficient memory to allocate an object.

Implements XrdSfsFileSystem.

Definition at line 244 of file XrdOfs.hh.

245 {return new XrdOfsDirFull(user, MonID);}

◆ newDir() [2/2]

XrdSfsDirectory * XrdOfs::newDir ( XrdOucErrInfo & eInfo)
inlinevirtual

Obtain a new wrapped directory object to be used for future requests.

Parameters
eInfo- Reference to the error object to be used by the new directory object. Note that an implementation is supplied for compatibility purposes but it returns a nil pointer which is considered to be a failure. You must supply an implementation for this to work correctly.
Returns
pointer- Pointer to an XrdSfsDirectory object.
nil - Insufficient memory to allocate an object.

Reimplemented from XrdSfsFileSystem.

Definition at line 247 of file XrdOfs.hh.

248 {return new XrdOfsDirectory(eInfo, eInfo.getErrUser());}
friend class XrdOfsDirectory
Definition XrdOfs.hh:237

References XrdOucErrInfo::getErrUser(), and XrdOfsDirectory.

Here is the call graph for this function:

◆ newFile() [1/2]

XrdSfsFile * XrdOfs::newFile ( char * user = 0,
int MonID = 0 )
inlinevirtual

Obtain a new file object to be used for a future file requests.

Parameters
user- Text identifying the client responsible for this call. The pointer may be null if identification is missing.
MonID- The monitoring identifier assigned to this and all future requests using the returned object.
Returns
pointer- Pointer to an XrdSfsFile object.
nil - Insufficient memory to allocate an object.

Implements XrdSfsFileSystem.

Definition at line 250 of file XrdOfs.hh.

251 {return new XrdOfsFileFull(user, MonID);}

◆ newFile() [2/2]

XrdSfsFile * XrdOfs::newFile ( XrdOucErrInfo & eInfo)
inlinevirtual

Obtain a new wrapped file object to be used for a future requests.

Parameters
eInfo- Reference to the error object to be used by the new file object. Note that an implementation is supplied for compatibility purposes but it returns a nil pointer which is considered to be a failure. You must supply an implementation for this to work correctly.
Returns
pointer- Pointer to an XrdSfsFile object.
nil - Insufficient memory to allocate an object.

Reimplemented from XrdSfsFileSystem.

Definition at line 253 of file XrdOfs.hh.

254 {return new XrdOfsFile(eInfo, eInfo.getErrUser());}
friend class XrdOfsFile
Definition XrdOfs.hh:238

References XrdOucErrInfo::getErrUser(), and XrdOfsFile.

Here is the call graph for this function:

◆ prepare()

int XrdOfs::prepare ( XrdSfsPrep & pargs,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client = 0 )
virtual

Prepare a file for future processing.

Parameters
pargs- The preapre arguments.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 2149 of file XrdOfs.cc.

2152{
2153 EPNAME("prepare");
2154 XrdOucEnv prep_Env(0,0,client);
2155 XrdOucTList *tp = pargs.paths;
2156 int retc;
2157
2158// Run through the paths to make sure client can read each one unless we aren't
2159// supposed to apply authorization.
2160//
2161 if (prepAuth)
2162 while(tp)
2163 {AUTHORIZE(client,0,AOP_Read,"prepare",tp->text,out_error);
2164 tp = tp->next;
2165 }
2166
2167// If there is a prepare plugin, invoke it and return the result.
2168//
2169 if (prepHandler)
2170 {if (pargs.opts & Prep_QUERY)
2171 return prepHandler->query(pargs, out_error, client);
2172 if (pargs.opts & Prep_CANCEL)
2173 return prepHandler->cancel(pargs, out_error, client);
2174
2175 return prepHandler->begin(pargs, out_error, client);
2176 }
2177
2178// If we have a finder object, use it to prepare the paths. Otherwise,
2179// ignore this prepare request (we may change this in the future).
2180//
2181 if (XrdOfsFS->Finder
2182 && (retc = XrdOfsFS->Finder->Prepare(out_error, pargs, &prep_Env)))
2183 return fsError(out_error, retc);
2184 return 0;
2185}
#define Prep_CANCEL
#define Prep_QUERY
XrdOucTList * paths
List of paths.
int opts
Prep_xxx.
virtual int Prepare(XrdOucErrInfo &Resp, XrdSfsPrep &pargs, XrdOucEnv *Info=0)
XrdOucTList * next

References AOP_Read, AUTHORIZE, EPNAME, fsError(), XrdOucTList::next, XrdSfsPrep::opts, XrdSfsPrep::paths, Prep_CANCEL, Prep_QUERY, XrdOucTList::text, and XrdOfsFS.

Here is the call graph for this function:

◆ rem()

int XrdOfs::rem ( const char * path,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
inlinevirtual

Remove a file.

Parameters
path- Pointer to the path of the file to be removed.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- Path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 309 of file XrdOfs.hh.

313 {return remove('f', path, out_error, client, info);}

◆ remdir()

int XrdOfs::remdir ( const char * path,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
inlinevirtual

Remove a directory.

Parameters
path- Pointer to the path of the directory to be removed.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- Path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 315 of file XrdOfs.hh.

319 {return remove('d',dirName,out_error,client,info);}

◆ rename()

int XrdOfs::rename ( const char * oPath,
const char * nPath,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaqueO = 0,
const char * opaqueN = 0 )
virtual

Rename a file or directory.

Parameters
oPath- Pointer to the path to be renamed.
nPath- Pointer to the path oPath is to have.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaqueO- oPath's CGI information (see common description).
opaqueN- nPath's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 2257 of file XrdOfs.cc.

2275{
2276 EPNAME("rename");
2277 static const int LocOpts = SFS_O_RDWR|SFS_O_META;
2278 int retc;
2279 const char *tident = einfo.getErrUser();
2280 XrdOucEnv old_Env(infoO,0,client);
2281 XrdOucEnv new_Env(infoN,0,client);
2282 XTRACE(rename, new_name, "old fn=" <<old_name <<" new ");
2283
2284// Apply security, as needed
2285//
2286 AUTHORIZE(client, &old_Env, AOP_Rename, "renaming", old_name, einfo);
2287
2288// The above authorization may mutate the XrdSecEntity by putting a mapped name
2289// into the extended attributes. This mapped name will affect the subsequent
2290// authorization check below, giving the client access that may not be permitted.
2291// Hence, we delete this attribute to reset the object back to "pristine" state.
2292// If there was a way to make a copy of the XrdSecEntity, we could avoid this
2293// hack-y reach inside the extended attributes.
2294 if (client) client->eaAPI->Add("request.name", "", true);
2295
2296// If we do not have full-blown insert authorization, we'll need to test for
2297// destination existence
2298 bool cannot_overwrite = false;
2299 if (client && XrdOfsFS->Authorization &&
2300 !XrdOfsFS->Authorization->Access(client, new_name, AOP_Insert, &new_Env))
2301 {cannot_overwrite = true;
2302 AUTHORIZE(client, &new_Env, AOP_Excl_Insert,
2303 "rename to existing file (overwrite disallowed)", new_name, einfo);
2304 }
2305
2306// Find out where we should rename this file
2307//
2308 if (Finder && Finder->isRemote())
2309 {if (fwdMV.Cmd)
2310 {if (Forward(retc,einfo,fwdMV,old_name,new_name,&old_Env,&new_Env))
2311 return retc;
2312 }
2313 else if ((retc = Finder->Locate(einfo, old_name, LocOpts, &old_Env)))
2314 return fsError(einfo, retc);
2315 }
2316
2317// Check if we should generate an event
2318//
2319 if (evsObject && evsObject->Enabled(XrdOfsEvs::Mv))
2320 {XrdOfsEvsInfo evInfo(tident, old_name, infoO, &old_Env, 0, 0,
2321 new_name, infoN, &new_Env);
2322 evsObject->Notify(XrdOfsEvs::Mv, evInfo);
2323 }
2324
2325// If we cannot overwrite, we must test for existence first. This will test whether
2326// we will destroy data in the rename (without actually destroying data).
2327// Note there's an obvious race condition here; it was seen as the lesser-of-evils
2328// compared to creating an exclusive file and potentially leaking it in the event
2329// of a crash.
2330//
2331 if (cannot_overwrite)
2332 {XrdSfsFileExistence exists_flag;
2333 if (SFS_OK != exists(new_name, exists_flag, einfo, client, infoN))
2334 {// File existence check itself failed; we can't prove that data won't
2335 // be overwritten so we return an error.
2336 return fsError(einfo, -einfo.getErrInfo());
2337 }
2338 if (exists_flag != XrdSfsFileExistNo)
2339 {// EPERM mimics the error code set by Linux when you invoke rename()
2340 // but cannot overwrite the destination file.
2341 einfo.setErrInfo(EPERM, "Overwrite of existing data not permitted");
2342 return fsError(einfo, -EPERM);
2343 }
2344 }
2345
2346// Perform actual rename operation
2347//
2348 if ((retc = XrdOfsOss->Rename(old_name, new_name, &old_Env, &new_Env)))
2349 {return XrdOfsFS->Emsg(epname, einfo, retc, "rename", old_name);
2350 }
2351 XrdOfsHandle::Hide(old_name);
2352 if (Balancer) {Balancer->Removed(old_name);
2353 Balancer->Added(new_name);
2354 }
2355 return SFS_OK;
2356}
@ AOP_Rename
mv() for source
@ AOP_Insert
mv() for target
@ AOP_Excl_Insert
mv() where destination doesn't exist.
XrdSfsFileExistence
static void Hide(const char *thePath)
int rename(const char *oldFileName, const char *newFileName, XrdOucErrInfo &out_error, const XrdSecEntity *client, const char *infoO=0, const char *infoN=0)
Definition XrdOfs.cc:2257
virtual int Rename(const char *oPath, const char *nPath, XrdOucEnv *oEnvP=0, XrdOucEnv *nEnvP=0)=0
bool Add(XrdSecAttr &attr)
XrdSecEntityAttr * eaAPI
non-const API to attributes

References XrdSecEntityAttr::Add(), AOP_Excl_Insert, AOP_Insert, AOP_Rename, AUTHORIZE, XrdSecEntity::eaAPI, EPNAME, exists(), Finder, fsError(), fwdMV, XrdOucErrInfo::getErrInfo(), XrdOucErrInfo::getErrUser(), XrdOfsHandle::Hide(), XrdOfsEvs::Mv, rename(), XrdOucErrInfo::setErrInfo(), SFS_O_META, SFS_O_RDWR, SFS_OK, tident, XrdOfsFS, XrdOfsOss, XrdSfsFileExistNo, and XTRACE.

Referenced by rename().

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

◆ Split()

const char * XrdOfs::Split ( const char * Args,
const char ** Opq,
char * Path,
int Plen )
protected

Definition at line 2686 of file XrdOfs.cc.

2688{
2689 int xlen;
2690 *Opq = index(Args, '?');
2691 if (!(*Opq)) return Args;
2692 xlen = (*Opq)-Args;
2693 if (xlen >= Plen) xlen = Plen-1;
2694 strncpy(Path, Args, xlen);
2695 Path[xlen] = 0;
2696 return Path;
2697}

References Path.

Referenced by fsctl().

Here is the caller graph for this function:

◆ Stall()

int XrdOfs::Stall ( XrdOucErrInfo & einfo,
int stime,
const char * path )
protected

Definition at line 2703 of file XrdOfs.cc.

2706{
2707 const char *msgfmt = "File %s is being %s; "
2708 "estimated time to completion %s";
2709 EPNAME("Stall")
2710#ifndef NODEBUG
2711 const char *tident = "";
2712#endif
2713 char Mbuff[2048], Tbuff[32];
2714 const char *What = "staged";
2715
2716// Check why the stall is occurring
2717//
2718 if (stime < 0) {stime = 60; What = "created";}
2719
2720// Format the stall message
2721//
2722 snprintf(Mbuff, sizeof(Mbuff)-1, msgfmt,
2723 Fname(path), What, WaitTime(stime, Tbuff, sizeof(Tbuff)));
2724 ZTRACE(delay, "Stall " <<stime <<": " <<Mbuff <<" for " <<path);
2725
2726// Place the error message in the error object and return
2727//
2728 einfo.setErrInfo(0, Mbuff);
2729
2730// All done
2731//
2732 return (stime > MaxDelay ? MaxDelay : stime);
2733}
char * WaitTime(int, char *, int)
Definition XrdOfs.cc:2782

References EPNAME, MaxDelay, XrdOucErrInfo::setErrInfo(), tident, WaitTime(), and ZTRACE.

Here is the call graph for this function:

◆ stat() [1/2]

int XrdOfs::stat ( const char * path,
mode_t & mode,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
virtual

Return mode information on a file or directory.

Parameters
path- Pointer to the path in question.
mode- Where full mode information is to be returned.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED When SFS_OK is returned, mode must contain mode information. If the mode is -1 then it is taken as an offline file.

Implements XrdSfsFileSystem.

Definition at line 2404 of file XrdOfs.cc.

2422{
2423 EPNAME("stat");
2424 struct stat buf;
2425 int retc;
2426 const char *tident = einfo.getErrUser();
2427 XrdOucEnv stat_Env(info,0,client);
2428 XTRACE(stat, path, "");
2429
2430// Apply security, as needed
2431//
2432 AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
2433 mode = (mode_t)-1;
2434
2435// Find out where we should stat this file
2436//
2437 if (Finder && Finder->isRemote()
2438 && (retc = Finder->Locate(einfo,path,SFS_O_NOWAIT|SFS_O_RDONLY|SFS_O_STAT,
2439 &stat_Env)))
2440 return fsError(einfo, retc);
2441
2442// Now try to find the file or directory
2443//
2444 if (!(retc = XrdOfsOss->Stat(path, &buf, XRDOSS_resonly, &stat_Env)))
2445 mode=buf.st_mode;
2446 else if ((-ENOMSG) != retc)
2447 return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
2448 return SFS_OK;
2449}
#define XRDOSS_resonly
Definition XrdOss.hh:486

References AOP_Stat, AUTHORIZE, EPNAME, Finder, fsError(), XrdOucErrInfo::getErrUser(), SFS_O_NOWAIT, SFS_O_RDONLY, SFS_O_STAT, SFS_OK, stat(), tident, XrdOfsFS, XrdOfsOss, XRDOSS_resonly, and XTRACE.

Here is the call graph for this function:

◆ stat() [2/2]

int XrdOfs::stat ( const char * Name,
struct stat * buf,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client,
const char * opaque = 0 )
virtual

Return state information on a file or directory.

Parameters
Name- Pointer to the path in question.
buf- Pointer to the structure where info it to be returned.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, SFS_STALL, or SFS_STARTED When SFS_OK is returned, buf must contain stat information.

Implements XrdSfsFileSystem.

Definition at line 2362 of file XrdOfs.cc.

2378{
2379 EPNAME("stat");
2380 int retc;
2381 const char *tident = einfo.getErrUser();
2382 XrdOucEnv stat_Env(info,0,client);
2383 XTRACE(stat, path, "");
2384
2385// Apply security, as needed
2386//
2387 AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
2388
2389// Find out where we should stat this file
2390//
2391 if (Finder && Finder->isRemote()
2392 && (retc = Finder->Locate(einfo, path, SFS_O_RDONLY|SFS_O_STAT, &stat_Env)))
2393 return fsError(einfo, retc);
2394
2395// Now try to find the file or directory
2396//
2397 if ((retc = XrdOfsOss->Stat(path, buf, 0, &stat_Env)))
2398 return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
2399 return SFS_OK;
2400}

References AOP_Stat, AUTHORIZE, EPNAME, Finder, fsError(), XrdOucErrInfo::getErrUser(), SFS_O_RDONLY, SFS_O_STAT, SFS_OK, stat(), tident, XrdOfsFS, XrdOfsOss, and XTRACE.

Referenced by chksum(), chmod(), exists(), fsctl(), stat(), and stat().

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

◆ truncate()

int XrdOfs::truncate ( const char * path,
XrdSfsFileOffset fsize,
XrdOucErrInfo & eInfo,
const XrdSecEntity * client = 0,
const char * opaque = 0 )
virtual

Truncate a file.

Parameters
path- Pointer to the path of the file to be truncated.
fsize- The size that the file is to have.
eInfo- The object where error info is to be returned.
client- Client's identify (see common description).
opaque- path's CGI information (see common description).
Returns
One of SFS_OK, SFS_ERROR, SFS_REDIRECT, or SFS_STALL

Implements XrdSfsFileSystem.

Definition at line 2455 of file XrdOfs.cc.

2471{
2472 EPNAME("truncate");
2473 const char *tident = einfo.getErrUser();
2474 XrdOucEnv trunc_Env(info,0,client);
2475 int retc;
2476 XTRACE(truncate, path, "");
2477
2478// Apply security, as needed
2479//
2480 AUTHORIZE(client,&trunc_Env,AOP_Update,"truncate",path,einfo);
2481
2482// Find out where we should chmod this file
2483//
2484 if (Finder && Finder->isRemote())
2485 {if (fwdTRUNC.Cmd)
2486 {char xSz[32];
2487 sprintf(xSz, "%lld", static_cast<long long>(Size));
2488 if (Forward(retc,einfo,fwdTRUNC,path,xSz,&trunc_Env)) return retc;
2489 }
2490 else if ((retc = Finder->Locate(einfo,path,SFS_O_RDWR,&trunc_Env)))
2491 return fsError(einfo, retc);
2492 }
2493
2494// Check if we should generate an event
2495//
2496 if (evsObject && evsObject->Enabled(XrdOfsEvs::Trunc))
2497 {XrdOfsEvsInfo evInfo(tident, path, info, &trunc_Env, 0, Size);
2498 evsObject->Notify(XrdOfsEvs::Trunc, evInfo);
2499 }
2500
2501// Now try to find the file or directory
2502//
2503 if (!(retc = XrdOfsOss->Truncate(path, Size, &trunc_Env))) return SFS_OK;
2504
2505// An error occurred, return the error info
2506//
2507 return XrdOfsFS->Emsg(epname, einfo, retc, "trunc", path);
2508}
int truncate(const char *Name, XrdSfsFileOffset fileOffset, XrdOucErrInfo &out_error, const XrdSecEntity *client=0, const char *opaque=0)
Definition XrdOfs.cc:2455
virtual int Truncate(const char *path, unsigned long long fsize, XrdOucEnv *envP=0)=0

References AOP_Update, AUTHORIZE, EPNAME, Finder, fsError(), fwdTRUNC, XrdOucErrInfo::getErrUser(), SFS_O_RDWR, SFS_OK, tident, XrdOfsEvs::Trunc, truncate(), XrdOfsFS, XrdOfsOss, and XTRACE.

Referenced by truncate().

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

◆ Unpersist()

void XrdOfs::Unpersist ( XrdOfsHandle * hP,
int xcev = 1 )
protected

Definition at line 2739 of file XrdOfs.cc.

2740{
2741 EPNAME("Unpersist");
2742 const char *tident = oh->PoscUsr();
2743 int poscNum, retc;
2744 short theMode;
2745
2746// Trace the call
2747//
2748 FTRACE(close, "use=0");
2749
2750// Generate a proper close event as one has not yet been generated
2751//
2752 if (xcev && XrdOfsFS->evsObject && *tident != '?'
2753 && XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Closew))
2754 {XrdOfsEvsInfo evInfo(tident, oh->Name());
2755 XrdOfsFS->evsObject->Notify(XrdOfsEvs::Closew, evInfo);
2756 }
2757
2758// Now generate a removal event
2759//
2760 if (XrdOfsFS->Balancer) XrdOfsFS->Balancer->Removed(oh->Name());
2761 if (XrdOfsFS->evsObject && XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Rm))
2762 {XrdOfsEvsInfo evInfo(tident, oh->Name());
2763 XrdOfsFS->evsObject->Notify(XrdOfsEvs::Rm, evInfo);
2764 }
2765
2766// Count this
2767//
2769
2770// Now unpersist the file
2771//
2772 OfsEroute.Emsg(epname, "Unpersisting", tident, oh->Name());
2773 if ((poscNum = oh->PoscGet(theMode))) poscQ->Del(oh->Name(), poscNum, 1);
2774 else if ((retc = XrdOfsOss->Unlink(oh->Name())))
2775 OfsEroute.Emsg(epname, retc, "unpersist", oh->Name());
2776}
#define FTRACE(act, x)
#define close(a)
Definition XrdPosix.hh:48
virtual void Removed(const char *path)
void Notify(Event eNum, XrdOfsEvsInfo &Info)
Definition XrdOfsEvs.cc:234
int Enabled(Event theEvents)
Definition XrdOfsEvs.hh:139
void Add(int &Cntr)
virtual int Unlink(const char *path, int Opts=0, XrdOucEnv *envP=0)=0

References close, XrdOfsEvs::Closew, EPNAME, FTRACE, XrdOfsHandle::Name(), OfsEroute, OfsStats, XrdOfsHandle::PoscGet(), XrdOfsHandle::PoscUsr(), XrdOfsEvs::Rm, tident, XrdOfsFS, and XrdOfsOss.

Here is the call graph for this function:

◆ WaitTime()

char * XrdOfs::WaitTime ( int stime,
char * buff,
int blen )
protected

Definition at line 2782 of file XrdOfs.cc.

2783{
2784 int hr, min, sec;
2785
2786// Compute hours, minutes, and seconds
2787//
2788 min = stime / 60;
2789 sec = stime % 60;
2790 hr = min / 60;
2791 min = min % 60;
2792
2793// Now format the message based on time duration
2794//
2795 if (!hr && !min)
2796 snprintf(buff,blen,"%d second%s",sec,(sec > 1 ? "s" : ""));
2797 else if (!hr)
2798 {if (sec > 10) min++;
2799 snprintf(buff,blen,"%d minute%s",min,(min > 1 ? "s" : ""));
2800 }
2801 else {if (hr == 1)
2802 if (min <= 30)
2803 snprintf(buff,blen,"%d minutes",min+60);
2804 else snprintf(buff,blen,"%d hour and %d minutes",hr,min);
2805 else {if (min > 30) hr++;
2806 snprintf(buff,blen,"%d hours",hr);
2807 }
2808 }
2809
2810// Complete the message
2811//
2812 buff[blen-1] = '\0';
2813 return buff;
2814}

Referenced by Stall().

Here is the caller graph for this function:

◆ XrdOfsDirectory

friend class XrdOfsDirectory
friend

Definition at line 237 of file XrdOfs.hh.

References XrdOfsDirectory.

Referenced by newDir(), and XrdOfsDirectory.

◆ XrdOfsFile

friend class XrdOfsFile
friend

Definition at line 238 of file XrdOfs.hh.

References XrdOfsFile.

Referenced by newFile(), and XrdOfsFile.

Member Data Documentation

◆ ConfigFN

char* XrdOfs::ConfigFN

Definition at line 420 of file XrdOfs.hh.

Referenced by XrdOfs(), Config_Display(), and Configure().

◆ dMask

mode_t XrdOfs::dMask[2]

Definition at line 384 of file XrdOfs.hh.

Referenced by XrdOfs(), chmod(), Configure(), and mkdir().

◆ evrObject

XrdOfsEvr XrdOfs::evrObject
protected

Definition at line 428 of file XrdOfs.hh.

Referenced by Configure().

◆ Finder

XrdCmsClient* XrdOfs::Finder
protected

Definition at line 429 of file XrdOfs.hh.

Referenced by XrdOfs(), chksum(), chmod(), Configure(), exists(), FAttr(), fsctl(), mkdir(), rename(), stat(), stat(), and truncate().

◆ fMask

mode_t XrdOfs::fMask[2]

Definition at line 385 of file XrdOfs.hh.

Referenced by XrdOfs(), chmod(), and Configure().

◆ fwdCHMOD

struct fwdOpt XrdOfs::fwdCHMOD

Definition at line 409 of file XrdOfs.hh.

Referenced by chmod(), Config_Display(), and Configure().

◆ fwdMKDIR

struct fwdOpt XrdOfs::fwdMKDIR

Definition at line 410 of file XrdOfs.hh.

Referenced by Config_Display(), Configure(), and mkdir().

◆ fwdMKPATH

struct fwdOpt XrdOfs::fwdMKPATH

Definition at line 411 of file XrdOfs.hh.

Referenced by Configure(), and mkdir().

◆ fwdMV

struct fwdOpt XrdOfs::fwdMV

Definition at line 412 of file XrdOfs.hh.

Referenced by Config_Display(), Configure(), and rename().

◆ fwdRM

struct fwdOpt XrdOfs::fwdRM

Definition at line 413 of file XrdOfs.hh.

Referenced by Config_Display(), and Configure().

◆ fwdRMDIR

struct fwdOpt XrdOfs::fwdRMDIR

Definition at line 414 of file XrdOfs.hh.

Referenced by Config_Display(), and Configure().

◆ fwdTRUNC

struct fwdOpt XrdOfs::fwdTRUNC

Definition at line 415 of file XrdOfs.hh.

Referenced by Config_Display(), Configure(), and truncate().

◆ MaxDelay

int XrdOfs::MaxDelay = 60
static

Definition at line 417 of file XrdOfs.hh.

Referenced by Config_Display(), and Stall().

◆ myIF

XrdNetIF* XrdOfs::myIF

Definition at line 394 of file XrdOfs.hh.

Referenced by Configure(), and fsctl().

◆ myPort

int XrdOfs::myPort

Definition at line 380 of file XrdOfs.hh.

Referenced by XrdOfs().

◆ Options

int XrdOfs::Options

Definition at line 379 of file XrdOfs.hh.

Referenced by Config_Display(), Configure(), and ConfigXeq().

◆ OSSDelay

int XrdOfs::OSSDelay = 30
static

Definition at line 418 of file XrdOfs.hh.

Referenced by Emsg().

◆ tpcRdrHost

char* XrdOfs::tpcRdrHost[2]

Definition at line 389 of file XrdOfs.hh.

Referenced by XrdOfs().

◆ tpcRdrPort

int XrdOfs::tpcRdrPort[2]

Definition at line 390 of file XrdOfs.hh.

Referenced by XrdOfs().


The documentation for this class was generated from the following files: