XrdSendQ Class Reference

#include <XrdSendQ.hh>

Inheritance diagram for XrdSendQ:

Collaboration diagram for XrdSendQ:

Public Member Functions
	XrdSendQ (XrdLink &lP, XrdSysMutex &mP)
unsigned int	Backlog ()
virtual void	DoIt ()
int	Send (const char *buff, int blen)
int	Send (const struct iovec *iov, int iovcnt, int iotot)
void	Terminate (XrdLink *lP=0)
Public Member Functions inherited from XrdJob
	XrdJob (const char *desc="")
virtual	~XrdJob ()

Static Public Member Functions
static void	SetAQ (bool onoff)
static void	SetQM (unsigned int qmVal)
static void	SetQW (unsigned int qwVal)

Additional Inherited Members
Public Attributes inherited from XrdJob
const char *	Comment
XrdJob *	NextJob

Detailed Description

Definition at line 42 of file XrdSendQ.hh.

Constructor & Destructor Documentation

XrdSendQ()

XrdSendQ::XrdSendQ	(	XrdLink &	lP,
		XrdSysMutex &	mP
	)

Definition at line 91 of file XrdSendQ.cc.

                  : XrdJob("sendQ runner"),
                    mLink(lP), wMutex(mP),
                    fMsg(0), lMsg(0), delQ(0), theFD(lP.FDnum()),
                    inQ(0), qWmsg(qWarn), discards(0),
                    active(false), terminate(false) {}

Member Function Documentation

Backlog()

unsigned int XrdSendQ::Backlog ( )

inline

Definition at line 46 of file XrdSendQ.hh.

{return inQ;}

Referenced by XrdLinkXeq::Backlog().

Here is the caller graph for this function:

DoIt()

void XrdSendQ::DoIt ( )

virtual

Implements XrdJob.

Definition at line 102 of file XrdSendQ.cc.

{
   mBuff   *theMsg;
   int      myFD, rc;
   bool     theEnd;
 
// Obtain the lock
//
   wMutex.Lock();
 
// Before we start check if we should delete any messages
//
   if (delQ) {RelMsgs(delQ); delQ = 0;}
 
// Send all queued messages (we can use a blocking send here)
//
   while(!terminate && (theMsg = fMsg))
        {if (!(fMsg = fMsg->next)) lMsg = 0;
         inQ--; myFD = theFD;
         wMutex.UnLock();
         rc = send(myFD, theMsg->mData, theMsg->mLen, 0);
         free(theMsg);
         wMutex.Lock();
         if (rc < 0) {Scuttle(); break;}
        }
 
// Before we exit check if we should delete any messages
//
   if (delQ) {RelMsgs(delQ); delQ = 0;}
   if ((theEnd = terminate) && fMsg) RelMsgs(fMsg);
   active = false;
   qWmsg  = qWarn;
 
// Release any messages that need to be released. Note that we may have been
// deleted at this point so we cannot reference anything via "this" once we
// unlock the mutex. We may also need to delete ourselves.
//
   wMutex.UnLock();
   if (theEnd) delete this;
}

References XrdSysMutex::Lock(), and XrdSysMutex::UnLock().

Here is the call graph for this function:

Send() [1/2]

int XrdSendQ::Send	(	const char *	buff,
		int	blen
	)

Definition at line 230 of file XrdSendQ.cc.

{
   mBuff *theMsg;
   int bleft, bsent;
 
// If there is an active thread handling messages then we have to queue it.
// Otherwise try to send it. We need to hold the lock here to prevent messing
// up the message is only part of it could be sent. This is a non-blocking call.
//
   if (active) bleft = blen;
      else if ((bleft = SendNB(buff, blen)) <= 0) return (bleft ? -1 : blen);
 
// Allocate buffer for the message
//
   if (!(theMsg = (mBuff *)malloc(sizeof(mBuff) + bleft)))
      {errno = ENOMEM;  return -1;}
 
// Copy the unsent message fragment
//
   bsent = blen - bleft;
   memcpy(theMsg->mData, buff+bsent, bleft);
   theMsg->mLen  = bleft;
 
// Queue the message.
//
   return (QMsg(theMsg) ? blen : -1);
}

