XrdOfsHandle Class Reference

#include <XrdOfsHandle.hh>

Collaboration diagram for XrdOfsHandle:

Public Member Functions
	XrdOfsHandle ()
	~XrdOfsHandle ()
void	Activate (XrdOssDF *ssP)
int	Inactive ()
void	Lock ()
const char *	Name ()
int	PoscGet (short &Mode, int Done=0)
int	PoscSet (const char *User, int Unum, short Mode)
const char *	PoscUsr ()
int	Retire (int &retc, long long *retsz=0, char *buff=0, int blen=0)
int	Retire (XrdOfsHanCB *, int DSec)
XrdOssDF &	Select (void)
void	Suppress (int rrc=-EDOM, int wrc=-EDOM)
void	UnLock ()
int	Usage ()

Static Public Member Functions
static int	Alloc (const char *thePath, int Opts, XrdOfsHandle **Handle)
static int	Alloc (XrdOfsHandle **Handle)
static void	Hide (const char *thePath)
static int	StartXpr (int Init=0)

Public Attributes
char	isChanged
char	isCompressed
char	isPending
char	isRW

Static Public Attributes
static const int	opPC = 3
static const int	opRW = 1

Friends
class	XrdOfsHanTab
class	XrdOfsHanXpr

Detailed Description

Definition at line 125 of file XrdOfsHandle.hh.

Constructor & Destructor Documentation

XrdOfsHandle()

XrdOfsHandle::XrdOfsHandle ( )

inline

Definition at line 172 of file XrdOfsHandle.hh.

: Path(0,0) {}

Referenced by Alloc(), Alloc(), Hide(), and StartXpr().

Here is the caller graph for this function:

~XrdOfsHandle()

XrdOfsHandle::~XrdOfsHandle ( )

inline

Definition at line 174 of file XrdOfsHandle.hh.

{int retc; Retire(retc);}

References Retire().

Here is the call graph for this function:

Member Function Documentation

Activate()

void XrdOfsHandle::Activate ( XrdOssDF * ssP )

inline

Definition at line 136 of file XrdOfsHandle.hh.

{ssi = ssP;}

Alloc() [1/2]

int XrdOfsHandle::Alloc ( const char * thePath, int Opts, XrdOfsHandle ** Handle )

static

Definition at line 260 of file XrdOfsHandle.cc.

{
   XrdOfsHandle *hP;
   XrdOfsHanTab *theTable = (Opts & opRW ? &rwTable : &roTable);
   XrdOfsHanKey theKey(thePath, (int)strlen(thePath));
   int          retc;
 
// Lock the search table and try to find the key. If found, increment the
// the link count (can only be done with the global lock) then release the
// lock and try to lock the handle. It can't escape between lock calls because
// the link count is positive. If we can't lock the handle then it must be the
// that a long running operation is occuring. Return the handle to its former
// state and return a delay. Otherwise, return the handle.
//
   myMutex.Lock();
   if ((hP = theTable->Find(theKey)))
      {hP->Path.Links++; myMutex.UnLock();
       if (hP->WaitLock()) {*Handle = hP; return 0;}
       myMutex.Lock(); hP->Path.Links--; myMutex.UnLock();
       return nolokDelay;
      }
 
// Get a new handle
//
   if (!(retc = Alloc(theKey, Opts, Handle))) theTable->Add(*Handle);
   OfsStats.Add(OfsStats.Data.numHandles);
 
// All done
//
   myMutex.UnLock();
   return retc;
}

References XrdOfsHandle(), XrdOfsHanTab::Add(), Alloc(), XrdOfsHanTab::Find(), XrdOfsHanKey::Links, OfsStats, opRW, and XrdOfsHanTab.

Referenced by XrdOfs::XrdOfs(), Alloc(), Alloc(), and XrdOfsFile::open().

Here is the call graph for this function:

Here is the caller graph for this function:

Alloc() [2/2]

int XrdOfsHandle::Alloc ( XrdOfsHandle ** Handle )

static

Definition at line 297 of file XrdOfsHandle.cc.

{
    XrdOfsHanKey myKey("dummy", 5);
    int retc;
 
    myMutex.Lock();
    if (!(retc = Alloc(myKey, 0, Handle))) 
       {(*Handle)->Path.Links = 0; (*Handle)->UnLock();}
    myMutex.UnLock();
    return retc;
}

