hsm_FHrelc Class Reference
[Classes for managing object list]
#include <hsm_FHrelc.h>
Detailed Description
Definition at line 92 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 205 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.
00214 : 00215 m_running(a_running), 00216 m_sleepingThread(false), 00217 m_goDown(false), 00218 m_migDisabled(false), 00219 m_thread_c(&m_thread_x), 00220 m_releaseInterval(a_releaseInterval), 00221 m_100_lowWaterMark(100 - a_lowWaterMark), 00222 m_100_highWaterMark(100 - a_highWaterMark), 00223 m_100_criticalWaterMark(100 - a_criticalWaterMark), 00224 m_logTimeCWM(0), 00225 m_logTimeHWM(0), 00226 m_smalestFileSize(a_smalestFileSize), 00227 m_smallRelCandRec(*g_RelCandSmall_p, 0), 00228 m_recalRelCandRec(*g_RelCandRecal_p, a_recRetentionTime), 00229 m_migrtRelCandRec(*g_RelCandMigrt_p, a_migRetentionTime), 00230 m_sizeOfApendedFiles(0), 00231 m_trans(*g_hsmDB_p->GetTransObj()), 00232 m_guardian(0), 00233 m_smallGuardian(0) 00234 { 00235 log_FUNC_m(hsm_FHrelc); 00236 log_DBG_m(dbg_LOW, "Create release candidate list. RootPath=" << 00237 g_fs_api_p->GetRootPath() << endl << 00238 "-----------------------------------------------------------------------" << endl << 00239 "ReleaseInterval " << setw(4) << a_releaseInterval << 00240 "\tCritWM " << setw(4) << a_criticalWaterMark << 00241 "\tHighWM " << setw(4) << a_highWaterMark << 00242 "\tLowWM " << setw(4) << a_lowWaterMark << endl << 00243 "MinFileSize " << setw(6) << a_smalestFileSize << 00244 "\tMigRetTime " << setw(6) << a_migRetentionTime << 00245 "\tRclRetTime " << setw(6)<< a_recRetentionTime << endl << 00246 "-----------------------------------------------------------------------"); 00247 m_countTruncFiles = m_countTruncMigFiles = m_countTruncRelFiles = m_countTruncSmlFiles = 0; 00248 m_sizeTruncFiles = m_sizeTruncMigFiles = m_sizeTruncRelFiles = m_sizeTruncSmlFiles = 0; 00249 m_countTruncations = 0; 00250 } //============================================================================//
| hsm_FHrelc::~hsm_FHrelc | ( | ) | [virtual] |
Definition at line 254 of file hsm_FHrelc.cpp.
References g_hsmDB_p, log_FUNC_m, m_trans, and fio_DataBase::ReleaseTransObj().
00255 { 00256 // release transaction 00257 g_hsmDB_p->ReleaseTransObj(m_trans); 00258 log_FUNC_m(~hsm_FHrelc); 00259 }
Member Function Documentation
| void hsm_FHrelc::Shutdown | ( | ) |
thread part
Definition at line 402 of file hsm_FHrelc.cpp.
References log_FUNC_m, m_goDown, and WakeUp().
Referenced by hsm_Containers::Stop().
00402 { 00403 log_FUNC_m(Shutdown); 00404 00405 m_goDown = true; 00406 WakeUp(); 00407 }
| void hsm_FHrelc::WakeUp | ( | void | ) |
Definition at line 411 of file hsm_FHrelc.cpp.
References cmn_Condition::Broadcast(), log_FUNC_m, m_thread_c, and m_thread_x.
Referenced by Shutdown(), and SpaceCheck().
00411 { 00412 log_FUNC_m(WakeUp); 00413 00414 cmn_MutexLock l(m_thread_x); 00415 00416 m_thread_c.Broadcast(); 00417 }
| void hsm_FHrelc::Run | ( | void * | arg | ) | [virtual] |
Wait MinWaitTime or wait to broadcast
Reimplemented from cmn_Thread.
Definition at line 421 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().
00421 { 00422 log_FUNC_m(Run); 00423 m_running = true; 00424 Init(); 00425 log_DBG_m(dbg_NORM, "Release cand. thread is starting up. WM checked on mount point " 00426 << m_fileSystem.GetFullPathRef()); 00427 00428 while (m_goDown == false) { 00429 00430 try { 00431 m_wakeUpTime = time(NULL) + m_releaseInterval; 00432 00433 cmn_Time cmntimewakeup(m_wakeUpTime, 0); 00434 log_DBG_m(dbg_DETAIL, "Release cand. thread will wake up at latest " << cmntimewakeup.Time2hms()); 00435 00436 { 00437 cmn_MutexLock l(m_thread_x); 00438 00439 m_sleepingThread = true; 00441 // int retv = m_thread_c.TimedWait(m_earliestWakeUpTime); 00442 m_thread_c.TimedWait(m_wakeUpTime); 00443 } 00444 00445 if (m_goDown) { 00446 break; 00447 } 00448 if (m_migDisabled) { 00449 continue; 00450 } 00451 00452 m_sleepingThread = false; 00453 TruncationCheck(); 00454 } 00455 catch (ivd_Error &ie) { 00456 log_DBG_m(dbg_DETAIL, "RelCndLThread return ERROR " << ie); 00457 } 00458 catch (ivd_SysError &ise) { 00459 log_DBG_m(dbg_DETAIL, "RelCndLThread WILL GO_DOWN on ERROR " << ise); 00460 break; 00461 } 00462 catch (...) { 00463 log_DBG_m(dbg_DETAIL, "RelCndListMgrThrd WILL GO_DOWN after thrown ERROR."); 00464 break; 00465 } 00466 } 00467 log_DBG_m(dbg_DETAIL, "Release cand. thread IS_DOWN."); 00468 m_running = false; 00469 }
| 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 292 of file hsm_FHrelc.cpp.
References hsm_ReleaseCandRec::Append(), clMigration, clNoList, clRecall, clSmall, 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().
00297 { 00298 log_FUNC_m(Append); 00299 00300 if (a_size == 0) { 00301 log_NOTE_m("Won't append to release candidate list (file size = 0): " << a_name); 00302 return 0; 00303 } 00304 00305 if (IsPatternMatch(a_name)) { 00306 log_DBG_m(dbg_NORM, "Won't append to release candidate list (file match in exclude list): " << a_name); 00307 return 0; 00308 } 00309 00310 a_circList = clNoList; 00311 ivd_RecordIDX_t idx = 0; 00312 00313 cmn_MutexLock l(m_relCandRec_x); 00314 00315 if (a_size < m_smalestFileSize) { 00316 idx = m_smallRelCandRec.Append(a_rc, a_trans); 00317 a_circList = clSmall; 00318 } 00319 else if (a_migrate) { 00320 idx = m_migrtRelCandRec.Append(a_rc, a_trans); 00321 a_circList = clMigration; 00322 } 00323 else { 00324 idx = m_recalRelCandRec.Append(a_rc, a_trans); 00325 a_circList = clRecall; 00326 } 00327 m_sizeOfApendedFiles += a_size; 00328 log_DBG_m(dbg_NORM, "File append to RCL. a_size: " << a_size 00329 << ", m_sizeOfApendedFiles: " << m_sizeOfApendedFiles); 00330 return idx; 00331 }
| ivd_RecordIDX_t hsm_FHrelc::Append | ( | hsm_FileHeader * | a_fh_p, | |
| bool | a_migrate, | |||
| fio_Transaction & | a_trans | |||
| ) |
Definition at line 335 of file hsm_FHrelc.cpp.
References Append(), clNoList, 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().
00337 { 00338 00339 log_FUNC_m(Append); 00340 00341 hdb_ReleaseCand_t rc(a_fh_p->GetfType(), 00342 a_fh_p->GetNameOwnIdx(), // nameOwnerIdx 00343 a_fh_p->GetInode(), 00344 a_fh_p->GetFileID()); 00345 00346 00347 hdb_circList_e circList = clNoList; 00348 ivd_RecordIDX_t idx = Append( rc, 00349 a_fh_p->GetFName(), 00350 a_fh_p->GetFileSize(), 00351 a_migrate, 00352 a_trans, 00353 circList); 00354 00355 a_fh_p->SetCircList(circList, idx); 00356 00357 // if entry is file then store fileID vs. HSMDB release candidate index relationship 00358 hdb_file2hdbID_t file2hdbID(a_fh_p->GetNameOwnIdx(), circList, idx); 00359 00360 g_File2hdbID_p->WriteRec(a_fh_p->GetFileID(), &file2hdbID, 1, &a_trans); 00361 00362 return idx; 00363 }
| 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 367 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().
00368 { 00369 log_FUNC_m(Release); 00370 00371 // Guardian change is made under general-inode lock. 00372 ivd_FileID_t fileID = a_fh_p->GetFileID(); 00373 if (m_smallGuardian == fileID) { 00374 m_smallGuardian = 0; 00375 } 00376 else if (m_guardian == fileID) { 00377 m_guardian = 0; 00378 } 00379 00380 // remove relation fileID hsmID 00381 hdb_file2hdbID_t file2hdbID; // default constructor fill it with zerroes 00382 g_File2hdbID_p->WriteRec(a_fh_p->GetFileID(), &file2hdbID, 1, &a_trans); 00383 00384 cmn_MutexLock l(m_relCandRec_x); 00385 switch (a_fh_p->GetRelCandCircList()) { 00386 case clMigration : 00387 m_migrtRelCandRec.Release(a_fh_p, a_trans); 00388 break; 00389 case clRecall : 00390 m_recalRelCandRec.Release(a_fh_p, a_trans); 00391 break; 00392 case clSmall : 00393 m_smallRelCandRec.Release(a_fh_p, a_trans); 00394 break; 00395 default: 00396 break; 00397 } 00398 }
| UInt32_t hsm_FHrelc::GetNumTruncations | ( | ) | [inline] |
Definition at line 192 of file hsm_FHrelc.h.
References m_countTruncations.
Referenced by i_HSM_i::GetInfo(), and i_HSM_i::ShowStatus().
00192 { return m_countTruncations;};
| 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 919 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().
00925 { 00926 log_FUNC_m(Reconfigure); 00927 00928 m_releaseInterval = a_CfgReleaseInterval; 00929 m_100_lowWaterMark = 100 - a_CfgLowWaterMark; 00930 m_100_highWaterMark = 100 - a_CfgHighWaterMark; 00931 m_100_criticalWaterMark = 100 - a_CfgCriticalWaterMark; 00932 m_smalestFileSize = a_CfgMinFileSize; 00933 m_recalRelCandRec.Reconfigure(a_CfgRecallRetentionTime); 00934 m_migrtRelCandRec.Reconfigure(a_CfgMigRetentionTime); 00935 00936 log_DBG_m(dbg_LOW, "Reconfigure release candidate list. RootPath=" << 00937 g_fs_api_p->GetRootPath() << endl << 00938 "-----------------------------------------------------------------------" << endl << 00939 "ReleaseInterval " << setw(4) << a_CfgReleaseInterval << 00940 "\tCritWM " << setw(4) << a_CfgCriticalWaterMark << 00941 "\tHighWM " << setw(4) << a_CfgHighWaterMark << 00942 "\tLowWM " << setw(4) << a_CfgLowWaterMark << endl << 00943 "MinFileSize " << setw(6) << a_CfgMinFileSize << 00944 "\tMigRetTime " << setw(6) << a_CfgMigRetentionTime << 00945 "\tRclRetTime " << setw(6)<< a_CfgRecallRetentionTime << endl << 00946 "-----------------------------------------------------------------------"); 00947 m_fileSystem.SetFullPath(g_fs_api_p->GetRootPath()); 00948 SetAvailBytes(); 00949 00950 m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged 00951 }
| ivd_Time32_t hsm_FHrelc::GetWakeUpTime | ( | ) | [inline] |
Definition at line 201 of file hsm_FHrelc.h.
References m_wakeUpTime.
Referenced by i_HSM_i::GetInfo(), and i_HSM_i::ShowStatus().
00201 {return m_wakeUpTime;};
| void hsm_FHrelc::SpaceCheck | ( | ) |
Definition at line 954 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().
00954 { 00955 log_FUNC_m(SpaceCheck); 00956 if (!(--m_eventNum) // check every hsm_eventNum_c number of events 00957 && !m_sleepingThread) { // Truncation already trigged 00958 // m_sleepingThread is not under mutex, does not matter if recently changed 00959 // just wait for another hsm_eventNum_c of events. 00960 m_eventNum = hsm_eventNum_c; 00961 return; 00962 } 00963 m_eventNum = hsm_eventNum_c; 00964 // check the disk space usage 00965 ivd_FileSystemSize_t a_info; 00966 m_fileSystem.GetFileSystemSize(a_info); 00967 // check if this is a same FS. 00968 if (m_fsBytesTotal != a_info.bytesTotal) { 00969 ostringstream sstr; 00970 sstr << " FS total bytes not match any more. Previous " << m_fsBytesTotal 00971 << " now " << a_info.bytesTotal << " Probably umount, SpaceCheck skipped."; 00972 log_NOTE_m(sstr.str()); 00973 log_DBG_m(dbg_NORM, sstr.str()); 00974 m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged 00975 return; 00976 } 00977 00978 if ((ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit) { 00979 { 00980 cmn_MutexLock l(m_relCandRec_x); 00981 if (m_sizeOfApendedFiles < (a_info.bytesAvail / 8)) { 00982 log_DBG_m(dbg_DETAIL, "Not enought new data to release. " 00983 << " m_sizeOfApendedFiles: " << m_sizeOfApendedFiles 00984 << ", bytes available / 8: " << (a_info.bytesAvail / 8)); 00985 return; 00986 }; 00987 } 00988 log_DBG_m(dbg_DETAIL, "Wake up release thread. FS available " << a_info.bytesAvail << " " 00989 << (100 * a_info.bytesAvail / a_info.bytesTotal) << "% " 00990 << " bytes at CWM " << m_availBytesAtCrit); 00991 WakeUp(); 00992 } 00993 else { 00994 log_DBG_m(dbg_DETAIL, "RCT not waked up. bytesAvail < m_availBytesAtCrit " 00995 << a_info.bytesAvail << " < " << m_availBytesAtCrit); 00996 } 00997 }
| void hsm_FHrelc::Init | ( | ) | [private] |
Definition at line 263 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().
00263 { 00264 log_FUNC_m(Init); 00265 m_fileSystem.SetFullPath(g_fs_api_p->GetRootPath()); 00266 log_DBG_m(dbg_NORM, "Mount point " << g_fs_api_p->GetRootPath()); 00267 00268 SetAvailBytes(); 00269 }
| void hsm_FHrelc::SetAvailBytes | ( | ) | [private] |
Definition at line 273 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().
00273 { 00274 ivd_FileSystemSize_t a_info; 00275 m_fileSystem.GetFileSystemSize(a_info); 00276 // fix bug 505 00277 m_fsBytesTotal = a_info.bytesTotal; 00278 // end 00279 m_availBytesAtHigh = ((ivd_FileSize_t)m_100_highWaterMark * a_info.bytesTotal) / 100; 00280 m_availBytesAtLow = ((ivd_FileSize_t)m_100_lowWaterMark * a_info.bytesTotal) / 100; 00281 m_availBytesAtCrit = ((ivd_FileSize_t)m_100_criticalWaterMark * a_info.bytesTotal) / 100; 00282 m_availBytesBetweenCritHigh = (m_availBytesAtHigh + m_availBytesAtCrit) / 2; 00283 }
| void hsm_FHrelc::TruncationCheck | ( | ) | [private] |
Definition at line 472 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().
00472 { 00473 log_FUNC_m(TruncationCheck); 00474 // check the disk space usage 00475 ivd_FileSystemSize_t a_info; 00476 m_fileSystem.GetFileSystemSize(a_info); 00477 00478 // fix bug 505 00479 if (m_fsBytesTotal != a_info.bytesTotal) { 00480 ostringstream sstr; 00481 sstr << " FS total bytes not match any more. Previous " << m_fsBytesTotal 00482 << " now " << a_info.bytesTotal << " Probably umount, truncation skipped."; 00483 log_NOTE_m(sstr.str()); 00484 log_DBG_m(dbg_NORM, sstr.str()); 00485 m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged 00486 return; // size of HSMFS changed, no truncation 00487 } 00488 // end 00489 00490 if ((ivd_FileSize_t)a_info.bytesAvail > m_availBytesAtHigh) { 00491 log_DBG_m(dbg_DETAIL, "FS available " << a_info.bytesAvail << " " 00492 << (100 * a_info.bytesAvail / a_info.bytesTotal) << "% " 00493 << " bytes at HWM " << m_availBytesAtHigh 00494 << " " << m_100_highWaterMark << "%"); 00495 m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged 00496 return; // below HWM , no truncation / release 00497 } 00498 // if we reach here we are above HWM 00499 00500 log_DBG_m(dbg_NORM, "Check for truncation (available). FS " << a_info.bytesAvail << " " 00501 << (100 * a_info.bytesAvail / a_info.bytesTotal) << "% " 00502 << " bytes at HWM " << m_availBytesAtHigh 00503 << " " << m_100_highWaterMark << "%" 00504 << " bytes at CWM " << m_availBytesAtCrit 00505 << " " << m_100_criticalWaterMark << "%"); 00506 00507 ivd_Time32_t now = time(NULL); 00508 bool criticalWM = (ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit; 00509 00510 UInt16_t spaceUsed = (ivd_FileSize_t)100 - 00511 (a_info.bytesAvail * (ivd_FileSize_t)100 / a_info.bytesTotal); 00512 00513 if (criticalWM) { 00514 log_DBG_m(dbg_NORM, "CRITICAL WaterMark reached." ); 00515 00516 if (m_logTimeCWM + (15*60) < now) { // log each 15 minutes 00517 ostringstream sstr; 00518 sstr << spaceUsed << "% used, Critical Water Mark reached, " 00519 << "starting forced release."; 00520 log_WriteEvent(evt_WARNING, sstr.str()); 00521 m_logTimeCWM = now; 00522 } 00523 } 00524 else { 00525 log_DBG_m(dbg_NORM, "HIGH WaterMark reached." ); 00526 00527 if (m_logTimeHWM + (15*60) < now) { // log each 15 minutes 00528 ostringstream sstr; 00529 sstr << spaceUsed << "% used, High Water Mark reached, " 00530 << "starting release."; 00531 log_WriteEvent(sstr.str()); 00532 m_logTimeHWM = now; 00533 } 00534 } 00535 00536 00537 // not to return from switch after finished 00538 m_countTruncFiles = m_countTruncMigFiles = m_countTruncRelFiles = m_countTruncSmlFiles = 0; 00539 m_sizeTruncFiles = m_sizeTruncMigFiles = m_sizeTruncRelFiles = m_sizeTruncSmlFiles = 0; 00540 // end by jandrej@hermes.si 00541 00542 m_guardian = 0; 00543 m_smallGuardian = 0; 00544 do { 00545 if (m_goDown) { 00546 log_DBG_m (dbg_NORM, "Shut down. Abort Truncation."); 00547 return; 00548 } 00549 // lock until inode is try to locked, 00550 // this is happened inside Truncate method 00551 m_relCandRec_x.Lock(); 00552 00553 // Choice the list of older file 00554 00555 // changed calling Truncate: now Truncate return file size 00556 // of truncated file if truncation was performed 00557 ivd_FileSize_t fsize = 0; 00558 00559 switch (ChoiceOldestList(criticalWM)) { 00560 case clMigration : 00561 fsize = Truncate(m_migrtRelCandRec); //, m_trans); 00562 if (fsize > 0) { 00563 m_countTruncMigFiles++; 00564 m_sizeTruncMigFiles += fsize; 00565 } 00566 break; 00567 case clRecall : 00568 fsize = Truncate(m_recalRelCandRec); //, m_trans); 00569 if (fsize > 0) { 00570 m_countTruncRelFiles++; 00571 m_sizeTruncRelFiles += fsize; 00572 } 00573 break; 00574 case clSmall : 00575 fsize = Truncate(m_smallRelCandRec); //, m_trans); 00576 if (fsize > 0) { 00577 m_countTruncSmlFiles++; 00578 m_sizeTruncSmlFiles += fsize; 00579 } 00580 break; 00581 case clNoList : // no more files to truncate 00582 default : 00583 m_sizeOfApendedFiles = 0; 00584 m_relCandRec_x.Unlock(); 00585 goto endTruncation; 00586 } 00587 00588 m_fileSystem.GetFileSystemSize(a_info); 00589 00590 // fix bug 505 00591 if (m_fsBytesTotal != a_info.bytesTotal) { 00592 ostringstream sstr; 00593 sstr << " FS total bytes not match any more. Previous " << m_fsBytesTotal 00594 << " now " << a_info.bytesTotal << " Probably umount, truncation skipped."; 00595 // log_WriteEvent(sstr.str()); 00596 log_NOTE_m(sstr.str()); 00597 log_DBG_m(dbg_NORM, sstr.str()); 00598 break; 00599 } 00600 // end 00601 00602 if ( criticalWM ) { 00603 if ((ivd_FileSize_t)a_info.bytesAvail > m_availBytesAtHigh) { 00604 log_DBG_m(dbg_DETAIL, "CRITICAL time switched off."); 00605 criticalWM = false; 00606 ostringstream sstr; 00607 sstr << spaceUsed << "% used, High Water Mark reached, " 00608 << "continuing with regular release."; 00609 log_WriteEvent(sstr.str()); 00610 m_logTimeCWM = m_logTimeHWM = now; 00611 } 00612 else { 00613 if (m_logTimeCWM + (5*60) < now) { // log each 5 minutes 00614 ostringstream sstr; 00615 sstr << spaceUsed << "% used, Critical Water Mark reached, " 00616 << "forced release in progress."; 00617 log_WriteEvent(evt_WARNING, sstr.str()); 00618 m_logTimeCWM = now; 00619 } 00620 } 00621 } 00622 else { 00623 criticalWM = (ivd_FileSize_t)a_info.bytesAvail < m_availBytesAtCrit; 00624 if (criticalWM) { 00625 log_DBG_m(dbg_DETAIL, "CRITICAL low space. FS avail " << a_info.bytesAvail 00626 << " bytes at HWM " << m_availBytesAtHigh 00627 << " bytes at CWM " << m_availBytesAtCrit); 00628 ostringstream sstr; 00629 sstr << spaceUsed << "% used, Critical Water Mark reached, " 00630 << "continuing with forced release"; 00631 log_WriteEvent(evt_WARNING, sstr.str()); 00632 m_logTimeCWM = m_logTimeHWM = now; 00633 } 00634 else { 00635 if (m_logTimeHWM + (5*60) < now) { // log each 5 minutes 00636 ostringstream sstr; 00637 sstr << spaceUsed << "% used, release in progress."; 00638 log_WriteEvent(sstr.str()); 00639 m_logTimeHWM = now; 00640 } 00641 } 00642 } 00643 } while((ivd_FileSize_t)a_info.bytesAvail <= m_availBytesAtLow); 00644 00645 endTruncation: 00646 00647 // modified by jandrej@hermes.si 00648 if (m_countTruncFiles > 0) { 00649 m_countTruncations++; 00650 00651 ostringstream sstr; 00652 sstr << (criticalWM ? "Forced release" : "Release") 00653 << " (#files: " << m_countTruncFiles << ", size: " 00654 << (m_sizeTruncFiles/1024) << " KB)."; 00655 00656 log_WriteEvent(sstr.str()); 00657 m_logTimeCWM = m_logTimeHWM = 0; // ensure that next try will be logged 00658 } 00659 else { 00660 // nothing released 00661 if (criticalWM && m_logTimeCWM == now) { // if CWH reported this run 00662 log_WriteEvent(evt_WARNING, 00663 "Critical Water Mark and nothing to release."); 00664 } 00665 00666 if (!criticalWM && m_logTimeHWM == now) { // if HWM reported this time 00667 log_WriteEvent(evt_WARNING, 00668 "High Water Mark and nothing to release."); 00669 } 00670 } 00671 00672 log_DBG_m(dbg_NORM, "ReleaseMgr FINISHED: " << endl << 00673 "Release statistic: All files: Migrated files: Recalled files: Small files:" << endl << 00674 "-----------------------------------------------------------------------------" << endl << 00675 "number of files: " << setw(12) << m_countTruncFiles << setw(16) << m_countTruncMigFiles << setw(16) << 00676 m_countTruncRelFiles << setw(16) << m_countTruncSmlFiles << endl << 00677 "size of files : " << setw(12) << m_sizeTruncFiles << setw(16) << m_sizeTruncMigFiles << setw(16) << 00678 m_sizeTruncRelFiles << setw(16) << m_sizeTruncSmlFiles ); 00679 // end by jandrej@hermes.si 00680 }
| ivd_FileSize_t hsm_FHrelc::Truncate | ( | hsm_ReleaseCandRec & | a_relCandObj | ) | [private] |
resolve FH owner using dirNode record got from DB
Definition at line 742 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().
00742 { 00743 // fio_Transaction &trans) { 00744 00745 hdb_ReleaseCand_t &relCandRec = a_relCandObj.GetRefRleaseCandRec(); 00746 log_FUNC_m(Truncate); 00747 cmn_Time removeTime(a_relCandObj.GetRemoveTime()); 00748 log_DBG_m(dbg_DETAIL, " Release candidate inode " 00749 << IVD_PRINT_ID_FS(relCandRec.generalInode) << endl 00750 << " NameOwnIdx " << relCandRec.nameOwnIdx << endl 00751 << " RemoveTime " << removeTime.Time2YMDhms() << endl 00752 << " Size " << relCandRec.dataSize ); 00753 00754 hsm_FileHeader *fileOwnHdr = NULL; // file owner 00755 ivd_FileID_t fileID = relCandRec.fileID; 00756 ivd_GenInode_t inode = relCandRec.generalInode; 00757 bool locked = false; 00758 // bool fileLocked = false; 00759 bool fileBusy = false; 00760 hdb_String name; 00761 ivd_FileSize_t truncSize = 0; 00762 ivd_FileSize_t fileSize = 0; 00763 cmn_Path path; 00764 cmn_File file; 00765 // NOTE 00766 try { 00767 if (!g_hsm_fhLock.CanLockByID(inode)) { 00768 // the File then it need to be truncate is active 00769 // it must be removed from release cand. list, so 00770 // wait a while and try again 00771 m_relCandRec_x.Unlock(); 00772 ivd_USleep(10000); // 10 mili sec 00773 return truncSize; 00774 // goto end3; 00775 } 00776 m_relCandRec_x.Unlock(); 00777 // reread record from file 00778 if (!a_relCandObj.IsValid()) { 00779 g_hsm_fhLock.UnLockByID(inode); 00780 return 0; 00781 } 00782 00783 locked = true; 00784 00785 hdb_DirNode_t dir; // default const. it filled with zeroes 00786 ivd_RecordIDX_t dirIdx; 00787 // get name and owner from DB 00788 hdbReadNameOwnRec(relCandRec.nameOwnIdx, dirIdx, name, dir); 00789 00790 hsm_FileHeader *fileHdr = g_hsm_FHCache_p->GetFH(inode); 00791 00792 if (fileHdr != NULL) { // file header is active skip it 00793 log_NOTE_m("File is getting dirty in meantime. '" << fileHdr->MakePath() ); 00794 m_trans.StartTransaction(); 00795 fileHdr->RemoveFromRelCandList(m_trans); 00796 m_trans.EndTransaction(); 00797 fileHdr->DecrRef(); // GetFH increment memberReference 00798 g_hsm_fhLock.UnLockByID(inode); 00799 return 0; 00800 } 00801 00802 //HPUX - The file needs to be opened ( to be in the kernel cache ) 00803 ivd_FS_File file(*g_fs_api_p,(g_fs_api_p->GetRootPath() + hsmdbGetPath(dir) + name)); 00804 file.Open(ivd_FS_File::e_Cache); 00805 if (dir.nameOwnIdx != 0) { // file is not on mount point 00807 fileOwnHdr = hsmGetDirFH(dir); 00808 } 00809 00810 hsm_InoObj *inodeObj = GetInodeObj(relCandRec.fileType, inode, fileID); 00811 //HPUX - Close file 00812 file.Close(); 00813 00814 00815 hsm_FileHeader fh(fileOwnHdr, inodeObj ,name); 00816 if (fileOwnHdr != NULL) { 00817 // increment is perform inside hsmGetDirFH inside constructor or cache search 00818 // now is decrement 00819 fileOwnHdr->DecrRef(); // this directory is dereferenced by release candidate 00820 } 00821 00822 // log_DBG_m(dbg_DETAIL, "release file " << rFHobj->GetFName() << 00823 // " size=" << rFHobj->GetFileSize()); 00824 00825 fileID = inodeObj->GetFileId(); 00826 fileSize = fh.GetFileSize(); 00827 try { 00828 fileSize = fh.TruncateFile(); 00829 m_countTruncFiles++; 00830 truncSize += fileSize; 00831 m_sizeTruncFiles += fileSize; 00832 } 00833 catch(ivd_SysError &ise) { // file was deleted or chaged name in mean time 00834 ostringstream sstr; 00835 sstr << " Truncation failed. Error: " << ise.GetError() 00836 << ", File: FID: " << fileID 00837 << ", INO " << IVD_PRINT_ID_FS(inode) 00838 << ", name '" << name 00839 << "' is BUSY. It is renamed, used or deleted."; 00840 00841 log_DBG_m(dbg_NORM, sstr.str()); 00842 if (ise.GetError() != ENOENT) { 00843 fileBusy = true; 00844 } 00845 else { 00846 log_DBG_m(dbg_NORM, " INO " << IVD_PRINT_ID_FS(inode) 00847 << ", file " << name << " is DELETED, remove from recall-relCandList."); 00848 } 00849 } 00850 } 00851 catch (...) { 00852 log_NOTE_m("->ReleaseFiles catch an ERROR" 00853 << " inode " << IVD_PRINT_ID_FS(inode) 00854 << " nameOwnIdx " << relCandRec.nameOwnIdx); 00855 } 00856 00857 m_trans.StartTransaction(); 00858 00859 // BUG 4287 "Open file is removed from release candidate list" 00860 // differ deletet files from busy. 00861 if (fileBusy) { // add FH to recall release list 00862 00863 ivd_RecordIDX_t nameOwnIdx = relCandRec.nameOwnIdx; 00864 00865 // a_relCandObj will NOT BE VALID after FindNextClearCurrRec() call 00866 a_relCandObj.FindNextClearCurrRec(m_trans); 00867 log_DBG_m(dbg_NORM, "file " << name << " is BUSY. Put on recall-relCandList."); 00868 hdb_ReleaseCand_t rc(ift_FILE, nameOwnIdx, inode, fileID); 00869 hdb_circList_e circList; 00870 ivd_RecordIDX_t idx = Append(rc, name, fileSize, false, m_trans, circList); 00871 hdb_file2hdbID_t file2hdbID(nameOwnIdx, circList, idx); 00872 g_File2hdbID_p->WriteRec(fileID, &file2hdbID, 1, &m_trans); 00873 00874 // Set guardian for preventing cycling (SSM Bug#1900). 00875 // Append moves to Recaled RelCand from Migrated, but not from Small. 00876 // NOTE! When guardian is set then new added files will not be processed in this loop 00877 // but after next time-out or when space check policy will be achive. 00878 if (fileSize < m_smalestFileSize) { 00879 if (m_smallGuardian == 0) { 00880 m_smallGuardian = fileID; 00881 } 00882 } 00883 else { 00884 if (m_guardian == 0) { 00885 m_guardian = fileID; 00886 } 00887 } 00888 } 00889 else { 00890 00891 // remove it from ivd system 00892 if (relCandRec.nameOwnIdx > 0) { 00893 g_NameOwner_p->ReleaseVectorIdx(relCandRec.nameOwnIdx, 1, &m_trans); 00894 } 00895 ivd_RecordIDX_t nameIdx(0); 00896 ivd_VectorSize_t nameVecSize(0); 00897 name.erase(); 00898 name.Write2DB(nameVecSize, nameIdx, m_trans); // release name 00899 00900 hdb_file2hdbID_t file2hdbID; // default constructor fill it with zerroes 00901 g_File2hdbID_p->WriteRec(fileID, &file2hdbID, 1, &m_trans); 00902 // NOTE !!!! 00903 // find next MUST be last sentance in transaction, 00904 // because it change relCandRec reference 00905 a_relCandObj.FindNextClearCurrRec(m_trans); 00906 } 00907 00908 m_trans.EndTransaction(); 00909 00910 if (locked) { 00911 g_hsm_fhLock.UnLockByID(inode); 00912 } 00913 return truncSize; 00914 }
| hdb_circList_e hsm_FHrelc::ChoiceOldestList | ( | bool | a_critical | ) | [private] |
Definition at line 684 of file hsm_FHrelc.cpp.
References clMigration, clNoList, clRecall, clSmall, 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().
00684 { 00685 log_FUNC_m(ChoiceOldestList); 00686 00687 hdb_circList_e list = clNoList; 00688 00689 ivd_Time32_t removeTime = m_migrtRelCandRec.GetRemoveTime(); 00690 cmn_Time remTime(removeTime, 0); 00691 log_DBG_m(dbg_DETAIL, " Migration remTime " << remTime.Time2hms()); 00692 if (removeTime != 0) { // candidate from mig list 00693 list = clMigration; 00694 } 00695 00696 // set from recal list if is older 00697 ivd_Time32_t recalRemTime = m_recalRelCandRec.GetRemoveTime(); 00698 cmn_Time recTime(recalRemTime, 0); 00699 log_DBG_m(dbg_DETAIL, " Recall remTime " << recTime.Time2hms()); 00700 if ( ( removeTime == 0 00701 && recalRemTime != 0) 00702 || 00703 ( recalRemTime != 0 00704 && recalRemTime < removeTime)) { 00705 if ((m_guardian != 0) 00706 && (m_guardian == m_recalRelCandRec.GetRefRleaseCandRec().fileID)) { 00707 log_DBG_m(dbg_DETAIL, "Skipping recall-relCandList. " 00708 "Been through whole list in this run (" << m_guardian << ")."); 00709 } 00710 else { 00711 removeTime = recalRemTime; 00712 list = clRecall; 00713 } 00714 } 00715 00716 // the oldest list is choiced or no elements in lists 00717 if (!a_critical) { 00718 if ( list != clNoList 00719 && removeTime > time(NULL)) { 00720 log_DBG_m(dbg_DETAIL, " No or not enought old files. list =" << list 00721 << " removeTime = " << removeTime); 00722 return clNoList; // no more enought old files 00723 } 00724 } // if stil not enought space on disk then remove small files too. 00725 else if (list == clNoList && m_smallRelCandRec.GetRemoveTime() > 0) { 00726 if ((m_smallGuardian != 0) 00727 && (m_smallGuardian == m_smallRelCandRec.GetRefRleaseCandRec().fileID)) { 00728 log_DBG_m(dbg_DETAIL, "Skipping small-relCandList. " 00729 "Been through whole list in this run (" << m_smallGuardian << ")."); 00730 } 00731 else { 00732 list = clSmall; 00733 } 00734 } 00735 cmn_Time newestTime(removeTime, 0); 00736 log_DBG_m(dbg_DETAIL, " Choiced list is " << list << " Newest removeTime " << newestTime.Time2hms()); 00737 return list; 00738 }
Member Data Documentation
| bool& hsm_FHrelc::m_running |
outside variable that set when thread is down
Definition at line 106 of file hsm_FHrelc.h.
Referenced by Run().
| bool hsm_FHrelc::m_goDown |
Definition at line 108 of file hsm_FHrelc.h.
Referenced by Run(), Shutdown(), and TruncationCheck().
percent of disk avail when truncatin of release candidate file stopped
Definition at line 117 of file hsm_FHrelc.h.
Referenced by Reconfigure(), and SetAvailBytes().
percent of disk avail when force truncation stopped or normal truncation startted
Definition at line 120 of file hsm_FHrelc.h.
Referenced by Reconfigure(), SetAvailBytes(), and TruncationCheck().
percent of disk avail when force truncation started
Definition at line 122 of file hsm_FHrelc.h.
Referenced by Reconfigure(), SetAvailBytes(), and TruncationCheck().
Definition at line 126 of file hsm_FHrelc.h.
Referenced by SetAvailBytes(), SpaceCheck(), and TruncationCheck().
Definition at line 129 of file hsm_FHrelc.h.
Referenced by Reconfigure(), SpaceCheck(), and TruncationCheck().
Definition at line 130 of file hsm_FHrelc.h.
Referenced by Reconfigure(), SpaceCheck(), and TruncationCheck().
The size of the file that are not released until critical WM occured and nothing else is to released.
Definition at line 140 of file hsm_FHrelc.h.
Referenced by Append(), Reconfigure(), and Truncate().
Definition at line 142 of file hsm_FHrelc.h.
Referenced by Append(), ChoiceOldestList(), Release(), and TruncationCheck().
Definition at line 143 of file hsm_FHrelc.h.
Referenced by Append(), ChoiceOldestList(), Reconfigure(), Release(), and TruncationCheck().
Definition at line 144 of file hsm_FHrelc.h.
Referenced by Append(), ChoiceOldestList(), Reconfigure(), Release(), and TruncationCheck().
Definition at line 151 of file hsm_FHrelc.h.
Referenced by Append(), SpaceCheck(), and TruncationCheck().
Append, release and truncation concure to RelCandRec.
Definition at line 157 of file hsm_FHrelc.h.
Referenced by Append(), Release(), SpaceCheck(), Truncate(), and TruncationCheck().
Definition at line 159 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 163 of file hsm_FHrelc.h.
Referenced by SetAvailBytes(), SpaceCheck(), and TruncationCheck().
int hsm_FHrelc::m_eventNum [private] |
UInt32_t hsm_FHrelc::m_countTruncations [private] |
Definition at line 215 of file hsm_FHrelc.h.
Referenced by GetNumTruncations(), hsm_FHrelc(), and TruncationCheck().
UInt32_t hsm_FHrelc::m_countTruncFiles [private] |
Definition at line 216 of file hsm_FHrelc.h.
Referenced by hsm_FHrelc(), Truncate(), and TruncationCheck().
UInt32_t hsm_FHrelc::m_countTruncMigFiles [private] |
UInt32_t hsm_FHrelc::m_countTruncRelFiles [private] |
UInt32_t hsm_FHrelc::m_countTruncSmlFiles [private] |
ivd_FileSize_t hsm_FHrelc::m_sizeTruncFiles [private] |
Definition at line 220 of file hsm_FHrelc.h.
Referenced by hsm_FHrelc(), Truncate(), and TruncationCheck().
ivd_Time32_t hsm_FHrelc::m_wakeUpTime [private] |
ivd_FileID_t hsm_FHrelc::m_guardian [private] |
Definition at line 227 of file hsm_FHrelc.h.
Referenced by ChoiceOldestList(), Release(), Truncate(), and TruncationCheck().
ivd_FileID_t hsm_FHrelc::m_smallGuardian [private] |
Definition at line 228 of file hsm_FHrelc.h.
Referenced by ChoiceOldestList(), Release(), Truncate(), and TruncationCheck().
The documentation for this class was generated from the following files:
