XrdOssSys Class Reference

#include <XrdOssApi.hh>

Inheritance diagram for XrdOssSys:

Collaboration diagram for XrdOssSys:

Public Member Functions
	XrdOssSys ()
virtual	~XrdOssSys ()
int	Chmod (const char *, mode_t mode, XrdOucEnv *eP=0)
void	Config_Display (XrdSysError &)
int	Configure (const char *, XrdSysError &, XrdOucEnv *envP)
virtual int	Create (const char *, const char *, mode_t, XrdOucEnv &, int opts=0)
uint64_t	Features ()
int	GenLocalPath (const char *, char *)
int	GenRemotePath (const char *, char *)
int	Init (XrdSysLogger *, const char *, XrdOucEnv *envP)
int	Init (XrdSysLogger *lP, const char *cP)
int	IsRemote (const char *path)
int	Lfn2Pfn (const char *Path, char *buff, int blen)
const char *	Lfn2Pfn (const char *Path, char *buff, int blen, int &rc)
int	Mkdir (const char *, mode_t mode, int mkpath=0, XrdOucEnv *eP=0)
int	Mkpath (const char *, mode_t mode)
int	MSS_Closedir (void *)
int	MSS_Create (const char *path, mode_t, XrdOucEnv &)
void *	MSS_Opendir (const char *, int &rc)
int	MSS_Readdir (void *fd, char *buff, int blen)
int	MSS_Remdir (const char *, const char *)
int	MSS_Rename (const char *, const char *)
int	MSS_Stat (const char *, struct stat *buff=0)
int	MSS_Unlink (const char *)
virtual XrdOssDF *	newDir (const char *tident)
virtual XrdOssDF *	newFile (const char *tident)
unsigned long long	PathOpts (const char *path)
int	Reloc (const char *tident, const char *path, const char *cgName, const char *anchor=0)
int	Remdir (const char *, int Opts=0, XrdOucEnv *eP=0)
int	Rename (const char *, const char *, XrdOucEnv *eP1=0, XrdOucEnv *eP2=0)
virtual int	Stage (const char *, const char *, XrdOucEnv &, int, mode_t, unsigned long long)
void *	Stage_In (void *carg)
int	Stat (const char *, struct stat *, int opts=0, XrdOucEnv *Env=0)
int	StatFS (const char *path, char *buff, int &blen, XrdOucEnv *Env=0)
int	StatFS (const char *path, unsigned long long &Opt, long long &fSize, long long &fSpace)
int	StatLS (XrdOucEnv &env, const char *path, char *buff, int &blen)
int	StatPF (const char *, struct stat *, int)
int	Stats (char *bp, int bl)
int	StatVS (XrdOssVSInfo *sP, const char *sname=0, int updt=0)
int	StatXA (const char *path, char *buff, int &blen, XrdOucEnv *Env=0)
int	StatXP (const char *path, unsigned long long &attr, XrdOucEnv *Env=0)
int	Truncate (const char *, unsigned long long Size, XrdOucEnv *eP=0)
int	Unlink (const char *, int Opts=0, XrdOucEnv *eP=0)
Public Member Functions inherited from XrdOss
	XrdOss ()
	Constructor and Destructor. More...
virtual	~XrdOss ()
virtual void	Connect (XrdOucEnv &env)
virtual void	Disc (XrdOucEnv &env)
virtual void	EnvInfo (XrdOucEnv *envP)
virtual int	FSctl (int cmd, int alen, const char *args, char **resp=0)
virtual bool	getErrMsg (std::string &eText)
virtual int	StatPF (const char *path, struct stat *buff)

Static Public Member Functions
static int	AioInit ()

Public Attributes
union {
XrdOssStatInfo_t	STT_Func
XrdOssStatInfo2_t	STT_Fund
};
char *	ConfigFN
unsigned long long	DirFlags
OssDPath *	DPList
int	FDFence
int	FDLimit
int	isMSSC
XrdOucName2Name *	lcl_N2N
int	lenDP
char *	LocalRoot
long long	MaxSize
int	MaxTwiddle
XrdVersionInfo *	myVersion
char *	N2N_Lib
char *	N2N_Parms
short	numCG
short	numDP
int	OptFlags
int	prActive
int	prBytes
short	prDepth
long long	prPBits
long long	prPMask
int	prPSize
short	prQSize
char *	RemoteRoot
XrdOucName2Name *	rmt_N2N
XrdOucPListAnchor	RPList
char *	RSSCmd
int	RSSTout
int	Solitary
XrdOucPListAnchor	SPList
char *	StageAction
int	StageActLen
int	StageAln [MaxArgs]
int	StageAnum
char *	StageArg [MaxArgs]
int	StageAsync
char *	StageCmd
int	StageCreate
char *	StageEvents
int	StageEvSize
int	StageFormat
XrdFrcProxy *	StageFrm
char *	StageMsg
int	StageRealTime
XrdOucMsubs *	StageSnd
char	STT_DoARE
char	STT_DoN2N
char *	STT_Lib
char *	STT_Parms
int	STT_PreOp
char	STT_V2
XrdOucName2Name *	the_N2N
int	Trace

Static Public Attributes
static int	AioAllOk = 0
static char	chkMmap = 0
static const int	MaxArgs = 15
static char	tryMmap = 0
Static Public Attributes inherited from XrdOss
static const int	PF_csVer = 0x00000001
	verified file checksums present More...
static const int	PF_csVun = 0x00000002
	unverified file checksums present More...
static const int	PF_dInfo = 0x00000001
static const int	PF_dNums = 0x00000002
static const int	PF_dStat = 0x00000008
static const int	PF_isLFN = 0x00000004

Protected Member Functions
int	Alloc_Cache (XrdOssCreateInfo &, XrdOucEnv &, bool)
int	Alloc_Local (XrdOssCreateInfo &, XrdOucEnv &)
int	BreakLink (const char *local_path, struct stat &statbuff)
int	CalcTime ()
int	CalcTime (XrdOssStage_Req *req)
void	ConfigCache (XrdSysError &Eroute, bool pass2=false)
void	ConfigMio (XrdSysError &Eroute)
int	ConfigN2N (XrdSysError &Eroute, XrdOucEnv *envP)
int	ConfigProc (XrdSysError &Eroute)
void	ConfigSpace (const char *Lfn)
void	ConfigSpace (XrdSysError &Eroute)
void	ConfigSpath (XrdSysError &Eroute, const char *Pn, unsigned long long &Fv, int noMSS)
int	ConfigStage (XrdSysError &Eroute)
int	ConfigStageC (XrdSysError &Eroute)
int	ConfigStatLib (XrdSysError &Eroute, XrdOucEnv *envP)
void	ConfigStats (dev_t Devnum, char *lP)
void	ConfigStats (XrdSysError &Eroute)
int	ConfigXeq (char *, XrdOucStream &, XrdSysError &)
void	doScrub ()
int	Find (XrdOssStage_Req *req, void *carg)
int	getCname (const char *path, struct stat *sbuff, char *cgbuff)
int	GetFile (XrdOssStage_Req *req)
int	getID (const char *, XrdOucEnv &, char *, int)
int	getStats (char *buff, int blen)
time_t	HasFile (const char *fn, const char *sfx, time_t *mTime=0)
void	List_Path (const char *, const char *, unsigned long long, XrdSysError &)
int	MSS_Xeq (XrdOucStream **xfd, int okerr, const char *cmd, const char *arg1=0, const char *arg2=0)
int	RenameLink (char *old_path, char *new_path)
int	RenameLink3 (char *cPath, char *old_path, char *new_path)
int	SetFattr (XrdOssCreateInfo &crInfo, int datfd, time_t mtime)
int	Stage_QT (const char *, const char *, XrdOucEnv &, int, mode_t)
int	Stage_RT (const char *, const char *, XrdOucEnv &, unsigned long long)
int	tranmode (char *)
int	xalloc (XrdOucStream &Config, XrdSysError &Eroute)
int	xcache (XrdOucStream &Config, XrdSysError &Eroute)
int	xcachescan (XrdOucStream &Config, XrdSysError &Eroute)
int	xdefault (XrdOucStream &Config, XrdSysError &Eroute)
int	xfdlimit (XrdOucStream &Config, XrdSysError &Eroute)
int	xmaxsz (XrdOucStream &Config, XrdSysError &Eroute)
int	xmemf (XrdOucStream &Config, XrdSysError &Eroute)
int	xnml (XrdOucStream &Config, XrdSysError &Eroute)
int	xpath (XrdOucStream &Config, XrdSysError &Eroute)
int	xprerd (XrdOucStream &Config, XrdSysError &Eroute)
int	xspace (XrdOucStream &Config, XrdSysError &Eroute, const char *grp, bool isAsgn)
int	xspace (XrdOucStream &Config, XrdSysError &Eroute, int *isCD=0)
int	xspaceBuild (OssSpaceConfig &sInfo, XrdSysError &Eroute)
int	xstg (XrdOucStream &Config, XrdSysError &Eroute)
int	xstl (XrdOucStream &Config, XrdSysError &Eroute)
int	xtrace (XrdOucStream &Config, XrdSysError &Eroute)
int	xusage (XrdOucStream &Config, XrdSysError &Eroute)
int	xxfr (XrdOucStream &Config, XrdSysError &Eroute)

Protected Attributes
int	badreqs
int	cscanint
int	fuzalloc
long long	minalloc
int	ovhalloc
bool	pfcMode
long long	pndbytes
char *	QFile
XrdOucProg *	RSSProg
XrdOucProg *	StageProg
long long	stgbytes
long long	totbytes
int	totreqs
char *	UDir
short	USync
char *	xfrFdir
int	xfrFdln
int	xfrhold
int	xfrkeep
int	xfrovhd
int	xfrspeed
int	xfrtcount
int	xfrthreads

Detailed Description

Definition at line 160 of file XrdOssApi.hh.

Constructor & Destructor Documentation

XrdOssSys()

XrdOssSys::XrdOssSys

(

)

Definition at line 185 of file XrdOssConfig.cc.

{
   static XrdVERSIONINFODEF(myVer, XrdOss, XrdVNUMBER, XrdVERSION);
   myVersion     = &myVer;
   xfrtcount     = 0;
   pndbytes      = 0;
   stgbytes      = 0;
   totbytes      = 0;
   totreqs       = 0;
   badreqs       = 0;
   MaxTwiddle    = 3;
   tryMmap       = 0;
   chkMmap       = 0;
   lcl_N2N = rmt_N2N = the_N2N = 0; 
   N2N_Lib = N2N_Parms         = 0;
   StageCmd      = 0;
   StageMsg      = 0; 
   StageSnd      = 0;
   StageFrm      = 0;
   StageRealTime = 1;
   StageAsync    = 0;
   StageCreate   = 0;
   StageEvents   = (char *)"-";
   StageEvSize   = 1;
   StageAction   = (char *)"wq "; 
   StageActLen   = 3;
   RSSCmd        = 0;
   isMSSC        = 0;
   RSSTout       =15*1000;
   DirFlags      = 0; 
   OptFlags      = 0;
   LocalRoot     = 0;
   RemoteRoot    = 0;
   cscanint      = 600;
   FDFence       = -1;
   FDLimit       = -1;
   MaxSize       = 0;
   minalloc      = 0;
   ovhalloc      = 0;
   fuzalloc      = 0;
   xfrspeed      = 9*1024*1024;
   xfrovhd       = 30;
   xfrhold       =  3*60*60;
   xfrkeep       = 20*60;
   xfrthreads    = 1;
   ConfigFN      = 0;
   QFile         = 0;
   UDir          = 0;
   USync         = 0;
   Solitary      = 0;
   DPList        = 0;
   lenDP         = 0;
   numCG = numDP = 0;
   xfrFdir       = 0;
   xfrFdln       = 0;
   pfcMode       = false;
   RSSProg       = 0;
   StageProg     = 0;
   prPBits       = (long long)sysconf(_SC_PAGESIZE);
   prPSize       = static_cast<int>(prPBits);
   prPBits--;
   prPMask       = ~prPBits;
   prBytes       = 0;
   prActive      = 0;
   prDepth       = 0;
   prQSize       = 0;
   STT_Lib       = 0;
   STT_Parms     = 0;
   STT_Func      = 0;
   STT_Fund      = 0;
   STT_PreOp     = 0;
   STT_DoN2N     = 1;
   STT_V2        = 0;
   STT_DoARE     = 0;
}

References badreqs, chkMmap, ConfigFN, cscanint, DirFlags, DPList, FDFence, FDLimit, fuzalloc, isMSSC, lcl_N2N, lenDP, LocalRoot, MaxSize, MaxTwiddle, minalloc, myVersion, N2N_Lib, N2N_Parms, numCG, numDP, OptFlags, ovhalloc, pfcMode, pndbytes, prActive, prBytes, prDepth, prPBits, prPMask, prPSize, prQSize, QFile, RemoteRoot, rmt_N2N, RSSCmd, RSSProg, RSSTout, Solitary, StageAction, StageActLen, StageAsync, StageCmd, StageCreate, StageEvents, StageEvSize, StageFrm, StageMsg, StageProg, StageRealTime, StageSnd, stgbytes, STT_DoARE, STT_DoN2N, STT_Lib, STT_Parms, STT_PreOp, STT_V2, the_N2N, totbytes, totreqs, tryMmap, UDir, USync, xfrFdir, xfrFdln, xfrhold, xfrkeep, xfrovhd, xfrspeed, xfrtcount, xfrthreads, and XrdCms::XrdVERSIONINFODEF().

Here is the call graph for this function:

~XrdOssSys()

virtual XrdOssSys::~XrdOssSys ( )

inlinevirtual

Definition at line 292 of file XrdOssApi.hh.

{}

Member Function Documentation

AioInit()

int XrdOssSys::AioInit ( )

static

Definition at line 281 of file XrdOssAio.cc.

{
#if defined(_POSIX_ASYNCHRONOUS_IO)
   EPNAME("AioInit");
   extern void *XrdOssAioWait(void *carg);
   pthread_t tid;
   int retc;
 
#ifndef HAVE_SIGWTI
// For those platforms that do not have sigwaitinfo(), we provide the
// appropriate emulation using a signal handler. We actually provide for
// two handlers since we separate reads from writes. To emulate synchronous
// signals, we prohibit one signal hander from interrupting another one.
//
    struct sigaction sa;
 
    sa.sa_sigaction = XrdOssAioRSH;
    sa.sa_flags = SA_SIGINFO;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, OSS_AIO_WRITE_DONE);
    if (sigaction(OSS_AIO_READ_DONE, &sa, NULL) < 0)
       {OssEroute.Emsg("AioInit", errno, "creating AIO read signal handler; "
                                 "AIO support terminated.");
        return 0;
       }
 
    sa.sa_sigaction = XrdOssAioWSH;
    sa.sa_flags = SA_SIGINFO;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, OSS_AIO_READ_DONE);
    if (sigaction(OSS_AIO_WRITE_DONE, &sa, NULL) < 0)
       {OssEroute.Emsg("AioInit", errno, "creating AIO write signal handler; "
                                 "AIO support terminated.");
        return 0;
       }
#endif
 
// The AIO signal handler consists of two thread (one for read and one for
// write) that synhronously wait for AIO events. We assume, blithely, that
// the first two real-time signals have been blocked for all threads.
//
   if ((retc = XrdSysThread::Run(&tid, XrdOssAioWait,
                                (void *)(&OSS_AIO_READ_DONE))) < 0)
      OssEroute.Emsg("AioInit", retc, "creating AIO read signal thread; "
                                 "AIO support terminated.");