References XrdOfsHandle(), and Alloc().

Here is the call graph for this function:

Hide()

void XrdOfsHandle::Hide ( const char * thePath )

static

Definition at line 346 of file XrdOfsHandle.cc.

{
   XrdOfsHandle *hP;
   XrdOfsHanKey theKey(thePath, (int)strlen(thePath));
 
// Lock the search table and try to find the key in each table. If found,
// clear the length field to effectively hide the item.
//
   myMutex.Lock();
   if ((hP = roTable.Find(theKey))) hP->Path.Len = 0;
   if ((hP = rwTable.Find(theKey))) hP->Path.Len = 0;
   myMutex.UnLock();
}

References XrdOfsHandle(), and XrdOfsHanKey::Len.

Referenced by XrdOfs::rename().

Here is the call graph for this function:

Here is the caller graph for this function:

Inactive()

int XrdOfsHandle::Inactive ( )

inline

Definition at line 146 of file XrdOfsHandle.hh.

{return (ssi == ossDF);}

Referenced by XrdOfsFile::close().

Here is the caller graph for this function:

Lock()

void XrdOfsHandle::Lock ( )

inline

Definition at line 169 of file XrdOfsHandle.hh.

{hMutex.Lock();}

Referenced by XrdOfsFile::close(), XrdOfs::Emsg(), and XrdOfsHanXpr::Get().

Here is the caller graph for this function:

Name()

const char * XrdOfsHandle::Name ( )

inline

Definition at line 148 of file XrdOfsHandle.hh.

{return Path.Val;}

Referenced by XrdOfsFile::close(), XrdOfs::Emsg(), and XrdOfs::Unpersist().

Here is the caller graph for this function:

PoscGet()

int XrdOfsHandle::PoscGet	(	short &	Mode,
		int	Done = 0 )

Definition at line 366 of file XrdOfsHandle.cc.

{
   XrdOfsHanPsc *pP;
   int pnum;
 
   if (Posc)
      {pnum = Posc->Unum;
       Mode = Posc->Mode;
       if (Done)
          {pP = Posc; Posc = 0;
           if (pP->xprP) {myMutex.Lock(); Path.Links--; myMutex.UnLock();}
           pP->Recycle();
          }
       return pnum;
      }
 
   Mode = 0;
   return 0;
}

References Mode, XrdOfsHanPsc::Recycle(), and XrdOfsHanPsc::xprP.

Referenced by XrdOfsFile::close(), and XrdOfs::Unpersist().

Here is the call graph for this function:

Here is the caller graph for this function:

PoscSet()

int XrdOfsHandle::PoscSet	(	const char *	User,
		int	Unum,
		short	Mode )

Definition at line 392 of file XrdOfsHandle.cc.

{
   static const char *Who = "?:0.0@?", *Whc = Who+1, *Whh = Who+5;
   const char *Col, *At;
   int retval = 0;
 
// If we have no posc object then we may just be able to return
//
   if (!Posc)
      {if (Unum > 0) Posc = XrdOfsHanPsc::Alloc();
          else return 0;
      }
 
// Find the markers in the incoming user
//
   if (!(Col = index(User, ':')) || !(At = index(User, '@')))
      {User = Who; Col = Whc; At = Whh;}
 
// If we already have a user check if it matches. We allow the same user to
// reconnect to the file even when it is in posc mode to allow for write error
// recovery. Other users must re-enable posc for the file to show that they are
// aware that the file is under POSC mode as this is not a recovery.
//
   if (Posc->User)
      {if (!Unum)
          {if (!strncmp(User, Posc->User, Posc->Ulen)
           &&  !strcmp(Posc->User + Posc->Uhst, At+1)) return 0;
           return -ETXTBSY;
          } else {
           char buff[1024];
           sprintf(buff, "%s to %s for", Posc->User, User);
           OfsEroute.Emsg("Posc", "Creator changed from", buff, Path.Val);
           if (Unum < 0) Unum = Posc->Unum;
              else if (Unum !=  Posc->Unum) retval = Posc->Unum;
          }
       free(Posc->User);
      }
 
// Assign creation values
//
   Posc->User = strdup(User);
   Posc->Ulen = Col - User + 1;
   Posc->Uhst = At  - User + 1;
   Posc->Unum = Unum;
   Posc->Mode = Umod;
   return retval;
}

