XrdBwmHandle Class Reference

#include <XrdBwmHandle.hh>

Collaboration diagram for XrdBwmHandle:

Public Types
enum	HandleState {   Idle = 0 ,   Scheduled ,   Dispatched }

Public Member Functions
	XrdBwmHandle ()
	~XrdBwmHandle ()
int	Activate (XrdOucErrInfo &einfo)
const char *	Name ()
void	Retire ()

Static Public Member Functions
static XrdBwmHandle *	Alloc (const char *theUsr, const char *thePath, const char *lclNode, const char *rmtNode, int Incoming)
static void *	Dispatch ()
static int	setPolicy (XrdBwmPolicy *pP, XrdBwmLogger *lP)

Public Attributes
HandleState	Status

Detailed Description

Definition at line 41 of file XrdBwmHandle.hh.

Member Enumeration Documentation

HandleState

enum XrdBwmHandle::HandleState

Enumerator
Idle
Scheduled
Dispatched

Definition at line 45 of file XrdBwmHandle.hh.

{Idle = 0, Scheduled, Dispatched};

Constructor & Destructor Documentation

XrdBwmHandle()

XrdBwmHandle::XrdBwmHandle ( )

inline

Definition at line 63 of file XrdBwmHandle.hh.

                                    : Status(Idle), Next(0), qTime(0), rTime(0),
                                      xSize(0), xTime(0)
                                    {}

~XrdBwmHandle()

XrdBwmHandle::~XrdBwmHandle ( )

inline

Definition at line 67 of file XrdBwmHandle.hh.

{}

Member Function Documentation

Activate()

int XrdBwmHandle::Activate

(

XrdOucErrInfo &

einfo

)

Definition at line 111 of file XrdBwmHandle.cc.

{
   EPNAME("Activate");
   XrdSysMutexHelper myHelper(hMutex);
   char *rBuff;
   int  rSize, rc;
 
// Check the status of this request.
//
   if (Status != Idle)
      {if (Status == Scheduled)
          einfo.setErrInfo(kXR_inProgress, "Request already scheduled.");
          else einfo.setErrInfo(kXR_InvalidRequest, "Visa already issued.");
       return SFS_ERROR;
      }
 
// Try to schedule this request.
//
   qTime = time(0);
   rBuff = einfo.getMsgBuff(rSize);
   if (!(rc = Policy->Schedule(rBuff, rSize, Parms))) return SFS_ERROR;
 
// If resource immediately available, let client run
//
   if (rc > 0)
      {rHandle = rc;
       Status  = Dispatched;
       rTime   = time(0);
       ZTRACE(sched,"Run " <<Parms.Lfn <<' ' <<Parms.LclNode
                    <<(Parms.Direction==XrdBwmPolicy::Incoming?" <- ":" -> ")
                    <<Parms.RmtNode);
       einfo.setErrCode(strlen(rBuff));
       return (*rBuff ? SFS_DATA : SFS_OK);
      }
 
// Request was queued. We need to hold on to this so we can issue an async
// response later when the resource becomes available.
//
   rHandle = -rc;
   ErrCB = einfo.getErrCB(ErrCBarg);
   einfo.setErrCB((XrdOucEICB *)&myEICB);
   Status = Scheduled;
   refHandle(rHandle, this);
   ZTRACE(sched, "inQ " <<Parms.Lfn <<' ' <<Parms.LclNode
                <<(Parms.Direction==XrdBwmPolicy::Incoming?" <- ":" -> ")
                <<Parms.RmtNode);
 
// Indicate that client needs to wait
//
   return SFS_STARTED;
}

References XrdBwmPolicy::SchedParms::Direction, Dispatched, EPNAME, XrdOucErrInfo::getErrCB(), XrdOucErrInfo::getMsgBuff(), Idle, XrdBwmPolicy::Incoming, kXR_inProgress, kXR_InvalidRequest, XrdBwmPolicy::SchedParms::LclNode, XrdBwmPolicy::SchedParms::Lfn, XrdBwmPolicy::SchedParms::RmtNode, XrdBwmPolicy::Schedule(), Scheduled, XrdOucErrInfo::setErrCB(), XrdOucErrInfo::setErrCode(), XrdOucErrInfo::setErrInfo(), SFS_DATA, SFS_ERROR, SFS_OK, SFS_STARTED, Status, and ZTRACE.

Referenced by XrdBwmFile::fctl().

Here is the call graph for this function:

Here is the caller graph for this function:

Alloc()

XrdBwmHandle * XrdBwmHandle::Alloc ( const char *  theUsr, const char *  thePath, const char *  lclNode, const char *  rmtNode, int  Incoming  )