#ifdef __FreeBSD__
      else {DEBUG("started AIO read signal thread.");
#else
      else {DEBUG("started AIO read signal thread; tid=" <<(unsigned int)tid);
#endif
            if ((retc = XrdSysThread::Run(&tid, XrdOssAioWait,
                                (void *)(&OSS_AIO_WRITE_DONE))) < 0)
               OssEroute.Emsg("AioInit", retc, "creating AIO write signal thread; "
                                 "AIO support terminated.");
#ifdef __FreeBSD__
               else {DEBUG("started AIO write signal thread.");
#else
               else {DEBUG("started AIO write signal thread; tid=" <<(unsigned int)tid);
#endif
                     AioAllOk = 1;
                    }
           }
 
// All done
//
   return AioAllOk;
#else
   return 1;
#endif
}

References AioAllOk, DEBUG, XrdSysError::Emsg(), EPNAME, OssEroute, XrdSysThread::Run(), and XrdOssAioWait().

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

Alloc_Cache()

int XrdOssSys::Alloc_Cache ( XrdOssCreateInfo &  crInfo, XrdOucEnv &  env, bool  forcecg  )

protected

Definition at line 247 of file XrdOssCreate.cc.

{
   EPNAME("Alloc_Cache")
   int datfd, rc;
   const char *spName;
   char pbuff[MAXPATHLEN+1], cgbuff[XrdOssSpace::minSNbsz], *tmp;
   XrdOssCache::allocInfo aInfo(crInfo.Path, pbuff, sizeof(pbuff));
 
// Grab the suggested size from the environment
//
   if ((tmp = env.Get(OSS_ASIZE))
   &&  XrdOuca2x::a2sz(OssEroute,"invalid asize",tmp,&aInfo.cgSize,0))
      return -XRDOSS_E8018;
 
// Determine the space we should use for this allocation
//
   spName = env.Get(OSS_CGROUP);
   if (!spName || (!forcecg && SPList.NotEmpty() && SPList.Default() == spAssign))
      {XrdOucPList *pl = SPList.About(crInfo.LFN);
       if (pl && (!spName || pl->Attr() == spAssign)) spName = pl->Name();
      }
 
// Get the correct cache group and partition path
//
   if ((aInfo.cgPath=XrdOssCache::Parse(spName,cgbuff,sizeof(cgbuff))))
      aInfo.cgPlen = strlen(aInfo.cgPath);
 
// Allocate space in the cache.
//
   aInfo.cgName = cgbuff;
   aInfo.aMode  = crInfo.Amode;
   if ((datfd = XrdOssCache::Alloc(aInfo)) < 0) return datfd;
 
// Set the pfn as the extended attribute if we are in new mode
//
   if (!(crInfo.pOpts & XRDEXP_NOXATTR)
   &&  (rc = XrdSysFAttr::Xat->Set(XrdFrcXAttrPfn::Name(), crInfo.Path,
                                   strlen(crInfo.Path)+1, pbuff, datfd)))
      {close(datfd); return rc;}
 
// Set extended attributes for this newly created file if allowed to do so.
// SetFattr() alaways closes the provided file descriptor!
//
   if ((rc = SetFattr(crInfo, datfd, 1))) return rc;
 
// Now create a symbolic link to the target
//
   if ((symlink(pbuff, crInfo.Path) && errno != EEXIST)
   ||  unlink(crInfo.Path) || symlink(pbuff, crInfo.Path))
      {rc = -errno; unlink(pbuff);}
 
// All done
//
   DEBUG(aInfo.cgName <<" cache for " <<pbuff);
   return rc;
}

References XrdOuca2x::a2sz(), XrdOucPListAnchor::About(), XrdOssCache::Alloc(), XrdOssCache::allocInfo::aMode, XrdOssCreateInfo::Amode, XrdOucPList::Attr(), XrdOssCache::allocInfo::cgName, XrdOssCache::allocInfo::cgPath, XrdOssCache::allocInfo::cgPlen, XrdOssCache::allocInfo::cgSize, close, DEBUG, XrdOucPListAnchor::Default(), EPNAME, XrdOucEnv::Get(), XrdOssCreateInfo::LFN, XrdOssSpace::minSNbsz, XrdFrcXAttrPfn::Name(), XrdOucPList::Name(), XrdOucPListAnchor::NotEmpty(), OSS_ASIZE, OSS_CGROUP, OssEroute, XrdOssCache::Parse(), XrdOssCreateInfo::Path, XrdOssCreateInfo::pOpts, XrdSysXAttr::Set(), SetFattr(), spAssign, SPList, unlink, XrdSysFAttr::Xat, XRDEXP_NOXATTR, and XRDOSS_E8018.

Referenced by Create().

Here is the call graph for this function:

Here is the caller graph for this function:

Alloc_Local()

int XrdOssSys::Alloc_Local ( XrdOssCreateInfo &  crInfo, XrdOucEnv &  env  )

protected

Definition at line 308 of file XrdOssCreate.cc.

{
   int datfd, rc;
 
// Simply open the file in the local filesystem, creating it if need be.
//
   do {datfd = open(crInfo.Path, O_RDWR|O_CREAT|O_TRUNC, crInfo.Amode);}
               while(datfd < 0 && errno == EINTR);
   if (datfd < 0) return -errno;
 
// Set extended attributes for this newly created file if allowed to do so.
// SetFattr() alaways closes the provided file descriptor!
//
   if ((rc = SetFattr(crInfo, datfd, 1))) return rc;
 
// All done
//
   return XrdOssOK;
}

References XrdOssCreateInfo::Amode, open, XrdOssCreateInfo::Path, SetFattr(), and XrdOssOK.

Referenced by Create().

Here is the call graph for this function:

Here is the caller graph for this function:

BreakLink()

int XrdOssSys::BreakLink ( const char *  local_path, struct stat &  statbuff  )

protected

Definition at line 172 of file XrdOssUnlink.cc.

{
    EPNAME("BreakLink")
    char *lP, lnkbuff[MAXPATHLEN+64];
    int lnklen, retc = 0;
 
// Read the contents of the link
//
    if ((lnklen = readlink(local_path, lnkbuff, sizeof(lnkbuff)-1)) < 0)
       return -errno;
 
// Return the actual stat information on the target (which might not exist
//
   lnkbuff[lnklen] = '\0';
   if (stat(lnkbuff, &statbuff)) statbuff.st_size = 0;
      else if (unlink(lnkbuff) && errno != ENOENT)
              {retc = -errno;
               OssEroute.Emsg("BreakLink",retc,"unlink symlink target",lnkbuff);
              } else {DEBUG("broke link " <<local_path <<"->" <<lnkbuff);}
 
// If this is a new-style cache, then we must also remove the pfn file.
// In any case, return the appropriate cache group.
//
   lP = lnkbuff+lnklen-1;
   if (*lP == XrdOssPath::xChar)
      {if (statbuff.st_size)
          {XrdOssPath::Trim2Base(lP);
           XrdOssCache::Adjust(lnkbuff, -statbuff.st_size);
          }
      } else if (statbuff.st_size)
                XrdOssCache::Adjust(statbuff.st_dev, -statbuff.st_size);
 
// All done
//
   return retc;
}

References XrdOssCache::Adjust(), DEBUG, XrdSysError::Emsg(), EPNAME, OssEroute, stat, XrdOssPath::Trim2Base(), unlink, and XrdOssPath::xChar.

Referenced by Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcTime() [1/2]

int XrdOssSys::CalcTime ( )

protected

Definition at line 384 of file XrdOssStage.cc.

{
 
// For queued staging we have no good way to estimate the time, as of yet.
// So, return 60 seconds. Note that the following code, which is far more
// elaborate, rarely returns the right estimate anyway.
//
   return (StageAsync ? -EINPROGRESS : 60);
}

References StageAsync.

Referenced by Stage_QT(), and Stage_RT().

Here is the caller graph for this function:

CalcTime() [2/2]

int XrdOssSys::CalcTime ( XrdOssStage_Req *  req )

protected

Definition at line 394 of file XrdOssStage.cc.

{
    unsigned long long numq = 1;
    unsigned long long tbytes = req->size + stgbytes/2;
    int xfrtime;
    time_t now;
    XrdOssStage_Req *rqp = req;
 
// Return an EINP{ROG if we are doing async staging
//
   if (StageAsync) return -EINPROGRESS;
 
// If the request is active, recalculate the time based on previous estimate
//
   if (req->flags & XRDOSS_REQ_ACTV) 
      {if ((xfrtime = req->sigtod - time(0)) > xfrovhd) return xfrtime;
          else return (xfrovhd < 4 ? 2 : xfrovhd / 2);
      }
 
// Calculate the number of pending bytes being transferred plus 1/2 of the
// current number of bytes being transferred
//
    while ((rqp=(rqp->pendList.Next()->Item()))) {tbytes += rqp->size; numq++;}
 
// Calculate when this request should be completed
//
    now = time(0);
    req->sigtod = tbytes / xfrspeed + numq * xfrovhd + now;
 
// Calculate the time it will take to get this file
//
   if ((xfrtime = req->sigtod - now) <= xfrovhd) return xfrovhd+3;
   return xfrtime;
}

References XrdOssStage_Req::flags, XrdOucDLlist< T >::Item(), XrdOucDLlist< T >::Next(), XrdOssStage_Req::pendList, XrdOssStage_Req::sigtod, XrdOssStage_Req::size, StageAsync, stgbytes, xfrovhd, xfrspeed, and XRDOSS_REQ_ACTV.

Here is the call graph for this function:

Chmod()

int XrdOssSys::Chmod ( const char *  path, mode_t  mode, XrdOucEnv *  envP = 0  )

virtual

Change file mode settings.

Parameters

path	- Pointer to the path of the file in question.
mode	- The new file mode setting.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 332 of file XrdOssApi.cc.

{
    char actual_path[MAXPATHLEN+1], *local_path;
    int retc;
 
// Generate local path
//
   if (lcl_N2N)
      if ((retc = lcl_N2N->lfn2pfn(path, actual_path, sizeof(actual_path)))) 
         return retc;
         else local_path = actual_path;
      else local_path = (char *)path;
 
// Change the file only in the local filesystem.
//
   return (chmod(local_path, mode) ? -errno : XrdOssOK);
}

References lcl_N2N, XrdOucName2Name::lfn2pfn(), and XrdOssOK.

Here is the call graph for this function:

Config_Display()

void XrdOssSys::Config_Display

(

XrdSysError &

Eroute

)

Definition at line 457 of file XrdOssConfig.cc.

{
     char buff[4096], *cloc;
     XrdOucPList *fp;
 
     // Preset some tests
     //
     int HaveRSSCmd     = (RSSCmd     && RSSCmd[0]);
     int HaveStageCmd   = (StageCmd   && StageCmd[0]);
     int HaveRemoteRoot = (RemoteRoot && RemoteRoot[0]);
     int HaveLocalRoot  = (LocalRoot  && LocalRoot[0]);
     int HaveStageMsg   = (StageMsg   && StageMsg[0]);
     int HaveN2N_Lib    = (N2N_Lib != 0);
 
     if (!ConfigFN || !ConfigFN[0]) cloc = (char *)"Default";
        else cloc = ConfigFN;
 
     snprintf(buff, sizeof(buff), "Config effective %s oss configuration:\n"
                                  "       oss.alloc        %lld %d %d\n"
                                  "       oss.spacescan    %d\n"
                                  "       oss.fdlimit      %d %d\n"
                                  "       oss.maxsize      %lld\n"
                                  "%s%s%s"
                                  "%s%s%s"
                                  "%s%s%s"
                                  "%s%s%s%s%s"
                                  "%s%s%s"
                                  "%s%s%s"
                                  "       oss.trace        %x\n"
                                  "       oss.xfr          %d deny %d keep %d",
             cloc,
             minalloc, ovhalloc, fuzalloc,
             cscanint,
             FDFence, FDLimit, MaxSize,
             XrdOssConfig_Val(N2N_Lib,    namelib),
             XrdOssConfig_Val(LocalRoot,  localroot),
             XrdOssConfig_Val(RemoteRoot, remoteroot),
             XrdOssConfig_Vop(StageCmd,   stagecmd, StageAsync,  "async ","sync ",
                                                    StageCreate, "creates ", ""),
             XrdOssConfig_Val(StageMsg,   stagemsg),
             XrdOssConfig_Val(RSSCmd,     rsscmd),
             OssTrace.What,
             xfrthreads, xfrhold, xfrkeep);
 
     Eroute.Say(buff);
 
     XrdOssMio::Display(Eroute);
 
     XrdOssCache::List("       oss.", Eroute);
           List_Path("       oss.defaults ", "", DirFlags, Eroute);
     fp = RPList.First();
     while(fp)
          {List_Path("       oss.path ", fp->Path(), fp->Flag(), Eroute);
           fp = fp->Next();
          }
     fp = SPList.First();
     while(fp)
          {Eroute.Say("       oss.space ", fp->Name(),
                      (fp->Attr() == spAssign ? " assign  " : " default "),
                       fp->Path());
           fp = fp->Next();
          }
}

References XrdOucPList::Attr(), ConfigFN, cscanint, DirFlags, XrdOssMio::Display(), FDFence, FDLimit, XrdOucPListAnchor::First(), XrdOucPList::Flag(), fuzalloc, XrdOssCache::List(), List_Path(), LocalRoot, MaxSize, minalloc, N2N_Lib, XrdOucPList::Name(), XrdOucPList::Next(), OssTrace, ovhalloc, XrdOucPList::Path(), RemoteRoot, RPList, RSSCmd, XrdSysError::Say(), spAssign, SPList, StageAsync, StageCmd, StageCreate, StageMsg, XrdSysTrace::What, xfrhold, xfrkeep, xfrthreads, XrdOssConfig_Val, and XrdOssConfig_Vop.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigCache()

void XrdOssSys::ConfigCache ( XrdSysError &  Eroute, bool  pass2 = false  )

protected

Definition at line 528 of file XrdOssConfig.cc.

{
     const unsigned long long conFlags = 
                    XRDEXP_NOCHECK | XRDEXP_NODREAD |
                    XRDEXP_MLOK    | XRDEXP_MKEEP   | XRDEXP_MMAP  |
                    XRDEXP_MIG     | XRDEXP_MWMODE  | XRDEXP_PURGE |
                    XRDEXP_RCREATE | XRDEXP_STAGE   | XRDEXP_STAGEMM;
 
     XrdOucPList *fp = RPList.First();
     unsigned long long oflag, pflag;
 
// If this is pass 2 then if we are in pfcMode, then reset r/o flag to r/w
// to allow the pfc to actually write into the cache paths.
//
   if (pass2)
      {if (pfcMode)
          {while(fp)
                {pflag = fp->Flag();
                 if (pflag & XRDEXP_PFCACHE) fp->Set(pflag & ~XRDEXP_NOTRW);
                 fp = fp->Next();
                }
          }
       return;
      }
 
// Run through all the paths and resolve any conflicts with a cache
//
   while(fp)
        {oflag = pflag = fp->Flag();
         if ((pflag & XRDEXP_PFCACHE)
         ||  (pfcMode && !(pflag & XRDEXP_PFCACHE_X)))
            {if (!(pflag & XRDEXP_NOTRW)) pflag |= XRDEXP_READONLY;
             pflag &= ~conFlags;
             pflag |=  XRDEXP_PFCACHE | XRDEXP_NOFICL;
             if (oflag != pflag) fp->Set(pflag);
            }
         fp = fp->Next();
        }
 
// Handle default settings
//
   if (DirFlags & XRDEXP_PFCACHE)
      {DirFlags |=  XRDEXP_READONLY | XRDEXP_NOFICL;
       DirFlags &= ~conFlags;
      }
}

References DirFlags, XrdOucPListAnchor::First(), XrdOucPList::Flag(), XrdOucPList::Next(), pfcMode, RPList, XrdOucPList::Set(), XRDEXP_MIG, XRDEXP_MKEEP, XRDEXP_MLOK, XRDEXP_MMAP, XRDEXP_MWMODE, XRDEXP_NOCHECK, XRDEXP_NODREAD, XRDEXP_NOFICL, XRDEXP_NOTRW, XRDEXP_PFCACHE, XRDEXP_PFCACHE_X, XRDEXP_PURGE, XRDEXP_RCREATE, XRDEXP_READONLY, XRDEXP_STAGE, and XRDEXP_STAGEMM.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigMio()

void XrdOssSys::ConfigMio ( XrdSysError &  Eroute )

protected

Definition at line 579 of file XrdOssConfig.cc.

{
     XrdOucPList *fp;
     unsigned long long flags = 0;
     int setoff = 0;
 
// Initialize memory mapping setting to speed execution
//
   if (!(tryMmap = XrdOssMio::isOn())) return;
   chkMmap = XrdOssMio::isAuto();
 
// Run through all the paths and get the composite flags
//
   fp = RPList.First();
   while(fp)
        {flags |= fp->Flag();
         fp = fp->Next();
        }
 
// Handle default settings
//
   if (DirFlags & XRDEXP_MEMAP && !(DirFlags & XRDEXP_NOTRW))
      DirFlags |= XRDEXP_FORCERO;
   flags |= DirFlags;
   if (DirFlags & (XRDEXP_MLOK | XRDEXP_MKEEP)) DirFlags |= XRDEXP_MMAP;
 
// Produce warnings if unsupported features have been selected
//
#if !defined(_POSIX_MAPPED_FILES)
   if (flags & XRDEXP_MEMAP)
      {Eroute.Say("Config warning: memory mapped files not supported; "
                             "feature disabled.");
       setoff = 1;
       fp = RPList.First();
       while(fp)
            {fp->Set(fp->Flag() & ~XRDEXP_MEMAP);
             fp = fp->Next();
            }
       DirFlags = DirFlags & ~XRDEXP_MEMAP;
      }
#elif !defined(_POSIX_MEMLOCK)
   if (flags & XRDEXP_MLOK)
      {Eroute.Say("Config warning: memory locked files not supported; "
                             "feature disabled.");
       fp = RPList.First();
       while(fp)
            {fp->Set(fp->Flag() & ~XRDEXP_MLOK);
             fp = fp->Next();
            }
       DirFlags = DirFlags & ~XRDEXP_MLOK;
      }
#endif
 
// If no memory flags are set, turn off memory mapped files
//
   if (!(flags & XRDEXP_MEMAP) || setoff)
     {XrdOssMio::Set(0, 0, 0);
      tryMmap = 0; chkMmap = 0;
     }
}

References chkMmap, DirFlags, XrdOucPListAnchor::First(), XrdOucPList::Flag(), XrdOssMio::isAuto(), XrdOssMio::isOn(), XrdOucPList::Next(), RPList, XrdSysError::Say(), XrdOucPList::Set(), XrdOssMio::Set(), tryMmap, XRDEXP_FORCERO, XRDEXP_MEMAP, XRDEXP_MKEEP, XRDEXP_MLOK, XRDEXP_MMAP, and XRDEXP_NOTRW.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigN2N()

int XrdOssSys::ConfigN2N ( XrdSysError &  Eroute, XrdOucEnv *  envP  )

protected

Definition at line 644 of file XrdOssConfig.cc.

{
   XrdOucN2NLoader n2nLoader(&Eroute,ConfigFN,N2N_Parms,LocalRoot,RemoteRoot);
 
// Get the plugin
//
   if (!(the_N2N = n2nLoader.Load(N2N_Lib, *myVersion, envP))) return 1;
 
// Optimize the local case
//
   if (N2N_Lib)   rmt_N2N = lcl_N2N = the_N2N;
      else {if (LocalRoot)  lcl_N2N = the_N2N;
            if (RemoteRoot) rmt_N2N = the_N2N;
           }
 
// All done
//
   return 0;
}

References ConfigFN, XrdProxy::envP, lcl_N2N, XrdOucN2NLoader::Load(), LocalRoot, myVersion, N2N_Lib, N2N_Parms, RemoteRoot, rmt_N2N, and the_N2N.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigProc()

int XrdOssSys::ConfigProc ( XrdSysError &  Eroute )

protected

Definition at line 668 of file XrdOssConfig.cc.

{
  char *var;
  int  cfgFD, retc, NoGo = XrdOssOK;
  XrdOucEnv myEnv;
  XrdOucStream Config(&Eroute, getenv("XRDINSTANCE"), &myEnv, "=====> ");
 
// If there is no config file, return with the defaults sets.
//
   if( !ConfigFN || !*ConfigFN)
     {Eroute.Say("Config warning: config file not specified; defaults assumed.");
      return XrdOssOK;
     }
 
// Try to open the configuration file.
//
   if ( (cfgFD = open(ConfigFN, O_RDONLY, 0)) < 0)
      {Eroute.Emsg("Config", errno, "open config file", ConfigFN);
       return 1;
      }
   Config.Attach(cfgFD);
   static const char *cvec[] = { "*** oss plugin config:", 0 };
   Config.Capture(cvec);
 
// Now start reading records until eof.
//
   while((var = Config.GetMyFirstWord()))
        {if (!strncmp(var, "oss.", 4))
            {if (ConfigXeq(var+4, Config, Eroute)) {Config.Echo(); NoGo = 1;}}
            else if (!strcmp(var,"all.export")
                 &&  xpath(Config, Eroute)) {Config.Echo(); NoGo = 1;}
        }
 
// 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();
 
// Return final return code
//
   return NoGo;
}

References XrdCms::Config, ConfigFN, ConfigXeq(), XrdSysError::Emsg(), open, XrdSysError::Say(), xpath(), and XrdOssOK.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigSpace() [1/2]

void XrdOssSys::ConfigSpace ( const char *  Lfn )

protected

Definition at line 755 of file XrdOssConfig.cc.

{
   struct stat statbuff;
   char Pfn[MAXPATHLEN+1+8], *Slash;
 
// Get local path for this lfn
//
   if (GenLocalPath(Lfn, Pfn)) return;
 
// Now try to find the actual existing base path
//
   while(stat(Pfn, &statbuff))
        {if (!(Slash = rindex(Pfn, '/')) || Slash == Pfn) return;
         *Slash = '\0';
        }
 
// Add this path to the file system data. We need to do this to track space
//
   XrdOssCache_FS::Add(Pfn);
}

References XrdOssCache_FS::Add(), GenLocalPath(), and stat.

Here is the call graph for this function:

ConfigSpace() [2/2]

void XrdOssSys::ConfigSpace ( XrdSysError &  Eroute )

protected

Definition at line 716 of file XrdOssConfig.cc.

{
   XrdOucPList *fp = RPList.First();
   int noCacheFS = !(OptFlags & XrdOss_CacheFS);
 
// Configure space for each non-cached exported path. We only keep track of
// space that can actually be modified in some way.
//
   while(fp)
        {if ( ((noCacheFS || (fp->Flag() & XRDEXP_INPLACE)) &&
               (fp->Flag() & (XRDEXP_STAGE | XRDEXP_PURGE)))
         ||   !(fp->Flag() &  XRDEXP_NOTRW)
         ||    (fp->Flag() &  XRDEXP_PFCACHE) )
            ConfigSpace(fp->Path());
         fp = fp->Next();
        }
 
// If there is a space list then verify it
//
   if ((fp = SPList.First()))
      {XrdOssCache_Group  *fsg;
       const char *what;
       bool zAssign = false;
       while(fp)
            {if (fp->Attr() != spAssign) what = "default space ";
                else {zAssign = true;    what = "assign space ";}
             const char *grp = fp->Name();
             fsg = XrdOssCache_Group::fsgroups;
             while(fsg) {if (!strcmp(fsg->group,grp)) break; fsg = fsg->next;}
             if (!fsg) Eroute.Say("Config warning: unable to ", what, grp,
                                  " to ", fp->Path(), "; space not defined.");
             fp = fp->Next();
            }
       if (zAssign) SPList.Default(static_cast<unsigned long long>(spAssign));
      }
}

References XrdOucPList::Attr(), XrdOucPListAnchor::Default(), XrdOucPListAnchor::First(), XrdOucPList::Flag(), XrdOssCache_Group::fsgroups, XrdOssCache_Group::group, XrdOucPList::Name(), XrdOssCache_Group::next, XrdOucPList::Next(), OptFlags, XrdOucPList::Path(), RPList, XrdSysError::Say(), spAssign, SPList, XRDEXP_INPLACE, XRDEXP_NOTRW, XRDEXP_PFCACHE, XRDEXP_PURGE, XRDEXP_STAGE, and XrdOss_CacheFS.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigSpath()

void XrdOssSys::ConfigSpath ( XrdSysError &  Eroute, const char *  Pn, unsigned long long &  Fv, int  noMSS  )

protected

Definition at line 780 of file XrdOssConfig.cc.

{
// mig+r/w -> check unless nocheck was specified
//
   if (!(flags & XRDEXP_CHECK_X))
      {if ((flags & XRDEXP_MIG) && !(flags & XRDEXP_NOTRW))
               flags &= ~XRDEXP_NOCHECK;
          else flags |=  XRDEXP_NOCHECK;
      }
// rsscmd  -> dread unless nodread was specified
//
   if (!(flags & XRDEXP_DREAD_X))
      {if (RSSCmd) flags &= ~XRDEXP_NODREAD;
          else     flags |=  XRDEXP_NODREAD;
      }
 
// If there is no mss then turn off all mss related optionss, otherwise check
// if the options may leave the system in an inconsistent state
//
   if (noMSS) flags=(flags & ~XRDEXP_RCREATE)|XRDEXP_NOCHECK|XRDEXP_NODREAD;
      else if ((flags & XRDEXP_MIG)   &&  (flags & XRDEXP_NOCHECK)
           && !(flags & XRDEXP_NOTRW))
              Eroute.Say("Config warning: 'all.export ", Path,
                          " nocheck mig r/w' allows file inconsistentcy!");
}

References Path, RSSCmd, XrdSysError::Say(), XRDEXP_CHECK_X, XRDEXP_DREAD_X, XRDEXP_MIG, XRDEXP_NOCHECK, XRDEXP_NODREAD, XRDEXP_NOTRW, and XRDEXP_RCREATE.

Referenced by ConfigStage().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigStage()

int XrdOssSys::ConfigStage ( XrdSysError &  Eroute )

protected

Definition at line 811 of file XrdOssConfig.cc.

{
   const char *What;
   char *tp, *stgp = 0;
   unsigned long long flags;
   int noMSS, needRSS = 0, NoGo = 0;
   XrdOucPList *fp;
 
// Determine if we are a manager/supervisor. These never stage files so we
// really don't need (nor want) a stagecmd or an msscmd.
//
   noMSS = ((tp = getenv("XRDREDIRECT"))
            && (!strcmp(tp, "R") || !strcmp(tp, "M"))) | Solitary;
 
// A rsscmd implies check+dread. Note that nostage is now always the default.
//
   flags = (RSSCmd ? 0 : XRDEXP_NOCHECK | XRDEXP_NODREAD);
   DirFlags = DirFlags | (flags & (~(DirFlags >> XRDEXP_MASKSHIFT)));
 
// Set default flags
//
   RPList.Default(DirFlags);
 
// Reprocess the paths to set correct defaults
//
   fp = RPList.First();
   while(fp) 
        {flags = fp->Flag(); ConfigSpath(Eroute, fp->Path(), flags, noMSS);
 
         // Record the fact that we have a stageable path
         //
         if (flags & XRDEXP_STAGE) stgp = fp->Path();
 
         // Check if path requires rsscmd and complain if we don't have one
         //
              if (!(flags & XRDEXP_NOCHECK)) What = "has check";
         else if (!(flags & XRDEXP_NODREAD)) What = "has dread";
         else if   (flags & XRDEXP_RCREATE)  What = "has recreate";
         else                                What = 0;
         if (!noMSS && !RSSCmd && What)
            {Eroute.Emsg("Config", fp->Path(), What,
                         "export attribute but rsscmd not specified.");
             NoGo  = 1;
            } else if (What) needRSS = 1;
 
         // Update flags and proceed to next path
         //
         fp->Set(flags); fp = fp->Next();
        }
 
// If we are a manager/supervisor, short circuit MSS initialization
//
   if (noMSS)
      {if (RSSCmd)   {free(RSSCmd);   RSSCmd   = 0;}
       if (StageCmd) {free(StageCmd); StageCmd = 0;}
       RSSProg = 0; StageCreate = 0;
       return NoGo;
      }
 
// Check if we don't need the stagecmd but one was specified
//
   if (StageCmd && !stgp)
      {Eroute.Say("Config warning: 'stagecmd' ignored; no stageable paths present.");
       free(StageCmd); StageCmd = 0;
      }
 
// Check if we don't need a remote storage service but one was specified
//
   if (RSSCmd && !needRSS)
      {Eroute.Say("Config warning: 'rsscmd' ignored; no path exported with "
                                           "check, dread, or rcreate.");
       free(RSSCmd); RSSCmd = 0;
      }
 
// If we have any errors at this point, just return failure
//
   if (NoGo) return 1;
   if (!RSSCmd && !StageCmd && !stgp) return 0;
   Eroute.Say("++++++ Remote Storage System interface initialization started.");
 
// Allocate a pr0gram object for the gateway command
//
   if (RSSCmd)
      {RSSProg = new XrdOucProg(&Eroute);
       if (RSSProg->Setup(RSSCmd)) NoGo = 1;
      }
 
// Initialize staging if we need to
//
   if (!NoGo && (StageCmd || stgp))
      {const int AMode = S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH; // 775
       if (StageCmd && *StageCmd) NoGo = ConfigStageC(Eroute);
          else {StageFrm = new XrdFrcProxy(Eroute.logger(),
                           XrdOucUtils::InstName(),OssTrace.What & TRACE_Debug);
                NoGo = !StageFrm->Init(XrdFrcProxy::opStg,
                                       getenv("XRDADMINPATH"), AMode);
                StageRealTime = 0; StageAsync = 1;
               }
 
      // Set up the event path
      //
         StageAction = (char *)"wfn "; StageActLen = 4;
         if ((tp = getenv("XRDOFSEVENTS")))
            {char sebuff[MAXPATHLEN+8];
             StageEvSize = sprintf(sebuff, "file:///%s", tp);
             StageEvents = strdup(sebuff);
            } else {StageEvents = (char *)"-"; StageEvSize = 1;}
      }
 
// All done
//
   tp = (NoGo ? (char *)"failed." : (char *)"completed.");
   Eroute.Say("------ Remote Storage System interface initialization ", tp);
   return NoGo;
}

References ConfigSpath(), ConfigStageC(), XrdOucPListAnchor::Default(), DirFlags, XrdSysError::Emsg(), XrdOucPListAnchor::First(), XrdOucPList::Flag(), XrdFrcProxy::Init(), XrdOucUtils::InstName(), XrdSysError::logger(), XrdOucPList::Next(), XrdFrcProxy::opStg, OssTrace, XrdOucPList::Path(), RPList, RSSCmd, RSSProg, XrdSysError::Say(), XrdOucPList::Set(), XrdOucProg::Setup(), Solitary, StageAction, StageActLen, StageAsync, StageCmd, StageCreate, StageEvents, StageEvSize, StageFrm, StageRealTime, TRACE_Debug, XrdSysTrace::What, XRDEXP_MASKSHIFT, XRDEXP_NOCHECK, XRDEXP_NODREAD, XRDEXP_RCREATE, and XRDEXP_STAGE.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigStageC()

int XrdOssSys::ConfigStageC ( XrdSysError &  Eroute )

protected

Definition at line 931 of file XrdOssConfig.cc.

{
   pthread_t tid;
   char *sp, *tp;
   int numt, retc, NoGo = 0;
 
// The stage command is interactive if it starts with an | (i.e., pipe in)
//
   tp = StageCmd;
   while(*tp && *tp == ' ') tp++;
   if (*tp == '|') {StageRealTime = 0;
                    do {tp++;} while(*tp == ' ');
                   }
   StageCmd = tp;
 
// This is a bit of hackery to get the traceid sent over to the
// new file residency manager (frm). Keeps the config simple.
//
   if ((sp = index(StageCmd, ' '))) *sp = '\0';
   if (!(tp = rindex (StageCmd, '/'))) tp = StageCmd;
      else tp++;
   if (!strncmp("frm_", tp, 4)) StageFormat = 1;
   if (sp) *sp = ' ';
 
// Set up a program object for the command
//
   StageProg = new XrdOucProg(&Eroute);
   if (StageProg->Setup(StageCmd)) NoGo = 1;
 
// For old-style real-time staging, create threads to handle the staging
// For queue-style staging, start the program that handles the queue
//
   if (!NoGo)
      {if (StageRealTime)
          {if ((numt = xfrthreads - xfrtcount) > 0) while(numt--)
              {if ((retc = XrdSysThread::Run(&tid,XrdOssxfr,(void *)0,0,"staging")))
                  Eroute.Emsg("Config", retc, "create staging thread");
                  else xfrtcount++;
              }
          } else NoGo = StageProg->Start();
      }
 
// Setup the additional stage information vector. Variable substitution:
// <data>$var;<data>.... (max of MaxArgs substitutions). This is only relevant
// when using an actual stagecmd.
//
   if (!NoGo && !StageRealTime && StageMsg)
      {XrdOucMsubs *msubs = new XrdOucMsubs(&Eroute);
       if (msubs->Parse("stagemsg", StageMsg)) StageSnd = msubs;
          else NoGo = 1;  // We will exit no need to delete msubs
      }
 
// All done
//
   return NoGo;
}

References XrdSysError::Emsg(), XrdOucMsubs::Parse(), XrdSysThread::Run(), XrdOucProg::Setup(), StageCmd, StageFormat, StageMsg, StageProg, StageRealTime, StageSnd, XrdOucProg::Start(), xfrtcount, xfrthreads, and XrdOssxfr().

Referenced by ConfigStage().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigStatLib()

int XrdOssSys::ConfigStatLib ( XrdSysError &  Eroute, XrdOucEnv *  envP  )

protected

Definition at line 992 of file XrdOssConfig.cc.

{
   XrdOucPinLoader myLib(&Eroute, myVersion, "statlib", STT_Lib);
   const char *stName2 = "?XrdOssStatInfoInit2";
 
// Get the plugin and stat function. Let's try version 2 first
//
   XrdOssStatInfoInit2_t siGet2;
   if (STT_V2) stName2++;
   if ((siGet2=(XrdOssStatInfoInit2_t)myLib.Resolve(stName2)))
      {if (!(STT_Fund = siGet2(this,Eroute.logger(),ConfigFN,STT_Parms,envP)))
          return 1;
       if (STT_DoARE) envP->PutPtr("XrdOssStatInfo2*", (void *)STT_Fund);
       STT_V2 = 1;
       return 0;
      }
 
// If we are here but the -2 was specified on the config then we fail
//
   if (STT_V2) return 1;
 
// OK, so we better find version 1 in the shared library
//
   XrdOssStatInfoInit_t siGet;
   if (!(siGet = (XrdOssStatInfoInit_t)myLib.Resolve("XrdOssStatInfoInit"))
   ||  !(STT_Func = siGet (this,Eroute.logger(),ConfigFN,STT_Parms)))
      return 1;
 
// Return success
//
   return 0;
}

References ConfigFN, XrdProxy::envP, XrdSysError::logger(), myVersion, XrdOucEnv::PutPtr(), XrdOucPinLoader::Resolve(), STT_DoARE, STT_Lib, STT_Parms, and STT_V2.

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigStats() [1/2]

void XrdOssSys::ConfigStats ( dev_t  Devnum, char *  lP  )

protected

Definition at line 1081 of file XrdOssConfig.cc.

{
   struct stat Stat;
   char *Slash, pP[MAXPATHLEN+1];
 
// Minimize the path
//
   while((Slash = rindex(lP+1, '/')))
        {*Slash = '\0';
         if (GenLocalPath(lP, pP) || stat(pP, &Stat) || Stat.st_dev != Devnum)
            break;
        }
 
// Extend path if need be and return
//
   if (Slash) *Slash = '/';
}

References GenLocalPath(), stat, and Stat().

Here is the call graph for this function:

ConfigStats() [2/2]

void XrdOssSys::ConfigStats ( XrdSysError &  Eroute )

protected

Definition at line 1029 of file XrdOssConfig.cc.

{
   struct StatsDev
         {StatsDev *Next;
          dev_t     st_dev;
          StatsDev(StatsDev *dP, dev_t dn) : Next(dP), st_dev(dn) {}
         };
 
   XrdOssCache_Group  *fsg = XrdOssCache_Group::fsgroups;
   XrdOucPList        *fP = RPList.First();
   StatsDev           *dP1st = 0, *dP, *dPp;
   struct stat         Stat;
   char LPath[MAXPATHLEN+1], PPath[MAXPATHLEN+1], *cP;
 
// Count actual cache groups
//
   while(fsg) {numCG++; fsg = fsg->next;}
 
// Develop the list of paths that we will report on
//
   if (fP) do
      {strcpy(LPath, fP->Path());
       if (GenLocalPath(LPath, PPath)) continue;
       if (stat(PPath, &Stat) && (cP = rindex(LPath, '/')))
          {*cP = '\0';
           if (GenLocalPath(LPath, PPath) || stat(PPath, &Stat)) continue;
          }
       dP = dP1st;
       while(dP && dP->st_dev != Stat.st_dev) dP = dP->Next;
       if (dP) continue;
       ConfigStats(Stat.st_dev, LPath);
       if (GenLocalPath(LPath, PPath)) continue;
       DPList = new OssDPath(DPList, strdup(LPath), strdup(PPath));
       lenDP += strlen(LPath) + strlen(PPath); numDP++;
       dP1st  = new StatsDev(dP1st, Stat.st_dev);
      } while ((fP = fP->Next()));
 
// If we have no exported paths then create a simple /tmp object
//
   if (!numDP)
      {DPList = new OssDPath(0, strdup("/tmp"), strdup("/tmp"));
       lenDP = 4; numDP = 1;
      }
 
// Now delete all of the device objects
//
   dP = dP1st;
   while(dP) {dPp = dP; dP = dP->Next; delete dPp;}
}

References DPList, XrdOucPListAnchor::First(), XrdOssCache_Group::fsgroups, GenLocalPath(), lenDP, XrdOssCache_Group::next, XrdOucPList::Next(), numCG, numDP, XrdOucPList::Path(), RPList, stat, and Stat().

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

Configure()

int XrdOssSys::Configure	(	const char *	configfn,
		XrdSysError &	Eroute,
		XrdOucEnv *	envP
	)

Definition at line 265 of file XrdOssConfig.cc.

{
/*
  Function: Establish default values using a configuration file.
 
  Input:    None.
 
  Output:   0 upon success or !0 otherwise.
*/
   XrdSysError_Table *ETab = new XrdSysError_Table(XRDOSS_EBASE, XRDOSS_ELAST,
                                                   XrdOssErrorText);
   XrdSysError_Table_Errno *ETabErrno = new XrdSysError_Table_Errno(XRDOSS_EBASE,
                                                   XRDOSS_ELAST, XrdOssErrnoMap);
 
   static const int maxFD = 1048576;
   struct rlimit rlim;
   char *val;
   int  retc, NoGo = XrdOssOK;
   pthread_t tid;
   bool setfd = false;
 
// Do the herald thing
//
   Eroute.Say("++++++ Storage system initialization started.");
   Eroute.addTable(ETab);
   Eroute.addTable(ETabErrno);
   if (getenv("XRDDEBUG")) OssTrace.What = TRACE_ALL;
 
// Preset all variables with common defaults
//
   ConfigFN = (configfn && *configfn ? strdup(configfn) : 0);
 
// Establish the FD limit and the fence (half way)
//
  if (getrlimit(RLIMIT_NOFILE, &rlim))
     {Eroute.Emsg("Config", errno, "get fd limit");
      rlim.rlim_cur = maxFD;
     }
     else {if (rlim.rlim_max == RLIM_INFINITY)
              {rlim.rlim_cur = maxFD;
               setfd = true;
              } else {
               if (rlim.rlim_cur != rlim.rlim_max)
                  {rlim.rlim_cur  = rlim.rlim_max;
                   setfd = true;
                  }
              }
           if (setfd)
              {if (setrlimit(RLIMIT_NOFILE, &rlim))
                  Eroute.Emsg("Config", errno, "set fd limit");
                  else
                     {
#ifdef __APPLE__
//
// As of macOS Sequoia 15.6, setrlimit above will be successful but the limit on the
// file descriptor table size may still be lower than RLIMIT_NOFILE.  Calls to
// `fcntl(fd, F_DUPFD, arg)` as is done in `XrdSysFD_Dup1` will fail if the provided
// `arg` is greater than `getdtablesize()` per the online man pages.  After testing,
// it seems the two limits exist independently.
//
// One can verify this by (a) testing `getrlimit()` again to see the larger limit and
// then doing a `XrdSysFD_Dup1` that's below `rlim.rlim_cur` and above `getdtablesize()`;
// it will fail with "Invalid Argument".
//
// On Linux, the man pages note that `getdtablesize()` is implemented via the equivalent
// `getrlimit` call; hence, there's no need for this extra check.
//
                      FDLimit = static_cast<rlim_t>(getdtablesize()) < rlim.rlim_cur ? getdtablesize() : rlim.rlim_cur;
#else
                      FDLimit = rlim.rlim_cur;
#endif
                     }
              } else {FDFence = static_cast<int>(rlim.rlim_cur)>>1;
                      FDLimit = rlim.rlim_cur;
                     }
          }
   if (FDFence < 0 || FDFence >= FDLimit) FDFence = FDLimit >> 1;
 
// Configure devices
//
   XrdOssCache::MapDevs(OssTrace.What != 0);
 
// Process the configuration file
//
   NoGo = ConfigProc(Eroute);
 
// Configure dependent plugins
//
   if (!NoGo)
      {if (N2N_Lib || LocalRoot || RemoteRoot) NoGo |= ConfigN2N(Eroute, envP);
       if (STT_Lib && !NoGo) NoGo |= ConfigStatLib(Eroute, envP);
      }
 
// If the export list is empty, add at least "/tmp" to it otherwise we will
// fail to correctly track space.
//
   if (RPList.First() == 0)
      RPList.Insert(new XrdOucPList("/tmp", (unsigned long long)0));
 
// Establish usage tracking and quotas, if need be. Note that if we are not
// a true data server, those services will be initialized but then disabled.
//
   Solitary = ((val = getenv("XRDREDIRECT")) && !strcmp(val, "Q"));
   pfcMode  = (envP && (val = envP->Get("oss.runmode")) && !strcmp(val,"pfc"));
  {const char *m1 = (Solitary ? "standalone " : 0);
   const char *m2 = (pfcMode  ? "pfc " : 0);
   if (m1 || m2) Eroute.Say("++++++ Configuring ", m1, m2, "mode . . .");
  }
   NoGo |= XrdOssCache::Init(UDir, QFile, Solitary, USync)
          |XrdOssCache::Init(minalloc, ovhalloc, fuzalloc);
 
// Configure the MSS interface including staging
//
   if (!NoGo) NoGo = ConfigStage(Eroute);
 
// Configure async I/O
//
   if (!NoGo) NoGo = !AioInit();
 
// Initialize memory mapping setting to speed execution
//
   if (!NoGo) ConfigMio(Eroute);
 
// Provide support for the PFC. This also resolve cache attribute conflicts.
//
   if (!NoGo) ConfigCache(Eroute);
 
// Establish the actual default path settings (modified by the above)
//
   RPList.Set(DirFlags);
 
// Configure space (final pass)
//
   ConfigSpace(Eroute);
 
// Set the prefix for files in cache file systems  
   if ( OptFlags & XrdOss_CacheFS ) 
       if (!NoGo) {
           NoGo = XrdOssPath::InitPrefix();
           if (NoGo) Eroute.Emsg("Config", "space initialization failed");
       }
 
// Configure statiscal reporting
//
   if (!NoGo) ConfigStats(Eroute);
 
// Start up the space scan thread unless specifically told not to. Some programs
// like the cmsd manually handle space updates.
//
   if (!(val = getenv("XRDOSSCSCAN")) || strcmp(val, "off"))
      {if ((retc = XrdSysThread::Run(&tid, XrdOssCacheScan,
                                    (void *)&cscanint, 0, "space scan")))
          Eroute.Emsg("Config", retc, "create space scan thread");
      }
 
// Display the final config if we can continue
//
   if (!NoGo) Config_Display(Eroute);
 
// Do final reset of paths if we are in proxy file cache mode
//
   if (pfcMode && !NoGo) ConfigCache(Eroute, true);
 
// Export the real path list (for frm et. al.)
//
   XrdOssRPList = &RPList;
   if (envP) envP->PutPtr("XrdOssRPList*", &RPList);
 
// All done, close the stream and return the return code.
//
   val = (NoGo ? (char *)"failed." : (char *)"completed.");
   Eroute.Say("------ Storage system initialization ", val);
   return NoGo;
}

References XrdSysError::addTable(), AioInit(), Config_Display(), ConfigCache(), ConfigFN, ConfigMio(), ConfigN2N(), ConfigProc(), ConfigSpace(), ConfigStage(), ConfigStatLib(), ConfigStats(), cscanint, DirFlags, XrdSysError::Emsg(), XrdProxy::envP, FDFence, FDLimit, XrdOucPListAnchor::First(), fuzalloc, XrdOucEnv::Get(), XrdOssCache::Init(), XrdOssPath::InitPrefix(), XrdOucPListAnchor::Insert(), LocalRoot, XrdOssCache::MapDevs(), minalloc, N2N_Lib, OptFlags, OssTrace, ovhalloc, pfcMode, XrdOucEnv::PutPtr(), QFile, RemoteRoot, RPList, XrdSysThread::Run(), XrdSysError::Say(), XrdOucPList::Set(), Solitary, STT_Lib, TRACE_ALL, UDir, USync, XrdSysTrace::What, XrdOss_CacheFS, XRDOSS_EBASE, XRDOSS_ELAST, XrdOssCacheScan(), XrdOssErrnoMap, XrdOssErrorText, XrdOssOK, and XrdOssRPList.

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigXeq()

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

protected

Definition at line 1103 of file XrdOssConfig.cc.

{
    char  myVar[80], buff[2048], *val;
    int nosubs;
    XrdOucEnv *myEnv = 0;
 
   TS_Xeq("alloc",         xalloc);
   TS_Xeq("cache",         xcache);
   TS_Xeq("cachescan",     xcachescan); // Backward compatibility
   TS_Xeq("spacescan",     xcachescan);
   TS_Xeq("defaults",      xdefault);
   TS_Xeq("fdlimit",       xfdlimit);
   TS_Xeq("maxsize",       xmaxsz);
   TS_Xeq("memfile",       xmemf);
   TS_Xeq("namelib",       xnml);
   TS_Xeq("path",          xpath);
   TS_Xeq("preread",       xprerd);
   TS_Xeq("space",         xspace);
   TS_Xeq("stagecmd",      xstg);
   TS_Xeq("statlib",       xstl);
   TS_Xeq("trace",         xtrace);
   TS_Xeq("usage",         xusage);
   TS_Xeq("xfr",           xxfr);
 
   // Check if var substitutions are prohibited (e.g., stagemsg). Note that
   // TS_String() returns upon success so be careful when adding new opts.
   //
   if ((nosubs = !strcmp(var, "stagemsg"))) myEnv = Config.SetEnv(0);
 
   // Copy the variable name as this may change because it points to an
   // internal buffer in Config. The vagaries of effeciency.
   //
   strlcpy(myVar, var, sizeof(myVar));
   var = myVar;
 
   // We need to suck all the tokens to the end of the line for remaining
   // options. Do so, until we run out of space in the buffer.
   //
   if (!Config.GetRest(buff, sizeof(buff)))
      {Eroute.Emsg("Config", "arguments too long for", var);
       if (nosubs) Config.SetEnv(myEnv);
       return 1;
      }
   val = buff;
 
   // Restore substititions at this point if need be
   //
   if (nosubs) Config.SetEnv(myEnv);
 
   // At this point, make sure we have a value
   //
   if (!(*val))
      {Eroute.Emsg("Config", "no value for directive", var);
       return 1;
      }
 
   // Check for tokens taking a variable number of parameters
   //
   TS_String("localroot",  LocalRoot);
   TS_String("remoteroot", RemoteRoot);
   TS_String("stagemsg",   StageMsg);
 
   // The following differentiates between a deprecated and a preferred command
   //
   if (!strcmp("msscmd", var)) {isMSSC = 1; Duplicate(val, RSSCmd); return 0;}
   if (!strcmp("rsscmd", var)) {isMSSC = 0; Duplicate(val, RSSCmd); return 0;}
 
   // No match found, complain.
   //
   Eroute.Say("Config warning: ignoring unknown directive '",var,"'.");
   Config.Echo();
   return 0;
}

References XrdCms::Config, Duplicate, XrdSysError::Emsg(), isMSSC, LocalRoot, RemoteRoot, RSSCmd, XrdSysError::Say(), StageMsg, strlcpy(), TS_String, TS_Xeq, xalloc(), xcache(), xcachescan(), xdefault(), xfdlimit(), xmaxsz(), xmemf(), xnml(), xpath(), xprerd(), xspace(), xstg(), xstl(), xtrace(), xusage(), and xxfr().

Referenced by ConfigProc().

Here is the call graph for this function:

Here is the caller graph for this function:

Create()

int XrdOssSys::Create ( const char *  tid, const char *  path, mode_t  mode, XrdOucEnv &  env, int  opts = 0  )

virtual

Create file.

Parameters

tid	- Pointer to the trace identifier.
path	- Pointer to the path of the file to create.
mode	- The new file mode setting.
env	- Reference to environmental information.
opts	- Create options: XRDOSS_coloc - Colocate file using the URL encoded path in env "oss.coloc" XRDOSS_mkpath - create dir path if it does not exist. XRDOSS_new - the file must not already exist. oflags<<8 - open flags shifted 8 bits to the left/

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 113 of file XrdOssCreate.cc.

{
    EPNAME("Create")
    const int AMode = S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH; // 775
    char  local_path[MAXPATHLEN+1], *p, pc;
    local_path[0] = '\0';
    unsigned long long remotefs;
    int isLink = 0, Missing = 1, retc = 0, datfd;
    XrdOssCreateInfo crInfo(local_path, path, access_mode, Opts);
    struct stat buf;
 
// Get options associated with this path and check if it's r/w
//
   remotefs = Check_RO(Create, crInfo.pOpts, path, "create");
 
// Generate the actual local path for this file.
//
   if ((retc = GenLocalPath(path, local_path))) return retc;
 
// Determine the state of the file. We will need this information as we go on.
//
   if ((Missing = lstat(local_path, &buf))) retc = errno;
      else {if ((isLink = ((buf.st_mode & S_IFMT) == S_IFLNK)))
               {if (stat(local_path, &buf))
                   {if (errno != ENOENT) return -errno;
                    OssEroute.Emsg("Create","removing dangling link",local_path);
                    if (unlink(local_path)) retc = errno;
                    Missing = 1; isLink = 0;
                   }
               }
            }
   if (retc && retc != ENOENT) return -retc;
 
// Check if we are requested to create the file at a specific location.
// If so set the cgroup to match the location we have been passed in the env.
   bool forcecg = false;
   if (Opts & XRDOSS_coloc)
      {if (crInfo.pOpts & XRDEXP_NOFICL) return -EPERM;
       const char *colocenv = env.Get("oss.coloc");
       std::string coloc(colocenv ? colocenv : "");
       coloc = XrdOucUtils::UrlDecode(coloc);
       char coloc_local[MAXPATHLEN+1];
       coloc_local[0] = '\0';
       if ((retc = GenLocalPath(coloc.c_str(), coloc_local))) return retc;
       XrdOssCache_FS *cp = XrdOssCache::Find(coloc_local);
       std::string gpath;
       if (cp) gpath = cp->group + std::string(":") + cp->path;
       env.Put(OSS_CGROUP, gpath.c_str());
       forcecg = true;
      }
 
// At this point, creation requests may need to be routed via the stagecmd.
// This is done if the file/link do not exist. Otherwise, we drop through.
//
   if (StageCreate && Missing)
      return XrdOssSS->Stage(tident, path, env, Opts>>8, 
                             access_mode, crInfo.pOpts);
 
// The file must not exist if it's declared "new". Otherwise, reuse the space.
// SetFattr() alaways closes the provided file descriptor!
//
   if (!Missing)
      {if (Opts & XRDOSS_new)                 return -EEXIST;
       if ((buf.st_mode & S_IFMT) == S_IFDIR) return -EISDIR;
       do {datfd = open(local_path, Opts>>8, access_mode);}
                   while(datfd < 0 && errno == EINTR);
       if (datfd < 0) return -errno;
       if ((retc = SetFattr(crInfo, datfd, buf.st_mtime))) return retc;
       if (Opts>>8 & O_TRUNC && buf.st_size)
          {off_t theSize = buf.st_size;
           if (isLink) {buf.st_mode = (buf.st_mode & ~S_IFMT) | S_IFLNK;
                        XrdOssCache::Adjust(local_path, -theSize, &buf);
                       }
          }
       return 0;
      }
 
// If the path is to be created, make sure the path exists at this point
//
   if ((Opts & XRDOSS_mkpath) && (p = rindex(local_path, '/')))
      {p++; pc = *p; *p = '\0';
       XrdOucUtils::makePath(local_path, AMode);
       *p = pc;
      }
 
// If this is a staging filesystem then we have lots more work to do.
//
   if (remotefs)
      {char remote_path[MAXPATHLEN+1];
 
      // Generate the remote path for this file
      //
         if ((retc = GenRemotePath(path,remote_path))) return retc;
 
     // Create the file in remote system unless not wanted so
     //
        if (crInfo.pOpts & XRDEXP_RCREATE)
           {if ((retc = MSS_Create(remote_path, access_mode, env)) < 0)
               {DEBUG("rc" <<retc <<" mode=" <<Xrd::oct1 <<access_mode
                           <<" remote path=" <<remote_path);
                return retc;
               }
           } else if (!(crInfo.pOpts & XRDEXP_NOCHECK))
                     {if (!(retc = MSS_Stat(remote_path))) return -EEXIST;
                         else if (retc != -ENOENT)         return retc;
                     }
      }
 
// Created file in the extended cache or the local name space
//
   if (XrdOssCache::fsfirst && !(crInfo.pOpts & XRDEXP_INPLACE))
           retc = Alloc_Cache(crInfo, env, forcecg);
      else retc = Alloc_Local(crInfo, env);
 
// If successful then check if xattrs were actually set
//
   if (retc == XrdOssOK && crInfo.cOpts & XRDOSS_setnoxa)
      {XrdOucPList *plP = RPList.About(path);
       if (plP) plP->Set(plP->Flag() | XRDEXP_NOXATTR);
      }
 
// All done.
//
   return retc;
}

References XrdOucPListAnchor::About(), XrdOssCache::Adjust(), Alloc_Cache(), Alloc_Local(), Check_RO, XrdOssCreateInfo::cOpts, DEBUG, XrdSysError::Emsg(), EPNAME, XrdOssCache::Find(), XrdOucPList::Flag(), XrdOssCache::fsfirst, GenLocalPath(), GenRemotePath(), XrdOucEnv::Get(), XrdOssCache_FS::group, lstat, XrdOucUtils::makePath(), MSS_Create(), MSS_Stat(), Xrd::oct1, open, XrdMpx::Opts, OSS_CGROUP, OssEroute, XrdOssCache_FS::path, XrdOssCreateInfo::pOpts, XrdOucEnv::Put(), RPList, XrdOucPList::Set(), SetFattr(), Stage(), StageCreate, stat, tident, unlink, XrdOucUtils::UrlDecode(), XRDEXP_INPLACE, XRDEXP_NOCHECK, XRDEXP_NOFICL, XRDEXP_NOXATTR, XRDEXP_RCREATE, XRDOSS_coloc, XRDOSS_mkpath, XRDOSS_new, XRDOSS_setnoxa, XrdOssOK, and XrdOssSS.

Here is the call graph for this function:

doScrub()

void XrdOssSys::doScrub ( )

protected

Features()

uint64_t XrdOssSys::Features ( )

inlinevirtual

Return storage system features.

Returns

Storage system features (see XRDOSS_HASxxx flags).

Reimplemented from XrdOss.

Definition at line 173 of file XrdOssApi.hh.

{return XRDOSS_HASNAIO|XRDOSS_HASFICL;} // Turn async I/O off for disk and clone aware

References XRDOSS_HASFICL, and XRDOSS_HASNAIO.

Find()

int XrdOssSys::Find ( XrdOssStage_Req *  req, void *  carg  )

protected

GenLocalPath()

int XrdOssSys::GenLocalPath	(	const char *	oldp,
		char *	newp
	)

Definition at line 237 of file XrdOssApi.cc.

{
    if (lcl_N2N) return -(lcl_N2N->lfn2pfn(oldp, newp, MAXPATHLEN));
    if (strlen(oldp) >= MAXPATHLEN) return -ENAMETOOLONG;
    strcpy(newp, oldp);
    return 0;
}

References lcl_N2N, and XrdOucName2Name::lfn2pfn().

Referenced by ConfigSpace(), ConfigStats(), Create(), GetFile(), HasFile(), Reloc(), Remdir(), Rename(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

GenRemotePath()

int XrdOssSys::GenRemotePath	(	const char *	oldp,
		char *	newp
	)

Definition at line 254 of file XrdOssApi.cc.

{
    if (rmt_N2N) return -(rmt_N2N->lfn2rfn(oldp, newp, MAXPATHLEN));
    if (strlen(oldp) >= MAXPATHLEN) return -ENAMETOOLONG;
    strcpy(newp, oldp);
    return 0;
}

References XrdOucName2Name::lfn2rfn(), and rmt_N2N.

Referenced by Create(), GetFile(), Rename(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

getCname()

int XrdOssSys::getCname ( const char *  path, struct stat *  sbuff, char *  cgbuff  )

protected

Definition at line 455 of file XrdOssStat.cc.

{
   const char *thePath;
   char actual_path[MAXPATHLEN+1];
   int retc;
 
// Get the pfn for this path
//
   if (lcl_N2N)
      if ((retc = lcl_N2N->lfn2pfn(path, actual_path, sizeof(actual_path))))
         return retc;
         else thePath = actual_path;
      else thePath = path;
 
// Get regular stat informtion for this file
//
   if ((retc = stat(thePath, sbuff))) return -errno;
 
// Now determine if we should get the cache group name. There is none
// for offline files and it's always public for directories.
//
   if (S_ISDIR(sbuff->st_mode))         strcpy(cgbuff, "public");
      else if (S_ISBLK(sbuff->st_mode)) strcpy(cgbuff, "*");
              else XrdOssPath::getCname(thePath, cgbuff);
 
// All done
//
   return 0;
}

References XrdOssPath::getCname(), lcl_N2N, XrdOucName2Name::lfn2pfn(), and stat.

Referenced by StatLS(), and StatXA().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFile()

int XrdOssSys::GetFile ( XrdOssStage_Req *  req )

protected

Definition at line 433 of file XrdOssStage.cc.

{
   char rfs_fn[MAXPATHLEN+1];
   char lfs_fn[MAXPATHLEN+1];
   int retc;
 
// Convert the local filename and generate the corresponding remote name.
//
   if ( (retc =  GenLocalPath(req->path, lfs_fn)) ) return retc;
   if ( (retc = GenRemotePath(req->path, rfs_fn)) ) return retc;
 
// Run the command to get the file
//
   if ((retc = StageProg->Run(rfs_fn, lfs_fn)))
      {OssEroute.Emsg("Stage", retc, "stage", req->path);
       return (retc == 2 ? -ENOENT : -XRDOSS_E8009);
      }
 
// All went well
//
   return 0;
}

References XrdSysError::Emsg(), GenLocalPath(), GenRemotePath(), OssEroute, XrdOssStage_Req::path, XrdOucProg::Run(), StageProg, and XRDOSS_E8009.

Referenced by Stage_In().

Here is the call graph for this function:

Here is the caller graph for this function:

getID()

int XrdOssSys::getID ( const char *  Tid, XrdOucEnv &  Env, char *  buff, int  bsz  )

protected

Definition at line 460 of file XrdOssStage.cc.

{
   char *bP;
   int n;
 
// The buffer always starts with a '+'
//
   *buff = '+'; bP = buff+1; bsz -= 3;
 
// Get the trace id
//
   if (Tid && (n = strlen(Tid)) <= bsz) {strcpy(bP, Tid); bP += n;}
 
// Insert space
//
   *bP++ = ' '; *bP = '\0';
   return bP - buff;
}

Referenced by Stage_QT().

Here is the caller graph for this function:

getStats()

int XrdOssSys::getStats ( char *  buff, int  blen  )

protected

Definition at line 489 of file XrdOssStat.cc.

{
   static const char ptag1[] = "<paths>%d";
   static const char ptag2[] = "<stats id=\"%d\"><lp>\"%s\"</lp><rp>\"%s\"</rp>"
   "<tot>%lld</tot><free>%lld</free><ino>%lld</ino><ifr>%lld</ifr></stats>";
   static const char ptag3[] = "</paths>";
 
   static const int ptag1sz = sizeof(ptag1);
   static const int ptag2sz = sizeof(ptag2) + (16*4);
   static const int ptag3sz = sizeof(ptag3);
 
   static const char stag1[] = "<space>%d";
   static const char stag2[] = "<stats id=\"%d\"><name>%s</name>"
                "<tot>%lld</tot><free>%lld</free><maxf>%lld</maxf>"
                "<fsn>%d</fsn><usg>%lld</usg>";
   static const char stagq[] = "<qta>%lld</qta>";
   static const char stags[] = "</stats>";
   static const char stag3[] = "</space>";
 
   static const int stag1sz = sizeof(stag1);
   static const int stag2sz = sizeof(stag2) + XrdOssSpace::maxSNlen + (16*5);
   static const int stagqsz = sizeof(stagq) + 16;
   static const int stagssz = sizeof(stags);
   static const int stag3sz = sizeof(stag3);
 
   static const int stagsz  = ptag1sz + ptag2sz + ptag3sz + 1024 +
                            + stag1sz + stag2sz + stag3sz
                            + stagqsz + stagssz;
 
   XrdOssCache_Group  *fsg = XrdOssCache_Group::fsgroups;
   OssDPath           *dpP = DPList;
   char *bp = buff;
   int dpNum = 0, spNum = 0, n, flen;
 
// If no buffer spupplied, return how much data we will generate. We also
// do one-time initialization here.
//
   if (!buff) return ptag1sz + (ptag2sz * numDP) + stag3sz + lenDP
                   + stag1sz + (stag2sz * numCG) + stag3sz
                   + stagqsz + stagssz;
 
// Make sure we have enough space for one entry
//
   if (blen <= stagsz) return 0;
 
// Output first header (we know we have one path, at least)
//
   flen = sprintf(bp, ptag1, numDP); bp += flen; blen -= flen;
 
// Output individual entries
//
   while(dpP && blen > 0)
        {XrdOssCache_Space CSpace;
         XrdOssCache_FS::freeSpace(CSpace, dpP->Path2);
         flen = snprintf(bp, blen, ptag2, dpNum, dpP->Path1, dpP->Path2,
                                   CSpace.Total>>10, CSpace.Free>>10,
                                   CSpace.Inodes,    CSpace.Inleft);
         dpP = dpP->Next; bp += flen; blen -= flen; dpNum++;
        }
 
// Output closing tag
//
   if (blen <= ptag3sz) return 0;
   strcpy(bp, ptag3); bp += (ptag3sz-1); blen -= (ptag3sz-1);
   dpNum = bp - buff;
 
// Output header
//
   if (blen <= stag1sz) return (blen < 0 ? 0 : dpNum);
   flen = snprintf(bp, blen, stag1, numCG); bp += flen; blen -= flen;
   if (blen <= stag1sz) return dpNum;
 
// Generate info for each path
//
   while(fsg && blen > 0)
        {XrdOssCache_Space CSpace;
         n = XrdOssCache_FS::getSpace(CSpace, fsg);
         flen = snprintf(bp, blen, stag2, spNum, fsg->group, CSpace.Total>>10,
                CSpace.Free>>10, CSpace.Maxfree>>10, n, CSpace.Usage>>10);
         bp += flen; blen -= flen; spNum++;
         if (CSpace.Quota >= 0 && blen > stagqsz)
            {flen = sprintf(bp, stagq, CSpace.Quota); bp += flen; blen -= flen;}
         if (blen < stagssz) return dpNum;
         strcpy(bp, stags); bp += (stagssz-1); blen -= (stagssz-1);
         fsg = fsg->next;
        }
 
// Insert trailer
//
   if (blen >= stag3sz) {strcpy(bp, stag3); bp += (stag3sz-1);}
      else return dpNum;
 
// All done
//
   return bp - buff;
}

References DPList, XrdOssCache_Space::Free, XrdOssCache_FS::freeSpace(), XrdOssCache_Group::fsgroups, XrdOssCache_FS::getSpace(), XrdOssCache_Group::group, XrdOssCache_Space::Inleft, XrdOssCache_Space::Inodes, lenDP, XrdOssCache_Space::Maxfree, XrdOssSpace::maxSNlen, XrdOssCache_Group::next, OssDPath::Next, numCG, numDP, OssDPath::Path1, OssDPath::Path2, XrdOssCache_Space::Quota, XrdOssCache_Space::Total, and XrdOssCache_Space::Usage.

Referenced by Stats().

Here is the call graph for this function:

Here is the caller graph for this function:

HasFile()

time_t XrdOssSys::HasFile ( const char *  fn, const char *  sfx, time_t *  mTime = 0  )

protected

Definition at line 483 of file XrdOssStage.cc.

{
    struct stat statbuff;
    int fnlen;
    char path[MAXPATHLEN+8];
    char *pp = path;
 
// Copy the path with possible conversion
//
   if (xfrFdir)
      {strcpy(path, xfrFdir);
       pp = path + xfrFdln;
      }
   if (GenLocalPath(fn, pp)) return 0;
   fnlen = strlen(path);
 
// Add the suffix
//
   if ((fnlen + strlen(fsfx)) >= sizeof(path)) return 0;
   strcpy(path+fnlen, fsfx);
 
// Now check if the file actually exists
//
   if (stat(path, &statbuff)) return 0;
   if (mTime) *mTime = statbuff.st_mtime;
   return statbuff.st_ctime;
}

References GenLocalPath(), stat, xfrFdir, and xfrFdln.

Referenced by Stage_QT(), and Stage_RT().

Here is the call graph for this function:

Here is the caller graph for this function:

Init() [1/2]

int XrdOssSys::Init ( XrdSysLogger *  lp, const char *  cfn, XrdOucEnv *  envP  )

virtual

Initialize the storage system V2.

Parameters

lp	- Pointer to the message logging object.
cfn	- Pointer to the configuration file.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOss.

Definition at line 191 of file XrdOssApi.cc.

{
     int retc;
 
// No need to do the herald thing as we are the default storage system
//
   OssEroute.logger(lp);
 
// Initialize the subsystems
//
   XrdOssSS = this;
   if ( (retc = Configure(configfn, OssEroute, envP)) ) return retc;
 
// All done.
//
   return XrdOssOK;
}

References Configure(), XrdProxy::envP, XrdSysError::logger(), OssEroute, XrdOssOK, and XrdOssSS.

Referenced by XrdOssGetSS().

Here is the call graph for this function:

Here is the caller graph for this function:

Init() [2/2]

int XrdOssSys::Init ( XrdSysLogger *  lp, const char *  cfn  )

inlinevirtual

Initialize the storage system V1 (deprecated).

Parameters

lp	- Pointer to the message logging object.
cfn	- Pointer to the configuration file.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 177 of file XrdOssApi.hh.

{return Init(lP, cP, 0);}

References Init().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

IsRemote()

int XrdOssSys::IsRemote ( const char *  path )

inline

Definition at line 178 of file XrdOssApi.hh.

                  {return (RPList.Find(path) & XRDEXP_REMOTE) != 0;}

References XrdOucPListAnchor::Find(), RPList, and XRDEXP_REMOTE.

Referenced by Stat().

Here is the call graph for this function:

Here is the caller graph for this function:

Lfn2Pfn() [1/2]

int XrdOssSys::Lfn2Pfn ( const char *  Path, char *  buff, int  blen  )

virtual

Translate logical name to physical name V1 (deprecated).

Parameters

Path	- Path in whose information is wanted.
buff	- Pointer to the buffer to hold the new path.
blen	- Length of the buffer.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOss.

Definition at line 213 of file XrdOssApi.cc.

{
    if (lcl_N2N) return -(lcl_N2N->lfn2pfn(oldp, newp, blen));
    if ((int)strlen(oldp) >= blen) return -ENAMETOOLONG;
    strcpy(newp, oldp);
    return 0;
}

References lcl_N2N, and XrdOucName2Name::lfn2pfn().

Here is the call graph for this function:

Lfn2Pfn() [2/2]

const char * XrdOssSys::Lfn2Pfn ( const char *  Path, char *  buff, int  blen, int &  rc  )

virtual

Translate logical name to physical name V2.

Parameters

Path	- Path in whose information is wanted.
buff	- Pointer to the buffer to hold the new path.
blen	- Length of the buffer.
rc	- Place where failure return code is to be returned: -errno or -osserr (see XrdOssError.hh).

Returns

Pointer to the translated path upon success or nil on failure.

Reimplemented from XrdOss.

Definition at line 221 of file XrdOssApi.cc.

{
    if (!lcl_N2N) {rc = 0; return oldp;}
    if ((rc = -(lcl_N2N->lfn2pfn(oldp, newp, blen)))) return 0;
    return newp;
}

References lcl_N2N, and XrdOucName2Name::lfn2pfn().

Here is the call graph for this function:

List_Path()

void XrdOssSys::List_Path ( const char *  pfx, const char *  pname, unsigned long long  flags, XrdSysError &  Eroute  )

protected

Definition at line 2147 of file XrdOssConfig.cc.

{
     std::string ss;
     const char *rwmode;
 
     if (flags & XRDEXP_FORCERO) rwmode = " forcero";
        else if (flags & XRDEXP_READONLY) rwmode = " r/o";
                else rwmode = " r/w";
 
     if (flags & XRDEXP_INPLACE) ss += " inplace";
     if (flags & XRDEXP_LOCAL)   ss += " local";
     if (flags & XRDEXP_GLBLRO)  ss += " globalro";
 
     if (!(flags & XRDEXP_PFCACHE))
        {if (flags & XRDEXP_PFCACHE_X) ss += " nocache";
         ss += (flags & XRDEXP_NOCHECK  ? " nocheck" : " check");
         ss += (flags & XRDEXP_NODREAD  ? " nodread" : " dread");
         ss += (flags & XRDEXP_MIG      ? " mig"     : " nomig");
         ss += (flags & XRDEXP_PURGE    ? " purge"   : " nopurge");
         ss += (flags & XRDEXP_RCREATE  ? " rcreate" : " norcreate");
         ss += (flags & XRDEXP_STAGE    ? " stage"   : " nostage");
         ss += (flags & XRDEXP_NOFICL   ? " noficl"  : " ficl");
        } else ss += " cache";
 
 
     if (flags & XRDEXP_MMAP)
        {ss += " mmap";
         ss += (flags & XRDEXP_MKEEP    ? " mkeep"   : " nomkeep");
         ss += (flags & XRDEXP_MLOK     ? " mlock"   : " nomlock");
        }
 
     Eroute.Say(pfx, pname, rwmode, ss.c_str());
}

References XrdSysError::Say(), XRDEXP_FORCERO, XRDEXP_GLBLRO, XRDEXP_INPLACE, XRDEXP_LOCAL, XRDEXP_MIG, XRDEXP_MKEEP, XRDEXP_MLOK, XRDEXP_MMAP, XRDEXP_NOCHECK, XRDEXP_NODREAD, XRDEXP_NOFICL, XRDEXP_PFCACHE, XRDEXP_PFCACHE_X, XRDEXP_PURGE, XRDEXP_RCREATE, XRDEXP_READONLY, and XRDEXP_STAGE.

Referenced by Config_Display().

Here is the call graph for this function:

Here is the caller graph for this function:

Mkdir()

int XrdOssSys::Mkdir ( const char *  path, mode_t  mode, int  mkpath = 0, XrdOucEnv *  envP = 0  )

virtual

Create a directory.

Parameters

path	- Pointer to the path of the directory to be created.
mode	- The directory mode setting.
mkpath	- When true the path is created if it does not exist.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 366 of file XrdOssApi.cc.

{
    char actual_path[MAXPATHLEN+1], *local_path;
    int retc;
 
// Make sure we can modify this path
//
   Check_RW(Mkdir, path, "create directory");
 
// Generate local path
//
   if (lcl_N2N)
      if ((retc = lcl_N2N->lfn2pfn(path, actual_path, sizeof(actual_path)))) 
         return retc;
         else local_path = actual_path;
      else local_path = (char *)path;
 
// Create the directory or full path only in the loal file system
//
   if (!mkdir(local_path, mode))  return XrdOssOK;
   if (mkpath && errno == ENOENT){return Mkpath(local_path, mode);}
   if (errno != EEXIST)           return -errno;
 
// Check if this is a duplicate request
//
   struct stat Stat;
   static const mode_t accBits = (S_IRWXU|S_IRWXG|S_IRWXO);
 
   if (!stat(local_path, &Stat) && S_ISDIR(Stat.st_mode)
   && mode == (Stat.st_mode & accBits)) return XrdOssOK;
   return -EEXIST;
}

References Check_RW, lcl_N2N, XrdOucName2Name::lfn2pfn(), mkdir(), Mkpath(), stat, Stat(), and XrdOssOK.

Here is the call graph for this function:

Mkpath()

int XrdOssSys::Mkpath	(	const char *	path,
		mode_t	mode
	)

Definition at line 413 of file XrdOssApi.cc.

{
    char local_path[MAXPATHLEN+1], *next_path;
    int  i = strlen(path);
 
// Copy the path so we can modify it
//
   strcpy(local_path, path);
 
// Trim off the trailing slashes so we can have predictable behaviour
//
   while(i && local_path[--i] == '/') local_path[i] = '\0';
   if (!i) return -ENOENT;
 
// Start creating directories starting with the root
//
   next_path = local_path;
   while((next_path = index(next_path+1, int('/'))))
        {*next_path = '\0';
         if (mkdir(local_path, mode) && errno != EEXIST) return -errno;
         *next_path = '/';
        }
 
// Create last component and return
//
   if (mkdir(local_path, mode) && errno != EEXIST) return -errno;
   return XrdOssOK;
}

References mkdir(), and XrdOssOK.

Referenced by Mkdir().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Closedir()

int XrdOssSys::MSS_Closedir

(

void *

dir_handle

)

Definition at line 185 of file XrdOssMSS.cc.

                                            {
/*
  Function: Close the directory associated with handle "dir_handle".
 
  Input:    dir_handle - The handle returned by opendir().
 
  Output:   Returns 0 upon success and (-errno) upon failure.
*/
    const char *epname = "MSS_Closedir";
    struct XrdOssHandle *oh = (struct XrdOssHandle *)dir_handle;
 
    if ( !(oh->hflag & XRDOSS_HT_DIR) )
       {OssEroute.Emsg(epname, "invalid mss handle"); return -EBADF;}
    delete oh;
    return XrdOssOK;
}

References XrdSysError::Emsg(), XrdOssHandle::hflag, OssEroute, XRDOSS_HT_DIR, and XrdOssOK.

Referenced by XrdOssDir::Close().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Create()

int XrdOssSys::MSS_Create	(	const char *	path,
		mode_t	file_mode,
		XrdOucEnv &	env
	)

Definition at line 206 of file XrdOssMSS.cc.

{
    const char *epname = "MSS_Create";
    char myMode[16];
 
    // Make sure the path is not too long.
    //
    if (strlen(path) > MAXPATHLEN)
       {OssEroute.Emsg(epname, "mss path too long - ", path);
        return -ENAMETOOLONG;
       }
 
    // Construct the cmd to create the file. We currently don't support cosid.
    //
    sprintf(myMode, "%o", static_cast<int>(file_mode));
 
    // Create the file in in the mass store system
    //
    return MSS_Xeq(0, 0, "create", path, myMode);
}

References XrdSysError::Emsg(), MSS_Xeq(), and OssEroute.

Referenced by Create().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Opendir()

void * XrdOssSys::MSS_Opendir	(	const char *	dir_path,
		int &	rc
	)

Definition at line 102 of file XrdOssMSS.cc.

                                                          {
/*
  Function: Open the directory `path' and prepare for reading.
 
  Input:    path      - The fully qualified name of the directory to open.
 
  Output:   Returns a directory handle to be used for subsequent
            operations. If an error occurs, (-errno) is returned.
*/
     const char *epname = "MSS_Opendir";
     struct XrdOssHandle *oh;
     XrdOucStream *sp;
 
     // Make sure the path is not too long.
     //
     if (strlen(dir_path) > MAXPATHLEN)
        {OssEroute.Emsg(epname, "mss path too long - ", dir_path);
         rc = -ENAMETOOLONG;
         return (void *)0;
        }
 
     // Issue it now to trap any errors but defer reading the result until
     // readdir() is called. This does tie up a process, sigh.
     //
     if ( (rc = MSS_Xeq(&sp, ENOENT, "dlist", dir_path)))
        return (void *)0;
 
     // Allocate storage for the handle and return a copy of it.
     //
     if (!(oh = new XrdOssHandle(XRDOSS_HT_DIR, sp))) 
        {delete sp; rc = -ENOMEM; return (void *)0;}
     return (void *)oh;
}

References XrdOssHandle::XrdOssHandle(), XrdSysError::Emsg(), MSS_Xeq(), OssEroute, XrdOssHandle::sp, and XRDOSS_HT_DIR.

Referenced by XrdOssDir::Opendir().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Readdir()

int XrdOssSys::MSS_Readdir	(	void *	fd,
		char *	buff,
		int	blen
	)

Definition at line 140 of file XrdOssMSS.cc.

                                                                 {
/*
  Function: Read the next entry if directory 'dir_handle'.
 
  Input:    dir_handle - The value returned by a successful opendir() call.
            buff       - Buffer to hold directory name.
            blen       - Size of the buffer.
 
  Output:   Upon success, places the contents of the next directory entry
            in buff. When the end of the directory is encountered buff
            will be set to a null string.
 
            Upon failure, returns a (-errno).
*/
    const char *epname = "MSS_Readdir";
    int retc;
    struct XrdOssHandle *oh = (struct XrdOssHandle *)dir_handle;
    char *resp;
 
    // Verify that the handle is correct.
    //
    if ( !(oh->hflag & XRDOSS_HT_DIR) )
       {OssEroute.Emsg(epname, "invalid mss handle"); return -EBADF;}
 
    // Read a record from the directory, if possible.
    //
    if (oh->hflag & XRDOSS_HT_EOF) *buff = '\0';
       else if ((resp = oh->sp->GetLine()))
               {if ( ((int)strlen(resp)) >= blen )
                   {*buff = '\0';
                    return OssEroute.Emsg(epname, -EOVERFLOW,
                                            "readdir rmt", resp);
                   }
                   strlcpy(buff, resp, blen);
               } else {
                if ((retc = oh->sp->LastError())) return NegVal(retc);
                   else {*buff = '\0'; oh->hflag |= XRDOSS_HT_EOF;}
               }
    return XrdOssOK;
}

References XrdSysError::Emsg(), XrdOucStream::GetLine(), XrdOssHandle::hflag, XrdOucStream::LastError(), NegVal, OssEroute, XrdOssHandle::sp, strlcpy(), XRDOSS_HT_DIR, XRDOSS_HT_EOF, and XrdOssOK.

Referenced by XrdOssDir::Readdir().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Remdir()

int XrdOssSys::MSS_Remdir ( const char *  , const char *    )

inline

Definition at line 217 of file XrdOssApi.hh.

{return -ENOTSUP;}

MSS_Rename()

int XrdOssSys::MSS_Rename	(	const char *	oldname,
		const char *	newname
	)

Definition at line 360 of file XrdOssMSS.cc.

                                                                  {
    const char *epname = "MSS_Rename";
 
    // Make sure the path is not too long.
    //
    if (strlen(oldname) > MAXPATHLEN
    ||  strlen(newname) > MAXPATHLEN)
       {OssEroute.Emsg(epname,"mss path too long - ", oldname, newname);
        return -ENAMETOOLONG;
       }
 
    // Rename the file in Mass Store System
    //
    return MSS_Xeq(0, 0, "mv", oldname, newname);
}

References XrdSysError::Emsg(), MSS_Xeq(), and OssEroute.

Referenced by Rename().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Stat()

int XrdOssSys::MSS_Stat	(	const char *	path,
		struct stat *	buff = 0
	)

Definition at line 253 of file XrdOssMSS.cc.

{
    const char *epname = "MSS_Stat";
    char ftype, mtype[10], *resp;
    int retc, xt_nlink;
    long xt_uid, xt_gid, atime, ctime, mtime, xt_blksize, xt_blocks;
    long long xt_size;
    XrdOucStream *sfd;
 
    // Make sure the path is not too long.
    //
    if (strlen(path) > MAXPATHLEN)
       {OssEroute.Emsg(epname, "mss path too long - ", path);
        return -ENAMETOOLONG;
       }
 
    // Issue the command. This may be an immediate exists a or full statx.
    //
    if (!buff) return MSS_Xeq(0, ENOENT, (isMSSC ? "statx" : "exists"), path);
    if ((retc = MSS_Xeq(&sfd, ENOENT, "statx", path))) return retc;
 
    // Read in the results.
    //
    if ( !(resp = sfd ->GetLine()))
       return OssEroute.Emsg(epname,-XRDOSS_E8012,"process ",path);
 
    // Extract data from the response.
    //
    sscanf(resp, "%c %9s %d %ld %ld %ld %ld %ld %lld %ld %ld", &ftype, mtype,
           &xt_nlink, &xt_uid, &xt_gid, &atime, &ctime, &mtime,
           &xt_size, &xt_blksize, &xt_blocks);
 
    // Set the stat buffer, appropriately.
    //
    memset( (char *)buff, 0, sizeof(struct stat) );
    buff->st_nlink = static_cast<nlink_t>(xt_nlink);
    buff->st_uid   = static_cast<uid_t>(xt_uid);
    buff->st_gid   = static_cast<gid_t>(xt_gid);
    buff->st_atime = static_cast<time_t>(atime);
    buff->st_ctime = static_cast<time_t>(ctime);
    buff->st_mtime = static_cast<time_t>(mtime);
    buff->st_size  = static_cast<off_t>(xt_size);
    buff->st_blksize=static_cast<long>(xt_blksize);
#ifdef __APPLE__
    buff->st_blocks =                      xt_blocks;
#else
    buff->st_blocks =static_cast<blkcnt_t>(xt_blocks);
#endif
 
    if (ftype == 'd') buff->st_mode |=  S_IFDIR;
       else if (ftype == 'l') buff->st_mode |= S_IFLNK;
               else buff->st_mode |= S_IFREG;
 
    buff->st_mode |= tranmode(&mtype[0]) << 6;
    buff->st_mode |= tranmode(&mtype[3]) << 3;
    buff->st_mode |= tranmode(&mtype[6]);
 
    delete sfd;
    return 0;
}

References XrdSysError::Emsg(), isMSSC, MSS_Xeq(), OssEroute, stat, tranmode(), and XRDOSS_E8012.

Referenced by Create(), Stage_RT(), and Stat().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Unlink()

int XrdOssSys::MSS_Unlink

(

const char *

path

)

Definition at line 333 of file XrdOssMSS.cc.

                                          {
    const char *epname = "MSS_Unlink";
 
    // Make sure the path is not too long.
    //
    if (strlen(path) > MAXPATHLEN)
       {OssEroute.Emsg(epname, "mss path too long - ", path);
        return -ENAMETOOLONG;
       }
 
    // Remove the file in Mass Store System.
    //
    return MSS_Xeq(0, ENOENT, "rm", path);
}

References XrdSysError::Emsg(), MSS_Xeq(), and OssEroute.

Referenced by Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

MSS_Xeq()

int XrdOssSys::MSS_Xeq ( XrdOucStream **  xfd, int  okerr, const char *  cmd, const char *  arg1 = 0, const char *  arg2 = 0  )

protected

Definition at line 383 of file XrdOssMSS.cc.

{
    EPNAME("MSS_Xeq")
    static int NoResp = 0;
    char *resp;
    int retc;
    XrdOucStream *sp;
 
// If we have no gateway command, return an error
//
   if (!RSSProg) return -XRDOSS_E8013;
 
// Allocate a stream for this command
//
   if (!(sp = new XrdOucStream(&OssEroute)))
      return OssEroute.Emsg("MSS_Xeq",-ENOMEM,"create stream for",RSSCmd);
 
// Run the command
//
   DEBUG("Invoking '" <<RSSCmd <<' ' <<cmd <<' ' <<(arg1 ? arg1 : "")
                      <<' ' <<(arg2 ? arg2 : ""));
   if ((retc = RSSProg->Run(sp, cmd, arg1, arg2)))
      {delete sp; return NegVal(retc);}
 
// Wait for data to appear. We do this to avoid hanging up and chewing through
// all of the threads while clients retry the requests with a new connection.
//
   if ((retc = sp->Wait4Data(RSSTout)))
      {if (retc < 0)
          {if (!(0xff & NoResp++))
               OssEroute.Emsg("MSS_Xeq", -ETIMEDOUT, "execute", cmd);
           retc = ETIMEDOUT;
          }
       delete sp; return NegVal(retc);
      }
 
// Read back the first record. The first records must be the return code
// from the command followed by any output. Make sure that this is the case.
//
   if ( !(resp = sp->GetLine()) ) retc = XRDOSS_E8023;
      else
      {DEBUG("received '" <<resp <<"'");
       if (sscanf(resp, "%d", &retc) <= 0) retc = XRDOSS_E8024;
      }
   if (retc)
      {if (retc != -okerr)
          OssEroute.Emsg("MSS_Xeq", NegVal(retc), "execute", cmd);
       delete sp;
       return NegVal(retc);
      }
 
// If the caller wants the stream pointer; return it. Otherwise close it.
//
   if (xfd) *xfd = sp;
      else delete sp;
   return 0;
}

References DEBUG, XrdSysError::Emsg(), EPNAME, XrdOucStream::GetLine(), NegVal, OssEroute, RSSCmd, RSSProg, RSSTout, XrdOucProg::Run(), XrdOssHandle::sp, XrdOucStream::Wait4Data(), XRDOSS_E8013, XRDOSS_E8023, and XRDOSS_E8024.

Referenced by MSS_Create(), MSS_Opendir(), MSS_Rename(), MSS_Stat(), and MSS_Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

newDir()

virtual XrdOssDF* XrdOssSys::newDir ( const char *  tident )

inlinevirtual

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

Parameters

tident

- The trace identifier.

Returns

pointer- Pointer to an XrdOssDF object.

nil - Insufficient memory to allocate an object.

Implements XrdOss.

Definition at line 163 of file XrdOssApi.hh.

                       {return (XrdOssDF *)new XrdOssDir(tident);}

References tident.

newFile()

virtual XrdOssDF* XrdOssSys::newFile ( const char *  tident )

inlinevirtual

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

Parameters

tident

- The trace identifier.

Returns

pointer- Pointer to an XrdOssDF object.

nil - Insufficient memory to allocate an object.

Implements XrdOss.

Definition at line 165 of file XrdOssApi.hh.

                       {return (XrdOssDF *)new XrdOssFile(tident);}

References tident.

PathOpts()

unsigned long long XrdOssSys::PathOpts ( const char *  path )

inline

Definition at line 184 of file XrdOssApi.hh.

{return RPList.Find(path);}

References XrdOucPListAnchor::Find(), and RPList.

Referenced by XrdOssFile::Open(), XrdOssDir::Opendir(), Stat(), StatFS(), and StatXP().

Here is the call graph for this function:

Here is the caller graph for this function:

Reloc()

int XrdOssSys::Reloc ( const char *  tident, const char *  path, const char *  cgName, const char *  anchor = 0  )

virtual

Relocate/Copy the file at ‘path’ to a new location.

Parameters

tident	- -> trace identifier for this operation.
path	- -> fully qualified name of the file to relocate.
cgName	- -> target space name[:path]
anchor	- Processing directions (see XrdOssReloc.cc example).

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOss.

Definition at line 83 of file XrdOssReloc.cc.

{
   EPNAME("Reloc")
   const int AMode = S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH; // 775
   class pendFiles
        {public:
         char *pbuff;
         char *tbuff;
         int   datfd;
               pendFiles(char *pb, char *tb) : datfd(-1)
                           {pbuff = pb; *pb = '\0';
                            tbuff = tb; *tb = '\0';
                           }
              ~pendFiles() {if (datfd >= 0) close(datfd);
                            if (pbuff && *pbuff) unlink(pbuff);
                            if (tbuff && *tbuff) unlink(tbuff);
                           }
        };
   char cgNow[XrdOssSpace::minSNbsz], cgbuff[XrdOssSpace::minSNbsz];
   char lbuff[MAXPATHLEN+8];
   char pbuff[MAXPATHLEN+8];
   char tbuff[MAXPATHLEN+8];
   char local_path[MAXPATHLEN+8];
   pendFiles PF(pbuff, tbuff);
   XrdOssCache::allocInfo aInfo(path, pbuff, sizeof(pbuff));
   int rc, lblen, datfd, Pure = (anchor && !strcmp(anchor, "."));
   off_t rc_c;
   struct stat buf;
 
// Generate the actual local path for this file.
//
   if (Pure) {strcpy(local_path, path); anchor = 0;}
      else if ((rc = GenLocalPath(path, local_path))) return rc;
 
// Determine the state of the file.
//
   if (stat(local_path, &buf)) return -errno;
   if ((buf.st_mode & S_IFMT) == S_IFDIR) return -EISDIR;
   if ((buf.st_mode & S_IFMT) != S_IFREG) return -ENOTBLK;
 
// Get the correct cache group and partition path
//
   if ((aInfo.cgPath = XrdOssCache::Parse(cgName, cgbuff, sizeof(cgbuff))))
      aInfo.cgPlen = strlen(aInfo.cgPath);
 
// Verify that this file will go someplace other than where it is now
//
   lblen = XrdOssPath::getCname(local_path, cgNow, lbuff, sizeof(lbuff)-7);
   lbuff[lblen] = '\0';
   if (!Pure && !strcmp(cgbuff, cgNow)
   && (!aInfo.cgPath || !strncmp(aInfo.cgPath, lbuff, aInfo.cgPlen)))
      return -EEXIST;
 
// Allocate space in the cache. Note that the target must be an xa cache
//
   aInfo.aMode  = buf.st_mode & S_IAMB;
   aInfo.cgSize = (Pure ? 0 : buf.st_size);
   aInfo.cgName = cgbuff;
   if ((PF.datfd = datfd = XrdOssCache::Alloc(aInfo)) < 0) return datfd;
   if (!aInfo.cgPsfx) return -ENOTSUP;
 
// Copy the original file to the new location. Copy() always closes the fd.
//
   PF.datfd = -1;
   if ((rc_c = XrdOssCopy::Copy(local_path, pbuff, datfd)) < 0) return (int)rc_c;
 
// If the file is to be merely copied, substitute the desired destination
//
   if (!anchor) {strcpy(tbuff, local_path); strcat(tbuff, ".anew");}
      else {struct stat sbuf;
            char *Slash;
            if (strlen(anchor)+strlen(path) >= sizeof(local_path))
               return -ENAMETOOLONG;
            strcpy(local_path, anchor); strcat(local_path, path);
            if (!(Slash = rindex(local_path, '/'))) return -ENOTDIR;
            *Slash = '\0'; rc = stat(local_path, &sbuf); *Slash = '/';
            if (rc && (rc = XrdOucUtils::makePath(local_path, AMode)))
               return rc;
            strcpy(tbuff, local_path);
           }
 
// Now create a symbolic link to the target
//
   if ((symlink(pbuff, tbuff) && errno != EEXIST)
   || unlink(tbuff) || symlink(pbuff, tbuff)) return -errno;
 
// Rename the link atomically over the existing name
//
   if (!anchor && rename(tbuff, local_path) < 0) return -errno;
   PF.tbuff = 0; PF.pbuff = 0; rc = 0;
 
// Issue warning if the pfn file could not be created (very very rare).
// At this point we can't do much about it.
//
   if (rc) OssEroute.Emsg("Reloc", rc, "create symlink", pbuff);
   *(aInfo.cgPsfx) = '\0';
 
// If this was a copy operation, we are done
//
   DEBUG(cgNow <<':' <<local_path <<" -> " <<aInfo.cgName <<':' <<pbuff);
   if (anchor) return XrdOssOK;
 
// Check if the original file was a symlink and that has to be deleted
// Adjust the space usage numbers at this point as well.
//
   if (*lbuff)
      {if (unlink(lbuff))     OssEroute.Emsg("Reloc",errno,"removing",lbuff);
       XrdOssCache::Adjust(XrdOssCache::Find(lbuff, lblen), -buf.st_size);
       } else XrdOssCache::Adjust(buf.st_dev, -buf.st_size);
 
// All done (permanently adjust usage for the target)
//
   XrdOssCache::Adjust(aInfo.cgFSp, buf.st_size);
   return XrdOssOK;
}

References XrdOssCache::Adjust(), XrdOssCache::Alloc(), XrdOssCache::allocInfo::aMode, XrdOssCache::allocInfo::cgFSp, XrdOssCache::allocInfo::cgName, XrdOssCache::allocInfo::cgPath, XrdOssCache::allocInfo::cgPlen, XrdOssCache::allocInfo::cgPsfx, XrdOssCache::allocInfo::cgSize, close, XrdOssCopy::Copy(), DEBUG, XrdSysError::Emsg(), EPNAME, XrdOssCache::Find(), GenLocalPath(), XrdOssPath::getCname(), XrdOucUtils::makePath(), XrdOssSpace::minSNbsz, OssEroute, XrdOssCache::Parse(), rename(), S_IAMB, stat, unlink, and XrdOssOK.

Here is the call graph for this function:

Remdir()

int XrdOssSys::Remdir ( const char *  path, int  Opts = 0, XrdOucEnv *  envP = 0  )

virtual

Remove a directory.

Parameters

path	- Pointer to the path of the directory to be removed.
Opts	- The processing options: XRDOSS_Online - only remove online copy XRDOSS_isPFN - path is already translated.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 70 of file XrdOssUnlink.cc.

{
    unsigned long long opts;
    int retc;
    struct stat statbuff;
    char  local_path[MAXPATHLEN+1+8];
 
// Build the right local and remote paths.
//
   if (Opts & XRDOSS_isPFN) strcpy(local_path, path);
      else {retc = Check_RO(Unlink, opts, path, "remove");
            if ( (retc = GenLocalPath( path,  local_path))) return retc;
           }
 
// Check if this path is really a directory
//
    if (lstat(local_path, &statbuff)) return (errno == ENOENT ? 0 : -errno);
    if ((statbuff.st_mode & S_IFMT) != S_IFDIR) return -ENOTDIR;
 
// Complete by calling Unlink()
//
    return Unlink(path, Opts);
}

References Check_RO, GenLocalPath(), lstat, XrdMpx::Opts, opts, stat, Unlink(), and XRDOSS_isPFN.

Here is the call graph for this function:

Rename()

int XrdOssSys::Rename ( const char *  oPath, const char *  nPath, XrdOucEnv *  oEnvP = 0, XrdOucEnv *  nEnvP = 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.
oEnvP	- Environmental information for oPath.
nEnvP	- Environmental information for nPath.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 74 of file XrdOssRename.cc.

{
    EPNAME("Rename")
    static const mode_t pMode = S_IRWXU | S_IRWXG;
    unsigned long long remotefs_Old, remotefs_New, remotefs;
    unsigned long long old_popts, new_popts;
    int retc2, retc = XrdOssOK;
    struct stat statbuff;
    char  *slashPlus, sPChar;
    char  local_path_Old[MAXPATHLEN+8];
    char  local_path_New[MAXPATHLEN+8];
    char remote_path_Old[MAXPATHLEN+1];
    char remote_path_New[MAXPATHLEN+1];
 
// Determine whether we can actually rename a file on this server.
//
   remotefs_Old = Check_RO(Rename, old_popts, oldname, "rename");
   remotefs_New = Check_RO(Rename, new_popts, newname, "rename to");
 
// Make sure we are renaming within compatible file systems
//
   if (remotefs_Old ^ remotefs_New
   || ((old_popts & XRDEXP_MIG) ^ (new_popts & XRDEXP_MIG)))
      {char buff[MAXPATHLEN+128];
       snprintf(buff, sizeof(buff), "rename %s to ", oldname);
       return OssEroute.Emsg("Rename",-XRDOSS_E8011,buff,(char *)newname);
      }
   remotefs = remotefs_Old | remotefs_New;
 
// Construct the filename that we will be dealing with.
//
   if ( (retc = GenLocalPath( oldname, local_path_Old))
     || (retc = GenLocalPath( newname, local_path_New)) ) return retc;
   if (remotefs
     && (((retc = GenRemotePath(oldname, remote_path_Old))
     ||   (retc = GenRemotePath(newname, remote_path_New)))) ) return retc;
 
// If on a remote FS or symlink, make sure that the target path does not exist
//
   if (!(retc2 = lstat(local_path_New, &statbuff)))
      { if (remotefs || (statbuff.st_mode & S_IFMT) == S_IFLNK) return -EEXIST;
      }
 
// We need to create the directory path if it does not exist.
//
   if (!(slashPlus = rindex(local_path_New, '/'))) return -EINVAL;
   slashPlus++; sPChar = *slashPlus; *slashPlus = '\0';
   retc2 = XrdOucUtils::makePath(local_path_New, pMode);
   *slashPlus = sPChar;
   if (retc2) return retc2;
 
// Check if this path is really a symbolic link elsewhere
//
    if (lstat(local_path_Old, &statbuff)) retc = -errno;
       else if ((statbuff.st_mode & S_IFMT) == S_IFLNK)
               retc = RenameLink(local_path_Old, local_path_New);
               else if (rename(local_path_Old, local_path_New)) retc = -errno;
    DEBUG("lcl rc=" <<retc <<" op=" <<local_path_Old <<" np=" <<local_path_New);
 
// Now rename the data file in the remote system if the local rename "worked".
// Do not do this if we really should not use the MSS.
//
   if (remotefs)
      {if (remotefs && (!retc || retc == -ENOENT) && RSSCmd)
          {if ( (retc2 = MSS_Rename(remote_path_Old, remote_path_New))
              != -ENOENT) retc = retc2;
           DEBUG("rmt rc=" <<retc2 <<" op=" <<remote_path_Old <<" np=" <<remote_path_New);
          }
      }
 
// All done.
//
   return retc;
}

References Check_RO, DEBUG, XrdSysError::Emsg(), EPNAME, GenLocalPath(), GenRemotePath(), lstat, XrdOucUtils::makePath(), MSS_Rename(), OssEroute, rename(), RenameLink(), RSSCmd, stat, XRDEXP_MIG, XRDOSS_E8011, and XrdOssOK.

Here is the call graph for this function:

RenameLink()

int XrdOssSys::RenameLink ( char *  old_path, char *  new_path  )

protected

Definition at line 157 of file XrdOssRename.cc.

{
   struct stat statbuff;
   char oldlnk[MAXPATHLEN+32], newlnk[MAXPATHLEN+32];
   int lnklen, n, rc = 0;
 
// Read the contents of the link
//
   if ((lnklen = readlink(old_path,oldlnk,sizeof(oldlnk)-1)) < 0) return -errno;
   oldlnk[lnklen] = '\0';
 
// Check if this is new or old style cache. Check if this is an offline rename
// and if so, add the space to the usage to account for stage-ins
//
   if (oldlnk[lnklen-1] == XrdOssPath::xChar)
      {rc = RenameLink3(oldlnk, old_path, new_path);
       if (rc) return rc;
       if (Solitary && UDir)
          {n = strlen(old_path);
           if (n < 6 || strcmp(old_path+n-5, ".anew")
           ||  stat(new_path, &statbuff) || !statbuff.st_size) return 0;
           XrdOssPath::Trim2Base(oldlnk+lnklen-1);
           XrdOssCache::Adjust(oldlnk, statbuff.st_size);
          }
       return 0;
      }
 
// Convert old name to the new name
//
   if ((rc = XrdOssPath::Convert(newlnk, sizeof(newlnk), oldlnk, new_path)))
      {OssEroute.Emsg("RenameLink", rc, "convert", oldlnk);
       return rc;
      }
 
// Make sure that the target name does not exist
//
   if (!lstat(newlnk, &statbuff))
      {OssEroute.Emsg("RenameLink",-EEXIST,"check new target", newlnk);
       return -EEXIST;
      }
 
// Insert a new link in the target cache
//
   if (symlink(newlnk, new_path))
      {rc = errno;
       OssEroute.Emsg("RenameLink", rc, "symlink to", newlnk);
       return -rc;
      }
 
// Rename the actual target file
//
   if (rename(oldlnk, newlnk))
      {rc = errno;
       OssEroute.Emsg("RenameLink", rc, "rename", oldlnk);
       unlink(new_path);
       return -rc;
      }
 
// Now, unlink the source path
//
   if (unlink(old_path))
      OssEroute.Emsg("RenameLink", rc, "unlink", old_path);
 
// All done
//
   return 0;
}

References XrdOssCache::Adjust(), XrdOssPath::Convert(), XrdSysError::Emsg(), lstat, OssEroute, rename(), RenameLink3(), Solitary, stat, XrdOssPath::Trim2Base(), UDir, unlink, and XrdOssPath::xChar.

Referenced by Rename().

Here is the call graph for this function:

Here is the caller graph for this function:

RenameLink3()

int XrdOssSys::RenameLink3 ( char *  cPath, char *  old_path, char *  new_path  )

protected

Definition at line 229 of file XrdOssRename.cc.

{
   int rc;
 
// First set the new extended attribute on this file
//
   if ((rc = XrdSysFAttr::Xat->Set(XrdFrcXAttrPfn::Name(), new_path,
                                   strlen(new_path)+1, cPath))) return rc;
 
// Now merely rename the old to the new
//
   if (!rename(old_path, new_path)) return 0;
 
// Rename failed, restore old attribute
//
   rc = -errno;
   XrdSysFAttr::Xat->Set(XrdFrcXAttrPfn::Name(),old_path,strlen(old_path)+1,cPath);
   OssEroute.Emsg("RenameLink", rc, "rename", old_path);
   return rc;
}

References XrdSysError::Emsg(), XrdFrcXAttrPfn::Name(), OssEroute, rename(), XrdSysXAttr::Set(), and XrdSysFAttr::Xat.

Referenced by RenameLink().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFattr()

int XrdOssSys::SetFattr ( XrdOssCreateInfo &  crInfo, int  datfd, time_t  mtime  )

protected

Definition at line 332 of file XrdOssCreate.cc.

{
   class  fdCloser
         {public:
          const char *Path;
          int         theFD;
          int         Done(int rc) {if (rc) unlink(Path); return rc;}
                      fdCloser(const char *pn, int fd) : Path(pn), theFD(fd) {}
                     ~fdCloser() {close(theFD);}
         } Act(crInfo.Path, fd);
 
   XrdOucXAttr<XrdFrcXAttrCpy> crX;
   int rc;
 
// Check if we need or can record the create time
//
   if (!(XRDEXP_MIGPRG & crInfo.pOpts)
   ||  (crInfo.pOpts & XRDEXP_NOXATTR)) return Act.Done(0);
 
// Set copy time
//
   crX.Attr.cpyTime = static_cast<long long>(mtime);
   rc = crX.Set(crInfo.Path, fd);
 
// Check if extended attribute were set and indicate whether it is supported
//
   if (rc == -ENOTSUP) {rc = 0; crInfo.cOpts |= XRDOSS_setnoxa;}
   return Act.Done(rc);
}

References XrdOucXAttr< T >::Attr, close, XrdOssCreateInfo::cOpts, XrdFrcXAttrCpy::cpyTime, XrdOssCreateInfo::Path, Path, XrdOssCreateInfo::pOpts, XrdOucXAttr< T >::Set(), unlink, XRDEXP_MIGPRG, XRDEXP_NOXATTR, and XRDOSS_setnoxa.

Referenced by Alloc_Cache(), Alloc_Local(), and Create().

Here is the call graph for this function:

Here is the caller graph for this function:

Stage()

int XrdOssSys::Stage ( const char *  Tid, const char *  fn, XrdOucEnv &  env, int  Oflag, mode_t  Mode, unsigned long long  Popts  )

virtual

Definition at line 110 of file XrdOssStage.cc.

{
// Use the appropriate method here: queued staging or real-time staging
//
   return (StageRealTime ? Stage_RT(Tid, fn, env, Popts)
                         : Stage_QT(Tid, fn, env, Oflag, Mode));
}

References Mode, Stage_QT(), Stage_RT(), and StageRealTime.

Referenced by Create(), and XrdOssFile::Open().

Here is the call graph for this function:

Here is the caller graph for this function:

Stage_In()

void * XrdOssSys::Stage_In

(

void *

carg

)

Definition at line 303 of file XrdOssStage.cc.

{
    XrdOucDLlist<XrdOssStage_Req> *rnode;
    XrdOssStage_Req              *req;
    int rc, alldone = 0;
    time_t etime;
 
      // Wait until something shows up in the ready queue and process
      //
   do   {XrdOssStage_Req::ReadyRequest.Wait();
 
      // Obtain exclusive control over the queues
      //
         XrdOssStage_Req::StageMutex.Lock();
 
      // Check if we really have something in the queue
      //
         if (XrdOssStage_Req::StageQ.pendList.Singleton())
            {XrdOssStage_Req::StageMutex.UnLock();
             continue;
            }
 
      // Remove the last entry in the queue
      //
         rnode = XrdOssStage_Req::StageQ.pendList.Prev();
         req   = rnode->Item();
         rnode->Remove();
         req->flags |= XRDOSS_REQ_ACTV;
 
      // Account for bytes being moved
      //
         pndbytes -= req->size;
         stgbytes += req->size;
 
      // Bring in the file (don't hold the stage lock while doing so)
      //
         XrdOssStage_Req::StageMutex.UnLock();
         etime = time(0);
         rc = GetFile(req);
         etime = time(0) - etime;
         XrdOssStage_Req::StageMutex.Lock();
 
      // Account for resources and adjust xfr rate
      //
         stgbytes -= req->size;
         if (!rc)
            {if (etime > 1) 
                {xfrspeed=((xfrspeed*(totreqs+1))+(req->size/etime))/(totreqs+1);
                 if (xfrspeed < 512000) xfrspeed = 512000;
                }
             totreqs++;          // Successful requests
             totbytes += req->size;
             delete req;
            }
            else {req->flags &= ~XRDOSS_REQ_ACTV;
                  req->flags |= (rc == 2 ? XRDOSS_REQ_ENOF : XRDOSS_REQ_FAIL);
                  req->sigtod = xfrhold + time(0);
                  badreqs++;
                 }
 
      // Check if we should continue or be terminated and unlock staging
      //
         if ((alldone = (xfrthreads < xfrtcount)))
            xfrtcount--;
         XrdOssStage_Req::StageMutex.UnLock();
 
         } while (!alldone);
 
// Notmally we would never get here
//
   return (void *)0;
}

References badreqs, XrdOssStage_Req::flags, GetFile(), XrdOucDLlist< T >::Item(), XrdSysMutex::Lock(), XrdOssStage_Req::pendList, pndbytes, XrdOucDLlist< T >::Prev(), XrdOssStage_Req::ReadyRequest, XrdOucDLlist< T >::Remove(), XrdOssStage_Req::sigtod, XrdOssStage_Req::size, XrdOssStage_Req::StageMutex, XrdOssStage_Req::StageQ, stgbytes, totbytes, totreqs, XrdSysMutex::UnLock(), XrdSysSemaphore::Wait(), xfrhold, xfrspeed, xfrtcount, xfrthreads, XRDOSS_REQ_ACTV, XRDOSS_REQ_ENOF, and XRDOSS_REQ_FAIL.

Referenced by XrdOssxfr().

Here is the call graph for this function:

Here is the caller graph for this function:

Stage_QT()

int XrdOssSys::Stage_QT ( const char *  Tid, const char *  fn, XrdOucEnv &  env, int  Oflag, mode_t  Mode  )

protected

Definition at line 123 of file XrdOssStage.cc.

{
   static XrdOucReqID ReqID;
   static XrdSysMutex      PTMutex;
   static XrdOucHash<char> PTable;
   static time_t nextScrub = xfrkeep + time(0);
   char *Found, *pdata[XrdOucMsubs::maxElem + 2];
   int pdlen[XrdOucMsubs::maxElem + 2];
   time_t cTime, mTime, tNow = time(0);
 
// If there is a fail file and the error occurred within the hold time,
// fail the request. Otherwise, try it again. This avoids tight loops.
//
   if ((cTime = HasFile(fn, XRDOSS_FAIL_FILE, &mTime))
   && xfrhold && (tNow - cTime) < xfrhold)
      return (mTime != 2 ? -XRDOSS_E8009 : -ENOENT);
 
// If enough time has gone by between the last scrub, do it now
//
   if (nextScrub < tNow) 
      {PTMutex.Lock(); 
       if (nextScrub < tNow) 
          {PTable.Apply(XrdOssScrubScan, (void *)0);
           nextScrub = xfrkeep + tNow;
          }
       PTMutex.UnLock();
      }
 
// Check if this file is already being brought in. If so, return calculated
// wait time for this file.
//
   PTMutex.Lock();
   Found = PTable.Add(fn, 0, xfrkeep, Hash_data_is_key);
   PTMutex.UnLock();
   if (Found) return CalcTime();
 
// Check if we should use our built-in frm interface
//
   if (StageFrm)
      {char idbuff[64];
       ReqID.ID(idbuff, sizeof(idbuff));
       int n;
       return (n = StageFrm->Add('+', fn, env.Env(n), Tid, idbuff,
                   StageEvents, StageAction)) ? n : CalcTime();
      }
 
// If a stagemsg template was not defined; use our default template
//
   if (!StageSnd)
      {char idbuff[64], usrbuff[512];
       ReqID.ID(idbuff, sizeof(idbuff));
       if (!StageFormat)
      {pdata[0] = (char *)"+ ";  pdlen[0] = 2;}
else  {pdlen[0] = getID(Tid,env,usrbuff,sizeof(usrbuff)); pdata[0] = usrbuff;}
       pdata[1] = idbuff;        pdlen[1] = strlen(idbuff);  // Request ID
       pdata[2] = (char *)" ";   pdlen[2] = 1;
       pdata[3] = StageEvents;   pdlen[3] = StageEvSize;     // notification
       pdata[4] = (char *)" ";   pdlen[4] = 1;
       pdata[5] = (char *)"0 ";  pdlen[5] = 2;               // prty
       pdata[6] = StageAction;   pdlen[6] = StageActLen;     // action
       pdata[7] = (char *)fn;    pdlen[7] = strlen(fn);
       pdata[8] = (char *)"\n";  pdlen[8] = 1;
       pdata[9] = 0;             pdlen[9] = 0;
       if (StageProg->Feed((const char **)pdata, pdlen)) return -XRDOSS_E8025;
      } else {
       XrdOucMsubsInfo Info(Tid, &env, lcl_N2N, fn, 0, 
                            Mode, Oflag, StageAction, "n/a");
       int k = StageSnd->Subs(Info, pdata, pdlen);
       pdata[k]   = (char *)"\n"; pdlen[k++] = 1;
       pdata[k]   = 0;            pdlen[k]   = 0;
       if (StageProg->Feed((const char **)pdata, pdlen)) return -XRDOSS_E8025;
      }
 
// All done
//
   return CalcTime();
}

References XrdFrcProxy::Add(), XrdOucHash< T >::Add(), XrdOucHash< T >::Apply(), CalcTime(), XrdOucEnv::Env(), XrdOucProg::Feed(), getID(), HasFile(), Hash_data_is_key, XrdOucReqID::ID(), TPC::Info, lcl_N2N, XrdSysMutex::Lock(), XrdOucMsubs::maxElem, Mode, StageAction, StageActLen, StageEvents, StageEvSize, StageFormat, StageFrm, StageProg, StageSnd, XrdOucMsubs::Subs(), XrdSysMutex::UnLock(), xfrhold, xfrkeep, XRDOSS_E8009, XRDOSS_E8025, XRDOSS_FAIL_FILE, and XrdOssScrubScan().

Referenced by Stage().

Here is the call graph for this function:

Here is the caller graph for this function:

Stage_RT()

int XrdOssSys::Stage_RT ( const char *  Tid, const char *  fn, XrdOucEnv &  env, unsigned long long  Popts  )

protected

Definition at line 206 of file XrdOssStage.cc.

{
    extern int XrdOssFind_Prty(XrdOssStage_Req *req, void *carg);
    XrdSysMutexHelper StageAccess(XrdOssStage_Req::StageMutex);
    XrdOssStage_Req req, *newreq, *oldreq;
    struct stat statbuff;
    extern int XrdOssFind_Req(XrdOssStage_Req *req, void *carg);
    char actual_path[MAXPATHLEN+1], *remote_path;
    char *val;
    int rc, prty;
 
// If there is no stagecmd then return an error
//
   if (!StageCmd) return -XRDOSS_E8006;
 
// Set up the minimal new request structure
//
   req.hash = XrdOucHashVal(fn);
   req.path = strdup(fn);
 
// Check if this file is already being brought in. If it's in the chain but
// has an error associated with it. If the error window is still in effect,
// check if a fail file exists. If one does exist, fail the request. If it
// doesn't exist or if the window has expired, delete the error element and
// retry the request. This keeps us from getting into tight loops.
//
   if ((oldreq = XrdOssStage_Req::StageQ.fullList.Apply(XrdOssFind_Req,(void *)&req)))
      {if (!(oldreq->flags & XRDOSS_REQ_FAIL)) return CalcTime(oldreq);
       if (oldreq->sigtod > time(0) && HasFile(fn, XRDOSS_FAIL_FILE))
          return (oldreq->flags & XRDOSS_REQ_ENOF ? -ENOENT : -XRDOSS_E8009);
       delete oldreq;
      }
 
// Generate remote path
//
   if (rmt_N2N)
      if ((rc = rmt_N2N->lfn2rfn(fn, actual_path, sizeof(actual_path)))) 
         return rc;
         else remote_path = actual_path;
      else remote_path = (char *)fn;
 
// Obtain the size of this file, if possible. Note that an exposure exists in
// that a request for the file may come in again before we have the size. This
// is ok, it just means that we'll be off in our time estimate
//
   if (Popts & XRDEXP_NOCHECK) statbuff.st_size = 1024*1024*1024;
      else {StageAccess.UnLock();
            if ((rc = MSS_Stat(remote_path, &statbuff))) return rc;
            StageAccess.Lock(&XrdOssStage_Req::StageMutex);
           }
 
// Create a new request
//
   if (!(newreq = new XrdOssStage_Req(req.hash, fn)))
       return OssEroute.Emsg("Stage",-ENOMEM,"create req for",fn);
 
// Add this request to the list of requests
//
   XrdOssStage_Req::StageQ.fullList.Insert(&(newreq->fullList));
 
// Recalculate the cumalitive pending stage queue and
//
   newreq->size = statbuff.st_size;
   pndbytes += statbuff.st_size;
 
// Calculate the system priority
//
   if (!(val = env.Get(OSS_SYSPRTY))) prty = OSS_USE_PRTY;
      else if (XrdOuca2x::a2i(OssEroute,"system prty",val,&prty,0)
           || prty > OSS_MAX_PRTY) return -XRDOSS_E8010;
           else prty = prty << 8;
 
// Calculate the user priority
//
   if (OptFlags & XrdOss_USRPRTY && (val = env.Get(OSS_USRPRTY)))
      {if (XrdOuca2x::a2i(OssEroute,"user prty",val,&rc,0)
       || rc > OSS_MAX_PRTY) return -XRDOSS_E8010;
       prty |= rc;
      }
 
// Queue the request at the right position and signal an xfr thread
//
   if ((oldreq = XrdOssStage_Req::StageQ.pendList.Apply(XrdOssFind_Prty,(void *)&prty)))
                           oldreq->pendList.Insert(&newreq->pendList);
      else XrdOssStage_Req::StageQ.pendList.Insert(&newreq->pendList);
   XrdOssStage_Req::ReadyRequest.Post();
 
// Return the estimated time to arrival
//
   return CalcTime(newreq);
}

References XrdOuca2x::a2i(), CalcTime(), XrdSysError::Emsg(), XrdOssStage_Req::flags, XrdOssStage_Req::fullList, XrdOucEnv::Get(), HasFile(), XrdOssStage_Req::hash, XrdOucDLlist< T >::Insert(), XrdOucName2Name::lfn2rfn(), XrdSysMutexHelper::Lock(), MSS_Stat(), OptFlags, OSS_MAX_PRTY, OSS_SYSPRTY, OSS_USE_PRTY, OSS_USRPRTY, OssEroute, XrdOssStage_Req::path, XrdOssStage_Req::pendList, pndbytes, XrdSysSemaphore::Post(), XrdOssStage_Req::ReadyRequest, rmt_N2N, XrdOssStage_Req::sigtod, XrdOssStage_Req::size, StageCmd, XrdOssStage_Req::StageMutex, XrdOssStage_Req::StageQ, stat, XrdSysMutexHelper::UnLock(), XRDEXP_NOCHECK, XRDOSS_E8006, XRDOSS_E8009, XRDOSS_E8010, XRDOSS_FAIL_FILE, XRDOSS_REQ_ENOF, XRDOSS_REQ_FAIL, XrdOss_USRPRTY, XrdOssFind_Prty(), XrdOssFind_Req(), and XrdOucHashVal().

Referenced by Stage().

Here is the call graph for this function:

Here is the caller graph for this function:

Stat()

int XrdOssSys::Stat ( const char *  path, struct stat *  buff, int  opts = 0, XrdOucEnv *  envP = 0  )

virtual

Return state information on a file or directory.

Parameters

path	- Pointer to the path in question.
buff	- Pointer to the structure where info it to be returned.
opts	- Options: XRDOSS_preop - this is a stat prior to open. XRDOSS_resonly - only look for resident files. XRDOSS_updtatm - update file access time.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 70 of file XrdOssStat.cc.

{
    const int ro_Mode = ~(S_IWUSR | S_IWGRP | S_IWOTH);
    char actual_path[MAXPATHLEN+1], *local_path, *remote_path;
    unsigned long long popts;
    int retc;
 
// Construct the processing options for this path
//
   popts = PathOpts(path);
 
// Generate local path
//
   if (lcl_N2N && STT_DoN2N)
      if ((retc = lcl_N2N->lfn2pfn(path, actual_path, sizeof(actual_path)))) 
         return retc;
         else local_path = actual_path;
      else local_path = (char *)path;
 
// Stat the file in the local filesystem first. If there. make sure the mode
// bits correspond to our reality and update access time if so requested.
//
   if (STT_Func)
      {retc = (STT_V2 ? (*STT_Fund)(local_path, buff, opts, EnvP, path)
                      : (*STT_Func)(local_path, buff, opts, EnvP));
      } else retc = stat(local_path, buff);
   if (!retc)
      {if (popts & XRDEXP_NOTRW) buff->st_mode &= ro_Mode;
       if (opts & XRDOSS_updtatm && (buff->st_mode & S_IFMT) == S_IFREG)
          {struct utimbuf times;
           times.actime  = time(0);
           times.modtime = buff->st_mtime;
           utime(local_path, &times);
          }
       return XrdOssOK;
      } else if (errno != ENOENT) return (errno ? -errno : -ENOMSG);
 
// The file may be offline in a mass storage system, check if this is possible
//
   if (!IsRemote(path) || opts & XRDOSS_resonly
   ||  (EnvP && EnvP->Get("oss.lcl"))) return -errno;
   if (!RSSCmd) return (popts & XRDEXP_NOCHECK ? -ENOENT : -ENOMSG);
 
// Generate remote path
//
   if (rmt_N2N)
      if ((retc = rmt_N2N->lfn2rfn(path, actual_path, sizeof(actual_path))))
         return retc;
         else remote_path = actual_path;
      else remote_path = (char *)path;
 
// Now stat the file in the remote system (it doesn't exist locally)
//
   if ((retc = MSS_Stat(remote_path, buff))) return retc;
   if (popts & XRDEXP_NOTRW) buff->st_mode &= ro_Mode;
   return XrdOssOK;
}

References XrdOucEnv::Get(), IsRemote(), lcl_N2N, XrdOucName2Name::lfn2pfn(), XrdOucName2Name::lfn2rfn(), MSS_Stat(), opts, PathOpts(), rmt_N2N, RSSCmd, stat, STT_DoN2N, STT_V2, XRDEXP_NOCHECK, XRDEXP_NOTRW, XRDOSS_resonly, XRDOSS_updtatm, and XrdOssOK.

Referenced by ConfigStats(), Mkdir(), xspace(), and xspaceBuild().

Here is the call graph for this function:

Here is the caller graph for this function:

StatFS() [1/2]

int XrdOssSys::StatFS ( const char *  path, char *  buff, int &  blen, XrdOucEnv *  envP = 0  )

virtual

Return filesystem physical space information associated with a path.

Parameters

path	- Path in the partition in question.
buff	- Pointer to the buffer to hold the information.
blen	- Length of the buffer. This is updated with the actual number of bytes placed in the buffer as in snprintf().
envP	- Pointer to environmental information.

Returns

"<wval> <fsp> <utl> <sval> <fsp> <utl>" where: <wval> is "0" if XRDEXP_NOTRW specified, otherwise "1" <fsp> is free space in megabytes. <utl> is percentage utilization (i.e. allocated space) <sval> is "1' if XRDEXP_STAGE specified, otherwise "0" Upon failure -errno or -osserr (see XrdOssError.hh) returned.

Reimplemented from XrdOss.

Definition at line 145 of file XrdOssStat.cc.

{
   int sVal, wVal, Util;
   long long fSpace, fSize;
   unsigned long long Opt;
 
// Get the values for this file system
//
   StatFS(path, Opt, fSize, fSpace);
   sVal = (Opt & XRDEXP_STAGE ? 1 : 0);
   wVal = (Opt & XRDEXP_NOTRW ? 0 : 1);
 
// Size the value to fit in an int
//
   if (fSpace <= 0) {fSize = fSpace = 0; Util = 0;}
      else {Util = (fSize ? (fSize - fSpace)*100LL/fSize : 0);
            fSpace = fSpace >> 20LL;
            if ((fSpace >> 31LL)) fSpace = 0x7fffffff;
           }
 
// Return the result
//
   blen = snprintf(buff, blen, "%d %lld %d %d %lld %d",
                               wVal, (wVal ? fSpace : 0LL), (wVal ? Util : 0),
                               sVal, (sVal ? fSpace : 0LL), (sVal ? Util : 0));
   return XrdOssOK;
}

References XRDEXP_NOTRW, XRDEXP_STAGE, and XrdOssOK.

Referenced by StatLS().

Here is the caller graph for this function:

StatFS() [2/2]

int XrdOssSys::StatFS	(	const char *	path,
		unsigned long long &	Opt,
		long long &	fSize,
		long long &	fSpace
	)

Definition at line 187 of file XrdOssStat.cc.

{
// Establish the path options
//
   Opt = PathOpts(path);
 
// For in-place paths we just get the free space in that partition, otherwise
// get the maximum available in any partition.
//
   if ((Opt & XRDEXP_STAGE) || !(Opt & XRDEXP_NOTRW))
      if ((Opt & XRDEXP_INPLACE) || !XrdOssCache_Group::fsgroups)
         {char lcl_path[MAXPATHLEN+1];
          if (lcl_N2N)
             if (lcl_N2N->lfn2pfn(path, lcl_path, sizeof(lcl_path)))
                fSpace = -1;
                else fSpace = XrdOssCache_FS::freeSpace(fSize, lcl_path);
             else    fSpace = XrdOssCache_FS::freeSpace(fSize, path);
         } else     {fSpace = XrdOssCache_FS::freeSpace(fSize);}
      else          {fSpace = 0;      fSize = 0;}
   return XrdOssOK;
}

References XrdOssCache_FS::freeSpace(), XrdOssCache_Group::fsgroups, lcl_N2N, XrdOucName2Name::lfn2pfn(), PathOpts(), XRDEXP_INPLACE, XRDEXP_NOTRW, XRDEXP_STAGE, and XrdOssOK.

Here is the call graph for this function:

StatLS()

int XrdOssSys::StatLS ( XrdOucEnv &  env, const char *  path, char *  buff, int &  blen  )

virtual

Return filesystem physical space information associated with a space name.

Parameters

env	- Ref to environmental information. If the environment has the key oss.cgroup defined, the associated value is used as the space name and the path is ignored.
path	- Path in the name space in question. The space name associated with gthe path is used unless overridden.
buff	- Pointer to the buffer to hold the information.
blen	- Length of the buffer. This is updated with the actual number of bytes placed in the buffer as in snprintf().

Returns

"oss.cgroup=<name>&oss.space=<totbytes>&oss.free=<freebytes> &oss.maxf=<maxcontigbytes>&oss.used=<bytesused> &oss.quota=<quotabytes>" in buff upon success. Upon failure -errno or -osserr (see XrdOssError.hh) returned.

Reimplemented from XrdOss.

Definition at line 225 of file XrdOssStat.cc.

{
   static const char *Resp="oss.cgroup=%s&oss.space=%lld&oss.free=%lld"
                           "&oss.maxf=%lld&oss.used=%lld&oss.quota=%lld";
   struct stat sbuff;
   XrdOssCache_Space   CSpace;
   char *cgrp, cgbuff[XrdOssSpace::minSNbsz];
   int retc;
 
// We provide pseudo support whould be not have a cache
//
   if (!XrdOssCache_Group::fsgroups)
      {unsigned long long Opt;
       long long fSpace, fSize;
       StatFS(path, Opt, fSize, fSpace);
       if (fSpace < 0) fSpace = 0;
       blen = snprintf(buff, blen, Resp, "public", fSize, fSpace, fSpace,
                                   fSize-fSpace, XrdOssCache_Group::PubQuota);
       return XrdOssOK;
      }
 
// Find the cache group. We provide pseudo support should we not have a cache
//
   if (!(cgrp = env.Get(OSS_CGROUP)))
      {if ((retc = getCname(path, &sbuff, cgbuff))) return retc;
          else cgrp = cgbuff;
      }
 
// Accumulate the stats and format the result
//
   blen = (XrdOssCache_FS::getSpace(CSpace, cgrp)
        ? snprintf(buff,blen,Resp,cgrp,CSpace.Total,CSpace.Free,CSpace.Maxfree,
                                       CSpace.Usage,CSpace.Quota)
        : snprintf(buff, blen, Resp, cgrp, 0LL, 0LL, 0LL, 0LL, -1LL));
   return XrdOssOK;
}

References XrdOssCache_Group::fsgroups, XrdOucEnv::Get(), getCname(), XrdOssCache_FS::getSpace(), XrdOssSpace::minSNbsz, OSS_CGROUP, XrdOssCache_Group::PubQuota, stat, StatFS(), and XrdOssOK.

Here is the call graph for this function:

StatPF()

int XrdOssSys::StatPF ( const char *  path, struct stat *  buff, int  opts  )

virtual

Reimplemented from XrdOss.

Definition at line 276 of file XrdOssStat.cc.

{
   char lcl_path[MAXPATHLEN+1];
   int retc;
 
// If just the maximum values wanted then we can return these right away
//
   if (opts & PF_dNums)
      {XrdOssCache::DevInfo(*buff, true);
       return 0;
      }
 
// Check if path is nil and do he appropriate thing
//
   if (!path)
      {if (opts & PF_dInfo) XrdOssCache::DevInfo(*buff, false);
          else return -EINVAL;
       return 0;
      }
 
// Check if we should do lfn2pfn conversion (previously we didn't allow it)
//
   if (lcl_N2N && (opts & PF_isLFN))
      {if ((retc = lcl_N2N->lfn2pfn(path, lcl_path, sizeof(lcl_path))))
          return retc;
       path = lcl_path;
      }
 
// We no longer use the custom stat plug-in for this function. It never
// worked in the first place, anyway.
//
   if (stat(path, buff)) return (errno ? -errno : -ENOMSG);
 
// Check of general stat information is to be returned
//
   if (opts %  PF_dStat)
      {buff->st_rdev = 0;
       return XrdOssOK;
      }
 
// Check if device info is to be returned
//
   if (opts & PF_dInfo) XrdOssCache::DevInfo(*buff);
 
// All done
//
   return XrdOssOK;
}

References XrdOssCache::DevInfo(), lcl_N2N, XrdOucName2Name::lfn2pfn(), opts, XrdOss::PF_dInfo, XrdOss::PF_dNums, XrdOss::PF_dStat, XrdOss::PF_isLFN, stat, and XrdOssOK.

Here is the call graph for this function:

Stats()

int XrdOssSys::Stats ( char *  buff, int  blen  )

virtual

Return statistics.

Parameters

buff	- Pointer to the buffer to hold statistics.
blen	- Length of the buffer.

Returns

The number of bytes placed in the buffer excluding null byte.

Reimplemented from XrdOss.

Definition at line 456 of file XrdOssApi.cc.

{
   static const char statfmt1[] = "<stats id=\"oss\" v=\"2\">";
   static const char statfmt2[] = "</stats>";
   static const int  statflen = sizeof(statfmt1) + sizeof(statfmt2);
   char *bp = buff;
   int n;
 
// If only size wanted, return what size we need
//
   if (!buff) return statflen + getStats(0,0);
 
// Make sure we have enough space
//
   if (blen < statflen) return 0;
   strcpy(bp, statfmt1);
   bp += sizeof(statfmt1)-1; blen -= sizeof(statfmt1)-1;
 
// Generate space statistics
//
   n = getStats(bp, blen);
   bp += n; blen -= n;
 
// Add trailer
//
   if (blen >= (int)sizeof(statfmt2))
      {strcpy(bp, statfmt2); bp += (sizeof(statfmt2)-1);}
   return bp - buff;
}

References getStats().

Here is the call graph for this function:

StatVS()

int XrdOssSys::StatVS ( XrdOssVSInfo *  vsP, const char *  sname = 0, int  updt = 0  )

virtual

Return space information for a space name.

Parameters

vsP	- Pointer to the XrdOssVSInfo object to hold results. It should be fully initialized (i.e. a new copy).
sname	- Pointer to the space name. If the name starts with a plus (e.g. "+public"), partition information is returned, should it exist. If nil, space information for all spaces is returned. See, XrdOssVS.hh for more info.
updt	- When true, a space update occurrs prior to a query.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOss.

Definition at line 339 of file XrdOssStat.cc.

{
   XrdOssCache_Space CSpace;
   XrdOssVSPart **vsP;
 
// Check if we should update the statistics
//
   if (updt) XrdOssCache::Scan(0);
 
// If no space name present or no spaces defined and the space is public then
// return information on all spaces.
//
   if (!sname || (!XrdOssCache_Group::fsgroups && !strcmp("public", sname)))
      {XrdOssCache::Mutex.Lock();
       sP->Total  = XrdOssCache::fsTotal;
       sP->Free   = XrdOssCache::fsTotFr;
       sP->LFree  = XrdOssCache::fsFree;
       sP->Large  = XrdOssCache::fsLarge;
       sP->Extents= XrdOssCache::fsCount;
       XrdOssCache::Mutex.UnLock();
       return XrdOssOK;
      }
 
// Check if partition table wanted
//
   if (*sname != '+') vsP = 0;
      else {sname++;
            vsP = &(sP->vsPart);
           }
 
// Get the space stats
//
   if (!(sP->Extents=XrdOssCache_FS::getSpace(CSpace, sname, vsP)))
      return -ENOENT;
 
// Return the result
//
   sP->Total = CSpace.Total;
   sP->Free  = CSpace.Free;
   sP->LFree = CSpace.Maxfree;
   sP->Large = CSpace.Largest;
   sP->Usage = CSpace.Usage;
   sP->Quota = CSpace.Quota;
   return XrdOssOK;
}

References XrdOssVSInfo::Extents, XrdOssCache_Space::Free, XrdOssVSInfo::Free, XrdOssCache::fsCount, XrdOssCache::fsFree, XrdOssCache_Group::fsgroups, XrdOssCache::fsLarge, XrdOssCache::fsTotal, XrdOssCache::fsTotFr, XrdOssCache_FS::getSpace(), XrdOssVSInfo::Large, XrdOssCache_Space::Largest, XrdOssVSInfo::LFree, XrdSysMutex::Lock(), XrdOssCache_Space::Maxfree, XrdOssCache::Mutex, XrdOssCache_Space::Quota, XrdOssVSInfo::Quota, XrdOssCache::Scan(), XrdOssCache_Space::Total, XrdOssVSInfo::Total, XrdSysMutex::UnLock(), XrdOssCache_Space::Usage, XrdOssVSInfo::Usage, XrdOssVSInfo::vsPart, and XrdOssOK.

Here is the call graph for this function:

StatXA()

int XrdOssSys::StatXA ( const char *  path, char *  buff, int &  blen, XrdOucEnv *  envP = 0  )

virtual

Return logical extended attributes associated with a path.

Parameters

path	- Path in whose information is wanted.
buff	- Pointer to the buffer to hold the information.
blen	- Length of the buffer. This is updated with the actual number of bytes placed in the buffer as in snprintf().
envP	- Pointer to environmental information.

Returns

"oss.cgroup=<name>&oss.type={'f'|'d'|'o'}&oss.used=<totbytes> &oss.mt=<mtime>&oss.ct=<ctime>&oss.at=<atime>&oss.u=*&oss.g=* &oss.fs={'w'|'r'}" Upon failure -errno or -osserr (see XrdOssError.hh) returned.

Reimplemented from XrdOss.

Definition at line 401 of file XrdOssStat.cc.

{
   struct stat sbuff;
   char cgbuff[XrdOssSpace::minSNbsz], fType;
   long long Size, Mtime, Ctime, Atime;
   int retc;
 
// Get the cache group and stat info for the file
//
   if ((retc = getCname(path, &sbuff, cgbuff))) return retc;
        if (S_ISREG(sbuff.st_mode)) fType = 'f';
   else if (S_ISDIR(sbuff.st_mode)) fType = 'd';
   else                             fType = 'o';
 
// Format the result
//
   Size = sbuff.st_size;
   Mtime = sbuff.st_mtime; Ctime = sbuff.st_ctime; Atime = sbuff.st_atime;
   blen = snprintf(buff, blen, 
          "oss.cgroup=%s&oss.type=%c&oss.used=%lld&oss.mt=%lld"
          "&oss.ct=%lld&oss.at=%lld&oss.u=*&oss.g=*&oss.fs=%c",
          cgbuff, fType, Size, Mtime, Ctime, Atime,
          (sbuff.st_mode & S_IWUSR ? 'w':'r'));
   return XrdOssOK;
}

References getCname(), XrdOssSpace::minSNbsz, stat, and XrdOssOK.

Here is the call graph for this function:

StatXP()

int XrdOssSys::StatXP ( const char *  path, unsigned long long &  attr, XrdOucEnv *  envP = 0  )

virtual

Return export attributes associated with a path.

Parameters

path	- Path in whose information is wanted.
attr	- Reference to where the inforamation is to be stored.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Reimplemented from XrdOss.

Definition at line 441 of file XrdOssStat.cc.

{
 
// Construct the processing options for this path
//
   attr = PathOpts(path);
   return XrdOssOK;
}

References PathOpts(), and XrdOssOK.

Here is the call graph for this function:

tranmode()

int XrdOssSys::tranmode ( char *  mode )

protected

Definition at line 314 of file XrdOssMSS.cc.

                                  {
    int mbits = 0;
    if (mode[0] == 'r') mbits |= S_IROTH;
    if (mode[1] == 'w') mbits |= S_IWOTH;
    if (mode[2] == 'x') mbits |= S_IXOTH;
    return mbits;
}

Referenced by MSS_Stat().

Here is the caller graph for this function:

Truncate()

int XrdOssSys::Truncate ( const char *  path, unsigned long long  fsize, XrdOucEnv *  envP = 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.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 502 of file XrdOssApi.cc.

{
    struct stat statbuff;
    char actual_path[MAXPATHLEN+1], *local_path;
    long long oldsz;
    int retc;
 
// Make sure we can modify this path
//
   Check_RW(Truncate, path, "truncate");
 
// Generate local path
//
   if (lcl_N2N)
      if ((retc = lcl_N2N->lfn2pfn(path, actual_path, sizeof(actual_path)))) 
         return retc;
         else local_path = actual_path;
      else local_path = (char *)path;
 
// Get file info to do the correct adjustment
//
   if (lstat(local_path, &statbuff)) return -errno;
       else if ((statbuff.st_mode & S_IFMT) == S_IFDIR) return -EISDIR;
       else if ((statbuff.st_mode & S_IFMT) == S_IFLNK)
               {struct stat buff;
                if (stat(local_path, &buff)) return -errno;
                oldsz = buff.st_size;
               } else oldsz = statbuff.st_size;
 
// Change the file only in the local filesystem and make space adjustemt
//
   if (truncate(local_path, size)) return -errno;
   XrdOssCache::Adjust(local_path,static_cast<long long>(size)-oldsz,&statbuff);
   return XrdOssOK;
}

References XrdOssCache::Adjust(), Check_RW, lcl_N2N, XrdOucName2Name::lfn2pfn(), lstat, stat, truncate, and XrdOssOK.

Here is the call graph for this function:

Unlink()

int XrdOssSys::Unlink ( const char *  path, int  Opts = 0, XrdOucEnv *  envP = 0  )

virtual

Remove a file.

Parameters

path	- Pointer to the path of the file to be removed.
Opts	- Options: XRDOSS_isMIG - this is a migratable path. XRDOSS_isPFN - do not apply name2name to path. XRDOSS_Online - remove only the online copy.
envP	- Pointer to environmental information.

Returns

0 upon success or -errno or -osserr (see XrdOssError.hh).

Implements XrdOss.

Definition at line 106 of file XrdOssUnlink.cc.

{
    EPNAME("Unlink")
    unsigned long long dummy, remotefs;
    int i, retc2, doAdjust = 0, retc = XrdOssOK;
    struct stat statbuff;
    //char *fnp;
    char  local_path[MAXPATHLEN+1+8];
    char remote_path[MAXPATHLEN+1];
 
// Build the right local and remote paths.
//
   if (Opts & XRDOSS_isPFN)
      {strcpy(local_path, path),
       *remote_path = '\0';
       remotefs = 0;
      } else {
       remotefs = Check_RO(Unlink, dummy, path, "remove");
       if ( (retc = GenLocalPath( path,  local_path))
       ||   (retc = GenRemotePath(path, remote_path)) ) return retc;
      }
 
// Check if this path is really a directory of a symbolic link elsewhere
//
    if (lstat(local_path, &statbuff)) retc = (errno == ENOENT ? 0 : -errno);
       else if ((statbuff.st_mode & S_IFMT) == S_IFLNK)
               retc = BreakLink(local_path, statbuff);
               else if ((statbuff.st_mode & S_IFMT) == S_IFDIR)
                       {i = strlen(local_path);
                        if (local_path[i-1] != '/') strcpy(local_path+i, "/");
                        if ((retc = rmdir(local_path))) retc = -errno;
                        DEBUG("dir rc=" <<retc <<" path=" <<local_path);
                        return retc;
                       } else doAdjust = 1;
 
// Delete the local copy and adjust usage
//
   if (!retc)
      {if (unlink(local_path)) retc = -errno;
          else {i = strlen(local_path); //fnp = &local_path[i];
                if (doAdjust && statbuff.st_size)
                   XrdOssCache::Adjust(statbuff.st_dev, -statbuff.st_size);
               }
       DEBUG("lcl rc=" <<retc <<" path=" <<local_path);
      }
 
// If local copy effectively deleted. delete the remote copy if need be
//
   if (remotefs && !(Opts & XRDOSS_Online) 
   && (!retc || retc == -ENOENT) && RSSCmd)
      {if ((retc2 = MSS_Unlink(remote_path)) != -ENOENT) retc = retc2;
       DEBUG("rmt rc=" <<retc2 <<" path=" <<remote_path);
      }
 
// All done
//
   return retc;
}

References XrdOssCache::Adjust(), BreakLink(), Check_RO, DEBUG, EPNAME, GenLocalPath(), GenRemotePath(), lstat, MSS_Unlink(), XrdMpx::Opts, rmdir(), RSSCmd, stat, unlink, XRDOSS_isPFN, XRDOSS_Online, and XrdOssOK.

Referenced by Remdir().

Here is the call graph for this function:

Here is the caller graph for this function:

xalloc()

int XrdOssSys::xalloc ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1197 of file XrdOssConfig.cc.

{
    char *val;
    long long mina = 0;
    int       fuzz = 0;
    int       hdrm = 0;
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "alloc minfree not specified"); return 1;}
    if (strcmp(val, "*") &&
        XrdOuca2x::a2sz(Eroute, "alloc minfree", val, &mina, 0)) return 1;
 
    if ((val = Config.GetWord()))
       {if (strcmp(val, "*") &&
            XrdOuca2x::a2i(Eroute,"alloc headroom",val,&hdrm,0,100)) return 1;
 
        if ((val = Config.GetWord()))
           {if (strcmp(val, "*") &&
            XrdOuca2x::a2i(Eroute, "alloc fuzz", val, &fuzz, 0, 100)) return 1;
           }
       }
 
    minalloc = mina;
    ovhalloc = hdrm;
    fuzalloc = fuzz;
    return 0;
}

References XrdOuca2x::a2i(), XrdOuca2x::a2sz(), XrdCms::Config, XrdSysError::Emsg(), fuzalloc, minalloc, and ovhalloc.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xcache()

int XrdOssSys::xcache ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1240 of file XrdOssConfig.cc.

{
   int rc, isXA = 0;
 
// Skip out to process this entry and upon success indicate that it is
// deprecated and "space" should be used instead if an XA-style space defined.
//
   if (!(rc = xspace(Config, Eroute, &isXA)))
      {if (isXA) Eroute.Say("Config warning: 'oss.cache' is deprecated; "
                            "use 'oss.space' instead!");
          else  {Eroute.Say("Config failure: non-xa spaces are no longer "
                            "supported!");
                 rc = 1;
                }
      }
    return rc;
}

References XrdCms::Config, XrdSysError::Say(), and xspace().

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xcachescan()

int XrdOssSys::xcachescan ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1270 of file XrdOssConfig.cc.

{   int cscan = 0;
    char *val;
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "cachescan not specified"); return 1;}
    if (XrdOuca2x::a2tm(Eroute, "cachescan", val, &cscan, 30)) return 1;
    cscanint = cscan;
    return 0;
}

References XrdOuca2x::a2tm(), XrdCms::Config, cscanint, and XrdSysError::Emsg().

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xdefault()

int XrdOssSys::xdefault ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1295 of file XrdOssConfig.cc.

{
   DirFlags = XrdOucExport::ParseDefs(Config, Eroute, DirFlags);
   return 0;
}

References XrdCms::Config, DirFlags, and XrdOucExport::ParseDefs().

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xfdlimit()

int XrdOssSys::xfdlimit ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1318 of file XrdOssConfig.cc.

{
    char *val;
    int fence = 0, FDHalf = FDLimit>>1;
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "fdlimit fence not specified"); return 1;}
 
    if (!strcmp(val, "*")) FDFence = FDHalf;
       else {if (XrdOuca2x::a2i(Eroute,"fdlimit fence",val,&fence,0)) return 1;
             FDFence = (fence < FDHalf ? fence : FDHalf);
            }
 
    while(Config.GetWord()) {}
 
