XrdSsiFileSess Class Reference

#include <XrdSsiFileSess.hh>

Collaboration diagram for XrdSsiFileSess:

Public Member Functions
bool	AttnInfo (XrdOucErrInfo &eInfo, const XrdSsiRespInfo *respP, unsigned int reqID)
int	close (bool viaDel=false)
bool	DeferFinalize (XrdSsiFileReq *req, uint64_t itemID)
void	DeferredFinalizeDone (XrdSsiFileReq *req, uint64_t itemID)
XrdOucErrInfo *	errInfo ()
int	fctl (const int cmd, int alen, const char *args, const XrdSecEntity *client)
const char *	FName ()
int	open (const char *fileName, XrdOucEnv &theEnv, XrdSfsFileOpenMode openMode)
XrdSfsXferSize	read (XrdSfsFileOffset fileOffset, char *buffer, XrdSfsXferSize buffer_size)
void	Recycle ()
XrdSsiFileResource &	Resource ()
int	SendData (XrdSfsDio *sfDio, XrdSfsFileOffset offset, XrdSfsXferSize size)
void	setXio (XrdSfsXio *xP)
int	truncate (XrdSfsFileOffset fileOffset)
XrdSfsXferSize	write (XrdSfsFileOffset fileOffset, const char *buffer, XrdSfsXferSize buffer_size)

Static Public Member Functions
static XrdSsiFileSess *	Alloc (XrdOucErrInfo &einfo, const char *user)
static void	SetAuthDNS ()

Detailed Description

Definition at line 46 of file XrdSsiFileSess.hh.

Member Function Documentation

Alloc()

XrdSsiFileSess * XrdSsiFileSess::Alloc ( XrdOucErrInfo & einfo, const char * user )

static

Definition at line 126 of file XrdSsiFileSess.cc.

{
   XrdSsiFileSess *fsP;
 
// Get a lock
//
   arMutex.Lock();
 
// Get either a reuseable object or a new one
//
   if ((fsP = freeList))
      {freeNum--;
       freeList = fsP->nextFree;
       arMutex.UnLock();
       fsP->Init(einfo, user, true);
      } else {
       freeNew++;
       if (freeMax <= freeAbs && freeNew >= freeMax/2)
          {freeMax += freeMax/2;
           freeNew = 0;
          }
       arMutex.UnLock();
       fsP = new XrdSsiFileSess(einfo, user);
      }
 
// Return the object
//
   return fsP;
}

Referenced by XrdSsiFile::open().

Here is the caller graph for this function:

AttnInfo()

bool XrdSsiFileSess::AttnInfo	(	XrdOucErrInfo &	eInfo,
		const XrdSsiRespInfo *	respP,
		unsigned int	reqID )

Definition at line 160 of file XrdSsiFileSess.cc.

