#include <XrdSsiStats.hh>

Inheritance diagram for XrdSsiStats:

Collaboration diagram for XrdSsiStats:

Public Member Functions
	XrdSsiStats ()

	~XrdSsiStats ()

void	setFS (XrdSfsFileSystem *fsp)

int	Stats (char *buff, int blen)

Public Member Functions inherited from XrdOucStats
	XrdOucStats ()

	~XrdOucStats ()

void	Bump (int &val)

void	Bump (int &val, int n)

void	Bump (long long &val)

void	Bump (long long &val, long long n)

Public Attributes
int	ReqAborts

int	ReqAlerts

int	ReqBound

long long	ReqBytes

int	ReqCancels

int	ReqCount

int	ReqFinForce

int	ReqFinished

int	ReqGets

long long	ReqMaxsz

int	ReqPrepErrs

int	ReqProcs

int	ReqRedir

int	ReqRelBuf

int	ReqStalls

int	ResAdds

int	ResRems

int	RspBad

int	RspCallBK

int	RspData

int	RspErrs

int	RspFile

long long	RspMDBytes

int	RspReady

int	RspStrm

int	RspUnRdy

int	SsiErrs

Public Attributes inherited from XrdOucStats
XrdSysMutex	statsMutex

Detailed Description

Definition at line 37 of file XrdSsiStats.hh.

Constructor & Destructor Documentation

◆ XrdSsiStats()

XrdSsiStats::XrdSsiStats ( )

Definition at line 49 of file XrdSsiStats.cc.

 {
  
 fsP      = 0;
  
 ReqBytes      = 0; // Stats: Number of requests bytes total
 ReqMaxsz      = 0; // Stats: Number of requests largest size
 RspMDBytes    = 0; // Stats: Number of metada  response bytes
 ReqAborts     = 0; // Stats: Number of request aborts
 ReqAlerts     = 0; // Stats: Number of request alerts
 ReqBound      = 0; // Stats: Number of requests bound
 ReqCancels    = 0; // Stats: Number of request Finished()+cancel
 ReqCount      = 0; // Stats: Number of requests (total)
 ReqFinForce   = 0; // Stats: Number of request Finished()+forced
 ReqFinished   = 0; // Stats: Number of request Finished()
 ReqGets       = 0; // Stats: Number of requests -> GetRequest()
 ReqPrepErrs   = 0; // Stats: Number of request prepare errors
 ReqProcs      = 0; // Stats: Number of requests -> ProcessRequest()
 ReqRedir      = 0; // Stats: Number of request redirects
 ReqRelBuf     = 0; // Stats: Number of request -> RelRequestBuff()
 ReqStalls     = 0; // Stats: Number of request stalls
 RspBad        = 0; // Stats: Number of invalid responses
 RspCallBK     = 0; // Stats: Number of request callbacks
 RspData       = 0; // Stats: Number of data    responses
 RspErrs       = 0; // Stats: Number of error   responses
 RspFile       = 0; // Stats: Number of file    responses
 RspReady      = 0; // Stats: Number of ready   responses
 RspStrm       = 0; // Stats: Number of stream  responses
 RspUnRdy      = 0; // Stats: Number of unready responses
 SsiErrs       = 0; // Stats: Number of SSI detected errors
 ResAdds       = 0; // Stats: Number of resource additions
 ResRems       = 0; // Stats: Number of resource removals
 }

◆ ~XrdSsiStats()

XrdSsiStats::~XrdSsiStats ( )

inline

Definition at line 73 of file XrdSsiStats.hh.

73 {}

Member Function Documentation

◆ setFS()

void XrdSsiStats::setFS ( XrdSfsFileSystem * fsp )

inline

Definition at line 68 of file XrdSsiStats.hh.

68 {fsP = fsp;}

Referenced by XrdSfsGetFileSystem2().

Here is the caller graph for this function:

◆ Stats()

int XrdSsiStats::Stats	(	char *	buff,
		int	blen
	)

Definition at line 87 of file XrdSsiStats.cc.

 {
    static const char statfmt[] = "<stats id=\"ssi\"><err>%d</err>"
    "<req>"
    "<bytes>%lld</bytes><maxsz>%lld</maxsz><cnt>%d</cnt>"
    "<bnd>%d</bnd><rdr>%d</rdr><dly>%d</dly>"
    "<ab>%d</ab><proc>%d</proc><gets>%d</gets>"
    "<relb>%d</relb><al>%d</al><fin>%d</fin>"
    "<can>%d</can><finf>%d</finf><perr>%d</perr>"
    "</req><rsp>"
    "<bad>%d</bad><cbk>%d</cbk><data>%d</data><errs>%d</errs>"
    "<file>%d</file><str>%d</str><rdy>%d</rdy><unr>%d</unr>"
    "<mdb>%lld</mdb"
    "</rsp><res>"
    "<add>%d</add><rem>%d</rem>"
    "</res></stats>";
 //                                   1 2 3 4 5 6 7 8
    static const long long LLMax = 0x7fffffffffffffffLL;
    static const int       INMax = 0x7fffffff;
    int len;
  
 // If no buffer, caller wants the maximum size we will generate
 //
    if (!buff)
       {char dummy[4096]; // Almost any size will do
        len = snprintf(dummy, sizeof(dummy), statfmt, INMax,
        /*<bytes>*/    LLMax, LLMax, INMax,
        /*<bnd>*/      INMax, INMax, INMax,
        /*<ab>*/       INMax, INMax, INMax,
        /*<relb>*/     INMax, INMax, INMax,
        /*<can>*/      INMax, INMax, INMax,
        /*<bad>*/      INMax, INMax, INMax, INMax,
        /*<file>*/     INMax, INMax, INMax, INMax, LLMax,
        /*<res>*/      INMax, INMax);
        return len + (fsP ? fsP->getStats(0,0) : 0);
       }
  
 // Format our statistics
 //
    statsMutex.Lock();
    len = snprintf(buff, blen, statfmt, SsiErrs,
                   ReqBytes,   ReqMaxsz,    ReqCount,
                   ReqBound,   ReqRedir,    ReqStalls,
                   ReqAborts,  ReqProcs,    ReqGets,
                   ReqRelBuf,  ReqAlerts,   ReqFinished,
                   ReqCancels, ReqFinForce, ReqPrepErrs,
                   RspBad,     RspCallBK,   RspData,      RspErrs,
                   RspFile,    RspStrm,     RspReady,     RspUnRdy,
                   RspMDBytes, ResAdds,     ResRems);
    statsMutex.UnLock();
  
 // Now include filesystem statistics and return
 //
    if (fsP) len += fsP->getStats(buff+len, blen-len);
    return len;
 }