//  Eroute.Say("Config warning: ", "fdlimit directive no longer supported.");
 
    return 0;
}

References XrdOuca2x::a2i(), XrdCms::Config, XrdSysError::Emsg(), FDFence, and FDLimit.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xmaxsz()

int XrdOssSys::xmaxsz ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1351 of file XrdOssConfig.cc.

{   long long msz;
    char *val;
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "maxsize value not specified"); return 1;}
    if (XrdOuca2x::a2sz(Eroute, "maxsize", val, &msz, 1024*1024)) return 1;
    MaxSize = msz;
    return 0;
}

References XrdOuca2x::a2sz(), XrdCms::Config, XrdSysError::Emsg(), and MaxSize.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xmemf()

int XrdOssSys::xmemf ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1383 of file XrdOssConfig.cc.

{
    char *val;
    int i, j, V_check=-1, V_preld = -1, V_on=-1;
    long long V_max = 0;
 
    static struct mmapopts {const char *opname; int otyp;
                            const char *opmsg;} mmopts[] =
       {
        {"off",        0, ""},
        {"preload",    1, "memfile preload"},
        {"check",      2, "memfile check"},
        {"max",        3, "memfile max"}};
    int numopts = sizeof(mmopts)/sizeof(struct mmapopts);
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "memfile option not specified"); return 1;}
 
    while (val)
         {for (i = 0; i < numopts; i++)
              if (!strcmp(val, mmopts[i].opname)) break;
          if (i >= numopts)
             Eroute.Say("Config warning: ignoring invalid memfile option '",val,"'.");
             else {if (mmopts[i].otyp >  1 && !(val = Config.GetWord()))
                      {Eroute.Emsg("Config","memfile",mmopts[i].opname,
                                   "value not specified");
                       return 1;
                      }
                   switch(mmopts[i].otyp)
                         {case 1: V_preld = 1;
                                  break;
                          case 2: if (!strcmp("xattr",val)
                                  ||  !strcmp("lock", val)
                                  ||  !strcmp("map",  val)
                                  ||  !strcmp("keep", val)) V_check=1;
                                 else {Eroute.Emsg("Config",
                                       "mmap check argument not xattr");
                                       return 1;
                                      }
                                  break;
                          case 3: j = strlen(val);
                                  if (val[j-1] == '%')
                                     {val[j-1] = '\0';
                                      if (XrdOuca2x::a2i(Eroute,mmopts[i].opmsg,
                                                     val, &j, 1, 1000)) return 1;
                                      V_max = -j;
                                     } else if (XrdOuca2x::a2sz(Eroute,
                                                mmopts[i].opmsg, val, &V_max,
                                                10*1024*1024)) return 1;
                                  break;
                          default: V_on = 0; break;
                         }
                  val = Config.GetWord();
                 }
         }
 