{
   EPNAME("AttnInfo");
   struct AttnResp {struct iovec ioV[4]; XrdSsiRRInfoAttn aHdr;};
 
   AttnResp *attnResp;
   char *mBuff;
   int n, ioN = 2;
   bool doFin;
 
// If there is no data we can send back to the client in the attn response,
// then simply reply with a short message to make the client come back.
//
   if (!respP->mdlen)
      {if (respP->rType != XrdSsiRespInfo::isData
       ||  respP->blen > XrdSsiResponder::MaxDirectXfr)
          {eInfo.setErrInfo(0, "");
           return false;
          }
      }
 
// We will be constructing the response in the message buffer. This is
// gauranteed to be big enough for our purposes so no need to check the size.
//
   mBuff = eInfo.getMsgBuff(n);
 
// Initialize the response
//
   attnResp = (AttnResp *)mBuff;
   memset(attnResp, 0, sizeof(AttnResp));
   attnResp->aHdr.pfxLen = htons(sizeof(XrdSsiRRInfoAttn));
 
// Fill out iovec to point to our header
//
//?attnResp->ioV[0].iov_len  = sizeof(XrdSsiRRInfoAttn) + respP->mdlen;
   attnResp->ioV[1].iov_base = mBuff+offsetof(struct AttnResp, aHdr);
   attnResp->ioV[1].iov_len  = sizeof(XrdSsiRRInfoAttn);
 
// Fill out the iovec for the metadata if we have some
//
   if (respP->mdlen)
      {attnResp->ioV[2].iov_base = (void *)respP->mdata;
       attnResp->ioV[2].iov_len  =         respP->mdlen; ioN = 3;
       attnResp->aHdr.mdLen = htonl(respP->mdlen);
       Stats.Bump(Stats.RspMDBytes, respP->mdlen);
       if (QTRACE(Debug))
          {char hexBuff[16],dotBuff[4];
           DEBUG(reqID <<':' <<gigID <<' ' <<respP->mdlen <<" byte metadata (0x"
                       <<DUMPIT(respP->mdata,respP->mdlen) <<") sent.");
          }
      }
 
// Check if we have actual data here as well and can send it along
//
   if (respP->rType == XrdSsiRespInfo::isData
   &&  respP->blen+respP->mdlen <= XrdSsiResponder::MaxDirectXfr)
      {if (respP->blen)
          {attnResp->ioV[ioN].iov_base = (void *)respP->buff;
           attnResp->ioV[ioN].iov_len  =         respP->blen; ioN++;
          }
         attnResp->aHdr.tag = XrdSsiRRInfoAttn::fullResp; doFin = true;
      }
   else {attnResp->aHdr.tag = XrdSsiRRInfoAttn::pendResp; doFin = false;}
 
// If we sent the full response we must remove the request from the request
// table as it will get finished off when the response is actually sent.
//
   if (doFin)
     {XrdSsiRRTableItem<XrdSsiFileReq> rqstP;
      if (!(rqstP = rTab.LookUp(reqID)))
        {eInfo.setErrInfo(0, "");
         return false;
        }
      attnFinCallBack.setReq(std::move(rqstP));
      eInfo.setErrCB(&attnFinCallBack);
      rTab.Del(reqID);
     }
 
// Setup to have metadata actually sent to the requestor
//
   eInfo.setErrCode(ioN);
   return doFin;
}

References DEBUG, Debug, DUMPIT, EPNAME, XrdSsiRRInfoAttn::fullResp, XrdSsiRespInfo::isData, XrdSsiResponder::MaxDirectXfr, XrdSsiRespInfo::mdata, XrdSsiRespInfo::mdlen, XrdSsiRRInfoAttn::pendResp, QTRACE, XrdSsiRespInfo::rType, and XrdSsi::Stats.

close()

int XrdSsiFileSess::close

(

bool

viaDel = false

)

Definition at line 250 of file XrdSsiFileSess.cc.

{
   const char *epname = "close";
 
// Do some debugging
//
   DEBUG((gigID ? gigID : "???") <<" del=" <<viaDel);
 
// Collect statistics if this is a delete which implies a lost connection
//
   if (viaDel)
      {int rCnt = rTab.Num();
       if (rCnt) Stats.Bump(Stats.ReqFinForce, rCnt);
      }
 
// Run through all outstanding requests and comlete them
//
   rTab.Reset();
 
// Free any in-progress buffers
//
   if (inProg)
      {if (oucBuff) {oucBuff->Recycle(); oucBuff = 0;}
       inProg = false;
      }
 
// Clean up storage
//
   isOpen = false;
   return SFS_OK;
}

References DEBUG, SFS_OK, and XrdSsi::Stats.

DeferFinalize()

bool XrdSsiFileSess::DeferFinalize ( XrdSsiFileReq * req, uint64_t itemID )

inline

Definition at line 56 of file XrdSsiFileSess.hh.

                           {return rTab.DeferFinalize(req,itemID);}

DeferredFinalizeDone()

void XrdSsiFileSess::DeferredFinalizeDone ( XrdSsiFileReq * req, uint64_t itemID )

inline

Definition at line 59 of file XrdSsiFileSess.hh.

                           {return rTab.DeferredFinalizeDone(req, itemID);}

errInfo()

XrdOucErrInfo * XrdSsiFileSess::errInfo ( )

inline

Definition at line 62 of file XrdSsiFileSess.hh.

{return eInfo;}

Referenced by open().

Here is the caller graph for this function:

fctl()

int XrdSsiFileSess::fctl	(	const int	cmd,
		int	alen,
		const char *	args,
		const XrdSecEntity *	client )

Definition at line 293 of file XrdSsiFileSess.cc.