static

Definition at line 168 of file XrdBwmHandle.cc.

{
   XrdBwmHandle *hP = Alloc();
 
// Initialize the hanlde
//
   if (hP)
      {hP->Parms.Tident    = theUsr;           // Always available
       hP->Parms.Lfn       = strdup(thePath);
       hP->Parms.LclNode   = strdup(LclNode);
       hP->Parms.RmtNode   = strdup(RmtNode);
       hP->Parms.Direction = (Incoming ? XrdBwmPolicy::Incoming
                                        : XrdBwmPolicy::Outgoing);
       hP->Status          = Idle;
       hP->qTime           = 0;
       hP->rTime           = 0;
       hP->xSize           = 0;
       hP->xTime           = 0;
      }
 
// All done
//
   return hP;
}

References Alloc(), XrdBwmPolicy::SchedParms::Direction, Idle, XrdBwmPolicy::Incoming, XrdBwmPolicy::SchedParms::LclNode, XrdBwmPolicy::SchedParms::Lfn, XrdBwmPolicy::Outgoing, XrdBwmPolicy::SchedParms::RmtNode, Status, and XrdBwmPolicy::SchedParms::Tident.

Referenced by XrdBwm::XrdBwm(), Alloc(), XrdBwmFile::open(), and Retire().

Here is the call graph for this function:

Here is the caller graph for this function:

Dispatch()

void * XrdBwmHandle::Dispatch ( )

static

Definition at line 225 of file XrdBwmHandle.cc.

{
   EPNAME("Dispatch");
   XrdBwmHandleCB *erP = XrdBwmHandleCB::Alloc();
   XrdBwmHandle   *hP;
   char *RespBuff;
   int   RespSize, readyH, Result, Err;
 
// Dispatch ready requests in an endless loop
//
   do {
 
// Setup buffer
//
   RespBuff = erP->getMsgBuff(RespSize); 
   *RespBuff = '\0';
   erP->setErrCode(0);
 
// Get next ready request and test if it ended with an error
//
   if ((Err = (readyH = Policy->Dispatch(RespBuff, RespSize)) < 0))
      readyH = -readyH;
 
// Find the matching handle
//
   if (!(hP = refHandle(readyH)))
      {sprintf(RespBuff, "%d", readyH);
       BwmEroute.Emsg("Dispatch", "Lost handle from", RespBuff);
       if (!Err) Policy->Done(readyH);
       continue;
      }
 
// Lock the handle and make sure it can be dispatched
//
   hP->hMutex.Lock();
   if (hP->Status != Scheduled)
      {BwmEroute.Emsg("Dispatch", "ref to unscheduled handle",
                      hP->Parms.Tident, hP->Parms.Lfn);
       if (!Err) Policy->Done(readyH);
      } else {
       hP->myEICB.Wait(); hP->rTime = time(0);
       erP->setErrCB((XrdOucEICB *)erP, hP->ErrCBarg);
       if (Err) {hP->Status = Idle; Result = SFS_ERROR;}
          else  {hP->Status = Dispatched;
                 erP->setErrCode(strlen(RespBuff));
                 Result = (*RespBuff ? SFS_DATA : SFS_OK);
                }
       ZTRACE(sched,(Err?"Err ":"Run ") <<hP->Parms.Lfn <<' ' <<hP->Parms.LclNode
             <<(hP->Parms.Direction == XrdBwmPolicy::Incoming ? " <- ":" -> ")
             <<hP->Parms.RmtNode);
       hP->ErrCB->Done(Result, (XrdOucErrInfo *)erP);
       erP = XrdBwmHandleCB::Alloc();
      }
    hP->hMutex.UnLock();
   } while(1);
 
// Keep the compiler happy
//
   return (void *)0;
}

References XrdBwmHandleCB::Alloc(), BwmEroute, XrdBwmPolicy::SchedParms::Direction, XrdBwmPolicy::Dispatch(), Dispatched, XrdOucEICB::Done(), XrdBwmPolicy::Done(), XrdSysError::Emsg(), EPNAME, Err, XrdOucErrInfo::getMsgBuff(), Idle, XrdBwmPolicy::Incoming, XrdBwmPolicy::SchedParms::LclNode, XrdBwmPolicy::SchedParms::Lfn, XrdSysMutex::Lock(), XrdBwmPolicy::SchedParms::RmtNode, Scheduled, XrdOucErrInfo::setErrCB(), XrdOucErrInfo::setErrCode(), SFS_DATA, SFS_ERROR, SFS_OK, Status, XrdBwmPolicy::SchedParms::Tident, XrdSysMutex::UnLock(), and ZTRACE.