// Set the values
//
   XrdOssMio::Set(V_on, V_preld, V_check);
   XrdOssMio::Set(V_max);
   return 0;
}

References XrdOuca2x::a2i(), XrdOuca2x::a2sz(), XrdCms::Config, XrdSysError::Emsg(), XrdSysError::Say(), and XrdOssMio::Set().

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xnml()

int XrdOssSys::xnml ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1460 of file XrdOssConfig.cc.

{
    char *val, parms[1040];
 
// Get the path
//
   if (!(val = Config.GetWord()) || !val[0])
      {Eroute.Emsg("Config", "namelib not specified"); return 1;}
 
// Record the path
//
   if (N2N_Lib) free(N2N_Lib);
   N2N_Lib = strdup(val);
 
// Record any parms
//
   if (!Config.GetRest(parms, sizeof(parms)))
      {Eroute.Emsg("Config", "namelib parameters too long"); return 1;}
   if (N2N_Parms) free(N2N_Parms);
   N2N_Parms = (*parms ? strdup(parms) : 0);
   return 0;
}

References XrdCms::Config, XrdSysError::Emsg(), N2N_Lib, and N2N_Parms.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xpath()

int XrdOssSys::xpath ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1497 of file XrdOssConfig.cc.

{
   XrdOucPList *pP;
 
// Parse the arguments
//
   pP = XrdOucExport::ParsePath(Config, Eroute, RPList, DirFlags);
   if (!pP) return 1;
 
// If this is an absolute path, we are done
//
   if (*(pP->Path()) == '/') return 0;
 
// If this is an objectid path then make sure to set the default for these
//
   if (*(pP->Path()) == '*')
      {RPList.Defstar(pP->Flag());
       return 0;
      }
 
// We do not (yet) support exporting specific object ID's
//
   Eroute.Emsg("Config", "Unsupported export -", pP->Path());
   return 1;
}