{
   static const char *epname = "fctl";
   XrdSsiRRInfo      *rInfo;
   XrdSsiRRTableItem<XrdSsiFileReq> rqstP;
   unsigned int       reqID;
 
// If this isn't the special query, then return an error
//
   if (cmd != SFS_FCTL_SPEC1)
      return XrdSsiUtils::Emsg(epname, ENOTSUP, "fctl", gigID, *eInfo);
 
// Caller wishes to find out if a request is ready and wait if it is not
//
   if (!args || alen < (int)sizeof(XrdSsiRRInfo))
      return XrdSsiUtils::Emsg(epname, EINVAL, "fctl", gigID, *eInfo);
 
// Grab the request identifier
//
   rInfo = (XrdSsiRRInfo *)args;
   reqID = rInfo->Id();
 
// Do some debugging
//
   DEBUG(reqID <<':' <<gigID <<" query resp status");
 
// Find the request
//
   if (!(rqstP = rTab.LookUp(reqID)))
      return XrdSsiUtils::Emsg(epname, ESRCH, "fctl", gigID, *eInfo);
 
// Check if a response is waiting for the caller
//
   if (rqstP->WantResponse(*eInfo))
      {DEBUG(reqID <<':' <<gigID <<" resp ready");
       Stats.Bump(Stats.RspReady);
       return SFS_DATAVEC;
      }
 
// Put this client into callback state
//
   DEBUG(reqID <<':' <<gigID <<" resp not ready");
   fctlCallBack.setReq(std::move(rqstP));
 
   eInfo->setErrCB(&fctlCallBack);
   eInfo->setErrInfo(respWT, "");
   Stats.Bump(Stats.RspUnRdy);
   return SFS_STARTED;
}

References DEBUG, XrdSsiUtils::Emsg(), XrdSsiRRInfo::Id(), XrdSsi::respWT, SFS_DATAVEC, SFS_FCTL_SPEC1, SFS_STARTED, and XrdSsi::Stats.

Here is the call graph for this function:

FName()

const char * XrdSsiFileSess::FName ( )

inline

Definition at line 71 of file XrdSsiFileSess.hh.

{return gigID;}

open()

int XrdSsiFileSess::open	(	const char *	fileName,
		XrdOucEnv &	theEnv,
		XrdSfsFileOpenMode	openMode )

Definition at line 403 of file XrdSsiFileSess.cc.

{
   static const char *epname = "open";
   XrdSsiErrInfo errInfo;
   const char *eText;
   int eNum;
 
// Verify that this object is not already associated with an open file
//
   if (isOpen)
      return XrdSsiUtils::Emsg(epname, EADDRINUSE, "open session", path, *eInfo);
 
// Make sure the open flag is correct (we now open this R/O so don't check)
//
// if (open_mode != SFS_O_RDWR)
//    return XrdSsiUtils::Emsg(epname, EPROTOTYPE, "open session", path, *eInfo);
 
// Setup the file resource object
//
   fileResource.Init(path, theEnv, authDNS);
 
// Notify the provider that we will be executing a request
//
   if (Service->Prepare(errInfo, fileResource))
      {const char *usr = fileResource.rUser.c_str();
       if (!(*usr)) gigID = strdup(path);
          else {char gBuff[2048];
                snprintf(gBuff, sizeof(gBuff), "%s:%s", usr, path);
                gigID = strdup(gBuff);
               }
       DEBUG(gigID <<" prepared.");
       isOpen = true;
       return SFS_OK;
      }
 
// Get error information
//
   eText = errInfo.Get(eNum).c_str();
   if (!eNum)
      {eNum = ENOMSG; eText = "Provider returned invalid prepare response.";}
 
// Decode the error
//
   switch(eNum)
         {case EAGAIN:
               if (!eText || !(*eText)) break;
               eNum = errInfo.GetArg();
               DEBUG(path <<" --> " <<eText <<':' <<eNum);
               eInfo->setErrInfo(eNum, eText);
               Stats.Bump(Stats.ReqRedir);
               return SFS_REDIRECT;
               break;
          case EBUSY:
               eNum = errInfo.GetArg();
               if (!eText || !(*eText)) eText = "Provider is busy.";
               DEBUG(path <<" dly " <<eNum <<' ' <<eText);
               if (eNum <= 0) eNum = 1;
               eInfo->setErrInfo(eNum, eText);
               Stats.Bump(Stats.ReqStalls);
               return eNum;
               break;
          default:
               if (!eText || !(*eText)) eText = XrdSysE2T(eNum);
               DEBUG(path <<" err " <<eNum <<' ' <<eText);
               eInfo->setErrInfo(eNum, eText);
               Stats.Bump(Stats.ReqPrepErrs);
               return SFS_ERROR;
               break;
         };
 
// Something is quite wrong here
//
   Log.Emsg(epname, "Provider redirect returned no target host name!");
   eInfo->setErrInfo(ENOMSG, "Server logic error");
   Stats.Bump(Stats.ReqPrepErrs);
   return SFS_ERROR;
}

