Loading...
Searching...
No Matches
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;
}
DEBUG
#define DEBUG(x)
Definition XrdBwmTrace.hh:54
EPNAME
#define EPNAME(x)
Definition XrdBwmTrace.hh:56
QTRACE
#define QTRACE(act)
Definition XrdCmsTrace.hh:49
Debug
bool Debug
Definition XrdSecgsiProxy.cc:95
DUMPIT
#define DUMPIT(x, y)
Definition XrdSsiFileReq.cc:58
XrdOucStats::Bump
void Bump(int &val)
Definition XrdOucStats.hh:47
XrdSsiResponder::MaxDirectXfr
static const int MaxDirectXfr
Definition XrdSsiResponder.hh:81
XrdSsiStats::RspMDBytes
long long RspMDBytes
Definition XrdSsiStats.hh:42
XrdSsi::Stats
XrdSsiStats Stats
Definition XrdSsiFileReq.cc:69
XrdSsiRRInfoAttn::fullResp
static const int fullResp
Definition XrdSsiRRInfo.hh:92
XrdSsiRRInfoAttn::pendResp
static const int pendResp
Definition XrdSsiRRInfo.hh:93
XrdSsiRespInfo::isData
@ isData
Definition XrdSsiRespInfo.hh:58
XrdSsiRespInfo::rType
Resp_t rType
Definition XrdSsiRespInfo.hh:59
XrdSsiRespInfo::mdlen
int mdlen
Metadata length.
Definition XrdSsiRespInfo.hh:55
XrdSsiRespInfo::mdata
const char * mdata
-> Metadata about response.
Definition XrdSsiRespInfo.hh:56

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;
}
SFS_OK
#define SFS_OK
Definition XrdSfsInterface.hh:108
XrdSsiStats::ReqFinForce
int ReqFinForce
Definition XrdSsiStats.hh:48

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;
}
SFS_DATAVEC
#define SFS_DATAVEC
Definition XrdSfsInterface.hh:113
SFS_STARTED
#define SFS_STARTED
Definition XrdSfsInterface.hh:111
SFS_FCTL_SPEC1
#define SFS_FCTL_SPEC1
Definition XrdSfsInterface.hh:88
XrdSsiRRInfo::Id
void Id(unsigned int id)
Definition XrdSsiRRInfo.hh:52
XrdSsiStats::RspReady
int RspReady
Definition XrdSsiStats.hh:61
XrdSsiStats::RspUnRdy
int RspUnRdy
Definition XrdSsiStats.hh:63
XrdSsiUtils::Emsg
static int Emsg(const char *pfx, int ecode, const char *op, const char *path, XrdOucErrInfo &eDest)
Definition XrdSsiUtils.cc:159
XrdSsi::respWT
int respWT
Definition XrdSsiSfsConfig.cc:101

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;
}
SFS_ERROR
#define SFS_ERROR
Definition XrdSfsInterface.hh:109
SFS_REDIRECT
#define SFS_REDIRECT
Definition XrdSfsInterface.hh:110
XrdSysE2T
const char * XrdSysE2T(int errcode)
Definition XrdSysE2T.cc:104
XrdSsiFileSess::errInfo
XrdOucErrInfo * errInfo()
Definition XrdSsiFileSess.hh:62
XrdSsiService::Prepare
virtual bool Prepare(XrdSsiErrInfo &eInfo, const XrdSsiResource &rDesc)
Prepare for processing subsequent resource request.
Definition XrdSsiService.cc:46
XrdSsiStats::ReqStalls
int ReqStalls
Definition XrdSsiStats.hh:55
XrdSsiStats::ReqPrepErrs
int ReqPrepErrs
Definition XrdSsiStats.hh:51
XrdSsiStats::ReqRedir
int ReqRedir
Definition XrdSsiStats.hh:53
XrdSysError::Emsg
int Emsg(const char *esfx, int ecode, const char *text1, const char *text2=0)
Definition XrdSysError.cc:95
XrdSsi::Service
XrdSsiService * Service
Definition XrdSsiFileSess.cc:72
XrdSsi::Log
XrdSysError Log
Definition XrdSsiFileReq.cc:66

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;
}
XrdSfsXferSize
int XrdSfsXferSize
Definition XrdSfsInterface.hh:131

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 | ( |  | ) |

inline static

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;
}
XrdSsiRRInfo::Opc
Opc
Definition XrdSsiRRInfo.hh:43
XrdSsiRRInfo::Can
@ Can
Definition XrdSsiRRInfo.hh:43

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;
}
XrdSfsXioHandle
class XrdBuffer * XrdSfsXioHandle
Definition XrdSfsXio.hh:46
XrdOucBuffPool::Alloc
XrdOucBuffer * Alloc(int sz)
Definition XrdOucBuffer.cc:100
XrdSsi::minRSZ
int minRSZ
Definition XrdSsiSfsConfig.cc:103
XrdSsi::BuffPool
XrdOucBuffPool * BuffPool
Definition XrdSsiSfsConfig.cc:89
XrdSsi::maxRSZ
int maxRSZ
Definition XrdSsiSfsConfig.cc:104

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