References XrdCms::Config, XrdOucPListAnchor::Defstar(), DirFlags, XrdSysError::Emsg(), XrdOucPList::Flag(), XrdOucExport::ParsePath(), XrdOucPList::Path(), and RPList.

Referenced by ConfigProc(), and ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xprerd()

int XrdOssSys::xprerd ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1547 of file XrdOssConfig.cc.

{
    static const long long m16 = 16777216LL;
    char *val;
    long long lim = 1048576;
    int depth, qeq = 0, qsz = 128;
 
      if (!(val = Config.GetWord()))
         {Eroute.Emsg("Config", "preread depth not specified"); return 1;}
 
      if (!strcmp(val, "on")) depth = 3;
         else if (XrdOuca2x::a2i(Eroute,"preread depth",val,&depth,0, 1024))
                 return 1;
 
      while((val = Config.GetWord()))
           {     if (!strcmp(val, "limit"))
                    {if (!(val = Config.GetWord()))
                        {Eroute.Emsg("Config","preread limit not specified");
                         return 1;
                        }
                     if (XrdOuca2x::a2sz(Eroute,"preread limit",val,&lim,0,m16))
                        return 1;
                    }
            else if (!strcmp(val, "qsize"))
                    {if (!(val = Config.GetWord()))
                        {Eroute.Emsg("Config","preread qsize not specified");
                         return 1;
                        }
                     if (XrdOuca2x::a2i(Eroute,"preread qsize",val,&qsz,0,1024))
                        return 1;
                     if (qsz < depth)
                        {Eroute.Emsg("Config","preread qsize must be >= depth");
                         return 1;
                        }
                    }
            else {Eroute.Emsg("Config","invalid preread option -",val); return 1;}
         }
 
      if (lim < prPSize || !qsz) depth = 0;
      if (!qeq && depth)
         {qsz = qsz/(depth/2+1);
          if (qsz < depth) qsz = depth;
         }
 
      prDepth = depth;
      prQSize = qsz;
      prBytes = lim;
      return 0;
}