References DEBUG, XrdSsiUtils::Emsg(), errInfo(), XrdSsi::Log, XrdSsi::Service, SFS_ERROR, SFS_OK, SFS_REDIRECT, XrdSsi::Stats, and XrdSysE2T().

Here is the call graph for this function:

read()

XrdSfsXferSize XrdSsiFileSess::read	(	XrdSfsFileOffset	fileOffset,
		char *	buffer,
		XrdSfsXferSize	buffer_size )

Definition at line 496 of file XrdSsiFileSess.cc.

{
   static const char *epname = "read";
   XrdSsiRRInfo   rInfo(offset);
   XrdSsiRRTableItem<XrdSsiFileReq> rqstP;
   XrdSfsXferSize retval;
   unsigned int   reqID = rInfo.Id();
   bool           noMore = false;
 
// Find the request object. If not there we may have encountered an eof
//
   if (!(rqstP = rTab.LookUp(reqID)))
      {if (eofVec.IsSet(reqID))
          {eofVec.UnSet(reqID);
           return 0;
          }
        return XrdSsiUtils::Emsg(epname, ESRCH, "read", gigID, *eInfo);
       }
 
// Simply effect the read via the request object
//
   retval = rqstP->Read(noMore, buff, blen);
 
// See if we just completed this request
//
   if (noMore)
      {rTab.DelFinalize(std::move(rqstP));
       eofVec.Set(reqID);
      }
 
// All done
//
   return retval;
}

References XrdSsiUtils::Emsg(), and XrdSsiRRInfo::Id().

Here is the call graph for this function:

Recycle()

void XrdSsiFileSess::Recycle

(

)

Definition at line 548 of file XrdSsiFileSess.cc.

{
 
// Do an immediate reset on ourselves to avoid getting too many locks
//
   Reset();
 
// Get a lock
//
   arMutex.Lock();
 
// Check if we should place this on the free list or simply delete it
//
   if (freeNum < freeMax)
      {nextFree = freeList;
       freeList = this;
       freeNum++;
       arMutex.UnLock();
      } else {
       arMutex.UnLock();
       delete this;
      }
}

Resource()

XrdSsiFileResource & XrdSsiFileSess::Resource ( )

inline

Definition at line 83 of file XrdSsiFileSess.hh.

{return fileResource;}

SendData()

int XrdSsiFileSess::SendData	(	XrdSfsDio *	sfDio,
		XrdSfsFileOffset	offset,
		XrdSfsXferSize	size )

Definition at line 594 of file XrdSsiFileSess.cc.

{
   static const char *epname = "SendData";
   XrdSsiRRInfo   rInfo(offset);
   XrdSsiRRTableItem<XrdSsiFileReq> rqstP;
   unsigned int reqID = rInfo.Id();
   int rc;
 
// Find the request object
//
   if (!(rqstP = rTab.LookUp(reqID)))
      return XrdSsiUtils::Emsg(epname, ESRCH, "send", gigID, *eInfo);
 
// Simply effect the send via the request object
//
   rc = rqstP->Send(sfDio, size);
 
// Determine how this ended
//
   if (rc > 0) rc = SFS_OK;
      else rTab.DelFinalize(std::move(rqstP));
 
   return rc;
}

References XrdSsiUtils::Emsg(), XrdSsiRRInfo::Id(), and SFS_OK.

Here is the call graph for this function:

SetAuthDNS()

void XrdSsiFileSess::SetAuthDNS ( )

inlinestatic

Definition at line 89 of file XrdSsiFileSess.hh.

{authDNS = true;}

setXio()

void XrdSsiFileSess::setXio ( XrdSfsXio * xP )

inline

Definition at line 91 of file XrdSsiFileSess.hh.

{xioP = xP;}

truncate()

int XrdSsiFileSess::truncate

(

XrdSfsFileOffset

fileOffset

)

Definition at line 625 of file XrdSsiFileSess.cc.

