XrdOssArcFSMon Class Reference

#include <XrdOssArcFSMon.hh>

Inheritance diagram for XrdOssArcFSMon:

Collaboration diagram for XrdOssArcFSMon:

Public Member Functions
	XrdOssArcFSMon ()
	~XrdOssArcFSMon ()
void	DoIt () override
bool	Init (const char *path, long long fVal, int fsupdt)
bool	Permit (XrdOssArcBackupTask *btP)
void	Release (size_t bytes)
Public Member Functions inherited from XrdJob
	XrdJob (const char *desc="")
virtual	~XrdJob ()

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

Detailed Description

Definition at line 41 of file XrdOssArcFSMon.hh.

Constructor & Destructor Documentation

XrdOssArcFSMon()

XrdOssArcFSMon::XrdOssArcFSMon ( )

inline

Definition at line 53 of file XrdOssArcFSMon.hh.

: fs_inBkp(0) {}

~XrdOssArcFSMon()

XrdOssArcFSMon::~XrdOssArcFSMon ( )

inline

Definition at line 54 of file XrdOssArcFSMon.hh.

{}

Member Function Documentation

DoIt()

void XrdOssArcFSMon::DoIt ( )

overridevirtual

Implements XrdJob.

Definition at line 93 of file XrdOssArcFSMon.cc.

{
   TraceInfo("FSMon", 0);
   XrdSysMutexHelper rmHelp(rmMutex);
   size_t tmpSize, tmpFree;
 
// Update file system  statistics
//
   if (!(tmpSize = getFSpace(tmpFree, fs_Path)))
      Elog.Emsg("FSMon", errno, "filesystem info for", fs_Path);
      else {fs_Size = tmpSize;
            fs_Free = tmpFree;
            fs_MaxUsed = fs_Size - fs_MinFree;
            fs_inUse   = fs_Size - fs_Free;
           }
 
// Perform some debugging
//
   DEBUG("FS info: Size="<<fs_Size<<" Free="<<fs_Free<<" Used="<<fs_inUse<<
         " Commit="<<fs_inBkp<<" Avail="<<
         (fs_Free <= fs_inBkp ? 0 : fs_Free - fs_inBkp));
 
// reschedule ourselves
//
   schedP->Schedule(this, time(0)+fs_Updt);
}

References DEBUG, XrdOssArcGlobals::Elog, XrdSysError::Emsg(), XrdOssArcGlobals::schedP, XrdScheduler::Schedule(), and TraceInfo.

Here is the call graph for this function:

Init()

bool XrdOssArcFSMon::Init	(	const char *	path,
		long long	fVal,
		int	fsupdt
	)

Definition at line 141 of file XrdOssArcFSMon.cc.

{
   char buff[1024], HSb1[16], HSb2[16], HSb3[16];
 
// Save the update frequescy
//
   fs_Updt = fsupdt;
 
// The first step is to get the relevant filesystem statistics we need
//
   if (!(fs_Size = getFSpace(fs_Free, path)))
      {Elog.Emsg("FSMon", errno, "filesystem info for", path);
       return false;
      }
 
// Calculate the minimum free space allowed (if fval < 0 -> percentage)
//
   if (fVal < 0) fs_MinFree = fs_Size*(static_cast<size_t>(-fVal))/100;
      else {fs_MinFree = static_cast<size_t>(fVal);
            if (fs_MinFree >= fs_Size)
               {snprintf(buff, sizeof(buff), "Minimum free space allowed (%s) "
                              ">= size of filesystem (%s) at",
                               HSZ(fs_MinFree, HSb1), HSZ(fs_Size, HSb2));
               Elog.Emsg("FSMon", buff, path);
               return false;
              }
           }
 
// Calculate the maximum amount of usage and set the filesystem path
//
   fs_MaxUsed = fs_Size - fs_MinFree;
   fs_inUse   = fs_Size - fs_Free;
   fs_Path = path;
 
// Check if we don't have enough free space at startup time
//
   if (fs_Free < fs_MinFree)
      {snprintf(buff, sizeof(buff), "Filesystme free space (%s) < minimum "
                      "allowed (%s) at ",
                       HSZ(fs_Free, HSb1), HSZ(fs_MinFree, HSb2));     
       Elog.Say("Config warning: ", buff, path);
      } else {
       snprintf(buff, sizeof(buff), "Filesystme free space: %s; "
                      "minimum allowed: %s; remaining: %s at ",
                      HSZ(fs_Free, HSb1), HSZ(fs_MinFree,HSb2),
                      HSZ(fs_Free-fs_MinFree, HSb3));
       Elog.Say("Config outcome: ", buff, path);
      }
 
// Start automatic filesystem updates
//
   schedP->Schedule(this, time(0)+fs_Updt);
 
// All done
//
   return true;     
}