References XrdOuca2x::a2i(), XrdOuca2x::a2sz(), XrdCms::Config, XrdSysError::Emsg(), prBytes, prDepth, prPSize, and prQSize.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xspace() [1/2]

int XrdOssSys::xspace ( XrdOucStream &  Config, XrdSysError &  Eroute, const char *  grp, bool  isAsgn  )

protected

Definition at line 1742 of file XrdOssConfig.cc.

{
   XrdOucPList *pl;
   char *path;
 
// Get the path
//
   path = Config.GetWord();
   if (!path || !path[0])
      {Eroute.Emsg("Config", "space path not specified"); return 1;}
 
// Create a new path list object and add it to list of paths
//
do{if ((pl = SPList.Match(path))) pl->Set(path, grp);
      else {pl = new XrdOucPList(path, grp);
            SPList.Insert(pl);
           }
   pl->Set((isAsgn ? spAssign : 0));
  } while((path = Config.GetWord()));
 
// All done
//
   return 0;
}

References XrdCms::Config, XrdSysError::Emsg(), XrdOucPListAnchor::Insert(), XrdOucPListAnchor::Match(), XrdOucPList::Set(), spAssign, and SPList.

Here is the call graph for this function:

xspace() [2/2]

int XrdOssSys::xspace ( XrdOucStream &  Config, XrdSysError &  Eroute, int *  isCD = 0  )

