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)
XrdSfsDirectory *	newDir (char *user=0, int MonID=0)
XrdSfsDirectory *	newDir (XrdOucErrInfo &eInfo)
XrdSfsFile *	newFile (char *user=0, int MonID=0)
XrdSfsFile *	newFile (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
XrdNetIF *	myIF
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
XrdCmsClient *	Finder
Protected Attributes inherited from XrdSfsFileSystem
uint64_t	FeatureSet
	Adjust features at initialization.

Friends
class	XrdOfsDirectory
class	XrdOfsFile

Detailed Description

Definition at line 237 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 366 of file XrdOfs.hh.

     {Authorize = 0x0001,    // Authorization wanted
      XAttrPlug = 0x0002,    // Extended Attribute Plugin
      isPeer    = 0x0050,    // Role peer
      isProxy   = 0x0020,    // Role proxy
      isManager = 0x0040,    // Role manager
      isServer  = 0x0080,    // Role server
      isSuper   = 0x00C0,    // Role supervisor
      isMeta    = 0x0100,    // Role meta + above
      haveRole  = 0x01F0,    // A role is present
      Forwarding= 0x1000,    // Fowarding wanted
      ThirdPC   = 0x2000,    // This party copy wanted
      SubCluster= 0x4000,    // all.subcluster directive encountered
      RdrTPC    = 0x8000
     };                      // These are set in Options below

Constructor & Destructor Documentation

XrdOfs()

XrdOfs::XrdOfs

(

)

Definition at line 169 of file XrdOfs.cc.

               : dMask{0000,0775}, fMask{0000,0775}, // Legacy
                   tpcRdrHost{}, tpcRdrPort{}
{
   const char *bp;
 
// Establish defaults
//
   ofsConfig     = 0;
   FSctl_PC      = 0;
   FSctl_PI      = 0;
   Authorization = 0;
   Finder        = 0;
   Balancer      = 0;
   evsObject     = 0;
   ossRPList     = 0;
   myRole        = strdup("server");
   OssIsProxy    = 0;
   ossRW         =' ';
   ossFeatures   = 0;
 
// Obtain port number we will be using. Note that the constructor must occur
// after the port number is known (i.e., this cannot be a global static).
//
   myPort = (bp = getenv("XRDPORT")) ? strtol(bp, (char **)NULL, 10) : 0;
 
// Defaults for POSC
//
   poscQ   = 0;
   poscLog = 0;
   poscHold= 10*60;
   poscAuto= 0;
   poscSync= 1;
 
// Set the configuration file name and dummy handle
//
   ConfigFN = 0;
   XrdOfsHandle::Alloc(&dummyHandle);
 
// Set checksum pointers
//
   Cks       = 0;
   CksPfn    = true;
   CksRdr    = true;
 
// Prepare handling
//
   prepHandler = 0;
   prepAuth = true;
 
// Eextended attribute limits
//
   usxMaxNsz = kXR_faMaxNlen;
   usxMaxVsz = kXR_faMaxVlen;
 
// Other options
//
   DirRdr    = false;
   reProxy   = false;
   OssHasPGrw= false;
}

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 358 of file XrdOfs.hh.

{}  // 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 1787 of file XrdOfs.cc.

{
   EPNAME("chksum");
   XrdOucEnv  cksEnv(opaque,0,client);
   XrdCksData cksData;
   const char *tident = einfo.getErrUser();
   char buff[MAXPATHLEN+8];
   int rc;
 
// Check if we support checksumming
//
   if (!Cks)
      {einfo.setErrInfo(ENOTSUP, "Checksums are not supported.");
       return SFS_ERROR;
      }
 
// A csSize request is issued usually once to verify everything is working. We
// take this opportunity to also verify the checksum name.
//
   rc = cksData.Set(csName);
   if (!rc || Func == XrdSfsFileSystem::csSize)
      {if (rc && (rc = Cks->Size(csName)))
          {einfo.setErrCode(rc); return SFS_OK;}
       strcpy(buff, csName); strcat(buff, " checksum not supported.");
       einfo.setErrInfo(ENOTSUP, buff);
       return SFS_ERROR;
      }
 
// Everything else requires a path
//
   if (!Path)
      {strcpy(buff, csName);
       strcat(buff, " checksum path not specified.");
       einfo.setErrInfo(EINVAL, buff);
       return SFS_ERROR;
      }
 
// Apply security, as needed
//
   XTRACE(stat, Path, csName);
   AUTHORIZE(client,&cksEnv,AOP_Stat,"checksum",Path,einfo);
 
// If we are a menager then we need to redirect the client to where the file is
//
   if (CksRdr && Finder && Finder->isRemote() 
   &&  (rc = Finder->Locate(einfo, Path, SFS_O_RDONLY, &cksEnv)))
      return fsError(einfo, rc);
 
// At this point we need to convert the lfn to a pfn
//
   if (CksPfn && !(Path = XrdOfsOss->Lfn2Pfn(Path, buff, MAXPATHLEN, rc)))
      return Emsg(epname, einfo, rc, "checksum", Path);
 
// Originally we only passed he env pointer for proxy servers. Due to popular
// demand, we always pass the env as it points to the SecEntity object unless
// we don't have it then we pass the caller's environment.
//
   if (Func == XrdSfsFileSystem::csGet || Func == XrdSfsFileSystem::csCalc)
      {if (client) cksData.envP = &cksEnv;
          else cksData.envP = (einfo.getEnv() ? einfo.getEnv() : &cksEnv);
      }
 
// Now determine what to do
//
        if (Func == XrdSfsFileSystem::csCalc) rc = Cks->Calc(Path, cksData);
   else if (Func == XrdSfsFileSystem::csGet)  rc = Cks->Get( Path, cksData);
   else {einfo.setErrInfo(EINVAL, "Invalid checksum function.");
         return SFS_ERROR;
        }
 
// See if all went well
//
#ifdef ENOATTR
   if (rc >= 0 || rc == -ENOATTR || rc == -ESTALE || rc == -ESRCH)
#else
   if (rc >= 0 || rc == -ENODATA || rc == -ESTALE || rc == -ESRCH)
#endif
      {if (rc >= 0) {cksData.Get(buff, MAXPATHLEN); rc = 0;}
          else {*buff = 0; rc = -rc;}
       einfo.setErrInfo(rc, buff);
       return SFS_OK;
      }
 
// We failed
//
   return Emsg(epname, einfo, rc, "checksum", Path);
}

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 1898 of file XrdOfs.cc.

{
   EPNAME("chmod");
   static const int locFlags = SFS_O_RDWR|SFS_O_META;
   struct stat Stat;
   mode_t acc_mode = Mode & S_IAMB;
   const char *tident = einfo.getErrUser();
   XrdOucEnv chmod_Env(info,0,client);
   int retc;
   XTRACE(chmod, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&chmod_Env,AOP_Chmod,"chmod",path,einfo);
 
// Find out where we should chmod this file
//
   if (Finder && Finder->isRemote())
      {if (fwdCHMOD.Cmd)
          {char buff[8];
           sprintf(buff, "%o", static_cast<int>(acc_mode));
           if (Forward(retc,einfo,fwdCHMOD,path,buff,&chmod_Env)) return retc;
          }
          else if ((retc = Finder->Locate(einfo, path, locFlags, &chmod_Env)))
                  return fsError(einfo, retc);
      }
 
// We need to adjust the mode based on whether this is a file or directory.
//
   if ((retc = XrdOfsOss->Stat(path, &Stat, 0, &chmod_Env)))
      return XrdOfsFS->Emsg(epname, einfo, retc, "change", path);
   if (S_ISDIR(Stat.st_mode)) acc_mode = (acc_mode | dMask[0]) & dMask[1];
      else acc_mode = (acc_mode | fMask[0]) & fMask[1];
 
// Check if we should generate an event
//
   if (evsObject && evsObject->Enabled(XrdOfsEvs::Chmod))
      {XrdOfsEvsInfo evInfo(tident, path, info, &chmod_Env, acc_mode);
       evsObject->Notify(XrdOfsEvs::Chmod, evInfo);
      }
 
// Now try to find the file or directory
//
   if (!(retc = XrdOfsOss->Chmod(path, acc_mode, &chmod_Env))) return SFS_OK;
 
// An error occurred, return the error info
//
   return XrdOfsFS->Emsg(epname, einfo, retc, "change", path);
}

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.

{
     const char *cloc, *pval;
     char buff[8192], fwbuff[512], *bp;
     int i;
 
     if (!ConfigFN || !ConfigFN[0]) cloc = "default";
        else cloc = ConfigFN;
     if (!poscQ) pval = "off";
        else     pval = (poscAuto ? "auto" : "manual");
 
     snprintf(buff, sizeof(buff), "Config effective %s ofs configuration:\n"
                                  "       all.role %s\n"
                                  "%s"
                                  "       ofs.maxdelay   %d\n"
                                  "       ofs.persist    %s hold %d%s%s\n"
                                  "       ofs.trace      %x",
              cloc, myRole,
              (Options & Authorize ? "       ofs.authorize\n" : ""),
               MaxDelay,
               pval, poscHold, (poscLog ? " logdir " : ""),
               (poscLog ? poscLog    : ""), OfsTrace.What);
 
     Eroute.Say(buff);
     ofsConfig->Display();
 
     if (Options & Forwarding)
        {*fwbuff = 0;
         if (ConfigDispFwd(buff, fwdCHMOD))
            {Eroute.Say(buff); strcat(fwbuff, " ch");}
         if (ConfigDispFwd(buff, fwdMKDIR))
            {Eroute.Say(buff); strcat(fwbuff, " mk");}
         if (ConfigDispFwd(buff, fwdMV))
            {Eroute.Say(buff); strcat(fwbuff, " mv");}
         if (ConfigDispFwd(buff, fwdRM))
            {Eroute.Say(buff); strcat(fwbuff, " rm");}
         if (ConfigDispFwd(buff, fwdRMDIR))
            {Eroute.Say(buff); strcat(fwbuff, " rd");}
         if (ConfigDispFwd(buff, fwdTRUNC))
            {Eroute.Say(buff); strcat(fwbuff, " tr");}
         if (*fwbuff) XrdOucEnv::Export("XRDOFS_FWD", fwbuff);
        }
 
     if (evsObject)
        {bp = buff;
         setBuff("       ofs.notify ", 18);              //  1234567890
         if (evsObject->Enabled(XrdOfsEvs::Chmod))  setBuff("chmod ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Closer)) setBuff("closer ", 7);
         if (evsObject->Enabled(XrdOfsEvs::Closew)) setBuff("closew ", 7);
         if (evsObject->Enabled(XrdOfsEvs::Create)) setBuff("create ", 7);
         if (evsObject->Enabled(XrdOfsEvs::Mkdir))  setBuff("mkdir ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Mv))     setBuff("mv ",     3);
         if (evsObject->Enabled(XrdOfsEvs::Openr))  setBuff("openr ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Openw))  setBuff("openw ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Rm))     setBuff("rm ",     3);
         if (evsObject->Enabled(XrdOfsEvs::Rmdir))  setBuff("rmdir ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Trunc))  setBuff("trunc ",  6);
         if (evsObject->Enabled(XrdOfsEvs::Fwrite)) setBuff("fwrite ", 7);
         setBuff("msgs ", 5);
         i=sprintf(fwbuff,"%d %d ",evsObject->maxSmsg(),evsObject->maxLmsg());
         setBuff(fwbuff, i);
         cloc = evsObject->Prog();
         if (*cloc != '>') setBuff("|",1);
         setBuff(cloc, strlen(cloc));
         setBuff("\0", 1);
         Eroute.Say(buff);
        }
}

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.

{return Configure(Eroute, 0);}

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.

                                                             {
/*
  Function: Establish default values using a configuration file.
 
  Input:    None.
 
  Output:   0 upon success or !0 otherwise.
*/
   char *var;
   const char *tmp;
   int   cfgFD, retc, NoGo = 0;
   XrdOucEnv myEnv;
   XrdOucStream Config(&Eroute, getenv("XRDINSTANCE"), &myEnv, "=====> ");
 
// Print warm-up message
//
   Eroute.Say("++++++ File system initialization started.");
 
// Start off with no POSC log. Note that XrdSfsGetDefaultFileSystem nakes sure
// that we are configured only once.
//
   poscLog = NULL;
 
// Establish the network interface that the caller must provide
//
   if (!EnvInfo || !(myIF = (XrdNetIF *)EnvInfo->GetPtr("XrdNetIF*")))
      {Eroute.Emsg("Finder", "Network i/f undefined; unable to self-locate.");
       NoGo = 1;
      }
   ofsSchedP = (XrdScheduler *)EnvInfo->GetPtr("XrdScheduler*");
 
// Preset all variables with common defaults
//
   Options            = 0;
   if (getenv("XRDDEBUG")) OfsTrace.What = TRACE_MOST | TRACE_debug;
 
// Allocate a our plugin configurator
//
   ofsConfig = XrdOfsConfigPI::New(ConfigFN, &Config, &Eroute, 0, this);
 
// If there is no config file, return with the defaults sets.
//
   if( !ConfigFN || !*ConfigFN)
     Eroute.Emsg("Config", "Configuration file not specified.");
     else {
           // Try to open the configuration file.
           //
           if ( (cfgFD = open(ConfigFN, O_RDONLY, 0)) < 0)
              return Eroute.Emsg("Config", errno, "open config file",
                                 ConfigFN);
           Config.Attach(cfgFD);
           static const char *cvec[] = {"*** ofs plugin config:",0};
           Config.Capture(cvec);
 
           // Now start reading records until eof.
           //
           while((var = Config.GetMyFirstWord()))
                {if (!strncmp(var, "ofs.", 4)
                 ||  !strcmp(var, "all.role")
                 ||  !strcmp(var, "all.subcluster"))
                   {if (ConfigXeq(var+4,Config,Eroute)) {Config.Echo();NoGo=1;}}
                    else if (!strcmp(var, "oss.defaults")
                         ||  !strcmp(var, "all.export"))
                            {xexp(Config, Eroute, *var == 'a');
                             Config.noEcho();
                            }
                }
 
           // Now check if any errors occurred during file i/o
           //
           if ((retc = Config.LastError()))
           NoGo = Eroute.Emsg("Config", -retc, "read config file",
                              ConfigFN);
           Config.Close();
          }
 
// If no exports were specified, the default is that we are writable
//
   if (ossRW == ' ') ossRW = 'w';
 
// Adjust the umask to correspond to the maximum mode allowed
//
   mode_t uMask = 0777 & (~(dMask[1] | fMask[1]));
   umask(uMask);
 
// Export our role if we actually have one
//
   if (myRole) XrdOucEnv::Export("XRDROLE", myRole);
 
// Set the redirect option for other layers
//
   if (Options & isManager)
           XrdOucEnv::Export("XRDREDIRECT", (Options & isMeta ? "M" : "R"));
      else XrdOucEnv::Export("XRDREDIRECT", "0");
 
// If we are a proxy, then figure out where the prosy storge system resides
//
   if ((Options & isProxy) && !(Options & isManager))
      {char buff[2048], *bp, *libofs = getenv("XRDOFSLIB");
       if (!libofs) bp = buff;
          else {strcpy(buff, libofs); bp = buff+strlen(buff)-1;
                while(bp != buff && *(bp-1) != '/') bp--;
               }
       strcpy(bp, "libXrdPss.so");
       ofsConfig->Default(XrdOfsConfigPI::theOssLib, buff, 0);
       ofsConfig->Default(XrdOfsConfigPI::theCksLib, buff, 0);
      }
 
// Configure third party copy but only if we are not a manager. Phase 1 needs
// to be done before we load the plugins as they may need this info.
//
   if ((Options & ThirdPC) && !(Options & isManager))
      NoGo |= ConfigTPC(Eroute, EnvInfo);
 
// We need to do pre-initialization for event recording as the oss needs some
// environmental information from that initialization to initialize the frm,
// should it need to be used. We will do full evr initialization after the oss
// and the finder are initialized. A bit messy in the current plug-in world.
//
   if (!(Options & isManager) && !evrObject.Init(&Eroute)) NoGo = 1;
 
// Determine whether we should load authorization
//
   int piOpts = XrdOfsConfigPI::allXXXLib;
   if (!(Options & Authorize)) piOpts &= ~XrdOfsConfigPI::theAutLib;
 
// We need to export plugins to other protocols which means we need to
// record them in the outmost environment. So get it.
//
   XrdOucEnv *xrdEnv = 0;
   if (EnvInfo) xrdEnv = (XrdOucEnv*)EnvInfo->GetPtr("xrdEnv*");
 
// Now load all of the required plugins
//
   if (!ofsConfig->Load(piOpts, EnvInfo)) NoGo = 1;
      else {ofsConfig->Plugin(XrdOfsOss);
            ossFeatures = XrdOfsOss->Features();
            if (ossFeatures & XRDOSS_HASNOSF)  FeatureSet |= XrdSfs::hasNOSF;
            if (ossFeatures & XRDOSS_HASCACH)
               {FeatureSet |= XrdSfs::hasCACH;
                if (xrdEnv) xrdEnv->Put("XrdCache", "T"); // Existence check
               }
            if (ossFeatures & XRDOSS_HASNAIO)  FeatureSet |= XrdSfs::hasNAIO;
            if (xrdEnv) xrdEnv->PutPtr("XrdOss*", XrdOfsOss);
            ofsConfig->Plugin(Cks);
            CksPfn = !ofsConfig->OssCks();
            CksRdr = !ofsConfig->LclCks();
            if (ofsConfig->Plugin(prepHandler))
               {prepAuth = ofsConfig->PrepAuth();
                FeatureSet |= XrdSfs::hasPRP2;
               }
            if (Options & Authorize)
               {ofsConfig->Plugin(Authorization);
                XrdOfsTPC::Init(Authorization);
                if (xrdEnv) xrdEnv->PutPtr("XrdAccAuthorize*",Authorization);
                FeatureSet |= XrdSfs::hasAUTZ;
               }
           }
 
// If a cache has been configured then that cache may want to interact with
// the cache-specific FSctl() operation. We check if a plugin was provided.
//
   if (ossFeatures & XRDOSS_HASCACH)
      FSctl_PC = (XrdOfsFSctl_PI*)EnvInfo->GetPtr("XrdFSCtl_PC*");
 
// Configure third party copy phase 2, but only if we are not a manager.
//
   if ((Options & ThirdPC) && !(Options & isManager)) NoGo |= ConfigTPC(Eroute);
 
// Extract out the export list should it have been supplied by the oss plugin
//
   ossRPList = (XrdOucPListAnchor *)EnvInfo->GetPtr("XrdOssRPList*");
 
// Initialize redirection.  We type te herald here to minimize confusion
//
   if (Options & haveRole)
      {Eroute.Say("++++++ Configuring ", myRole, " role. . .");
       if (ConfigRedir(Eroute, EnvInfo))
          {Eroute.Emsg("Config", "Unable to create cluster management client.");
           NoGo = 1;
          }
      }
 
// Initialize the FSctl plugin if we have one. Note that we needed to defer
// until now because we needed to configure the cms plugin first (see above).
//
   if (ofsConfig->Plugin(FSctl_PI) && !ofsConfig->ConfigCtl(Finder, EnvInfo))
      {Eroute.Emsg("Config", "Unable to configure FSctl plugin.");
       NoGo = 1;
      }
 
// Initialize the cache FSctl handler if we have one. The same deferal applies.
//
   if (FSctl_PC)
      {struct XrdOfsFSctl_PI::Plugins thePI = {Authorization, Finder,
                                               XrdOfsOss, XrdOfsFS};
       XrdOucEnv pcEnv;                                    
       pcEnv.PutPtr("XrdOfsHandle*", dummyHandle);
       if (!FSctl_PC->Configure(ConfigFN, 0, &pcEnv, thePI))
          {Eroute.Emsg("Config", "Unable to configure cache FSctl handler.");
           NoGo = 1;
          }
      }
 
// Initialize th Evr object if we are an actual server
//
   if (!(Options & isManager) && !evrObject.Init(Balancer)) NoGo = 1;
 
// Turn off forwarding if we are not a pure remote redirector or a peer
//
   if (Options & Forwarding)
      {const char *why = 0;
       if (!(Options & Authorize)) why = "authorization not enabled";
           else if (!(Options & isPeer) && (Options & (isServer | isProxy)))
                   why = "not a pure manager";
       if (why)
         {Eroute.Say("Config warning: forwarding turned off; ", why);
          Options &= ~(Forwarding);
          fwdCHMOD.Reset(); fwdMKDIR.Reset(); fwdMKPATH.Reset();
          fwdMV.Reset();    fwdRM.Reset();    fwdRMDIR.Reset();
          fwdTRUNC.Reset();
         }
      }
 
// If we need to send notifications, initialize the interface
//
   if (!NoGo && evsObject) NoGo = evsObject->Start(&Eroute);
 
// If the OSS plugin is really a proxy. If it is, it will export its origin.
// We also suppress translating lfn to pfn (usually done via osslib +cksio).
// Note: consulting the ENVAR below is historic and remains for compatibility
// Otherwise we can configure checkpointing if we are a data server.
//
   if (ossFeatures & XRDOSS_HASPRXY || getenv("XRDXROOTD_PROXY"))
      {OssIsProxy = 1;
       CksPfn = false;
       FeatureSet |= XrdSfs::hasPRXY;
      } else if (!(Options & isManager) && !XrdOfsConfigCP::Init()) NoGo = 1;
 
// Indicate wheter oss implements pgrw or it has to be simulated
//
   OssHasPGrw = (ossFeatures & XRDOSS_HASPGRW) != 0;
 
// If POSC processing is enabled (as by default) do it. Warning! This must be
// the last item in the configuration list as we need a working filesystem.
// Note that in proxy mode we always disable posc!
//
   if (OssIsProxy || getenv("XRDXROOTD_NOPOSC"))
      {if (poscAuto != -1 && !NoGo)
          Eroute.Say("Config POSC has been disabled by the osslib plugin.");
      } else if (poscAuto != -1 && !NoGo) NoGo |= ConfigPosc(Eroute);
 
// Setup statistical monitoring
//
   OfsStats.setRole(myRole);
 
// Display final configuration
//
   if (!NoGo) Config_Display(Eroute);
   delete ofsConfig; ofsConfig = 0;
 
// All done
//
   tmp = (NoGo ? " initialization failed." : " initialization completed.");
   Eroute.Say("------ File system ", myRole, tmp);
   return NoGo;
}

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.

{
    char *val, vBuff[64];
 
    // Now assign the appropriate global variable
    //
    TS_Bit("authorize",     Options, Authorize);
    TS_XPI("authlib",       theAutLib);
    TS_XPI("ckslib",        theCksLib);
    TS_Xeq("cksrdsz",       xcrds);
    TS_XPI("cmslib",        theCmsLib);
    TS_Xeq("crmode",        xcrm);
    TS_XPI("ctllib",        theCtlLib);
    TS_Xeq("dirlist",       xdirl);
    TS_Xeq("forward",       xforward);
    TS_Xeq("maxdelay",      xmaxd);
    TS_Xeq("notify",        xnot);
    TS_Xeq("notifymsg",     xnmsg);
    TS_XPI("osslib",        theOssLib);
    TS_Xeq("persist",       xpers);
    TS_XPI("preplib",       thePrpLib);
    TS_Xeq("role",          xrole);
    TS_Xeq("tpc",           xtpc);
    TS_Xeq("trace",         xtrace);
    TS_Xeq("xattr",         xatr);
    TS_XPI("xattrlib",      theAtrLib);
 
    // Process miscellaneous directives handled elsemwhere
    //
    if (!strcmp("chkpnt", var)) return (XrdOfsConfigCP::Parse(Config) ? 0 : 1);
 
    // Screen out the subcluster directive (we need to track that)
    //
    TS_Bit("subcluster",Options,SubCluster);
 
    // Get the actual value for simple directives
    //
    strlcpy(vBuff, var, sizeof(vBuff)); var = vBuff;
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "value not specified for", var); return 1;}
 
    // No match found, complain.
    //
    Eroute.Say("Config warning: ignoring unknown directive '",var,"'.");
    Config.Echo();
    return 0;
}

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 1966 of file XrdOfs.cc.

{
   XrdOucEnv myEnv(0, 0, client);
 
// Pass this call along
//
   XrdOfsOss->Connect(myEnv);
}

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 1979 of file XrdOfs.cc.

{
   XrdOucEnv myEnv(0, 0, client);
 
// Pass this call along
//
   XrdOfsOss->Disc(myEnv);
}

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 2546 of file XrdOfs.cc.

{
   char buffer[MAXPATHLEN+80];
 
// If the error is EBUSY then we just need to stall the client. This is
// a hack in order to provide for proxy support
//
// The hack unfotunately is now beinng triggered for reads and writes when
// it was never so before (presumably due to client changes). So do not
// apply the hack for these operations. This gets a better fix in R 6.0
//
if (strcmp("read", op) && strcmp("readv", op) && strcmp("pgRead", op) && 
    strcmp("write",op) && strcmp("pgwrite",op)) {
    if (ecode < 0) ecode = -ecode;
    if (ecode == EBUSY) return 5;  // A hack for proxy support
 
// Check for timeout conditions that require a client delay
//
   if (ecode == ETIMEDOUT) return OSSDelay;
   }
 
// Format the error message
//
   XrdOucERoute::Format(buffer, sizeof(buffer), ecode, op, target);
 
// Print it out if debugging is enabled
//
#ifndef NODEBUG
    OfsEroute.Emsg(pfx, einfo.getErrUser(), buffer);
#endif
 
// Place the error message in the error object and return
//
    einfo.setErrInfo(ecode, buffer);
    return SFS_ERROR;
}

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 2518 of file XrdOfs.cc.

{
   int rc;
 
// First issue the error message so if we have to unpersist it makes sense
//
   if ((rc = Emsg(pfx, einfo, ecode, op, hP->Name())) != SFS_ERROR) return rc;
 
// If this is a POSC file then we need to unpersist it. Note that we are always
// called with the handle **unlocked**
//
   if (hP->isRW == XrdOfsHandle::opPC)
      {hP->Lock();
       XrdOfsFS->Unpersist(hP);
       hP->UnLock();
      }
 
// Now return the error
//
   return SFS_ERROR;
}

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 1992 of file XrdOfs.cc.

{
   EPNAME("exists");
   struct stat fstat;
   int retc;
   const char *tident = einfo.getErrUser();
   XrdOucEnv stat_Env(info,0,client);
   XTRACE(exists, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
 
// Find out where we should stat this file
//
   if (Finder && Finder->isRemote() 
   &&  (retc = Finder->Locate(einfo, path, SFS_O_RDONLY, &stat_Env)))
      return fsError(einfo, retc);
 
// Now try to find the file or directory
//
   retc = XrdOfsOss->Stat(path, &fstat, 0, &stat_Env);
   if (!retc)
      {     if (S_ISDIR(fstat.st_mode)) file_exists=XrdSfsFileExistIsDirectory;
       else if (S_ISREG(fstat.st_mode)) file_exists=XrdSfsFileExistIsFile;
       else                             file_exists=XrdSfsFileExistNo;
       return SFS_OK;
      }
   if (retc == -ENOENT)
      {file_exists=XrdSfsFileExistNo;
       return SFS_OK;
      }
 
// An error occurred, return the error info
//
   return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
}

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.

{
   EPNAME("FAttr");
   const char *tident = einfo.getErrUser();
   char pfnbuff[MAXPATHLEN+8];
   const char *accType;
   long long xOpts;
 
   struct faArgs {const char *name; int fArg; Access_Operation aop;};
 
   static faArgs faTab[] = {{ "del fattr", SFS_O_RDWR, AOP_Update}, // del
                            { "get fattr", 0,          AOP_Read},   // get
                            {"list fattr", 0,          AOP_Read},   // list
                            { "set fattr", SFS_O_RDWR, AOP_Update}  // set
                           };
   static const int faNum = sizeof(faTab)/sizeof(struct faArgs);
 
   int rc;
 
// Check if we need only return support information
//
   if (!faReq)
      {XrdOucEnv *envP = einfo.getEnv();
       ZTRACE(fsctl, "FAttr req=info");
       if (!envP || !usxMaxNsz)
          {einfo.setErrInfo(ENOTSUP, "Not supported.");
           return SFS_ERROR;
          }
       envP->PutInt("usxMaxNsz", usxMaxNsz);
       envP->PutInt("usxMaxVsz", usxMaxVsz);
       return SFS_OK;
      }
 
// Setup for to perform attribute functions
//
   XrdSfsFACtl &faCtl = *faReq;
   XrdOucEnv FAttr_Env(faCtl.pcgi,0,client);
 
// Make sure request code is valid (we also set some options)
//
   if (faCtl.rqst > faNum)
      return Emsg(epname, einfo, EINVAL, "process fattrs", faCtl.path);
   accType  = faTab[faCtl.rqst].name;
 
// Trace this call
//
   ZTRACE(fsctl, "FAttr " <<accType <<' ' <<faCtl.path);
 
// Extract the export options if we can
//
   xOpts = (ossRPList ? ossRPList->Find(faCtl.path) : 0);
 
// Perform authrorization and redirection if required
//
   if (faCtl.opts & XrdSfsFACtl::accChk)
      {int luFlag           = faTab[faCtl.rqst].fArg;
       Access_Operation aOP = faTab[faCtl.rqst].aop;
 
       AUTHORIZE(client, 0, aOP, accType ,faCtl.path, einfo);
 
       if (Finder && Finder->isRemote()
       &&  (rc = Finder->Locate(einfo, faCtl.path, luFlag, &FAttr_Env)))
          return fsError(einfo, rc);
 
       if (aOP == AOP_Update && xOpts & XRDEXP_NOTRW)
          return Emsg(epname, einfo, EROFS, accType, faCtl.path);
      }
 
// If this is a proxy server then hand this request to the storage system
// as it will need to be executed elsewhere.
//
   if (OssIsProxy)
      {faCtl.envP = &FAttr_Env;
       rc = XrdOfsOss->FSctl(XRDOSS_FSCTLFA, 0, (const char *)&faCtl);
       if (rc) return XrdOfsFS->Emsg(epname, einfo, rc, accType, faCtl.path);
       return SFS_OK;
      }
 
// Make sure we can use xattrs on the path
//
   if (xOpts & XRDEXP_NOXATTR)
      return XrdOfsFS->Emsg(epname, einfo, EPERM, accType, faCtl.path);
 
// Convert the lfn to a pfn for actual calls to the attribute processor
//
   faCtl.pfnP = XrdOfsOss->Lfn2Pfn(faCtl.path, pfnbuff, sizeof(pfnbuff), rc);
   if (!faCtl.pfnP) return XrdOfsFS->Emsg(epname,einfo,rc,accType,faCtl.path);
 
// Fan out for processing this on the local file system
//
   switch(faCtl.rqst)
         {case XrdSfsFACtl::faDel:
               return ctlFADel(faCtl, FAttr_Env, einfo);
               break;
          case XrdSfsFACtl::faGet:
               return ctlFAGet(faCtl, FAttr_Env, einfo);
               break;
          case XrdSfsFACtl::faLst:
               return ctlFALst(faCtl, FAttr_Env, einfo);
               break;
          case XrdSfsFACtl::faSet:
               return ctlFASet(faCtl, FAttr_Env, einfo);
               break;
          default: break;
         }
 
// The request code is not one we understand
//
   return XrdOfsFS->Emsg(epname, einfo, EINVAL, "process fattrs", faCtl.path);
}

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.

{
   EPNAME("FSctl");
 
// If this is the cache-specfic we need to do a lot more work. Otherwise this
// is a simple case of wheter we have a plug-in for this or not.
//
   if (cmd == SFS_FSCTL_PLUGXC)
      {if (FSctl_PC)
          {if (args.Arg2Len == -2)
              {XrdOucEnv pc_Env(args.ArgP[1] ? args.ArgP[1] : 0, 0, client);
               AUTHORIZE(client,&pc_Env,AOP_Read,"FSctl",args.ArgP[0],eInfo);
              }
           return FSctl_PC->FSctl(cmd, args, eInfo, client);
          }
      }
      else if (FSctl_PI) return FSctl_PI->FSctl(cmd, args, eInfo, client);
 
// Operation is not supported
//
   return XrdOfsFS->Emsg("FSctl", eInfo, ENOTSUP, "FSctl", "");
}

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 "*‍/" 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.

{
   EPNAME("fsctl");
   static int PrivTab[]     = {XrdAccPriv_Delete, XrdAccPriv_Insert,
                               XrdAccPriv_Lock,   XrdAccPriv_Lookup,
                               XrdAccPriv_Rename, XrdAccPriv_Read,
                               XrdAccPriv_Write};
   static char PrivLet[]    = {'d',               'i',
                               'k',               'l',
                               'n',               'r',
                               'w'};
   static const int PrivNum = sizeof(PrivLet);
 
   int retc, i, blen, privs, opcode = cmd & SFS_FSCTL_CMD;
   const char *tident = einfo.getErrUser();
   char *bP, *cP;
 
// Process the LOCATE request
//
   if (opcode == SFS_FSCTL_LOCATE)
      {static const int locMask = (SFS_O_FORCE|SFS_O_NOWAIT|SFS_O_RESET|
                                   SFS_O_HNAME|SFS_O_RAWIO |SFS_O_DIRLIST);
       struct stat fstat;
       char pbuff[1024], rType[3];
       const char *Resp[2] = {rType, pbuff};
       const char *locArg, *opq, *Path = Split(args,&opq,pbuff,sizeof(pbuff));
       XrdNetIF::ifType ifType;
       int Resp1Len;
       int find_flag = SFS_O_LOCATE | (cmd & locMask);
       XrdOucEnv loc_Env(opq ? opq+1 : 0,0,client);
 
       ZTRACE(fsctl, "locate args=" <<(args ? args : "''"));
 
       if (cmd & SFS_O_TRUNC)           locArg = (char *)"*";
          else {     if (*Path == '*') {locArg = Path; Path++;}
                        else            locArg = Path;
                AUTHORIZE(client,&loc_Env,AOP_Stat,"locate",Path,einfo);
               }
       if (Finder && Finder->isRemote()
       &&  (retc = Finder->Locate(einfo, locArg, find_flag, &loc_Env)))
          return fsError(einfo, retc);
 
       if (cmd & SFS_O_TRUNC) {rType[0] = 'S'; rType[1] = ossRW;}
          else {if ((retc = XrdOfsOss->Stat(Path, &fstat, 0, &loc_Env)))
                   return XrdOfsFS->Emsg(epname, einfo, retc, "locate", Path);
                rType[0] = ((fstat.st_mode & S_IFBLK) == S_IFBLK ? 's' : 'S');
                rType[1] =  (fstat.st_mode & S_IWUSR             ? 'w' : 'r');
               }
       rType[2] = '\0';
 
       ifType = XrdNetIF::GetIFType((einfo.getUCap() & XrdOucEI::uIPv4)  != 0,
                                    (einfo.getUCap() & XrdOucEI::uIPv64) != 0,
                                    (einfo.getUCap() & XrdOucEI::uPrip)  != 0);
       bool retHN = (cmd & SFS_O_HNAME) != 0;
       if ((Resp1Len = myIF->GetDest(pbuff, sizeof(pbuff), ifType, retHN)))
           {einfo.setErrInfo(Resp1Len+3, (const char **)Resp, 2);
            return SFS_DATA;
           }
       return Emsg(epname, einfo, ENETUNREACH, "locate", Path);
      }
 
// Process the STATFS request
//
   if (opcode == SFS_FSCTL_STATFS)
      {char pbuff[1024];
       const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
       XrdOucEnv fs_Env(opq ? opq+1 : 0,0,client);
       ZTRACE(fsctl, "statfs args=" <<(args ? args : "''"));
       AUTHORIZE(client,&fs_Env,AOP_Stat,"statfs",Path,einfo);
       if (Finder && Finder->isRemote()
       &&  (retc = Finder->Space(einfo, Path, &fs_Env)))
          return fsError(einfo, retc);
       bP = einfo.getMsgBuff(blen);
       if ((retc = XrdOfsOss->StatFS(Path, bP, blen, &fs_Env)))
          return XrdOfsFS->Emsg(epname, einfo, retc, "statfs", args);
       einfo.setErrCode(blen+1);
       return SFS_DATA;
      }
 
// Process the STATLS request
//
   if (opcode == SFS_FSCTL_STATLS)
      {char pbuff[1024];
       const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
       XrdOucEnv statls_Env(opq ? opq+1 : 0,0,client);
       ZTRACE(fsctl, "statls args=" <<(args ? args : "''"));
       AUTHORIZE(client,&statls_Env,AOP_Stat,"statfs",Path,einfo);
       if (Finder && Finder->isRemote())
          {statls_Env.Put("cms.qvfs", "1");
           if ((retc = Finder->Space(einfo, Path, &statls_Env)))
              {if (retc == SFS_DATA) retc = Reformat(einfo);
               return fsError(einfo, retc);
              }
          }
       bP = einfo.getMsgBuff(blen);
       if ((retc = XrdOfsOss->StatLS(statls_Env, Path, bP, blen)))
          return XrdOfsFS->Emsg(epname, einfo, retc, "statls", Path);
       einfo.setErrCode(blen+1);
       return SFS_DATA;
      }
 
// Process the STATXA request
//
   if (opcode == SFS_FSCTL_STATXA)
      {char pbuff[1024];
       const char *opq, *Path = Split(args, &opq, pbuff, sizeof(pbuff));
       XrdOucEnv xa_Env(opq ? opq+1 : 0,0,client);
       ZTRACE(fsctl, "statxa args=" <<(args ? args : "''"));
       AUTHORIZE(client,&xa_Env,AOP_Stat,"statxa",Path,einfo);
       if (Finder && Finder->isRemote()
       && (retc = Finder->Locate(einfo,Path,SFS_O_RDONLY|SFS_O_STAT,&xa_Env)))
          return fsError(einfo, retc);
       bP = einfo.getMsgBuff(blen);
       if ((retc = XrdOfsOss->StatXA(Path, bP, blen, &xa_Env)))
          return XrdOfsFS->Emsg(epname, einfo, retc, "statxa", Path);
       if (!client || !XrdOfsFS->Authorization) privs = XrdAccPriv_All;
          else privs = XrdOfsFS->Authorization->Access(client, Path, AOP_Any);
       cP = bP + blen; strcpy(cP, "&ofs.ap="); cP += 8;
       if (privs == XrdAccPriv_All) *cP++ = 'a';
          else {for (i = 0; i < PrivNum; i++)
                    if (PrivTab[i] & privs) *cP++ = PrivLet[i];
                if (cP == (bP + blen + 1)) *cP++ = '?';
               }
       *cP++ = '\0';
       einfo.setErrCode(cP-bP+1);
       return SFS_DATA;
      }
 
// Process the STATCC request (this should always succeed)
//
   if (opcode == SFS_FSCTL_STATCC)
      {static const int lcc_flag = SFS_O_LOCATE | SFS_O_LOCAL;
       XrdOucEnv lcc_Env(0,0,client);
       ZTRACE(fsctl, "statcc args=" <<(args ? args : "''"));
            if (Finder)   retc = Finder  ->Locate(einfo,".",lcc_flag,&lcc_Env);
       else if (Balancer) retc = Balancer->Locate(einfo,".",lcc_flag,&lcc_Env);
       else retc = SFS_ERROR;
       if (retc != SFS_DATA) einfo.setErrInfo(5, "none|");
       return fsError(einfo, SFS_DATA);
      }
 
// Operation is not supported
//
   return XrdOfsFS->Emsg(epname, einfo, ENOTSUP, "fsctl", args);
}

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 2633 of file XrdOfs.cc.

{
 
// Screen the error code (update statistics w/o a lock for speed!)
//
   if (rc == SFS_REDIRECT) {OfsStats.Data.numRedirect++; return SFS_REDIRECT;}
   if (rc == SFS_STARTED)  {OfsStats.Data.numStarted++;  return SFS_STARTED; }
   if (rc > 0)             {OfsStats.Data.numDelays++;   return rc;          }
   if (rc == SFS_DATA)     {OfsStats.Data.numReplies++;  return SFS_DATA;    }
                           {OfsStats.Data.numErrors++;   return SFS_ERROR;   }
}

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 2055 of file XrdOfs.cc.

{
   int n;
 
// See if the size just wanted
//
  if (!buff) return OfsStats.Report(0,0) + XrdOfsOss->Stats(0,0);
 
// Report ofs info followed by the oss info
//
   n = OfsStats.Report(buff, blen);
   buff += n; blen -= n;
   n += XrdOfsOss->Stats(buff, blen);
 
// All done
//
   return n;
}

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.

{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 2078 of file XrdOfs.cc.

{
   EPNAME("mkdir");
   static const int LocOpts = SFS_O_RDWR | SFS_O_CREAT | SFS_O_META;
   mode_t acc_mode = (Mode | dMask[0]) & dMask[1];
   int retc, mkpath = Mode & SFS_O_MKPTH;
   const char *tident = einfo.getErrUser();
   XrdOucEnv mkdir_Env(info,0,client);
   XTRACE(mkdir, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&mkdir_Env,AOP_Mkdir,"mkdir",path,einfo);
 
// Find out where we should remove this file
//
   if (Finder && Finder->isRemote())
      {if (fwdMKDIR.Cmd)
          {char buff[8];
           sprintf(buff, "%o", static_cast<int>(acc_mode));
           if (Forward(retc, einfo, (mkpath ? fwdMKPATH:fwdMKDIR),
                       path, buff, &mkdir_Env)) return retc;
          }
          else if ((retc = Finder->Locate(einfo,path,LocOpts,&mkdir_Env)))
                  return fsError(einfo, retc);
      }
 
// Perform the actual operation
//
    if ((retc = XrdOfsOss->Mkdir(path, acc_mode, mkpath, &mkdir_Env)))
       return XrdOfsFS->Emsg(epname, einfo, retc, "mkdir", path);
 
// Check if we should generate an event
//
   if (evsObject && evsObject->Enabled(XrdOfsEvs::Mkdir))
      {XrdOfsEvsInfo evInfo(tident, path, info, &mkdir_Env, acc_mode);
       evsObject->Notify(XrdOfsEvs::Mkdir, evInfo);
      }
 
// If we have a redirector, tell it that we now have this path
//
   if (Balancer)
      {if (!mkpath) Balancer->Added(path);
          else     {char *slash, *myPath = strdup(path);
                    do {Balancer->Added(myPath);
                        if ((slash = rindex(myPath, '/'))) *slash = 0;
                       } while(slash && slash != myPath);
                    free(myPath);
                   }
      }
 
    return SFS_OK;
}

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 246 of file XrdOfs.hh.

                        {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 249 of file XrdOfs.hh.

                        {return new XrdOfsDirectory(eInfo, eInfo.getErrUser());}

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 252 of file XrdOfs.hh.

                        {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 255 of file XrdOfs.hh.

                        {return new XrdOfsFile(eInfo, eInfo.getErrUser());}

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 2153 of file XrdOfs.cc.

{
   EPNAME("prepare");
   XrdOucEnv prep_Env(0,0,client);
   XrdOucTList *tp = pargs.paths;
   int retc;
 
// Run through the paths to make sure client can read each one unless we aren't
// supposed to apply authorization.
//
   if (prepAuth)
      while(tp)
           {AUTHORIZE(client,0,AOP_Read,"prepare",tp->text,out_error);
            tp = tp->next;
           }
 
// If there is a prepare plugin, invoke it and return the result.
//
   if (prepHandler)
      {if (pargs.opts & Prep_QUERY)
          return prepHandler->query(pargs, out_error, client);
       if (pargs.opts & Prep_CANCEL)
          return prepHandler->cancel(pargs, out_error, client);
 
       return prepHandler->begin(pargs, out_error, client);
      }
 
// If we have a finder object, use it to prepare the paths. Otherwise,
// ignore this prepare request (we may change this in the future).
//
   if (XrdOfsFS->Finder
   && (retc = XrdOfsFS->Finder->Prepare(out_error, pargs, &prep_Env)))
      return fsError(out_error, retc);
   return 0;
}

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 311 of file XrdOfs.hh.

                          {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 317 of file XrdOfs.hh.

                             {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 2261 of file XrdOfs.cc.

{
   EPNAME("rename");
   static const int LocOpts = SFS_O_RDWR|SFS_O_META;
   int retc;
   const char *tident = einfo.getErrUser();
   XrdOucEnv old_Env(infoO,0,client);
   XrdOucEnv new_Env(infoN,0,client);
   XTRACE(rename, new_name, "old fn=" <<old_name <<" new ");
 
// Apply security, as needed
//
   AUTHORIZE(client, &old_Env, AOP_Rename, "renaming", old_name, einfo);
 
// The above authorization may mutate the XrdSecEntity by putting a mapped name
// into the extended attributes.  This mapped name will affect the subsequent
// authorization check below, giving the client access that may not be permitted.
// Hence, we delete this attribute to reset the object back to "pristine" state.
// If there was a way to make a copy of the XrdSecEntity, we could avoid this
// hack-y reach inside the extended attributes.
   if (client) client->eaAPI->Add("request.name", "", true);
 
// If we do not have full-blown insert authorization, we'll need to test for
// destination existence
   bool cannot_overwrite = false;
   if (client && XrdOfsFS->Authorization &&
      !XrdOfsFS->Authorization->Access(client, new_name, AOP_Insert, &new_Env))
      {cannot_overwrite = true;
       AUTHORIZE(client, &new_Env, AOP_Excl_Insert,
             "rename to existing file (overwrite disallowed)", new_name, einfo);
      }
 
// Find out where we should rename this file
//
   if (Finder && Finder->isRemote())
      {if (fwdMV.Cmd)
          {if (Forward(retc,einfo,fwdMV,old_name,new_name,&old_Env,&new_Env))
              return retc;
          }
          else if ((retc = Finder->Locate(einfo, old_name, LocOpts, &old_Env)))
                  return fsError(einfo, retc);
      }
 
// Check if we should generate an event
//
   if (evsObject && evsObject->Enabled(XrdOfsEvs::Mv))
      {XrdOfsEvsInfo evInfo(tident, old_name, infoO, &old_Env, 0, 0,
                                    new_name, infoN, &new_Env);
       evsObject->Notify(XrdOfsEvs::Mv, evInfo);
      }
 
// If we cannot overwrite, we must test for existence first.  This will test whether
// we will destroy data in the rename (without actually destroying data).
// Note there's an obvious race condition here; it was seen as the lesser-of-evils
// compared to creating an exclusive file and potentially leaking it in the event
// of a crash.
//
   if (cannot_overwrite)
      {XrdSfsFileExistence exists_flag = XrdSfsFileExistNo;
       if (SFS_OK != exists(new_name, exists_flag, einfo, client, infoN))
          {// File existence check itself failed; we can't prove that data won't
           // be overwritten so we return an error.
           return fsError(einfo, -einfo.getErrInfo());
          }
       if (exists_flag != XrdSfsFileExistNo)
          {// EPERM mimics the error code set by Linux when you invoke rename()
           // but cannot overwrite the destination file.
           einfo.setErrInfo(EPERM, "Overwrite of existing data not permitted");
           return fsError(einfo, -EPERM);
          }
      }
 
// Perform actual rename operation
//
   if ((retc = XrdOfsOss->Rename(old_name, new_name, &old_Env, &new_Env)))
      {return XrdOfsFS->Emsg(epname, einfo, retc, "rename", old_name);
      }
   XrdOfsHandle::Hide(old_name);
   if (Balancer) {Balancer->Removed(old_name);
                  Balancer->Added(new_name);
                 }
   return SFS_OK;
}

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 2690 of file XrdOfs.cc.

{
   int xlen;
   *Opq = index(Args, '?');
   if (!(*Opq)) return Args;
   xlen = (*Opq)-Args;
   if (xlen >= Plen) xlen = Plen-1;
   strncpy(Path, Args, xlen);
   Path[xlen] = 0;
   return Path;
}

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 2707 of file XrdOfs.cc.

{
    const char *msgfmt = "File %s is being %s; "
                         "estimated time to completion %s";
    EPNAME("Stall")
#ifndef NODEBUG
    const char *tident = "";
#endif
    char Mbuff[2048], Tbuff[32];
    const char *What = "staged";
 
// Check why the stall is occurring
//
   if (stime < 0) {stime = 60; What = "created";}
 
// Format the stall message
//
    snprintf(Mbuff, sizeof(Mbuff)-1, msgfmt,
             Fname(path), What, WaitTime(stime, Tbuff, sizeof(Tbuff)));
    ZTRACE(delay, "Stall " <<stime <<": " <<Mbuff <<" for " <<path);
 
// Place the error message in the error object and return
//
    einfo.setErrInfo(0, Mbuff);
 
// All done
//
   return (stime > MaxDelay ? MaxDelay : stime);
}

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 2408 of file XrdOfs.cc.

{
   EPNAME("stat");
   struct stat buf;
   int retc;
   const char *tident = einfo.getErrUser();
   XrdOucEnv stat_Env(info,0,client);
   XTRACE(stat, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
   mode = (mode_t)-1;
 
// Find out where we should stat this file
//
   if (Finder && Finder->isRemote()
   &&  (retc = Finder->Locate(einfo,path,SFS_O_NOWAIT|SFS_O_RDONLY|SFS_O_STAT,
                              &stat_Env)))
      return fsError(einfo, retc);
 
// Now try to find the file or directory
//
   if (!(retc = XrdOfsOss->Stat(path, &buf, XRDOSS_resonly, &stat_Env)))
       mode=buf.st_mode;
      else if ((-ENOMSG) != retc)
              return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
   return SFS_OK;
}

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 2366 of file XrdOfs.cc.

{
   EPNAME("stat");
   int retc;
   const char *tident = einfo.getErrUser();
   XrdOucEnv stat_Env(info,0,client);
   XTRACE(stat, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&stat_Env,AOP_Stat,"locate",path,einfo);
 
// Find out where we should stat this file
//
   if (Finder && Finder->isRemote()
   &&  (retc = Finder->Locate(einfo, path, SFS_O_RDONLY|SFS_O_STAT, &stat_Env)))
      return fsError(einfo, retc);
 
// Now try to find the file or directory
//
   if ((retc = XrdOfsOss->Stat(path, buf, 0, &stat_Env)))
      return XrdOfsFS->Emsg(epname, einfo, retc, "locate", path);
   return SFS_OK;
}

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 2459 of file XrdOfs.cc.

{
   EPNAME("truncate");
   const char *tident = einfo.getErrUser();
   XrdOucEnv trunc_Env(info,0,client);
   int retc;
   XTRACE(truncate, path, "");
 
// Apply security, as needed
//
   AUTHORIZE(client,&trunc_Env,AOP_Update,"truncate",path,einfo);
 
// Find out where we should chmod this file
//
   if (Finder && Finder->isRemote())
      {if (fwdTRUNC.Cmd)
          {char xSz[32];
           sprintf(xSz, "%lld", static_cast<long long>(Size));
           if (Forward(retc,einfo,fwdTRUNC,path,xSz,&trunc_Env)) return retc;
          }
          else if ((retc = Finder->Locate(einfo,path,SFS_O_RDWR,&trunc_Env)))
                  return fsError(einfo, retc);
      }
 
// Check if we should generate an event
//
   if (evsObject && evsObject->Enabled(XrdOfsEvs::Trunc))
      {XrdOfsEvsInfo evInfo(tident, path, info, &trunc_Env, 0, Size);
       evsObject->Notify(XrdOfsEvs::Trunc, evInfo);
      }
 
// Now try to find the file or directory
//
   if (!(retc = XrdOfsOss->Truncate(path, Size, &trunc_Env))) return SFS_OK;
 
// An error occurred, return the error info
//
   return XrdOfsFS->Emsg(epname, einfo, retc, "trunc", path);
}

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 2743 of file XrdOfs.cc.

{
   EPNAME("Unpersist");
   const char *tident = oh->PoscUsr();
   int   poscNum, retc;
   short theMode;
 
// Trace the call
//
    FTRACE(close, "use=0");
 
// Generate a proper close event as one has not yet been generated
//
   if (xcev && XrdOfsFS->evsObject && *tident != '?'
   &&  XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Closew))
       {XrdOfsEvsInfo evInfo(tident, oh->Name());
        XrdOfsFS->evsObject->Notify(XrdOfsEvs::Closew, evInfo);
       }
 
// Now generate a removal event
//
   if (XrdOfsFS->Balancer) XrdOfsFS->Balancer->Removed(oh->Name());
   if (XrdOfsFS->evsObject && XrdOfsFS->evsObject->Enabled(XrdOfsEvs::Rm))
      {XrdOfsEvsInfo evInfo(tident, oh->Name());
       XrdOfsFS->evsObject->Notify(XrdOfsEvs::Rm, evInfo);
      }
 
// Count this
//
   OfsStats.Add(OfsStats.Data.numUnpsist);
 
// Now unpersist the file
//
   OfsEroute.Emsg(epname, "Unpersisting", tident, oh->Name());
   if ((poscNum = oh->PoscGet(theMode))) poscQ->Del(oh->Name(), poscNum, 1);
       else if ((retc = XrdOfsOss->Unlink(oh->Name())))
               OfsEroute.Emsg(epname, retc, "unpersist", oh->Name());
}

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 2786 of file XrdOfs.cc.

{
   int hr, min, sec;
 
// Compute hours, minutes, and seconds
//
   min = stime / 60;
   sec = stime % 60;
   hr  = min   / 60;
   min = min   % 60;
 
// Now format the message based on time duration
//
        if (!hr && !min)
           snprintf(buff,blen,"%d second%s",sec,(sec > 1 ? "s" : ""));
   else if (!hr)
          {if (sec > 10) min++;
           snprintf(buff,blen,"%d minute%s",min,(min > 1 ? "s" : ""));
          }
   else   {if (hr == 1)
              if (min <= 30)
                      snprintf(buff,blen,"%d minutes",min+60);
                 else snprintf(buff,blen,"%d hour and %d minutes",hr,min);
              else {if (min > 30) hr++;
                      snprintf(buff,blen,"%d hours",hr);
                   }
          }
 
// Complete the message
//
   buff[blen-1] = '\0';
   return buff;
}

Referenced by Stall().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

XrdOfsDirectory

friend class XrdOfsDirectory

friend

Definition at line 239 of file XrdOfs.hh.

References XrdOfsDirectory.

Referenced by newDir(), and XrdOfsDirectory.

XrdOfsFile

friend class XrdOfsFile

friend

Definition at line 240 of file XrdOfs.hh.

References XrdOfsFile.

Referenced by newFile(), and XrdOfsFile.

Member Data Documentation

ConfigFN

char* XrdOfs::ConfigFN

Definition at line 422 of file XrdOfs.hh.

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

dMask

mode_t XrdOfs::dMask[2]

Definition at line 386 of file XrdOfs.hh.

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

evrObject

XrdOfsEvr XrdOfs::evrObject

protected

Definition at line 430 of file XrdOfs.hh.

Referenced by Configure().

Finder

XrdCmsClient* XrdOfs::Finder

protected

Definition at line 431 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 387 of file XrdOfs.hh.

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

fwdCHMOD

struct fwdOpt XrdOfs::fwdCHMOD

Definition at line 411 of file XrdOfs.hh.

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

fwdMKDIR

struct fwdOpt XrdOfs::fwdMKDIR

Definition at line 412 of file XrdOfs.hh.

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

fwdMKPATH

struct fwdOpt XrdOfs::fwdMKPATH

Definition at line 413 of file XrdOfs.hh.

Referenced by Configure(), and mkdir().

fwdMV

struct fwdOpt XrdOfs::fwdMV

Definition at line 414 of file XrdOfs.hh.

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

fwdRM

struct fwdOpt XrdOfs::fwdRM

Definition at line 415 of file XrdOfs.hh.

Referenced by Config_Display(), and Configure().

fwdRMDIR

struct fwdOpt XrdOfs::fwdRMDIR

Definition at line 416 of file XrdOfs.hh.

Referenced by Config_Display(), and Configure().

fwdTRUNC

struct fwdOpt XrdOfs::fwdTRUNC

Definition at line 417 of file XrdOfs.hh.

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

MaxDelay

int XrdOfs::MaxDelay = 60

static

Definition at line 419 of file XrdOfs.hh.

Referenced by Config_Display(), and Stall().

myIF

XrdNetIF* XrdOfs::myIF

Definition at line 396 of file XrdOfs.hh.

Referenced by Configure(), and fsctl().

myPort

int XrdOfs::myPort

Definition at line 382 of file XrdOfs.hh.

Referenced by XrdOfs().

Options

int XrdOfs::Options

Definition at line 381 of file XrdOfs.hh.

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

OSSDelay

int XrdOfs::OSSDelay = 30

static

Definition at line 420 of file XrdOfs.hh.

Referenced by Emsg().

tpcRdrHost

char* XrdOfs::tpcRdrHost[2]

Definition at line 391 of file XrdOfs.hh.

Referenced by XrdOfs().

tpcRdrPort

int XrdOfs::tpcRdrPort[2]

Definition at line 392 of file XrdOfs.hh.

Referenced by XrdOfs().

---

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

• XrdOfs.hh
• XrdOfs.cc
• XrdOfsConfig.cc
• XrdOfsFAttr.cc
• XrdOfsFSctl.cc