References XrdOssArcGlobals::Elog, XrdSysError::Emsg(), HSZ, XrdSysError::Say(), XrdOssArcGlobals::schedP, and XrdScheduler::Schedule().

Referenced by XrdOssArcConfig::Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

Permit()

bool XrdOssArcFSMon::Permit

(

XrdOssArcBackupTask *

btP

)

Definition at line 203 of file XrdOssArcFSMon.cc.

{
// Check if we can permit this request or the caller will need to wait
//
   rmMutex.Lock();
   if ((fs_inUse + fs_inBkp + btP->numBytes) <= fs_MaxUsed)
      {fs_inBkp += btP->numBytes;
       btP->relSpace = true;
       rmMutex.UnLock();
       return true;
      }
 
// There is not enough space to permit the request. Place it on the re-drive
// queue and tell the call to wait.
//
   btWaitQ.push_back(btP);
   rmMutex.UnLock();
   return false;
}

References XrdOssArcBackupTask::numBytes, and XrdOssArcBackupTask::relSpace.

Referenced by XrdOssArcBackupTask::BkpXeq().

Here is the caller graph for this function:

Release()

void XrdOssArcFSMon::Release

(

size_t

bytes

)

Definition at line 227 of file XrdOssArcFSMon.cc.

{
   XrdSysMutexHelper mHelp(rmMutex);
   size_t tmpSize, tmpFree;
   int n;
 
// Release the number of bytes previously reserved
//
   if (bytes >= fs_inBkp) fs_inBkp = 0;
      else fs_inBkp -= bytes;
 
// Update file system  statistics
//
   if (!(tmpSize = getFSpace(tmpFree, fs_Path)))
      Elog.Emsg("FSMon", errno, "filesystem info for", fs_Path);
      else {fs_Size = tmpSize;
            fs_Free = tmpFree;
            fs_MaxUsed = fs_Size - fs_MinFree;
            fs_inUse   = fs_Size - fs_Free;
           }
 
// If a backup is waiting for space, see if it can proceed
//
   size_t nTot = 0;
   while(!btWaitQ.empty())
      {XrdOssArcBackupTask* btP = btWaitQ.front();
       if ((fs_inUse + fs_inBkp + btP->numBytes + nTot) <= fs_MaxUsed)
          {nTot += btP->numBytes;
           btP->btSem.Post();
           btWaitQ.pop_front();
          } else break;
      }
 
// Issue message if there are still queued backups
//
   if ((n = btWaitQ.size()))
      {char buff[1024], HSb1[16], HSb2[16];
       size_t free = (fs_Free <= fs_inBkp ? 0 : fs_Free - fs_inBkp); 
       snprintf(buff, sizeof(buff), "Insufficient free space (%s < %s); "
                      "%d backup(s) still pending!",
                       HSZ(free, HSb1), HSZ(fs_MinFree, HSb2), n);
       Elog.Emsg("FSMon", buff);
      }
}

References XrdOssArcBackupTask::btSem, XrdOssArcGlobals::Elog, XrdSysError::Emsg(), HSZ, XrdOssArcBackupTask::numBytes, and XrdSysSemaphore::Post().

Referenced by XrdOssArcBackupTask::~XrdOssArcBackupTask().

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:

• XrdOssArcFSMon.hh
• XrdOssArcFSMon.cc