protected

Definition at line 1615 of file XrdOssConfig.cc.

{
   XrdOucString grp, fn, mn;
   OssSpaceConfig sInfo(grp, fn, mn);
   char *val;
   int  k;
   bool isAsgn, isStar;
 
// Get the space name
//
   if (!(val = Config.GetWord()))
      {Eroute.Emsg("Config", "space name not specified"); return 1;}
   if ((int)strlen(val) > XrdOssSpace::maxSNlen)
      {Eroute.Emsg("Config","excessively long space name - ",val); return 1;}
   grp = val;
 
// Get the path to the space
//
   if (!(val = Config.GetWord()) || !(*val))
      {Eroute.Emsg("Config", "space path not specified"); return 1;}
 
// Check if assignment
//
   if (((isAsgn = !strcmp("assign",val)) || ! strcmp("default",val)) && !isCD)
      return xspace(Config, Eroute, grp.c_str(), isAsgn);
 
// Preprocess this path and validate it
//
   k = strlen(val)-1;
   if ((isStar = val[k] == '*')) val[k--] = 0;
      else while(k > 0 && val[k] == '/') val[k--] = 0;
 
   if (k >= MAXPATHLEN || val[0] != '/' || (k < 2 && !isStar))
      {Eroute.Emsg("Config", "invalid space path - ", val); return 1;}
   fn = val;
 
// Sanitize the path as we are sensitive to proper placement of slashes
//
   do {k = fn.replace("/./", "/");} while(k);
   do {k = fn.replace("//",  "/");} while(k);
 
// Additional options (for now) are only available to the old-style cache
// directive. So, ignore any unless we entered via the directive.
//
   if (isCD)
      {if ((val = Config.GetWord()))
          {if (strcmp("xa", val))
              {Eroute.Emsg("Config","invalid cache option - ",val); return 1;}
              else *isCD = 1;
          } else  {*isCD = 0; sInfo.isXA = false;}
      } else {
       if ((val = Config.GetWord()) && !strcmp("chkmount", val))
          {if (!(val = Config.GetWord()))
              {Eroute.Emsg("Config","chkmount ID not specified"); return 1;}
           if ((int)strlen(val) > XrdOssSpace::maxSNlen)
              {Eroute.Emsg("Config","excessively long mount name - ",val);
               return 1;
              }
           mn = val;
           sInfo.chkMnt = true;
           if ((val = Config.GetWord()))
              {if (!strcmp("nofail", val)) sInfo.noFail = true;
                  else {Eroute.Emsg("Config","invalid space option - ",val);
                        return 1;
                       }
              }
          }
      }
 
// Check if this directory in the parent is only to be used for the space
//
   if (!isStar)
      {if (!fn.endswith('/')) fn += '/';
       return !xspaceBuild(sInfo, Eroute);
      }
 
// We now need to build a space for each directory in the parent
//
   struct dirent *dp;
   struct stat    Stat;
   XrdOucString   pfx, basepath(fn);
   DIR  *dirP;
   int   dFD, rc, snum = 0;
   bool  chkPfx, failed = false;
 
   if (basepath.endswith('/')) chkPfx = false;
      else {int pos = basepath.rfind('/');
            pfx = &basepath[pos+1];
            basepath.keep(0, pos+1);
            chkPfx = true;
           }
 
   if ((dFD=open(basepath.c_str(),O_DIRECTORY)) < 0 || !(dirP=fdopendir(dFD)))
      {Eroute.Emsg("Config",errno,"open space directory",fn.c_str()); return 1;}
 
   errno = 0;
   while((dp = readdir(dirP)))
        {if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")
         || (chkPfx && strncmp(dp->d_name,pfx.c_str(),pfx.length()))) continue;
 
         if (fstatat(dFD, dp->d_name, &Stat, AT_SYMLINK_NOFOLLOW))
            {basepath += dp->d_name;
             break;
            }
 
         if ((Stat.st_mode & S_IFMT) == S_IFDIR)
            {fn = basepath; fn += dp->d_name; fn += '/';
             if (!xspaceBuild(sInfo, Eroute)) failed = true;
             snum++;
            }
         errno = 0;
        }
 
