Public Member Functions | Public Attributes | Private Member Functions | Private Attributes

hsm_FHrelc Class Reference
[Classes for managing object list]

#include <hsm_FHrelc.h>

Inheritance diagram for hsm_FHrelc:
Inheritance graph
[legend]
Collaboration diagram for hsm_FHrelc:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 hsm_FHrelc (bool &a_running, ivd_Time32_t a_releaseInterval, UInt32_t a_lowWaterMark, UInt32_t a_highWaterMark, UInt32_t a_criticalWaterMark, ivd_Time32_t a_migRetentionTime, ivd_Time32_t a_recRetentionTime, ivd_FileSize_t a_smalestFileSize)
virtual ~hsm_FHrelc ()
void Shutdown ()
 thread part
void WakeUp (void)
virtual void Run (void *arg)
ivd_RecordIDX_t Append (hdb_ReleaseCand_t &a_rc, const string &a_name, ivd_FileSize_t a_size, bool a_migrate, fio_Transaction &a_trans, hdb_circList_e &a_circList)
 append FH
ivd_RecordIDX_t Append (hsm_FileHeader *a_fh_p, bool a_migrate, fio_Transaction &a_trans)
void Release (hsm_FileHeader *a_fh_p, fio_Transaction &a_trans)
 release record at a_idx index, fill it with zerroes and release relation fileID hsmID
UInt32_t GetNumTruncations ()
void Reconfigure (ivd_Time32_t a_CfgReleaseInterval, UInt32_t a_CfgLowWaterMark, UInt32_t a_CfgHighWaterMark, UInt32_t a_CfgCriticalWaterMark, ivd_Time32_t a_CfgMigRetentionTime, ivd_Time32_t a_CfgRecallRetentionTime, ivd_FileSize_t a_CfgMinFileSize)
ivd_Time32_t GetWakeUpTime ()
void SpaceCheck ()

Public Attributes

bool & m_running
 outside variable that set when thread is down
bool m_sleepingThread
bool m_goDown
bool m_migDisabled
cmn_Mutex m_thread_x
cmn_Condition m_thread_c
ivd_Time32_t m_releaseInterval
UInt32_t m_100_lowWaterMark
 percent of disk avail when truncatin of release candidate file stopped
UInt32_t m_100_highWaterMark
 percent of disk avail when force truncation stopped or normal truncation startted
UInt32_t m_100_criticalWaterMark
 percent of disk avail when force truncation started
ivd_FileSize_t m_availBytesAtHigh
ivd_FileSize_t m_availBytesAtLow
ivd_FileSize_t m_availBytesAtCrit
ivd_FileSize_t m_availBytesBetweenCritHigh
ivd_Time32_t m_logTimeCWM
ivd_Time32_t m_logTimeHWM
ivd_FileSize_t m_smalestFileSize
 The size of the file that are not released until critical WM occured and nothing else is to released.
hsm_ReleaseCandRec m_smallRelCandRec
hsm_ReleaseCandRec m_recalRelCandRec
hsm_ReleaseCandRec m_migrtRelCandRec
UInt64_t m_sizeOfApendedFiles
fio_Transactionm_trans
cmn_Mutex m_relCandRec_x
 Append, release and truncation concure to RelCandRec.
cmn_File m_fileSystem
UInt64_t m_fsBytesTotal
 total bytes of FS, checked if equal at every fs info
 log_CLASSID_m

Private Member Functions

void Init ()
void SetAvailBytes ()
void TruncationCheck ()
ivd_FileSize_t Truncate (hsm_ReleaseCandRec &a_relCandObj)
hdb_circList_e ChoiceOldestList (bool a_critical)

Private Attributes

int m_eventNum
UInt32_t m_countTruncations
UInt32_t m_countTruncFiles
UInt32_t m_countTruncMigFiles
UInt32_t m_countTruncRelFiles
UInt32_t m_countTruncSmlFiles
ivd_FileSize_t m_sizeTruncFiles
ivd_FileSize_t m_sizeTruncMigFiles
ivd_FileSize_t m_sizeTruncRelFiles
ivd_FileSize_t m_sizeTruncSmlFiles
ivd_Time32_t m_wakeUpTime
ivd_FileID_t m_guardian
ivd_FileID_t m_smallGuardian

Detailed Description

Definition at line 106 of file hsm_FHrelc.h.


Constructor & Destructor Documentation

hsm_FHrelc::hsm_FHrelc ( bool &  a_running,
ivd_Time32_t  a_releaseInterval,
UInt32_t  a_lowWaterMark,
UInt32_t  a_highWaterMark,
UInt32_t  a_criticalWaterMark,
ivd_Time32_t  a_migRetentionTime,
ivd_Time32_t  a_recRetentionTime,
ivd_FileSize_t  a_smalestFileSize 
)

Definition at line 219 of file hsm_FHrelc.cpp.

References dbg_LOW, g_fs_api_p, ivd_FileSystemAPI::GetRootPath(), log_DBG_m, log_FUNC_m, m_countTruncations, m_countTruncFiles, m_countTruncMigFiles, m_countTruncRelFiles, m_countTruncSmlFiles, m_sizeTruncFiles, m_sizeTruncMigFiles, m_sizeTruncRelFiles, and m_sizeTruncSmlFiles.

        :
        m_running(a_running),
        m_sleepingThread(false),
        m_goDown(false),
        m_migDisabled(false),
        m_thread_c(&m_thread_x),
        m_releaseInterval(a_releaseInterval),
        m_100_lowWaterMark(100 - a_lowWaterMark),
        m_100_highWaterMark(100 - a_highWaterMark),
        m_100_criticalWaterMark(100 - a_criticalWaterMark),
        m_logTimeCWM(0),
        m_logTimeHWM(0),
        m_smalestFileSize(a_smalestFileSize),
        m_smallRelCandRec(*g_RelCandSmall_p, 0),
        m_recalRelCandRec(*g_RelCandRecal_p, a_recRetentionTime),
        m_migrtRelCandRec(*g_RelCandMigrt_p, a_migRetentionTime),
        m_sizeOfApendedFiles(0),
        m_trans(*g_hsmDB_p->GetTransObj()),
        m_guardian(0),
        m_smallGuardian(0)
{
    log_FUNC_m(hsm_FHrelc);
    log_DBG_m(dbg_LOW, "Create release candidate list. RootPath=" << 
        g_fs_api_p->GetRootPath() << endl <<
        "-----------------------------------------------------------------------" << endl <<
        "ReleaseInterval " << setw(4) << a_releaseInterval << 
        "\tCritWM " << setw(4) << a_criticalWaterMark << 
        "\tHighWM " << setw(4) << a_highWaterMark <<
        "\tLowWM  " << setw(4) << a_lowWaterMark << endl <<
        "MinFileSize " << setw(6) << a_smalestFileSize << 
        "\tMigRetTime " << setw(6) << a_migRetentionTime <<
        "\tRclRetTime " << setw(6)<< a_recRetentionTime << endl <<
        "-----------------------------------------------------------------------");
    m_countTruncFiles = m_countTruncMigFiles = m_countTruncRelFiles = m_countTruncSmlFiles = 0;
    m_sizeTruncFiles  = m_sizeTruncMigFiles  = m_sizeTruncRelFiles  = m_sizeTruncSmlFiles = 0;
    m_countTruncations = 0;
}