References XrdOfsHanPsc::Alloc(), and OfsEroute.

Here is the call graph for this function:

PoscUsr()

const char * XrdOfsHandle::PoscUsr

(

)

Definition at line 446 of file XrdOfsHandle.cc.

{
   if (Posc) return Posc->User;
   return "?@?";
}

Referenced by XrdOfs::Unpersist().

Here is the caller graph for this function:

Retire() [1/2]

int XrdOfsHandle::Retire	(	int &	retc,
		long long *	retsz = 0,
		char *	buff = 0,
		int	blen = 0 )

Definition at line 458 of file XrdOfsHandle.cc.

{
   XrdOssDF *mySSI;
   int numLeft;
 
// Get the global lock as the links field can only be manipulated with it.
// Decrement the links count and if zero, remove it from the table and
// place it on the free list. Otherwise, it is still in use.
//
   retc = 0;
   myMutex.Lock();
   if (Path.Links == 1)
      {if (buff) strlcpy(buff, Path.Val, blen);
       numLeft = 0; OfsStats.Dec(OfsStats.Data.numHandles);
       if ( (isRW ? rwTable.Remove(this) : roTable.Remove(this)) )
         {if (Posc) {Posc->Recycle(); Posc = 0;}
          if (Path.Val) {free((void *)Path.Val); Path.Val = (char *)"";}
          Path.Len = 0; mySSI = ssi; ssi = ossDF;
          Next = Free; Free = this; UnLock(); myMutex.UnLock();
          if (mySSI && mySSI != ossDF)
             {retc = mySSI->Close(retsz); delete mySSI;}
         } else {
          UnLock(); myMutex.UnLock();
          OfsEroute.Emsg("Retire", "Lost handle to", buff);
        }
      } else {numLeft = --Path.Links; UnLock(); myMutex.UnLock();}
   return numLeft;
}

References XrdOssDF::Close(), isRW, OfsEroute, OfsStats, strlcpy(), and UnLock().

Referenced by ~XrdOfsHandle(), XrdOfsFile::close(), XrdOfsFile::open(), Retire(), and StartXpr().

Here is the call graph for this function:

Here is the caller graph for this function:

Retire() [2/2]

int XrdOfsHandle::Retire	(	XrdOfsHanCB *	cbP,
		int	DSec )

Definition at line 489 of file XrdOfsHandle.cc.

{
   static int allOK = StartXpr(1);
   XrdOfsHanXpr *xP;
   int retc;
 
// The handle can only be held by one reference and only if it's a POSC and
// deferred handling was properly set up.
//
   myMutex.Lock();
   if (!Posc || !allOK)
      {OfsEroute.Emsg("Retire", "ignoring deferred retire of", Path.Val);
       if (Path.Links != 1 || !Posc || !cbP) myMutex.UnLock();
          else {myMutex.UnLock(); cbP->Retired(this);}
       return Retire(retc);
      }
   myMutex.UnLock();
 
// If this object already has an xpr object (happens for bouncing connections)
// then reuse that object. Otherwise create a new one and put it on the queue.
//
   if (Posc->xprP) Posc->xprP->Set(cbP, hTime+time(0));
      else {xP = Posc->xprP = new XrdOfsHanXpr(this, cbP, hTime+time(0));
            xP->add2Q();
           }
   UnLock();
   return 0;
}

References XrdOfsHanXpr::add2Q(), OfsEroute, Retire(), XrdOfsHanCB::Retired(), StartXpr(), UnLock(), and XrdOfsHanXpr.

Here is the call graph for this function:

Select()

XrdOssDF & XrdOfsHandle::Select ( void )

inline

Definition at line 161 of file XrdOfsHandle.hh.

{return *ssi;}   // To allow for mt interfaces

Referenced by XrdOfsFile::close().

Here is the caller graph for this function:

StartXpr()

int XrdOfsHandle::StartXpr ( int Init = 0 )

static

Definition at line 522 of file XrdOfsHandle.cc.