// Make sure we built all space successfully and have at least one space
//
   if ((rc = errno))
      Eroute.Emsg("Config", errno, "process space directory", fn.c_str());
      else if (!snum)
              Eroute.Say("Config warning: no space directories found in ",
                         fn.c_str());
 
   closedir(dirP);
   return rc != 0 || failed;
}

References XrdOucString::c_str(), OssSpaceConfig::chkMnt, closedir(), XrdCms::Config, XrdSysError::Emsg(), XrdOucString::endswith(), fstatat, OssSpaceConfig::isXA, XrdOssSpace::maxSNlen, OssSpaceConfig::noFail, open, readdir, XrdOucString::replace(), XrdSysError::Say(), stat, Stat(), and xspaceBuild().

Referenced by ConfigXeq(), and xcache().

Here is the call graph for this function:

Here is the caller graph for this function:

xspaceBuild()

int XrdOssSys::xspaceBuild ( OssSpaceConfig &  sInfo, XrdSysError &  Eroute  )

protected

Definition at line 1770 of file XrdOssConfig.cc.

{
    XrdOssCache_FS::FSOpts fopts = (sInfo.isXA ? XrdOssCache_FS::isXA
                                               : XrdOssCache_FS::None);
    int rc = 0;
 
// Check if we need to verify the mount. Note: sPath must end with a '/'!
//
   if (sInfo.chkMnt)
      {XrdOucString mFile(sInfo.mName), mPath(sInfo.sPath);
       struct stat Stat;
       mPath.erasefromend(1);
       mFile += '.';
       mFile += rindex(mPath.c_str(), '/')+1;
       mPath += '/'; mPath += mFile;
       if (stat(mPath.c_str(), &Stat))
          {char buff[2048];
           snprintf(buff, sizeof(buff), "%s@%s; ",
                          mFile.c_str(), sInfo.sPath.c_str());
           Eroute.Say((sInfo.noFail ? "Config warning:" : "Config failure:"),
                      " Unable to verify mount point ", buff, XrdSysE2T(errno));
           return (sInfo.noFail ? 1 : 0);
          }
      }
 
// Add the space to the configuration
 
    XrdOssCache_FS *fsp = new XrdOssCache_FS(rc, sInfo.sName.c_str(),
                                                 sInfo.sPath.c_str(), fopts);
    if (rc)
       {char buff[256];
        snprintf(buff, sizeof(buff), "create %s space at", sInfo.sName.c_str());
        Eroute.Emsg("Config", rc, buff, sInfo.sPath.c_str());
        if (fsp) delete fsp;
        return 0;
       }
    OptFlags |= XrdOss_CacheFS;
    return 1;
}

References XrdOucString::c_str(), OssSpaceConfig::chkMnt, XrdSysError::Emsg(), XrdOucString::erasefromend(), XrdOssCache_FS::isXA, OssSpaceConfig::isXA, OssSpaceConfig::mName, OssSpaceConfig::noFail, XrdOssCache_FS::None, OptFlags, XrdSysError::Say(), OssSpaceConfig::sName, OssSpaceConfig::sPath, stat, Stat(), XrdOss_CacheFS, and XrdSysE2T().

Referenced by xspace().

Here is the call graph for this function:

Here is the caller graph for this function:

xstg()

int XrdOssSys::xstg ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1828 of file XrdOssConfig.cc.

{
    char *val, buff[2048], *bp = buff;
    int vlen, blen = sizeof(buff)-1, isAsync = 0, isCreate = 0;
 
// Get the aync or async option
//
   if ((val = Config.GetWord()))
       if ((isAsync = !strcmp(val, "async")) || !strcmp(val, "sync"))
          val = Config.GetWord();
 
// Get the create option
//
   if (val)
       if ((isCreate = !strcmp(val, "creates"))) val = Config.GetWord();
 
// Get the command
//
   if (!val) {Eroute.Emsg("Config", "stagecmd not specified"); return 1;}
 
// Copy the command and all of it's arguments
//
   do {if ((vlen = strlen(val)) >= blen)
          {Eroute.Emsg("Config", "stagecmd arguments too long"); break;}
       *bp = ' '; bp++; strcpy(bp, val); bp += vlen; blen -= vlen;
      } while((val = Config.GetWord()));
 
    if (val) return 1;
    *bp = '\0'; val = buff+1;
 
// Record the command and operating mode
//
   StageAsync = (isAsync ? 1 : 0);
   StageCreate= isCreate;
   if (StageCmd) free(StageCmd);
   StageCmd = strdup(val);
   return 0;
}

References XrdCms::Config, XrdSysError::Emsg(), StageAsync, StageCmd, and StageCreate.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xstl()

int XrdOssSys::xstl ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1886 of file XrdOssConfig.cc.

{
    char *val, parms[1040];
 
// Get the path or preopen option
//
   if (!(val = Config.GetWord()) || !val[0])
      {Eroute.Emsg("Config", "statlib not specified"); return 1;}
 
// Check for options we support the old and new versions here
//
   STT_V2 = 0; STT_PreOp = 0; STT_DoN2N = 1; STT_DoARE = 0;
do{     if (!strcmp(val, "-2")) STT_V2    = 1;
   else if (!strcmp(val, "arevents") || !strcmp(val, "-arevents")) STT_DoARE=1;
   else if (!strcmp(val, "non2n")    || !strcmp(val, "-non2n"))    STT_DoN2N=0;
   else if (!strcmp(val, "preopen")  || !strcmp(val, "-preopen"))  STT_PreOp=1;
   else break;
  } while((val = Config.GetWord()) && val[0]);
 
// Make sure we have a statlib
//
   if (!val || !(*val))
      {Eroute.Emsg("Config", "statlib not specified"); return 1;}
 
// Record the path
//
   if (STT_Lib) free(STT_Lib);
   STT_Lib = strdup(val);
 
// Record any parms
//
   if (!Config.GetRest(parms, sizeof(parms)))
      {Eroute.Emsg("Config", "statlib parameters too long"); return 1;}
   if (STT_Parms) free(STT_Parms);
   STT_Parms = (*parms ? strdup(parms) : 0);
   return 0;
}

References XrdCms::Config, XrdSysError::Emsg(), STT_DoARE, STT_DoN2N, STT_Lib, STT_Parms, STT_PreOp, and STT_V2.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xtrace()

int XrdOssSys::xtrace ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1938 of file XrdOssConfig.cc.

{
    char *val;
    static struct traceopts {const char *opname; int opval;} tropts[] =
       {
        {"all",      TRACE_ALL},
        {"debug",    TRACE_Debug},
        {"open",     TRACE_Open},
        {"opendir",  TRACE_Opendir}
       };
    int i, neg, trval = 0, numopts = sizeof(tropts)/sizeof(struct traceopts);
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "trace option not specified"); return 1;}
    while (val)
         {if (!strcmp(val, "off")) trval = 0;
             else {if ((neg = (val[0] == '-' && val[1]))) val++;
                   for (i = 0; i < numopts; i++)
                       {if (!strcmp(val, tropts[i].opname))
                           {if (neg) trval &= ~tropts[i].opval;
                               else  trval |=  tropts[i].opval;
                            break;
                           }
                       }
                   if (i >= numopts)
                      Eroute.Say("Config warning: ignoring invalid trace option '",val,"'.");
                  }
          val = Config.GetWord();
         }
    OssTrace.What = trval;
    return 0;
}

References XrdCms::Config, XrdSysError::Emsg(), OssTrace, XrdSysError::Say(), TRACE_ALL, TRACE_Debug, TRACE_Open, TRACE_Opendir, and XrdSysTrace::What.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xusage()

int XrdOssSys::xusage ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 1990 of file XrdOssConfig.cc.

{
    char *val;
    int usval;
 
    if (!(val = Config.GetWord()))
       {Eroute.Emsg("Config", "usage option not specified"); return 1;}
 
    while(val)
         {     if (!strcmp("nolog", val))
                  {if (UDir)  {free(UDir);  UDir = 0;}}
          else if (!strcmp("log"  , val))
                  {if (UDir)  {free(UDir);  UDir = 0;}
                   if (!(val = Config.GetWord()))
                      {Eroute.Emsg("Config", "usage log path not specified");
                       return 1;
                      }
                   if (*val != '/')
                      {Eroute.Emsg("Config", "usage log path not absolute");
                       return 1;
                      }
                   UDir = strdup(val);
                   if (!(val = Config.GetWord()) || strcmp("sync", val))
                      continue;
                   if (!(val = Config.GetWord()))
                      {Eroute.Emsg("Config", "log sync value not specified");
                       return 1;
                      }
                    if (XrdOuca2x::a2i(Eroute,"sync value",val,&usval,1,32767))
                       return 1;
                    USync = usval;
                  }
          else if (!strcmp("noquotafile",val))
                  {if (QFile) {free(QFile); QFile= 0;}}
          else if (!strcmp("quotafile",val))
                  {if (QFile) {free(QFile); QFile= 0;}
                   if (!(val = Config.GetWord()))
                      {Eroute.Emsg("Config", "quota file not specified");
                       return 1;
                      }
                   QFile = strdup(val);
                  }
          else {Eroute.Emsg("Config", "invalid usage option -",val); return 1;}
 
          val = Config.GetWord();
         }
    return 0;
}

References XrdOuca2x::a2i(), XrdCms::Config, XrdSysError::Emsg(), QFile, UDir, and USync.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

xxfr()

int XrdOssSys::xxfr ( XrdOucStream &  Config, XrdSysError &  Eroute  )

protected

Definition at line 2064 of file XrdOssConfig.cc.

{
    static const int maxfdln = 256;
    const char *wantParm = 0;
    char *val;
    int       thrds = 1;
    long long speed = 9*1024*1024;
    int       ovhd  = 30;
    int       htime = 3*60*60;
    int       ktime;
    int       upon = 0;
 
    while((val = Config.GetWord()))        // deny |fdir | keep | up
         {     if (!strcmp("deny", val))
                  {wantParm = "xfr deny";
                   if ((val = Config.GetWord()))     // keep time
                      {if (XrdOuca2x::a2tm(Eroute,wantParm,val,&htime,0))
                          return 1;
                       wantParm=0;
                      }
                  }
          else if (!strcmp("fdir", val))
                  {wantParm = "xfr fdir";
                   if ((val = Config.GetWord()))     // fdir path
                      {if (xfrFdir) free(xfrFdir);
                       xfrFdln = strlen(val);
                       if (xfrFdln > maxfdln)
                          {Eroute.Emsg("Config","xfr fdir path too long");
                           xfrFdir = 0; xfrFdln = 0; return 1;
                          }
                       xfrFdir = strdup(val); 
                       wantParm = 0;
                      }
                  }
          else if (!strcmp("keep", val))
                  {wantParm = "xfr keep";
                   if ((val = Config.GetWord()))     // keep time
                      {if (XrdOuca2x::a2tm(Eroute,wantParm,val,&ktime,0))
                          return 1;
                       xfrkeep=ktime; wantParm=0;
                      }
                  }
          else if (!strcmp("up", val)) {upon = 1; wantParm = 0;}
          else break;
         };
 
    xfrhold    = htime;
    if (upon) OptFlags |= XrdOss_USRPRTY;
 
    if (!val) {if (!wantParm) return 0;
                  else {Eroute.Emsg("Config", wantParm, "value not specified");
                        return 1;
                       }
              }
 
      if (strcmp(val, "*") && XrdOuca2x::a2i(Eroute,"xfr threads",val,&thrds,1))
         return 1;
 
      if ((val = Config.GetWord()))         // <speed>
         {if (strcmp(val, "*") && 
              XrdOuca2x::a2sz(Eroute,"xfr speed",val,&speed,1024)) return 1;
 
          if ((val = Config.GetWord()))     // <ovhd>
             {if (strcmp(val, "*") && 
                  XrdOuca2x::a2tm(Eroute,"xfr overhead",val,&ovhd,0)) return 1;
 
              if ((val = Config.GetWord())) // <hold>
                 if (strcmp(val, "*") && 
                    XrdOuca2x::a2tm(Eroute,"xfr hold",val,&htime,0)) return 1;
             }
         }
 
      xfrhold    = htime;
      xfrthreads = thrds;
      xfrspeed   = speed;
      xfrovhd    = ovhd;
      return 0;
}

References XrdOuca2x::a2i(), XrdOuca2x::a2sz(), XrdOuca2x::a2tm(), XrdCms::Config, XrdSysError::Emsg(), OptFlags, xfrFdir, xfrFdln, xfrhold, xfrkeep, xfrovhd, xfrspeed, xfrthreads, and XrdOss_USRPRTY.

Referenced by ConfigXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

union { ... }

AioAllOk

int XrdOssSys::AioAllOk = 0

static

Definition at line 208 of file XrdOssApi.hh.

Referenced by AioInit(), XrdOssFile::Fsync(), XrdOssFile::Read(), XrdOssFile::Write(), and XrdOssAioWait().

badreqs

int XrdOssSys::badreqs

protected

Definition at line 311 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and Stage_In().

chkMmap

char XrdOssSys::chkMmap = 0

static

Definition at line 211 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigMio(), and XrdOssFile::Open().

ConfigFN

char* XrdOssSys::ConfigFN

Definition at line 224 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigN2N(), ConfigProc(), ConfigStatLib(), and Configure().

cscanint

int XrdOssSys::cscanint

protected

Definition at line 300 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xcachescan().

DirFlags

unsigned long long XrdOssSys::DirFlags

Definition at line 251 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigCache(), ConfigMio(), ConfigStage(), Configure(), XrdOssFile::Read(), xdefault(), and xpath().

DPList

OssDPath* XrdOssSys::DPList

Definition at line 265 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStats(), and getStats().

FDFence

int XrdOssSys::FDFence

Definition at line 249 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xfdlimit().

FDLimit

int XrdOssSys::FDLimit

Definition at line 250 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xfdlimit().

fuzalloc

int XrdOssSys::fuzalloc

protected

Definition at line 299 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xalloc().

isMSSC

int XrdOssSys::isMSSC

Definition at line 246 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigXeq(), and MSS_Stat().

lcl_N2N

XrdOucName2Name* XrdOssSys::lcl_N2N

Definition at line 261 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Chmod(), ConfigN2N(), GenLocalPath(), getCname(), Lfn2Pfn(), Mkdir(), XrdOssFile::Open(), XrdOssDir::Opendir(), Stage_QT(), Stat(), StatFS(), StatPF(), and Truncate().

lenDP

int XrdOssSys::lenDP

Definition at line 266 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStats(), and getStats().

LocalRoot

char* XrdOssSys::LocalRoot

Definition at line 225 of file XrdOssApi.hh.

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

MaxArgs

const int XrdOssSys::MaxArgs = 15

static

Definition at line 222 of file XrdOssApi.hh.

MaxSize

long long XrdOssSys::MaxSize

Definition at line 248 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), XrdOssFile::Write(), and xmaxsz().

MaxTwiddle

int XrdOssSys::MaxTwiddle

Definition at line 227 of file XrdOssApi.hh.

Referenced by XrdOssSys().

minalloc

long long XrdOssSys::minalloc

protected

Definition at line 297 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xalloc().

myVersion

XrdVersionInfo* XrdOssSys::myVersion

Definition at line 289 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigN2N(), ConfigStatLib(), and XrdOssGetSS().

N2N_Lib

char* XrdOssSys::N2N_Lib

Definition at line 259 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigN2N(), Configure(), and xnml().

N2N_Parms

char* XrdOssSys::N2N_Parms

Definition at line 260 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigN2N(), and xnml().

numCG

short XrdOssSys::numCG

Definition at line 268 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStats(), and getStats().

numDP

short XrdOssSys::numDP

Definition at line 267 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStats(), and getStats().

OptFlags

int XrdOssSys::OptFlags

Definition at line 254 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigSpace(), Configure(), Stage_RT(), xspaceBuild(), and xxfr().

ovhalloc

int XrdOssSys::ovhalloc

protected

Definition at line 298 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Configure(), and xalloc().

pfcMode

bool XrdOssSys::pfcMode

protected

Definition at line 321 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigCache(), and Configure().

pndbytes

long long XrdOssSys::pndbytes

protected

Definition at line 307 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Stage_In(), and Stage_RT().

prActive

int XrdOssSys::prActive

Definition at line 285 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and XrdOssFile::ReadV().

prBytes

int XrdOssSys::prBytes

Definition at line 284 of file XrdOssApi.hh.

Referenced by XrdOssSys(), XrdOssFile::ReadV(), and xprerd().

prDepth

short XrdOssSys::prDepth

Definition at line 286 of file XrdOssApi.hh.

Referenced by XrdOssSys(), XrdOssFile::ReadV(), and xprerd().

prPBits

long long XrdOssSys::prPBits

Definition at line 281 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and XrdOssFile::ReadV().

prPMask

long long XrdOssSys::prPMask

Definition at line 282 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and XrdOssFile::ReadV().

prPSize

int XrdOssSys::prPSize

Definition at line 283 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and xprerd().

prQSize

short XrdOssSys::prQSize

Definition at line 287 of file XrdOssApi.hh.

Referenced by XrdOssSys(), XrdOssFile::ReadV(), and xprerd().

QFile

char* XrdOssSys::QFile

protected

Definition at line 317 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Configure(), and xusage().

RemoteRoot

char* XrdOssSys::RemoteRoot

Definition at line 226 of file XrdOssApi.hh.

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

rmt_N2N

XrdOucName2Name* XrdOssSys::rmt_N2N

Definition at line 262 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigN2N(), GenRemotePath(), XrdOssDir::Opendir(), Stage_RT(), and Stat().

RPList

XrdOucPListAnchor XrdOssSys::RPList

Definition at line 264 of file XrdOssApi.hh.

Referenced by Config_Display(), ConfigCache(), ConfigMio(), ConfigSpace(), ConfigStage(), ConfigStats(), Configure(), Create(), IsRemote(), PathOpts(), and xpath().

RSSCmd

char* XrdOssSys::RSSCmd

Definition at line 245 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigSpath(), ConfigStage(), ConfigXeq(), MSS_Xeq(), Rename(), Stat(), and Unlink().

RSSProg

XrdOucProg* XrdOssSys::RSSProg

protected

Definition at line 314 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and MSS_Xeq().

RSSTout

int XrdOssSys::RSSTout

Definition at line 247 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and MSS_Xeq().

Solitary

int XrdOssSys::Solitary

Definition at line 253 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), Configure(), and RenameLink().

SPList

XrdOucPListAnchor XrdOssSys::SPList

Definition at line 256 of file XrdOssApi.hh.

Referenced by Alloc_Cache(), Config_Display(), ConfigSpace(), and xspace().

StageAction

char* XrdOssSys::StageAction

Definition at line 240 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and Stage_QT().

StageActLen

int XrdOssSys::StageActLen

Definition at line 239 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and Stage_QT().

StageAln

int XrdOssSys::StageAln[MaxArgs]

Definition at line 243 of file XrdOssApi.hh.

StageAnum

int XrdOssSys::StageAnum

Definition at line 244 of file XrdOssApi.hh.

StageArg

char* XrdOssSys::StageArg[MaxArgs]

Definition at line 242 of file XrdOssApi.hh.

StageAsync

int XrdOssSys::StageAsync

Definition at line 229 of file XrdOssApi.hh.

Referenced by XrdOssSys(), CalcTime(), Config_Display(), ConfigStage(), and xstg().

StageCmd

char* XrdOssSys::StageCmd

Definition at line 232 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigStage(), ConfigStageC(), Stage_RT(), and xstg().

StageCreate

int XrdOssSys::StageCreate

Definition at line 230 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigStage(), Create(), and xstg().

StageEvents

char* XrdOssSys::StageEvents

Definition at line 237 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and Stage_QT().

StageEvSize

int XrdOssSys::StageEvSize

Definition at line 238 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and Stage_QT().

StageFormat

int XrdOssSys::StageFormat

Definition at line 231 of file XrdOssApi.hh.

Referenced by ConfigStageC(), and Stage_QT().

StageFrm

XrdFrcProxy* XrdOssSys::StageFrm

Definition at line 235 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), and Stage_QT().

StageMsg

char* XrdOssSys::StageMsg

Definition at line 233 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigStageC(), and ConfigXeq().

StageProg

XrdOucProg* XrdOssSys::StageProg

protected

Definition at line 313 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStageC(), GetFile(), and Stage_QT().

StageRealTime

int XrdOssSys::StageRealTime

Definition at line 228 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStage(), ConfigStageC(), and Stage().

StageSnd

XrdOucMsubs* XrdOssSys::StageSnd

Definition at line 234 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStageC(), and Stage_QT().

stgbytes

long long XrdOssSys::stgbytes

protected

Definition at line 308 of file XrdOssApi.hh.

Referenced by XrdOssSys(), CalcTime(), and Stage_In().

STT_DoARE

char XrdOssSys::STT_DoARE

Definition at line 279 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStatLib(), and xstl().

STT_DoN2N

char XrdOssSys::STT_DoN2N

Definition at line 277 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Stat(), and xstl().

STT_Lib

char* XrdOssSys::STT_Lib

Definition at line 270 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStatLib(), Configure(), and xstl().

STT_Parms

char* XrdOssSys::STT_Parms

Definition at line 271 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStatLib(), and xstl().

STT_PreOp

int XrdOssSys::STT_PreOp

Definition at line 276 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and xstl().

STT_V2

char XrdOssSys::STT_V2

Definition at line 278 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStatLib(), Stat(), and xstl().

the_N2N

XrdOucName2Name* XrdOssSys::the_N2N

Definition at line 263 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and ConfigN2N().

totbytes

long long XrdOssSys::totbytes

protected

Definition at line 309 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and Stage_In().

totreqs

int XrdOssSys::totreqs

protected

Definition at line 310 of file XrdOssApi.hh.

Referenced by XrdOssSys(), and Stage_In().

Trace

int XrdOssSys::Trace

Definition at line 252 of file XrdOssApi.hh.

tryMmap

char XrdOssSys::tryMmap = 0

static

Definition at line 210 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigMio(), and XrdOssFile::Open().

UDir

char* XrdOssSys::UDir

protected

Definition at line 316 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Configure(), RenameLink(), and xusage().

USync

short XrdOssSys::USync

protected

Definition at line 320 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Configure(), and xusage().

xfrFdir

char* XrdOssSys::xfrFdir

protected

Definition at line 318 of file XrdOssApi.hh.

Referenced by XrdOssSys(), HasFile(), and xxfr().

xfrFdln

int XrdOssSys::xfrFdln

protected

Definition at line 319 of file XrdOssApi.hh.

Referenced by XrdOssSys(), HasFile(), and xxfr().

xfrhold

int XrdOssSys::xfrhold

protected

Definition at line 303 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Stage_In(), Stage_QT(), and xxfr().

xfrkeep

int XrdOssSys::xfrkeep

protected

Definition at line 304 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), Stage_QT(), and xxfr().

xfrovhd

int XrdOssSys::xfrovhd

protected

Definition at line 302 of file XrdOssApi.hh.

Referenced by XrdOssSys(), CalcTime(), and xxfr().

xfrspeed

int XrdOssSys::xfrspeed

protected

Definition at line 301 of file XrdOssApi.hh.

Referenced by XrdOssSys(), CalcTime(), Stage_In(), and xxfr().

xfrtcount

int XrdOssSys::xfrtcount

protected

Definition at line 306 of file XrdOssApi.hh.

Referenced by XrdOssSys(), ConfigStageC(), and Stage_In().

xfrthreads

int XrdOssSys::xfrthreads

protected

Definition at line 305 of file XrdOssApi.hh.

Referenced by XrdOssSys(), Config_Display(), ConfigStageC(), Stage_In(), and xxfr().

---

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

• XrdOssApi.hh
• XrdOssAio.cc
• XrdOssApi.cc
• XrdOssConfig.cc
• XrdOssCreate.cc
• XrdOssMSS.cc
• XrdOssReloc.cc
• XrdOssRename.cc
• XrdOssStage.cc
• XrdOssStat.cc
• XrdOssUnlink.cc