Referenced by XrdBwmHanXeq().

Here is the call graph for this function:

Here is the caller graph for this function:

Name()

const char * XrdBwmHandle::Name ( )

inline

Definition at line 57 of file XrdBwmHandle.hh.

{return Parms.Lfn;}

References XrdBwmPolicy::SchedParms::Lfn.

Referenced by XrdBwmFile::close(), XrdBwmFile::FName(), and XrdBwmFile::truncate().

Here is the caller graph for this function:

Retire()

void XrdBwmHandle::Retire

(

)

Definition at line 332 of file XrdBwmHandle.cc.

{
   XrdSysMutexHelper myHelper(hMutex);
 
// Get the global lock as the links field can only be manipulated with it.
// If not idle, cancel the resource. If scheduled, remove it from the table.
//
   if (Status != Idle) 
      {Policy->Done(rHandle);
       if (Status == Scheduled && !refHandle(rHandle, this))
          BwmEroute.Emsg("Retire", "Lost handle to", Parms.Tident, Parms.Lfn);
       Status = Idle; rHandle = 0;
      }
 
// If we have a logger, then log this event
//
   if (Logger && qTime)
      {XrdBwmLogger::Info myInfo;
       myInfo.Tident  = Parms.Tident;
       myInfo.Lfn     = Parms.Lfn;
       myInfo.lclNode = Parms.LclNode;
       myInfo.rmtNode = Parms.RmtNode;
       myInfo.ATime   = qTime;
       myInfo.BTime   = rTime;
       myInfo.CTime   = time(0);
       myInfo.Size    = xSize;
       myInfo.ESec    = xTime;
       myInfo.Flow    = (Parms.Direction == XrdBwmPolicy::Incoming ? 'I':'O');
       Policy->Status(myInfo.numqIn, myInfo.numqOut, myInfo.numqXeq);
       Logger->Event(myInfo);
      }
 
// Free storage appendages and recycle handle
//
   if (Parms.Lfn)     {free(Parms.Lfn);     Parms.Lfn = 0;}
   if (Parms.LclNode) {free(Parms.LclNode); Parms.LclNode = 0;}
   if (Parms.RmtNode) {free(Parms.RmtNode); Parms.RmtNode = 0;}
   Alloc(this);
}

References Alloc(), XrdBwmLogger::Info::ATime, XrdBwmLogger::Info::BTime, BwmEroute, XrdBwmLogger::Info::CTime, XrdBwmPolicy::SchedParms::Direction, XrdBwmPolicy::Done(), XrdSysError::Emsg(), XrdBwmLogger::Info::ESec, XrdBwmLogger::Event(), XrdBwmLogger::Info::Flow, Idle, XrdBwmPolicy::Incoming, XrdBwmLogger::Info::lclNode, XrdBwmPolicy::SchedParms::LclNode, XrdBwmLogger::Info::Lfn, XrdBwmPolicy::SchedParms::Lfn, XrdBwmLogger::Info::numqIn, XrdBwmLogger::Info::numqOut, XrdBwmLogger::Info::numqXeq, XrdBwmLogger::Info::rmtNode, XrdBwmPolicy::SchedParms::RmtNode, Scheduled, XrdBwmLogger::Info::Size, Status, XrdBwmPolicy::Status(), XrdBwmLogger::Info::Tident, and XrdBwmPolicy::SchedParms::Tident.

Referenced by XrdBwmFile::close().

Here is the call graph for this function:

Here is the caller graph for this function:

setPolicy()

int XrdBwmHandle::setPolicy ( XrdBwmPolicy *  pP, XrdBwmLogger *  lP  )

static

Definition at line 376 of file XrdBwmHandle.cc.

{
   pthread_t tid;
   int rc, startThread = (Policy == 0);
 
// Set the policy and then start a thread to do dispatching if we have none
//
   Policy = pP;
   if (startThread)
      if ((rc = XrdSysThread::Run(&tid, XrdBwmHanXeq, (void *)0,
                                  0, "Handle Dispatcher")))
         {BwmEroute.Emsg("setPolicy", rc, "create handle dispatch thread");
          return 1;
         }
 
// All done
//
   Logger = lP;
   return 0;
}

References BwmEroute, XrdSysError::Emsg(), XrdSysThread::Run(), and XrdBwmHanXeq().

Referenced by XrdBwm::Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Status

HandleState XrdBwmHandle::Status

Definition at line 47 of file XrdBwmHandle.hh.

Referenced by Activate(), Alloc(), Dispatch(), and Retire().

---

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

• XrdBwmHandle.hh
• XrdBwmHandle.cc