Referenced by XrdLinkXeq::Send(), XrdLinkXeq::Send(), XrdLinkXeq::TLS_Send(), and XrdLinkXeq::TLS_Send().

Here is the caller graph for this function:

Send() [2/2]

int XrdSendQ::Send	(	const struct iovec *	iov,
		int	iovcnt,
		int	iotot
	)

Definition at line 262 of file XrdSendQ.cc.

{
   mBuff *theMsg;
   char  *body;
   int bleft, bmore, iovX;
 
// If there is an active thread handling messages then we have to queue it.
// Otherwise try to send it. We need to hold the lock here to prevent messing
// up the message is only part of it could be sent. This is a non-blocking call.
//
   if (active)
      {bleft = 0;
       for (iovX = 0; iovX < iovcnt; iovX++)
           if ((bleft = iov[iovX].iov_len)) break;
       if (!bleft) return iotot;
      } else {
       if ((bleft = SendNB(iov, iovcnt, iotot, iovX)) <= 0)
          return (bleft ? -1 : 0);
      }
 
// Readjust the total amount not sent based on where we stopped in the iovec.
//
   bmore = bleft;
   for (int i = iovX+1; i < iovcnt; i++) bmore += iov[i].iov_len;
 
// Copy the unsent message (for simplicity we will copy the whole iovec stop).
//
   if (!(theMsg = (mBuff *)malloc(bmore+sizeof(mBuff))))
      {errno = ENOMEM;  return -1;}
 
// Setup the message length
//
   theMsg->mLen = bmore;
 
// Copy the first fragment (it cannot be zero length)
//
   body = theMsg->mData;
   memcpy(body, ((char *)iov[iovX].iov_base)+(iov[iovX].iov_len-bleft), bleft);
   body += bleft;
 
// All remaining items
//
   for (int i = iovX+1; i < iovcnt; i++)
       {if (iov[i].iov_len)
           {memcpy(body, iov[i].iov_base, iov[i].iov_len);
            body += iov[i].iov_len;
           }
       }
 
// Queue the message.
//
   return (QMsg(theMsg) ? iotot : 0);
}

SetAQ()

static void XrdSendQ::SetAQ ( bool  onoff )

inlinestatic

Definition at line 54 of file XrdSendQ.hh.

{qPerm = onoff;}

SetQM()

static void XrdSendQ::SetQM ( unsigned int  qmVal )

inlinestatic

Definition at line 56 of file XrdSendQ.hh.

{qMax  = qmVal;}

Referenced by XrdCmsConfig::Configure1().

Here is the caller graph for this function:

SetQW()

static void XrdSendQ::SetQW ( unsigned int  qwVal )

inlinestatic

Definition at line 58 of file XrdSendQ.hh.

{qWarn = qwVal;}

Terminate()

void XrdSendQ::Terminate

(

XrdLink *

lP = 0

)

Definition at line 396 of file XrdSendQ.cc.

{
// First step is to see if we need to schedule a shutdown prior to quiting
//
   if (lP) Sched.Schedule((XrdJob *)new LinkShutdown(lP));
 
// If there is an active thread then we need to let the thread handle the
// termination of this object. Otherwise, we can do it now.
//
   if (active)
      {Scuttle();
       terminate = true;
       theFD     =-1;
      } else {
       if (fMsg) {RelMsgs(fMsg); fMsg = lMsg = 0;}
       if (delQ) {RelMsgs(delQ); delQ = 0;}
       delete this;
      }
}

References XrdGlobal::Sched, and XrdScheduler::Schedule().

Referenced by XrdLinkXeq::Close().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• XrdSendQ.hh
• XrdSendQ.cc