{
   static int InitDone = 0;
   XrdOfsHanXpr *xP;
   XrdOfsHandle *hP;
   int retc;
 
// If this is the initial all and we have not been initialized do so
//
   if (Init)
      {pthread_t tid;
       int rc;
       if (InitDone) return InitDone == 1;
       if ((rc = XrdSysThread::Run(&tid, XrdOfsHanXpire, (void *)0,
                                   0, "Handle Timeout")))
          {OfsEroute.Emsg("StartXpr", rc, "create handle timeout thread");
           InitDone = -1; return 0;
          }
       InitDone = 1; return 1;
      }
 
// Simply loop waiting for expired handles to become available. The Get() will
// return an Xpr object with the associated handle locked. 
//
do{xP = XrdOfsHanXpr::Get(); hP = xP->Handle;
 
// Perform validity check on the handle to catch instances where the handle
// was closed while we were in the process of getting it. While this is safe
// it should never happen, so issue a message so we know to fix it.
//
   if (hP->Posc && xP == hP->Posc->xprP) hP->Posc->xprP = 0;
      else {OfsEroute.Emsg("StarXtpr", "Invalid xpr ref to", hP->Path.Val);
            hP->UnLock(); delete xP; continue;
           }
 
// As the handle is locked we can get the global handle lock to prevent
// additions and removals of handles as we need a stable reference count to
// effect the callout, if any. Do so only if the reference count is one (for us)
// and the handle is active. In all cases, drop the global lock.
//
   myMutex.Lock();
   if (hP->Path.Links != 1 || !xP->Call) myMutex.UnLock();
      else {myMutex.UnLock();
            xP->Call->Retired(hP);
           }
 
// We can now officially retire the handle and delete the xpr object
//
   hP->Retire(retc);
   delete xP;
  } while(1);
 
// Keep the compiler happy
//
   return 0;
}

References XrdOfsHandle(), XrdOfsHanXpr::Get(), XrdOfsHanKey::Links, OfsEroute, Retire(), XrdOfsHanCB::Retired(), XrdSysThread::Run(), UnLock(), XrdOfsHanKey::Val, XrdOfsHanPsc::xprP, XrdOfsHanXpire(), and XrdOfsHanXpr.

Referenced by Retire(), and XrdOfsHanXpire().

Here is the call graph for this function:

Here is the caller graph for this function:

Suppress()

void XrdOfsHandle::Suppress	(	int	rrc = -EDOM,
		int	wrc = -EDOM )

Definition at line 583 of file XrdOfsHandle.cc.

{
   ssi = new XrdOfsHanOssErr(ssi, rrc, wrc);
}

UnLock()

void XrdOfsHandle::UnLock ( )

inline

Definition at line 170 of file XrdOfsHandle.hh.

{hMutex.UnLock();}

Referenced by XrdOfs::Emsg(), Retire(), Retire(), and StartXpr().

Here is the caller graph for this function:

Usage()

int XrdOfsHandle::Usage ( )

inline

Definition at line 167 of file XrdOfsHandle.hh.

{return Path.Links;}

Friends And Related Symbol Documentation

XrdOfsHanTab

friend class XrdOfsHanTab

friend

Definition at line 127 of file XrdOfsHandle.hh.

References XrdOfsHanTab.

Referenced by Alloc(), and XrdOfsHanTab.

XrdOfsHanXpr

friend class XrdOfsHanXpr

friend

Definition at line 128 of file XrdOfsHandle.hh.

References XrdOfsHanXpr.

Referenced by Retire(), StartXpr(), and XrdOfsHanXpr.

Member Data Documentation

isChanged

char XrdOfsHandle::isChanged

Definition at line 132 of file XrdOfsHandle.hh.

isCompressed

char XrdOfsHandle::isCompressed

Definition at line 133 of file XrdOfsHandle.hh.

isPending

char XrdOfsHandle::isPending

Definition at line 131 of file XrdOfsHandle.hh.

isRW

char XrdOfsHandle::isRW

Definition at line 134 of file XrdOfsHandle.hh.

Referenced by XrdOfsFile::close(), XrdOfs::Emsg(), and Retire().

opPC

const int XrdOfsHandle::opPC = 3

static

Definition at line 139 of file XrdOfsHandle.hh.

Referenced by XrdOfsFile::close(), XrdOfs::Emsg(), XrdOfsFile::open(), XrdOfsFile::pgWrite(), and XrdOfsFile::write().

opRW

const int XrdOfsHandle::opRW = 1

static

Definition at line 138 of file XrdOfsHandle.hh.

Referenced by Alloc(), and XrdOfsFile::open().

---

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

• XrdOfsHandle.hh
• XrdOfsHandle.cc