{
   static const char *epname = "trunc";
   XrdSsiRRTableItem<XrdSsiFileReq> rqstP;
   XrdSsiRRInfo       rInfo(flen);
   XrdSsiRRInfo::Opc  reqXQ = rInfo.Cmd();
   unsigned int       reqID = rInfo.Id();
 
// Find the request object. If not there we may have encountered an eof
//
   if (!(rqstP = rTab.LookUp(reqID)))
      {if (eofVec.IsSet(reqID))
          {eofVec.UnSet(reqID);
           return 0;
          }
        return XrdSsiUtils::Emsg(epname, ESRCH, "cancel", gigID, *eInfo);
       }
 
// Process request (this can only be a cancel request)
//
   if (reqXQ != XrdSsiRRInfo::Can)
      return XrdSsiUtils::Emsg(epname, ENOTSUP, "trunc", gigID, *eInfo);
 
// Perform the cancellation
//
   DEBUG(reqID <<':' <<gigID <<" cancelled");
   rTab.DelFinalize(std::move(rqstP));
   return SFS_OK;
}

References XrdSsiRRInfo::Can, XrdSsiRRInfo::Cmd(), DEBUG, XrdSsiUtils::Emsg(), XrdSsiRRInfo::Id(), and SFS_OK.

Here is the call graph for this function:

write()

XrdSfsXferSize XrdSsiFileSess::write	(	XrdSfsFileOffset	fileOffset,
		const char *	buffer,
		XrdSfsXferSize	buffer_size )

Definition at line 666 of file XrdSsiFileSess.cc.

{
   static const char *epname = "write";
   XrdSsiRRInfo   rInfo(offset);
   unsigned int reqID = rInfo.Id();
   int reqPass;
 
// Check if we are reading a request segment and handle that. This assumes that
// writes to different requests cannot be interleaved (which they can't be).
//
   if (inProg) return writeAdd(buff, blen, reqID);
 
// Make sure this request does not refer to an active request
//
   if (rTab.LookUp(reqID))
      return XrdSsiUtils::Emsg(epname, EADDRINUSE, "write", gigID, *eInfo);
 
// The offset contains the actual size of the request, make sure it's OK. Note 
// that it can be zero and by convention the blen must be one if so.
//
   reqPass = reqSize = rInfo.Size();
   if (reqSize < blen)
      {if (reqSize || blen != 1)
          return XrdSsiUtils::Emsg(epname, EPROTO, "write", gigID, *eInfo);
       reqSize = 1;
      } else if (reqSize < 0 || reqSize > maxRSZ)
                return XrdSsiUtils::Emsg(epname, EFBIG, "write", gigID, *eInfo);
 
// Indicate we are in the progress of collecting the request arguments
//
   inProg = true;
   eofVec.UnSet(reqID);
 
// Do some debugging
//
   DEBUG(reqID <<':' <<gigID <<" rsz=" <<reqSize <<" wsz=" <<blen);
 
// If the complete request is here then grab the buffer, transfer ownership to
// the request object, and then activate it for processing.
//
   if (reqSize == blen && xioP)
      {XrdSfsXioHandle bRef = xioP->Claim(buff, reqSize, minRSZ);
       if (!bRef)
          {if (errno) Log.Emsg(epname,"Xio.Claim() failed;",XrdSysE2T(errno));}
          else {if (!NewRequest(reqID, 0, bRef, reqPass))
                   return XrdSsiUtils::Emsg(epname,ENOMEM,"write xio",gigID,*eInfo);
                return blen;
               }
      }
 
// The full request is not present, so get a buffer to piece it together
//
   if (!(oucBuff = BuffPool->Alloc(reqSize)))
      return XrdSsiUtils::Emsg(epname, ENOMEM, "write alloc", gigID, *eInfo);
 
// Setup to buffer this
//
   reqLeft = reqSize - blen;
   memcpy(oucBuff->Data(), buff, blen);
   if (!reqLeft)
      {oucBuff->SetLen(reqSize);
 
       if (!NewRequest(reqID, oucBuff, 0, reqPass))
          return XrdSsiUtils::Emsg(epname, ENOMEM, "write sfs", gigID, *eInfo);
       oucBuff = 0;
      } else oucBuff->SetLen(blen, blen);
   return blen;
}

References XrdSsi::BuffPool, DEBUG, XrdSsiUtils::Emsg(), XrdSsiRRInfo::Id(), XrdSsi::Log, XrdSsi::maxRSZ, XrdSsi::minRSZ, XrdSsiRRInfo::Size(), and XrdSysE2T().

Here is the call graph for this function:

---

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

• XrdSsiFileSess.hh
• XrdSsiFileSess.cc