Here is the call graph for this function:

hsm_FHrelc::~hsm_FHrelc (  )  [virtual]

Definition at line 268 of file hsm_FHrelc.cpp.

References g_hsmDB_p, log_FUNC_m, m_trans, and fio_DataBase::ReleaseTransObj().

{
    // release transaction
    g_hsmDB_p->ReleaseTransObj(m_trans);
    log_FUNC_m(~hsm_FHrelc);
}

Here is the call graph for this function:


Member Function Documentation

ivd_RecordIDX_t hsm_FHrelc::Append ( hdb_ReleaseCand_t a_rc,
const string &  a_name,
ivd_FileSize_t  a_size,
bool  a_migrate,
fio_Transaction a_trans,
hdb_circList_e a_circList 
)

append FH

Definition at line 306 of file hsm_FHrelc.cpp.

References hsm_ReleaseCandRec::Append(), dbg_NORM, IsPatternMatch(), log_DBG_m, log_FUNC_m, log_NOTE_m, m_migrtRelCandRec, m_recalRelCandRec, m_relCandRec_x, m_sizeOfApendedFiles, m_smalestFileSize, and m_smallRelCandRec.

Referenced by hsm_FileHeader::AddToReleaseCanList(), Append(), hsm_FileHeader::CompleteMigIsDone(), hsm_FileHeader::Recalled(), and Truncate().

                                                                  {
    log_FUNC_m(Append);

    if (a_size == 0) {
        log_NOTE_m("Won't append to release candidate list (file size = 0): " << a_name);
        return 0;
    }

    if (IsPatternMatch(a_name)) {
        log_DBG_m(dbg_NORM, "Won't append to release candidate list (file match in exclude list): " << a_name);
        return 0;
    }

    a_circList = clNoList;
    ivd_RecordIDX_t idx = 0;

    cmn_MutexLock l(m_relCandRec_x);

    if (a_size < m_smalestFileSize) {
        idx = m_smallRelCandRec.Append(a_rc, a_trans);
        a_circList = clSmall;
    }
    else if (a_migrate) {
        idx = m_migrtRelCandRec.Append(a_rc, a_trans);
        a_circList = clMigration;
    }
    else {
        idx = m_recalRelCandRec.Append(a_rc, a_trans);
        a_circList = clRecall;
    }
    m_sizeOfApendedFiles += a_size;
    log_DBG_m(dbg_NORM, "File append to RCL. a_size: " << a_size 
                    <<  ", m_sizeOfApendedFiles: " << m_sizeOfApendedFiles);
    return idx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_RecordIDX_t hsm_FHrelc::Append ( hsm_FileHeader a_fh_p,
bool  a_migrate,
fio_Transaction a_trans 
)

Definition at line 349 of file hsm_FHrelc.cpp.

References Append(), g_File2hdbID_p, hsm_FileHeader::GetFileID(), hsm_FileHeader::GetFileSize(), hsm_FileHeader::GetFName(), hsm_FileHeader::GetfType(), hsm_FileHeader::GetInode(), hsm_FileHeader::GetNameOwnIdx(), log_FUNC_m, hsm_ListPos::SetCircList(), and fio_RelFile::WriteRec().

                                                              {
    
    log_FUNC_m(Append);

    hdb_ReleaseCand_t rc(a_fh_p->GetfType(),
                         a_fh_p->GetNameOwnIdx(),  // nameOwnerIdx
                         a_fh_p->GetInode(),
                         a_fh_p->GetFileID());


    hdb_circList_e  circList = clNoList;
    ivd_RecordIDX_t idx = Append(   rc, 
                                    a_fh_p->GetFName(), 
                                    a_fh_p->GetFileSize(), 
                                    a_migrate, 
                                    a_trans, 
                                    circList);

    a_fh_p->SetCircList(circList, idx);    
    
    // if entry is file then store fileID vs. HSMDB release candidate index relationship
    hdb_file2hdbID_t file2hdbID(a_fh_p->GetNameOwnIdx(), circList, idx);
    
    g_File2hdbID_p->WriteRec(a_fh_p->GetFileID(), &file2hdbID, 1, &a_trans);
    
    return idx;
}

Here is the call graph for this function:

hdb_circList_e hsm_FHrelc::ChoiceOldestList ( bool  a_critical  )  [private]

Definition at line 698 of file hsm_FHrelc.cpp.

References clNoList, dbg_DETAIL, hdb_ReleaseCand_t::fileID, hsm_ReleaseCandRec::GetRefRleaseCandRec(), hsm_ReleaseCandRec::GetRemoveTime(), log_DBG_m, log_FUNC_m, m_guardian, m_migrtRelCandRec, m_recalRelCandRec, m_smallGuardian, m_smallRelCandRec, NULL, and cmn_Time::Time2hms().

Referenced by TruncationCheck().

                                                           {
    log_FUNC_m(ChoiceOldestList);

    hdb_circList_e list = clNoList;

    ivd_Time32_t removeTime = m_migrtRelCandRec.GetRemoveTime();
    cmn_Time remTime(removeTime, 0);
    log_DBG_m(dbg_DETAIL, " Migration remTime " << remTime.Time2hms());
    if (removeTime != 0) { // candidate from mig list
        list = clMigration;
    }        

    // set from recal list if is older
    ivd_Time32_t recalRemTime = m_recalRelCandRec.GetRemoveTime();
    cmn_Time recTime(recalRemTime, 0);
    log_DBG_m(dbg_DETAIL, " Recall remTime " << recTime.Time2hms());
    if (  (  removeTime   == 0
          && recalRemTime != 0)
       ||
          (  recalRemTime != 0 
          && recalRemTime < removeTime)) { 
        if ((m_guardian != 0) 
            && (m_guardian == m_recalRelCandRec.GetRefRleaseCandRec().fileID)) {
            log_DBG_m(dbg_DETAIL, "Skipping recall-relCandList. "
                "Been through whole list in this run (" << m_guardian << ").");
        } 
        else {
            removeTime = recalRemTime;
            list = clRecall;
        }
    }    

    // the oldest list is choiced or no elements in lists
    if (!a_critical) {
        if (  list != clNoList 
          && removeTime > time(NULL)) {
            log_DBG_m(dbg_DETAIL, " No or not enought old files.  list =" << list 
                                   << " removeTime = " << removeTime);
            return clNoList;  // no more enought old files
        }
    } // if stil not enought space on disk then remove small files too.
    else if (list == clNoList && m_smallRelCandRec.GetRemoveTime() > 0) {
        if ((m_smallGuardian != 0)
            && (m_smallGuardian == m_smallRelCandRec.GetRefRleaseCandRec().fileID)) {
            log_DBG_m(dbg_DETAIL, "Skipping small-relCandList. "
                "Been through whole list in this run (" << m_smallGuardian << ").");
        } 
        else {
            list = clSmall;
        }
    }
    cmn_Time newestTime(removeTime, 0);
    log_DBG_m(dbg_DETAIL, " Choiced list is " << list << " Newest removeTime " << newestTime.Time2hms());
    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UInt32_t hsm_FHrelc::GetNumTruncations (  )  [inline]

Definition at line 206 of file hsm_FHrelc.h.

References m_countTruncations.

Referenced by i_HSM_i::GetInfo(), and i_HSM_i::ShowStatus().

{ return m_countTruncations;};

Here is the caller graph for this function:

ivd_Time32_t hsm_FHrelc::GetWakeUpTime (  )  [inline]

Definition at line 215 of file hsm_FHrelc.h.

References m_wakeUpTime.

Referenced by i_HSM_i::GetInfo(), and i_HSM_i::ShowStatus().

{return m_wakeUpTime;};

Here is the caller graph for this function:

void hsm_FHrelc::Init (  )  [private]

Definition at line 277 of file hsm_FHrelc.cpp.

References dbg_NORM, g_fs_api_p, ivd_FileSystemAPI::GetRootPath(), log_DBG_m, log_FUNC_m, m_fileSystem, SetAvailBytes(), and cmn_File::SetFullPath().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::Reconfigure ( ivd_Time32_t  a_CfgReleaseInterval,
UInt32_t  a_CfgLowWaterMark,
UInt32_t  a_CfgHighWaterMark,
UInt32_t  a_CfgCriticalWaterMark,
ivd_Time32_t  a_CfgMigRetentionTime,
ivd_Time32_t  a_CfgRecallRetentionTime,
ivd_FileSize_t  a_CfgMinFileSize 
)

Definition at line 933 of file hsm_FHrelc.cpp.

References dbg_LOW, g_fs_api_p, ivd_FileSystemAPI::GetRootPath(), log_DBG_m, log_FUNC_m, m_100_criticalWaterMark, m_100_highWaterMark, m_100_lowWaterMark, m_fileSystem, m_logTimeCWM, m_logTimeHWM, m_migrtRelCandRec, m_recalRelCandRec, m_releaseInterval, m_smalestFileSize, hsm_ReleaseCandRec::Reconfigure(), SetAvailBytes(), and cmn_File::SetFullPath().

Referenced by i_HSM_i::Reconfigure().

                                                              {
    log_FUNC_m(Reconfigure);

    m_releaseInterval   = a_CfgReleaseInterval;
    m_100_lowWaterMark  = 100 - a_CfgLowWaterMark;
    m_100_highWaterMark = 100 - a_CfgHighWaterMark;
    m_100_criticalWaterMark = 100 - a_CfgCriticalWaterMark;
    m_smalestFileSize   = a_CfgMinFileSize;
    m_recalRelCandRec.Reconfigure(a_CfgRecallRetentionTime);
    m_migrtRelCandRec.Reconfigure(a_CfgMigRetentionTime);
    
    log_DBG_m(dbg_LOW, "Reconfigure release candidate list. RootPath=" << 
        g_fs_api_p->GetRootPath() << endl <<
        "-----------------------------------------------------------------------" << endl <<
        "ReleaseInterval " << setw(4) << a_CfgReleaseInterval << 
        "\tCritWM " << setw(4) << a_CfgCriticalWaterMark << 
        "\tHighWM " << setw(4) << a_CfgHighWaterMark <<
        "\tLowWM  " << setw(4) << a_CfgLowWaterMark << endl <<
        "MinFileSize " << setw(6) << a_CfgMinFileSize << 
        "\tMigRetTime " << setw(6) << a_CfgMigRetentionTime <<
        "\tRclRetTime " << setw(6)<< a_CfgRecallRetentionTime << endl <<
        "-----------------------------------------------------------------------");
    m_fileSystem.SetFullPath(g_fs_api_p->GetRootPath());
    SetAvailBytes();

    m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::Release ( hsm_FileHeader a_fh_p,
fio_Transaction a_trans 
)

release record at a_idx index, fill it with zerroes and release relation fileID hsmID

Definition at line 381 of file hsm_FHrelc.cpp.

References clMigration, clRecall, clSmall, g_File2hdbID_p, hsm_FileHeader::GetFileID(), hsm_ListPos::GetRelCandCircList(), log_FUNC_m, m_guardian, m_migrtRelCandRec, m_recalRelCandRec, m_relCandRec_x, m_smallGuardian, m_smallRelCandRec, hsm_ReleaseCandRec::Release(), and fio_RelFile::WriteRec().

Referenced by hsm_FileHeader::RemoveFromRelCandList().

                                                   {
    log_FUNC_m(Release);

    // Guardian change is made under general-inode lock.
    ivd_FileID_t fileID = a_fh_p->GetFileID();
    if (m_smallGuardian == fileID) {
        m_smallGuardian = 0;
    } 
    else if (m_guardian == fileID) {
        m_guardian = 0;
    }

    // remove relation fileID hsmID
    hdb_file2hdbID_t file2hdbID; // default constructor fill it with zerroes
    g_File2hdbID_p->WriteRec(a_fh_p->GetFileID(), &file2hdbID, 1, &a_trans);    

    cmn_MutexLock l(m_relCandRec_x);
    switch (a_fh_p->GetRelCandCircList()) {
    case clMigration : 
        m_migrtRelCandRec.Release(a_fh_p, a_trans);
        break;
    case clRecall : 
        m_recalRelCandRec.Release(a_fh_p, a_trans);
        break;
    case clSmall :
        m_smallRelCandRec.Release(a_fh_p, a_trans);
        break;
    default:
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::Run ( void *  arg  )  [virtual]

Wait MinWaitTime or wait to broadcast

Reimplemented from cmn_Thread.

Definition at line 435 of file hsm_FHrelc.cpp.

References dbg_DETAIL, dbg_NORM, cmn_File::GetFullPathRef(), Init(), log_DBG_m, log_FUNC_m, m_fileSystem, m_goDown, m_migDisabled, m_releaseInterval, m_running, m_sleepingThread, m_thread_c, m_thread_x, m_wakeUpTime, NULL, cmn_Time::Time2hms(), cmn_Condition::TimedWait(), and TruncationCheck().

                             {
    log_FUNC_m(Run);
    m_running = true;
    Init();
    log_DBG_m(dbg_NORM, "Release cand. thread is starting up. WM checked on mount point " 
                          << m_fileSystem.GetFullPathRef());

    while (m_goDown == false) {

        try {
            m_wakeUpTime = time(NULL) + m_releaseInterval;
            
            cmn_Time cmntimewakeup(m_wakeUpTime, 0);                                   
            log_DBG_m(dbg_DETAIL, "Release cand. thread will wake up at latest " << cmntimewakeup.Time2hms());
            
            {
                cmn_MutexLock l(m_thread_x);

                m_sleepingThread = true;
                // int retv = m_thread_c.TimedWait(m_earliestWakeUpTime);
                m_thread_c.TimedWait(m_wakeUpTime);
            }

            if (m_goDown) {
                break;
            }
            if (m_migDisabled) { 
                continue;
            }

            m_sleepingThread = false;
            TruncationCheck();    
        }
        catch (ivd_Error &ie) {
            log_DBG_m(dbg_DETAIL, "RelCndLThread return ERROR " << ie);
        }
        catch (ivd_SysError &ise) {
            log_DBG_m(dbg_DETAIL, "RelCndLThread WILL GO_DOWN on ERROR " << ise);
            break;
        }
        catch (...) {
            log_DBG_m(dbg_DETAIL, "RelCndListMgrThrd WILL GO_DOWN after thrown ERROR.");
            break;
        }
    }
    log_DBG_m(dbg_DETAIL, "Release cand. thread IS_DOWN.");
    m_running = false;
}

Here is the call graph for this function:

void hsm_FHrelc::SetAvailBytes (  )  [private]

Definition at line 287 of file hsm_FHrelc.cpp.

References ivd_FileSystemSize_t::bytesTotal, cmn_File::GetFileSystemSize(), m_100_criticalWaterMark, m_100_highWaterMark, m_100_lowWaterMark, m_availBytesAtCrit, m_availBytesAtHigh, m_availBytesAtLow, m_availBytesBetweenCritHigh, m_fileSystem, and m_fsBytesTotal.

Referenced by Init(), and Reconfigure().

                               {
    ivd_FileSystemSize_t a_info;  
    m_fileSystem.GetFileSystemSize(a_info);
    // fix bug 505
    m_fsBytesTotal = a_info.bytesTotal;
    // end
    m_availBytesAtHigh = ((ivd_FileSize_t)m_100_highWaterMark     * a_info.bytesTotal) / 100;   
    m_availBytesAtLow  = ((ivd_FileSize_t)m_100_lowWaterMark      * a_info.bytesTotal) / 100;
    m_availBytesAtCrit = ((ivd_FileSize_t)m_100_criticalWaterMark * a_info.bytesTotal) / 100;
    m_availBytesBetweenCritHigh = (m_availBytesAtHigh + m_availBytesAtCrit) / 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::Shutdown (  ) 

thread part

Definition at line 416 of file hsm_FHrelc.cpp.

References log_FUNC_m, m_goDown, and WakeUp().

Referenced by hsm_Containers::Stop().

                          {
    log_FUNC_m(Shutdown);
    
    m_goDown = true;
    WakeUp();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::SpaceCheck (  ) 

Definition at line 968 of file hsm_FHrelc.cpp.

References ivd_FileSystemSize_t::bytesAvail, ivd_FileSystemSize_t::bytesTotal, dbg_DETAIL, dbg_NORM, cmn_File::GetFileSystemSize(), hsm_eventNum_c, log_DBG_m, log_FUNC_m, log_NOTE_m, m_availBytesAtCrit, m_eventNum, m_fileSystem, m_fsBytesTotal, m_logTimeCWM, m_logTimeHWM, m_relCandRec_x, m_sizeOfApendedFiles, m_sleepingThread, and WakeUp().

Referenced by hsm_FileHeader::Event(), and hsm_FileHeader::EventOffline().

                            {
    log_FUNC_m(SpaceCheck);
    if (!(--m_eventNum) // check every hsm_eventNum_c number of events
       && !m_sleepingThread) { // Truncation already trigged
         // m_sleepingThread is not under mutex, does not matter if recently changed 
         // just wait for another hsm_eventNum_c of events.
        m_eventNum = hsm_eventNum_c;
        return;
    }
    m_eventNum = hsm_eventNum_c;
    // check the disk space usage
    ivd_FileSystemSize_t a_info;  
    m_fileSystem.GetFileSystemSize(a_info);
    // check if this is a same FS.
    if (m_fsBytesTotal != a_info.bytesTotal) {
        ostringstream sstr;
        sstr << " FS total bytes not match any more.  Previous " << m_fsBytesTotal
             << " now " << a_info.bytesTotal << "  Probably umount, SpaceCheck skipped.";
        log_NOTE_m(sstr.str());
        log_DBG_m(dbg_NORM, sstr.str());
        m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged
        return;
    }
    
    if ((ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit) {
        {
            cmn_MutexLock l(m_relCandRec_x);
            if (m_sizeOfApendedFiles < (a_info.bytesAvail / 8)) {
                log_DBG_m(dbg_DETAIL, "Not enought new data to release. "
                                << " m_sizeOfApendedFiles: " << m_sizeOfApendedFiles 
                                << ", bytes available / 8: " << (a_info.bytesAvail / 8));
                return;
            };
        }
        log_DBG_m(dbg_DETAIL, "Wake up release thread. FS available " <<  a_info.bytesAvail << " "
                           << (100 * a_info.bytesAvail / a_info.bytesTotal) << "%  "
                           << "  bytes at CWM " << m_availBytesAtCrit);
        WakeUp();
    }
    else {
        log_DBG_m(dbg_DETAIL, "RCT not waked up. bytesAvail < m_availBytesAtCrit "
                           << a_info.bytesAvail << " < " << m_availBytesAtCrit);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_FileSize_t hsm_FHrelc::Truncate ( hsm_ReleaseCandRec a_relCandObj  )  [private]

resolve FH owner using dirNode record got from DB

Definition at line 756 of file hsm_FHrelc.cpp.

References Append(), ivd_FS_File::Close(), hdb_ReleaseCand_t::dataSize, dbg_DETAIL, dbg_NORM, hsm_FileHeader::DecrRef(), ivd_FS_File::e_Cache, fio_Transaction::EndTransaction(), file, hdb_ReleaseCand_t::fileID, hdb_ReleaseCand_t::fileType, hsm_ReleaseCandRec::FindNextClearCurrRec(), g_File2hdbID_p, g_fs_api_p, g_hsm_FHCache_p, g_hsm_fhLock, g_NameOwner_p, hdb_ReleaseCand_t::generalInode, ivd_BaseException::GetError(), hsm_FHcache::GetFH(), hsm_InoObj::GetFileId(), hsm_FileHeader::GetFileSize(), GetInodeObj(), hsm_ReleaseCandRec::GetRefRleaseCandRec(), hsm_ReleaseCandRec::GetRemoveTime(), ivd_FileSystemAPI::GetRootPath(), hdbReadNameOwnRec(), hsmdbGetPath(), hsmGetDirFH(), ift_FILE, hsm_ReleaseCandRec::IsValid(), IVD_PRINT_ID_FS, ivd_USleep, log_DBG_m, log_FUNC_m, log_NOTE_m, m_countTruncFiles, m_guardian, m_relCandRec_x, m_sizeTruncFiles, m_smalestFileSize, m_smallGuardian, m_trans, hsm_FileHeader::MakePath(), hdb_DirNode_t::nameOwnIdx, hdb_ReleaseCand_t::nameOwnIdx, NULL, ivd_FS_File::Open(), path, fio_RelFileTrans::ReleaseVectorIdx(), hsm_FileHeader::RemoveFromRelCandList(), fio_Transaction::StartTransaction(), hsm_FileHeader::TruncateFile(), cmn_Mutex::Unlock(), fio_BasicString::Write2DB(), and fio_RelFile::WriteRec().

Referenced by TruncationCheck().

                                                                    {
//                          fio_Transaction    &trans) {

    hdb_ReleaseCand_t &relCandRec = a_relCandObj.GetRefRleaseCandRec();
    log_FUNC_m(Truncate);
    cmn_Time removeTime(a_relCandObj.GetRemoveTime());
    log_DBG_m(dbg_DETAIL, " Release candidate inode " 
                << IVD_PRINT_ID_FS(relCandRec.generalInode)    << endl
                << " NameOwnIdx " << relCandRec.nameOwnIdx     << endl 
                << " RemoveTime " << removeTime.Time2YMDhms() << endl
                << " Size       " << relCandRec.dataSize );

    hsm_FileHeader *fileOwnHdr = NULL; // file owner
    ivd_FileID_t    fileID = relCandRec.fileID;
    ivd_GenInode_t  inode  = relCandRec.generalInode;
    bool            locked = false;
//    bool        fileLocked = false;
    bool        fileBusy   = false;
    hdb_String      name;
    ivd_FileSize_t  truncSize = 0;
    ivd_FileSize_t  fileSize = 0;
    cmn_Path path;
    cmn_File file;
// NOTE 
    try {
        if (!g_hsm_fhLock.CanLockByID(inode)) { 
            // the File then it need to be truncate is active
            // it must be removed from release cand. list, so 
            // wait a while and try again 
            m_relCandRec_x.Unlock();  
            ivd_USleep(10000); // 10 mili sec
            return truncSize;
//            goto end3;
        }
        m_relCandRec_x.Unlock();  
        // reread record from file
        if (!a_relCandObj.IsValid()) {
            g_hsm_fhLock.UnLockByID(inode);
            return 0;        
        }
        
        locked = true;

        hdb_DirNode_t dir; // default const. it filled with zeroes
        ivd_RecordIDX_t dirIdx;
        // get name and owner from DB
        hdbReadNameOwnRec(relCandRec.nameOwnIdx, dirIdx, name, dir);

        hsm_FileHeader *fileHdr = g_hsm_FHCache_p->GetFH(inode);

        if (fileHdr != NULL) {  // file header is active  skip it
            log_NOTE_m("File is getting dirty in meantime. '" << fileHdr->MakePath() );
            m_trans.StartTransaction();
            fileHdr->RemoveFromRelCandList(m_trans);
            m_trans.EndTransaction();
            fileHdr->DecrRef(); // GetFH increment memberReference
            g_hsm_fhLock.UnLockByID(inode);
            return 0;
        }

        //HPUX - The file needs to be opened ( to be in the kernel cache )
        ivd_FS_File file(*g_fs_api_p,(g_fs_api_p->GetRootPath() + hsmdbGetPath(dir) + name));
        file.Open(ivd_FS_File::e_Cache);
        if (dir.nameOwnIdx != 0) { // file is not on mount point
            fileOwnHdr = hsmGetDirFH(dir);
        }

        hsm_InoObj *inodeObj = GetInodeObj(relCandRec.fileType, inode, fileID);
            //HPUX - Close file
            file.Close();

    
        hsm_FileHeader fh(fileOwnHdr, inodeObj ,name);
        if (fileOwnHdr != NULL) {
        // increment is perform inside hsmGetDirFH inside constructor or cache search
        // now is decrement
            fileOwnHdr->DecrRef(); // this directory is dereferenced by release candidate
        }

//     log_DBG_m(dbg_DETAIL, "release file " << rFHobj->GetFName() << 
//                              " size=" << rFHobj->GetFileSize());

        fileID = inodeObj->GetFileId();
        fileSize = fh.GetFileSize();
        try {
                fileSize = fh.TruncateFile();
                m_countTruncFiles++;
                truncSize += fileSize;
                m_sizeTruncFiles += fileSize;
        }
        catch(ivd_SysError &ise) {  // file was deleted or chaged name in mean time
            ostringstream sstr;
            sstr << " Truncation failed. Error: " <<  ise.GetError()
                << ", File: FID: " << fileID 
                << ", INO " << IVD_PRINT_ID_FS(inode)
                << ", name '" << name 
                << "' is BUSY. It is renamed, used or deleted.";

            log_DBG_m(dbg_NORM, sstr.str());
            if (ise.GetError() != ENOENT) {
                fileBusy = true;
            } 
            else {
                log_DBG_m(dbg_NORM, " INO " << IVD_PRINT_ID_FS(inode) 
                                << ", file " << name << " is DELETED, remove from recall-relCandList.");
            }
        }
    }
    catch (...) {
        log_NOTE_m("->ReleaseFiles catch an ERROR" 
                << " inode " << IVD_PRINT_ID_FS(inode)
                << " nameOwnIdx "  << relCandRec.nameOwnIdx);
    }

    m_trans.StartTransaction();

    // BUG 4287 "Open file is removed from release candidate list"
    // differ deletet files from busy.
    if (fileBusy) { // add FH to recall release list

        ivd_RecordIDX_t nameOwnIdx = relCandRec.nameOwnIdx; 

        // a_relCandObj will NOT BE VALID after FindNextClearCurrRec() call
        a_relCandObj.FindNextClearCurrRec(m_trans); 
        log_DBG_m(dbg_NORM, "file " << name << " is BUSY. Put on recall-relCandList.");
        hdb_ReleaseCand_t rc(ift_FILE, nameOwnIdx, inode, fileID);
        hdb_circList_e  circList;
        ivd_RecordIDX_t idx = Append(rc, name, fileSize, false, m_trans, circList);
        hdb_file2hdbID_t file2hdbID(nameOwnIdx, circList, idx); 
        g_File2hdbID_p->WriteRec(fileID, &file2hdbID, 1, &m_trans);    

        // Set guardian for preventing cycling (SSM Bug#1900).
        // Append moves to Recaled RelCand from Migrated, but not from Small.
        // NOTE! When guardian is set then new added files will not be processed in this loop
        // but after next time-out or when space check policy will be achive.
        if (fileSize < m_smalestFileSize) {
            if (m_smallGuardian == 0) {
                m_smallGuardian = fileID;
            }
        } 
        else {
            if (m_guardian == 0) {
                m_guardian = fileID;
            }
        }
    } 
    else {
        
        // remove it from ivd system
        if (relCandRec.nameOwnIdx > 0) {
            g_NameOwner_p->ReleaseVectorIdx(relCandRec.nameOwnIdx, 1, &m_trans);
        }
        ivd_RecordIDX_t nameIdx(0);
        ivd_VectorSize_t nameVecSize(0);
        name.erase();
        name.Write2DB(nameVecSize, nameIdx, m_trans);  // release name

        hdb_file2hdbID_t file2hdbID; // default constructor fill it with zerroes
        g_File2hdbID_p->WriteRec(fileID, &file2hdbID, 1, &m_trans);        
        // NOTE !!!! 
        // find next MUST be last sentance in transaction,
        // because it change relCandRec reference
        a_relCandObj.FindNextClearCurrRec(m_trans);
    }

    m_trans.EndTransaction();

    if (locked) {
        g_hsm_fhLock.UnLockByID(inode);
    }
    return truncSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::TruncationCheck (  )  [private]

Definition at line 486 of file hsm_FHrelc.cpp.

References ivd_FileSystemSize_t::bytesAvail, ivd_FileSystemSize_t::bytesTotal, ChoiceOldestList(), clMigration, clNoList, clRecall, clSmall, dbg_DETAIL, dbg_NORM, evt_WARNING, cmn_File::GetFileSystemSize(), if(), cmn_Mutex::Lock(), log_DBG_m, log_FUNC_m, log_NOTE_m, log_WriteEvent(), m_100_criticalWaterMark, m_100_highWaterMark, m_availBytesAtCrit, m_availBytesAtHigh, m_availBytesAtLow, m_countTruncations, m_countTruncFiles, m_countTruncMigFiles, m_countTruncRelFiles, m_countTruncSmlFiles, m_fileSystem, m_fsBytesTotal, m_goDown, m_guardian, m_logTimeCWM, m_logTimeHWM, m_migrtRelCandRec, m_recalRelCandRec, m_relCandRec_x, m_sizeOfApendedFiles, m_sizeTruncFiles, m_sizeTruncMigFiles, m_sizeTruncRelFiles, m_sizeTruncSmlFiles, m_smallGuardian, m_smallRelCandRec, NULL, Truncate(), and cmn_Mutex::Unlock().

Referenced by Run().

                                 {
    log_FUNC_m(TruncationCheck);
    // check the disk space usage
    ivd_FileSystemSize_t a_info;  
    m_fileSystem.GetFileSystemSize(a_info);

    // fix bug 505
    if (m_fsBytesTotal != a_info.bytesTotal) {
        ostringstream sstr;
        sstr << " FS total bytes not match any more.  Previous " << m_fsBytesTotal
             << " now " << a_info.bytesTotal << "  Probably umount, truncation skipped.";
        log_NOTE_m(sstr.str());
        log_DBG_m(dbg_NORM, sstr.str());
        m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged
        return;  // size of HSMFS changed, no truncation
    }
    // end 
    
    if ((ivd_FileSize_t)a_info.bytesAvail > m_availBytesAtHigh) {
        log_DBG_m(dbg_DETAIL, "FS available " <<  a_info.bytesAvail << " "
                           << (100 * a_info.bytesAvail / a_info.bytesTotal) << "%  "
                           << "  bytes at HWM " << m_availBytesAtHigh
                           << " " << m_100_highWaterMark << "%");
        m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged
        return;  // below HWM , no truncation / release
    }
    // if we reach here we are above HWM

    log_DBG_m(dbg_NORM, "Check for truncation (available). FS " << a_info.bytesAvail << " "
                       << (100 * a_info.bytesAvail / a_info.bytesTotal) << "%  "
                       << "  bytes at HWM " << m_availBytesAtHigh 
                       << " " << m_100_highWaterMark << "%"
                       << "  bytes at CWM " << m_availBytesAtCrit
                       << " " << m_100_criticalWaterMark << "%");

    ivd_Time32_t now = time(NULL);
    bool criticalWM = (ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit;

    UInt16_t spaceUsed = (ivd_FileSize_t)100 - 
                  (a_info.bytesAvail * (ivd_FileSize_t)100 / a_info.bytesTotal);

    if (criticalWM) {
        log_DBG_m(dbg_NORM, "CRITICAL WaterMark reached." );

        if (m_logTimeCWM + (15*60) < now) { // log each 15 minutes
            ostringstream sstr;
            sstr << spaceUsed << "% used, Critical Water Mark reached, "
                              << "starting forced release.";
            log_WriteEvent(evt_WARNING, sstr.str());
            m_logTimeCWM = now;
        }
    }
    else {
        log_DBG_m(dbg_NORM, "HIGH WaterMark reached." );

        if (m_logTimeHWM + (15*60) < now) { // log each 15 minutes
            ostringstream sstr;
            sstr << spaceUsed << "% used, High Water Mark reached, "
                              << "starting release.";
            log_WriteEvent(sstr.str());
            m_logTimeHWM = now;
        }
    }


    // not to return from switch after finished
    m_countTruncFiles = m_countTruncMigFiles = m_countTruncRelFiles = m_countTruncSmlFiles = 0;
    m_sizeTruncFiles  = m_sizeTruncMigFiles  = m_sizeTruncRelFiles  = m_sizeTruncSmlFiles  = 0;
    // end by jandrej@hermes.si

    m_guardian = 0;
    m_smallGuardian = 0;
    do {
        if (m_goDown) {
            log_DBG_m (dbg_NORM, "Shut down. Abort Truncation."); 
            return;
        }
        // lock until inode is try to locked, 
        // this is happened inside Truncate method
        m_relCandRec_x.Lock();  

        // Choice the list of older file

        // changed calling Truncate: now Truncate return file size 
        // of truncated file if truncation was performed
        ivd_FileSize_t fsize = 0;

        switch (ChoiceOldestList(criticalWM)) {
        case clMigration :
            fsize = Truncate(m_migrtRelCandRec); //, m_trans);
            if (fsize > 0) {
                m_countTruncMigFiles++;
                m_sizeTruncMigFiles += fsize;
            }
            break;
        case clRecall :
            fsize = Truncate(m_recalRelCandRec); //, m_trans);
            if (fsize > 0) {
                m_countTruncRelFiles++;
                m_sizeTruncRelFiles += fsize;
            }
            break;
        case clSmall :
            fsize = Truncate(m_smallRelCandRec); //, m_trans);
            if (fsize > 0) {
                m_countTruncSmlFiles++;
                m_sizeTruncSmlFiles += fsize;
            }
            break;
        case clNoList : // no more files to truncate
        default :
            m_sizeOfApendedFiles = 0;
            m_relCandRec_x.Unlock();  
            goto endTruncation;
        }

        m_fileSystem.GetFileSystemSize(a_info);

        // fix bug 505
        if (m_fsBytesTotal != a_info.bytesTotal) {
            ostringstream sstr;
            sstr << " FS total bytes not match any more.  Previous " << m_fsBytesTotal
                 << " now " << a_info.bytesTotal << "  Probably umount, truncation skipped.";
//            log_WriteEvent(sstr.str());
            log_NOTE_m(sstr.str());
            log_DBG_m(dbg_NORM, sstr.str());
            break;
        }
        // end 

        if ( criticalWM ) {
            if ((ivd_FileSize_t)a_info.bytesAvail > m_availBytesAtHigh) {
                log_DBG_m(dbg_DETAIL, "CRITICAL time switched off."); 
                criticalWM = false;
                ostringstream sstr;
                sstr << spaceUsed << "% used, High Water Mark reached, "
                                  << "continuing with regular release.";
                log_WriteEvent(sstr.str());
                m_logTimeCWM = m_logTimeHWM = now;
            }
            else {
                if (m_logTimeCWM + (5*60) < now) { // log each 5 minutes
                    ostringstream sstr;
                    sstr << spaceUsed << "% used, Critical Water Mark reached, "
                                      << "forced release in progress.";
                    log_WriteEvent(evt_WARNING, sstr.str());
                    m_logTimeCWM = now;
                }
            }
        }
        else {
            criticalWM = (ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit;
            if (criticalWM) {
                log_DBG_m(dbg_DETAIL, "CRITICAL low space. FS avail " << a_info.bytesAvail 
                                   << "  bytes at HWM " << m_availBytesAtHigh 
                                   << "  bytes at CWM " << m_availBytesAtCrit);
                ostringstream sstr;
                sstr << spaceUsed << "% used, Critical Water Mark reached, "
                                  << "continuing with forced release";
                log_WriteEvent(evt_WARNING, sstr.str());
                m_logTimeCWM = m_logTimeHWM = now;
            }
            else {
                if (m_logTimeHWM + (5*60) < now) { // log each 5 minutes
                    ostringstream sstr;
                    sstr << spaceUsed << "% used, release in progress.";
                    log_WriteEvent(sstr.str());
                    m_logTimeHWM = now;
                }
            }
        }
    } while((ivd_FileSize_t)a_info.bytesAvail <= m_availBytesAtLow);

endTruncation:

    // modified  by jandrej@hermes.si
    if (m_countTruncFiles > 0) {
        m_countTruncations++;

        ostringstream sstr;
        sstr << (criticalWM ? "Forced release" : "Release")
             << " (#files: " << m_countTruncFiles << ", size: " 
             << (m_sizeTruncFiles/1024) << " KB).";

        log_WriteEvent(sstr.str());
        m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged
    }
    else {
        // nothing released 
        if (criticalWM && m_logTimeCWM == now) {  // if CWH reported this run
            log_WriteEvent(evt_WARNING, 
                           "Critical Water Mark and nothing to release.");
        }

        if (!criticalWM && m_logTimeHWM == now) {  // if HWM reported this time
            log_WriteEvent(evt_WARNING, 
                           "High Water Mark and nothing to release.");
        }
    }

    log_DBG_m(dbg_NORM, "ReleaseMgr FINISHED: "  << endl <<
        "Release statistic: All files: Migrated files: Recalled files:    Small files:" << endl <<
        "-----------------------------------------------------------------------------" << endl <<
        "number of files: " << setw(12) << m_countTruncFiles << setw(16) << m_countTruncMigFiles  << setw(16) << 
                                           m_countTruncRelFiles   << setw(16) << m_countTruncSmlFiles  << endl <<  
        "size of files  : " << setw(12) << m_sizeTruncFiles  << setw(16) << m_sizeTruncMigFiles << setw(16) << 
                                           m_sizeTruncRelFiles  << setw(16) << m_sizeTruncSmlFiles );
    // end by jandrej@hermes.si
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hsm_FHrelc::WakeUp ( void   ) 

Definition at line 425 of file hsm_FHrelc.cpp.

References cmn_Condition::Broadcast(), log_FUNC_m, m_thread_c, and m_thread_x.

Referenced by Shutdown(), and SpaceCheck().

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Reimplemented from cmn_Thread.

Definition at line 180 of file hsm_FHrelc.h.

percent of disk avail when force truncation started

Definition at line 136 of file hsm_FHrelc.h.

Referenced by Reconfigure(), SetAvailBytes(), and TruncationCheck().

percent of disk avail when force truncation stopped or normal truncation startted

Definition at line 134 of file hsm_FHrelc.h.

Referenced by Reconfigure(), SetAvailBytes(), and TruncationCheck().

percent of disk avail when truncatin of release candidate file stopped

Definition at line 131 of file hsm_FHrelc.h.

Referenced by Reconfigure(), and SetAvailBytes().

Definition at line 140 of file hsm_FHrelc.h.

Referenced by SetAvailBytes(), SpaceCheck(), and TruncationCheck().

Definition at line 138 of file hsm_FHrelc.h.

Referenced by SetAvailBytes(), and TruncationCheck().

Definition at line 139 of file hsm_FHrelc.h.

Referenced by SetAvailBytes(), and TruncationCheck().

Definition at line 141 of file hsm_FHrelc.h.

Referenced by SetAvailBytes().

Definition at line 229 of file hsm_FHrelc.h.

Referenced by GetNumTruncations(), hsm_FHrelc(), and TruncationCheck().

Definition at line 230 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), Truncate(), and TruncationCheck().

Definition at line 231 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

Definition at line 232 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

Definition at line 233 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

int hsm_FHrelc::m_eventNum [private]

Definition at line 226 of file hsm_FHrelc.h.

Referenced by SpaceCheck().

Definition at line 173 of file hsm_FHrelc.h.

Referenced by Init(), Reconfigure(), Run(), SetAvailBytes(), SpaceCheck(), and TruncationCheck().

total bytes of FS, checked if equal at every fs info

Definition at line 177 of file hsm_FHrelc.h.

Referenced by SetAvailBytes(), SpaceCheck(), and TruncationCheck().

Definition at line 122 of file hsm_FHrelc.h.

Referenced by Run(), Shutdown(), and TruncationCheck().

Definition at line 241 of file hsm_FHrelc.h.

Referenced by ChoiceOldestList(), Release(), Truncate(), and TruncationCheck().

Definition at line 143 of file hsm_FHrelc.h.

Referenced by Reconfigure(), SpaceCheck(), and TruncationCheck().

Definition at line 144 of file hsm_FHrelc.h.

Referenced by Reconfigure(), SpaceCheck(), and TruncationCheck().

Definition at line 123 of file hsm_FHrelc.h.

Referenced by Run().

Definition at line 158 of file hsm_FHrelc.h.

Referenced by Append(), ChoiceOldestList(), Reconfigure(), Release(), and TruncationCheck().

Definition at line 157 of file hsm_FHrelc.h.

Referenced by Append(), ChoiceOldestList(), Reconfigure(), Release(), and TruncationCheck().

Append, release and truncation concure to RelCandRec.

Definition at line 171 of file hsm_FHrelc.h.

Referenced by Append(), Release(), SpaceCheck(), Truncate(), and TruncationCheck().

Definition at line 128 of file hsm_FHrelc.h.

Referenced by Reconfigure(), and Run().

outside variable that set when thread is down

Definition at line 120 of file hsm_FHrelc.h.

Referenced by Run().

Definition at line 165 of file hsm_FHrelc.h.

Referenced by Append(), SpaceCheck(), and TruncationCheck().

Definition at line 234 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), Truncate(), and TruncationCheck().

Definition at line 235 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

Definition at line 236 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

Definition at line 237 of file hsm_FHrelc.h.

Referenced by hsm_FHrelc(), and TruncationCheck().

Definition at line 121 of file hsm_FHrelc.h.

Referenced by Run(), and SpaceCheck().

The size of the file that are not released until critical WM occured and nothing else is to released.

Definition at line 154 of file hsm_FHrelc.h.

Referenced by Append(), Reconfigure(), and Truncate().

Definition at line 242 of file hsm_FHrelc.h.

Referenced by ChoiceOldestList(), Release(), Truncate(), and TruncationCheck().

Definition at line 156 of file hsm_FHrelc.h.

Referenced by Append(), ChoiceOldestList(), Release(), and TruncationCheck().

Definition at line 126 of file hsm_FHrelc.h.

Referenced by Run(), and WakeUp().

Definition at line 125 of file hsm_FHrelc.h.

Referenced by Run(), and WakeUp().

Definition at line 168 of file hsm_FHrelc.h.

Referenced by Truncate(), and ~hsm_FHrelc().

Definition at line 238 of file hsm_FHrelc.h.

Referenced by GetWakeUpTime(), and Run().


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