bea_Volume Class Reference
[IVD Back-End Agent]

#include <bea_volume.h>

Inheritance diagram for bea_Volume:

Inheritance graph
[legend]
Collaboration diagram for bea_Volume:

Collaboration graph
[legend]

List of all members.

Detailed Description

Definition at line 95 of file bea_volume.h.


Public Member Functions

 bea_Volume (bea_Medium *const a_medium, UInt32_t a_volNumber, UInt32_t a_size)
virtual ~bea_Volume ()
UInt32_t GetSize () const
 Declared volume size in MB.
UInt32_t GetVolumeNumber () const
virtual UInt32_t GetPosition ()=0
UInt32_t GetEstimTotalSize ()
 Estimated size w/ compression in MB.
UInt32_t GetEstimRemainingSize ()
 Estimated available space w/ compression in MB.
bea_Medium * GetMedium () const
void Write (const UInt8_t *a_buf)
void WriteVolHdr (const UInt8_t *a_buf)
void Read (UInt8_t *a_buf)
void ReadVolHdr (UInt8_t *a_buf)
virtual void Erase ()=0
virtual void WriteFileMarks (UInt32_t a_count=1)=0
virtual void Flush ()=0
virtual void SeekEOD ()=0
virtual void Rewind ()=0
virtual void SeekBlock (UInt32_t a_block)=0
virtual void SeekFileMark (Int32_t a_relativeFM)=0
void InvalidateEOD ()
 Class "knows" if it is at the end of the volume or not.
void Init (const bea_VolInfo_t &a_volInfo)
bool MustDumpFRI (UInt32_t *a_checkOffset=NULL)
UInt32_t GetStartOfDataPosition () const
bea_VolumeType GetVolumeType ()
UInt32_t GetBlockSize ()
void SetBlockSize (UInt32_t a_blkSize)
void OverrideIDs (const cmn_UUID_t &a_volID, const cmn_UUID_t &a_poolID, const cmn_UUID_t &a_partID)
cmn_UUID_t & GetVolumeID ()
cmn_UUID_t & GetPoolID ()
cmn_UUID_t & GetPartitionID ()
const bea_VolInfo_t & GetVolumeInfo ()
bool IsSysVolume ()
UInt64_t GetJobID () const
bool DoMediumLogging () const
void ReadVolInfoFromHeader ()

Protected Member Functions

virtual void WriteRaw (const UInt8_t *a_buf, UInt32_t a_size)=0
virtual void ReadRaw (UInt8_t *a_buf, UInt32_t a_size)=0
virtual void ReadEstimSizes ()=0
void SetDeclaredSize (UInt32_t a_size)
void InvalidateSizes ()
void SetEstimatedSizes (UInt32_t a_size, UInt32_t a_free)

Protected Attributes

bea_Medium *const m_medium_p
bool m_atEOD

Private Member Functions

void ReadVolInfoFromMediumMem ()
void UpdateMediumMem (const bea_VolInfo_t &a_volInfo)

Private Attributes

 log_CLASSID_m
UInt32_t m_volNumber
UInt32_t m_size
bool m_validSizes
UInt32_t m_estimSize
UInt32_t m_estimFree
bool m_validVolInfo
 Is volume info record valid?
bea_VolInfo_t m_volInfo

Constructor & Destructor Documentation

bea_Volume::bea_Volume ( bea_Medium *const   a_medium,
UInt32_t  a_volNumber,
UInt32_t  a_size 
)

Definition at line 41 of file bea_volume.cpp.

References ie_INVALID_ARG, ivd_Error, log_FUNC_A_m, m_size, m_volNumber, and NULL.

00045   : m_medium_p(a_medium),
00046     m_atEOD(false),
00047     m_volNumber(a_volNumber),
00048     m_size(a_size),
00049     m_validSizes(false),
00050     m_estimSize(0),
00051     m_estimFree(0),
00052     m_validVolInfo(false) {
00053 
00054     log_FUNC_A_m(bea_Volume,
00055         "num: " << m_volNumber << " size: " << m_size);
00056 
00057     if (a_medium == NULL) {
00058         throw ivd_Error(ie_INVALID_ARG, "a_medium may not be NULL.");
00059     }
00060 }

bea_Volume::~bea_Volume (  )  [virtual]

Definition at line 64 of file bea_volume.cpp.

References log_FUNC_m.

00064                         {
00065     log_FUNC_m(~bea_Volume);
00066 }

Member Function Documentation

UInt32_t bea_Volume::GetSize (  )  const

Declared volume size in MB.

Definition at line 82 of file bea_volume.cpp.

References m_size.

Referenced by bea_DupWriteThread::AppendVolume(), bea_DiskVolume::ReadEstimSizes(), bea_DiskVolume::ReadVolInfo(), and bea_DiskVolume::WriteVolInfo().

00082                                    {
00083     return m_size;
00084 }

Here is the caller graph for this function:

UInt32_t bea_Volume::GetVolumeNumber (  )  const

Definition at line 76 of file bea_volume.cpp.

References m_volNumber.

Referenced by bea_TapeMedium::ChangeVolume(), bea_DiskMedium::ChangeVolume(), bea_MigrationThread::CheckFRI(), bea_FRIThread::CheckFRI(), bea_FRI::CloseVolume(), bea_FRI::CloseVolumeInRMDB(), bea_FRI::CopyFromDiskToMedium(), bea_FRI::CreateFRI(), bea_FRI::DeleteFRIOnDisk(), bea_FRI::DeleteFRIOnVolume(), bea_MigrationThread::FRIVolumeStart(), bea_FRIThread::IsClosed(), bea_MigrationThread::Migrate(), bea_FRI::PositionToStartOfFRI(), bea_MigrationThread::PrepareVolume(), bea_FRIThread::ProcessFromDataVol(), bea_TapeVolume::ReadEstimSizes(), bea_DiskVolume::ReadEstimSizes(), bea_FRIThread::ReadFRI(), bea_FRI::ReadFRI(), bea_FRI::ReadFRIStart(), bea_RecallThread::Recall(), bea_TapeVolume::Rewind(), bea_DiskVolume::Rewind(), bea_VolumeReader::Run(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekEOD(), bea_DiskVolume::SeekEOD(), bea_TapeVolume::SeekFileMark(), bea_DiskVolume::SeekFileMark(), i_BackEndAgent_i::UpdateVolumeUsed(), bea_FRI::VerifyExistenceOfFileMark(), i_BackEndAgent_i::VerifyIDs(), bea_MigrationThread::WriteBlock(), bea_TapeVolume::WriteFileMarks(), bea_DiskVolume::WriteFileMarks(), and bea_FRI::WriteFRI().

00076                                            {
00077     return m_volNumber;
00078 }

Here is the caller graph for this function:

virtual UInt32_t bea_Volume::GetPosition (  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CloseVolume(), bea_MigrationThread::FRIVolumeEnd(), bea_MigrationThread::FRIVolumeStart(), Init(), bea_MigrationThread::Migrate(), bea_FRI::PositionToStartOfFRI(), bea_MigrationThread::PrepareVolume(), bea_FRIThread::ReadFRI(), bea_FRIThread::ReadFromSysVol(), bea_RecallThread::Recall(), bea_VolumeReader::Run(), i_BackEndAgent_i::UpdateVolumeUsed(), and bea_MigrationThread::WriteBlock().

Here is the caller graph for this function:

UInt32_t bea_Volume::GetEstimTotalSize (  ) 

Estimated size w/ compression in MB.

Estimated total capacity in MB.

Definition at line 91 of file bea_volume.cpp.

References log_FUNC_m, m_estimSize, m_validSizes, and ReadEstimSizes().

Referenced by bea_DupWriteThread::AppendVolume(), MustDumpFRI(), and i_BackEndAgent_i::UpdateVolumeUsed().

00091                                        {
00092     log_FUNC_m(GetEstimTotalSize);
00093     if (!m_validSizes) {
00094         ReadEstimSizes();
00095     }
00096     return m_estimSize;
00097 }

Here is the call graph for this function:

Here is the caller graph for this function:

UInt32_t bea_Volume::GetEstimRemainingSize (  ) 

Estimated available space w/ compression in MB.

Estimated remaining capacity in MB.

Definition at line 104 of file bea_volume.cpp.

References log_FUNC_m, m_estimFree, m_validSizes, and ReadEstimSizes().

Referenced by bea_DupWriteThread::AppendVolume(), bea_MigrationThread::FRIVolumeEnd(), bea_MigrationThread::FRIVolumeStart(), MustDumpFRI(), and i_BackEndAgent_i::UpdateVolumeUsed().

00104                                            {
00105     log_FUNC_m(GetEstimRemainingSize);
00106 
00107     if (!m_validSizes) {
00108         ReadEstimSizes();
00109     }
00110     return m_estimFree;
00111 }

Here is the call graph for this function:

Here is the caller graph for this function:

bea_Medium * bea_Volume::GetMedium (  )  const

Definition at line 70 of file bea_volume.cpp.

References m_medium_p.

Referenced by bea_VolumeReader::Run(), and bea_MigrationThread::WriteBlock().

00070                                          {
00071     return m_medium_p;
00072 }

Here is the caller graph for this function:

void bea_Volume::Write ( const UInt8_t *  a_buf  ) 

Definition at line 115 of file bea_volume.cpp.

References bea_VolInfo_t::blockSize, m_atEOD, m_validSizes, m_volInfo, and WriteRaw().

Referenced by bea_FRI::CopyFromDiskToMedium(), Init(), bea_MigrationThread::WriteBlock(), and bea_DupWriteThread::WriteMedVolume().

00115                                            {
00116     m_validSizes = false;
00117     WriteRaw(a_buf, m_volInfo.blockSize);
00118     m_atEOD = true;
00119 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::WriteVolHdr ( const UInt8_t *  a_buf  ) 

Definition at line 123 of file bea_volume.cpp.

References df_VOLHDR_REC_SIZE, log_FUNC_m, m_atEOD, m_validSizes, and WriteRaw().

Referenced by Init(), and bea_DupWriteThread::WriteMedVolume().

00123                                                  {
00124     log_FUNC_m(WriteVolHdr);
00125     m_validSizes = false;
00126     WriteRaw(a_buf, df_VOLHDR_REC_SIZE);
00127     m_atEOD = true;
00128 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::Read ( UInt8_t *  a_buf  ) 

Definition at line 132 of file bea_volume.cpp.

References bea_VolInfo_t::blockSize, dbg_NORM, ivd_BaseException::GetError(), ie_SCSI_EOM, ie_SCSI_ILENGTH, log_DBG_m, log_ERR_m, log_FUNC_m, m_volInfo, and ReadRaw().

Referenced by bea_FRI::ReadFRI(), bea_FRI::ReadFRIStart(), bea_DupReadThread::ReadMedVolume(), bea_RecallThread::Recall(), bea_VolumeReader::Run(), and bea_FRI::VerifyExistenceOfFileMark().

00132                                     {
00133     try {
00134         ReadRaw(a_buf, m_volInfo.blockSize);
00135     }
00136     catch (const ivd_Error& ie) {
00137         log_FUNC_m(Read);
00138         if (ie.GetError() == ie_SCSI_EOM) {
00139             log_DBG_m(dbg_NORM, "Ignored early EOM on reading.");
00140         }
00141         else if (ie.GetError() == ie_SCSI_ILENGTH) {
00142             log_ERR_m("Invalid block size when reading data:" << ie);
00143             throw;
00144         }
00145         else {
00146             throw;
00147         }
00148     }
00149 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::ReadVolHdr ( UInt8_t *  a_buf  ) 

Definition at line 153 of file bea_volume.cpp.

References df_VOLHDR_REC_SIZE, log_FUNC_m, and ReadRaw().

Referenced by bea_DupReadThread::ReadMedVolume(), and ReadVolInfoFromHeader().

00153                                           {
00154     log_FUNC_m(ReadVolHdr);
00155     ReadRaw(a_buf, df_VOLHDR_REC_SIZE);
00156 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void bea_Volume::Erase (  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CloseVolume(), bea_FRI::CreateFRI(), bea_FRI::DeleteFRIOnVolume(), bea_TapeMedium::Format(), bea_DiskMedium::Format(), and Init().

Here is the caller graph for this function:

virtual void bea_Volume::WriteFileMarks ( UInt32_t  a_count = 1  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CloseVolume(), Init(), and bea_DupWriteThread::WriteMedVolume().

Here is the caller graph for this function:

virtual void bea_Volume::Flush (  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CopyFromDiskToMedium(), bea_MigrationThread::Migrate(), and bea_DupWriteThread::WriteMedVolume().

Here is the caller graph for this function:

virtual void bea_Volume::SeekEOD (  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CloseVolume(), Init(), and bea_MigrationThread::PrepareVolume().

Here is the caller graph for this function:

virtual void bea_Volume::Rewind (  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_TapeMedium::Format(), Init(), bea_FRI::PositionToStartOfFRI(), bea_FRIThread::ReadFromSysVol(), bea_DupReadThread::ReadMedVolume(), ReadVolInfoFromHeader(), and bea_DupWriteThread::WriteMedVolume().

Here is the caller graph for this function:

virtual void bea_Volume::SeekBlock ( UInt32_t  a_block  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_DiskMedium::ChangeVolume(), bea_FRI::CreateFRI(), bea_FRIThread::ReadFRI(), bea_FRIThread::ReadFromSysVol(), bea_RecallThread::Recall(), and bea_FRI::VerifyExistenceOfFileMark().

Here is the caller graph for this function:

virtual void bea_Volume::SeekFileMark ( Int32_t  a_relativeFM  )  [pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by bea_FRI::CloseVolume(), bea_FRI::CreateFRI(), bea_FRI::PositionToStartOfFRI(), and bea_FRIThread::ReadFromSysVol().

Here is the caller graph for this function:

void bea_Volume::InvalidateEOD (  ) 

Class "knows" if it is at the end of the volume or not.

By invoking this call it resets this internal state.

Definition at line 164 of file bea_volume.cpp.

References log_FUNC_m, and m_atEOD.

Referenced by bea_TapeMedium::ChangeVolume(), bea_TapeVolume::Erase(), bea_TapeVolume::Rewind(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekFileMark(), and bea_DiskVolume::SeekFileMark().

00164                                {
00165     log_FUNC_m(InvalidateEOD);
00166 
00167     m_atEOD = false;
00168 }

Here is the caller graph for this function:

void bea_Volume::Init ( const bea_VolInfo_t &  a_volInfo  ) 

Definition at line 330 of file bea_volume.cpp.

References bea_VolInfo_t::accessNum, bea_VolInfo_t::accessTime, bea_VolInfo_t::appendNum, bea_VolInfo_t::appendTime, bea_VolInfo_t::blockSize, bea_Medium::ChangeVolume(), dbg_LOW, dbg_NORM, cmn_File::DeleteFile(), df_verMaj_c, df_verMin_c, df_volFlagSystem_c, df_VOLHDR_REC_SIZE, cmn_Global::dirs, Erase(), ivd_Directories::fri, g_cmn, bea_Medium::GetCurVolNumber(), ivd_BaseException::GetError(), GetPosition(), ivd_Versions::GetProductVersionShort(), GetVolumeType(), ie_BEA_INIT, ie_MEDIUM_BLANK, ie_MEDIUM_EOD, ie_MEDIUM_EOM, bea_Medium::IsWORM(), ivd_Error, log_DBG_m, log_FUNC_m, log_MARKLINE_m, m_medium_p, ivd_Product::m_nameShort, m_validVolInfo, m_volInfo, m_volNumber, bea_VolInfo_t::medVolID, bea_VolInfo_t::owriteNum, bea_VolInfo_t::owriteTime, bea_VolInfo_t::partID, bea_VolInfo_t::poolID, cmn_Global::prod, ReadVolInfoFromHeader(), Rewind(), SeekEOD(), SetBlockSize(), bea_VolInfo_t::sysVolNum, cmn_UUID_t::ToString(), UpdateMediumMem(), VOL_BLANK, VOL_IVD, Write(), WriteFileMarks(), df_Packer::WriteRecMedVolHdr(), and WriteVolHdr().

00330                                                     {
00331     log_FUNC_m(Init);
00332 
00333     log_DBG_m(dbg_LOW,
00334         "** Initializing medium volume " << endl <<
00335         "Volume ID: " << a_volInfo.medVolID << endl <<
00336         "Pool ID  : " << a_volInfo.poolID << endl <<
00337         "Part ID  : " << a_volInfo.partID << endl <<
00338         "Vol #    : " << m_volNumber << endl <<
00339         "SysVol on: " << a_volInfo.sysVolNum << endl <<
00340         "Blk size : " << a_volInfo.blockSize);
00341 
00342     try {
00343         if (m_medium_p->GetCurVolNumber() != m_volNumber) {
00344             m_medium_p->ChangeVolume(m_volNumber, 0);
00345         }
00346         else {
00347             Rewind();
00348         }
00349 
00350         ReadVolInfoFromHeader();
00351         if (GetVolumeType() == VOL_IVD) {
00352             cmn_Path fri = g_cmn.dirs.fri + m_volInfo.medVolID.ToString();
00353             log_DBG_m(dbg_LOW, "Trying to delete old FRI file: " << fri);
00354             try {
00355                 cmn_File::DeleteFile(fri);
00356             }
00357             catch (...) {
00358                 // Ignore all errors
00359             }
00360         }
00361     }
00362     catch (ivd_Error &ie) {
00363         if (ie.GetError() == ie_MEDIUM_BLANK ||
00364             ie.GetError() == ie_MEDIUM_EOD ||
00365             ie.GetError() == ie_MEDIUM_EOM) {
00366             log_DBG_m(dbg_NORM, "Blank volume. Just proceed.");
00367         }
00368         else {
00369             log_DBG_m(dbg_NORM,
00370                 "Init volume: Got error on seek: " << ie);
00371             throw;
00372         }
00373     }
00374 
00375     if (m_medium_p->IsWORM()) {
00376         // Verify volume type and prevent initialization of non-blank media.
00377         if (GetVolumeType() != VOL_BLANK) {
00378             log_MARKLINE_m;
00379             throw ivd_Error(ie_BEA_INIT, "WORM medium: volume is not blank.");
00380         }
00381     }
00382 
00383     // Invalidate contents of volume info.
00384     m_validVolInfo = false;
00385     SetBlockSize(a_volInfo.blockSize);
00386 
00387     if (m_medium_p->IsWORM()) {
00388         // Worm media doesn't like to be erased on any position.
00389         // Writing new blocks will do.
00390         log_DBG_m(dbg_NORM, "WORM medium. Won't use Erase(). Position to EOD.");
00391         // Sony AIT WORM drive doesn't "know" that it is at the end of the volume
00392         // so it is necessary to seek to EOD on empty volume.
00393         SeekEOD();
00394     }
00395     else {
00396         Rewind();
00397         Erase();
00398     }
00399 
00400     {
00401         vector<UInt8_t> hdrBlock(df_VOLHDR_REC_SIZE, 0);
00402 
00403         ostringstream appStr;
00404         appStr
00405             << g_cmn.prod.m_nameShort << " "
00406             << ivd_Versions::GetProductVersionShort() << "/"
00407             << df_verMaj_c << "." << df_verMin_c;
00408 
00409         df_Packer::WriteRecMedVolHdr(
00410             a_volInfo.medVolID,
00411             a_volInfo.poolID,
00412             a_volInfo.partID,
00413             m_volNumber, /* We need ECMA partition # here (starts from 1) */
00414             a_volInfo.blockSize,
00415             a_volInfo.accessNum,
00416             a_volInfo.appendNum,
00417             a_volInfo.owriteNum,
00418             a_volInfo.accessTime,
00419             a_volInfo.appendTime,
00420             a_volInfo.owriteTime,
00421             appStr.str(),
00422             (a_volInfo.sysVolNum == m_volNumber) ? df_volFlagSystem_c : 0,
00423             a_volInfo.sysVolNum,
00424 
00425             &(hdrBlock[0]),
00426             (UInt32_t)(df_VOLHDR_REC_SIZE));
00427 
00428         WriteVolHdr(&(hdrBlock[0]));
00429         {
00430             log_DBG_m(dbg_NORM, "HSM: Writing second header block for future use.");
00431 
00432             vector<UInt8_t> emptyBlock(a_volInfo.blockSize, 0);
00433             Write(&(emptyBlock[0]));
00434         }
00435 
00436         log_DBG_m(dbg_NORM, "HSM: Writing filemark after reserved block.");
00437         WriteFileMarks(1);
00438 
00439         log_DBG_m(dbg_NORM, "Position on medium after volume header: " << GetPosition());
00440     }
00441 
00442     UpdateMediumMem(a_volInfo);
00443 
00444     log_DBG_m(dbg_LOW, "Medium volume initialized");
00445 }

Here is the call graph for this function:

bool bea_Volume::MustDumpFRI ( UInt32_t *  a_checkOffset = NULL  ) 

Definition at line 449 of file bea_volume.cpp.

References bmf_DISK, cmn_GetEnvVariable(), cmn_Str2Num(), dbg_DETAIL, dbg_LOW, dbg_NORM, cmn_Global::dirs, ivd_Directories::fri, g_cmn, GetBlockSize(), ivd_BaseException::GetError(), GetEstimRemainingSize(), GetEstimTotalSize(), bea_Medium::GetMediumFamily(), GetVolumeID(), log_DBG_m, log_FUNC_m, log_WRN_m, m_medium_p, NULL, and cmn_File::StatF().

Referenced by bea_FRI::CreateFRI(), and bea_MigrationThread::Migrate().

00449                                                     {
00450     log_FUNC_m(MustDumpFRI);
00451 
00452     //parse env variable, should be in MB
00453     static const char* const FriTapeSafetyBuf_c("HSM_FRI_SAFETYBUF_TAPE");
00454     string friTapeSafetyBuf = cmn_GetEnvVariable(FriTapeSafetyBuf_c);
00455 
00456     UInt32_t friTapeSafetyBufNum(100*1024);
00457     UInt32_t parsedValue = cmn_Str2Num(friTapeSafetyBuf);
00458 
00459     log_DBG_m(dbg_NORM, "friTapeSafetyBuf: " << friTapeSafetyBuf <<
00460         ",  parsedValue:" << parsedValue );
00461 
00462     if (parsedValue*1024 < friTapeSafetyBufNum){
00463         if (parsedValue > 0){
00464             //ignore less than minimum
00465             log_WRN_m("HSM_FRI_SAFETYBUF_TAPE was set to " <<
00466                 parsedValue << " MB. Minimum value is " << friTapeSafetyBuf <<
00467                 " MB.");
00468         }
00469     }
00470     else {
00471         friTapeSafetyBufNum = parsedValue*1024;
00472         log_DBG_m(dbg_LOW, "Using friTapeSafetyBuf:" <<
00473                                 parsedValue  << "KB");
00474     };
00475 
00476     // Safety buffer for disk media is much smaller than for tape media
00477     static const UInt32_t c_FriTapeSafetyBuf(friTapeSafetyBufNum);  // in KB 100 MB by default
00478     static const UInt32_t c_FriDiskSafetyBuf(5*1024);   // in KB - 5 MB by default
00479     UInt32_t safetyBuf;
00480 
00481     if (m_medium_p->GetMediumFamily() == bmf_DISK) {
00482         safetyBuf = c_FriDiskSafetyBuf;
00483     }
00484     else {
00485         safetyBuf = c_FriTapeSafetyBuf;
00486     };
00487 
00488     UInt64_t friSize(0); // in KB
00489 
00490     try {
00491         cmn_File friFile(g_cmn.dirs.fri + GetVolumeID().ToString());
00492         ivd_FileInfo_t  friInfo;
00493         friFile.StatF(friInfo);
00494         friSize = (friInfo.size / 1024);
00495     }
00496     catch (const ivd_SysError &se) {
00497         if (se.GetError() == ENOENT) {
00498             // FRI does not exist yet - that's fine
00499             log_DBG_m(dbg_DETAIL, "No FRI yet.");
00500         }
00501         else {
00502             throw;
00503         }
00504     };
00505 
00506     // Convert from MB to kB
00507     UInt32_t remain = GetEstimRemainingSize() * 1024;
00508     UInt32_t total  = GetEstimTotalSize() * 1024;
00509 
00510     log_DBG_m(dbg_LOW, "FRI Capacity Check:" << endl <<
00511             "Remaining  = " << remain << " KB  " <<
00512             "FRISize   = " << friSize << " KB  " <<
00513             "SafetyBuf = " << safetyBuf << " KB");
00514 
00515     friSize += safetyBuf;
00516 
00517     if (friSize > remain) {
00518         log_DBG_m(dbg_LOW, "FRI must be dumped.");
00519         return true;
00520     }
00521 
00522     if (a_checkOffset != NULL) {
00523         // Space left on volume -> calculate # of blocks to next check
00524 
00525         // Best case: the remaining blocks until EOM
00526         UInt32_t chkOffset = (remain - friSize) / (GetBlockSize() / 1024);
00527 
00528         // Decrease check interval as medium is getting filled up
00529         UInt32_t fullRatio = (total)/(remain+1);
00530         if (fullRatio < 1) {
00531             fullRatio = 1;
00532         }
00533         fullRatio *= 2;
00534 
00535         static const UInt32_t mb300_c(300*1024); // 300 MB in KB units
00536         static const UInt32_t mb100_c(100*1024); // 100 MB in KB units
00537         // Check the capacity more often when approaching end of medium
00538         if (remain < mb300_c) {
00539             *a_checkOffset = 4;
00540         }
00541         else if (remain < mb100_c) {
00542             *a_checkOffset = 1;
00543         }
00544         else {
00545             *a_checkOffset = (chkOffset/fullRatio) + 1;
00546         }
00547 
00548         log_DBG_m(dbg_LOW, "Next capacity check offset: " << (*a_checkOffset) );
00549     }
00550 
00551     return false;
00552 }

Here is the call graph for this function:

Here is the caller graph for this function:

UInt32_t bea_Volume::GetStartOfDataPosition (  )  const

Definition at line 556 of file bea_volume.cpp.

Referenced by bea_MigrationThread::CheckFRI(), bea_FRI::CloseVolume(), bea_FRI::CreateFRI(), bea_FRIThread::ProcessFromDataVol(), and bea_FRI::ReadFRIStart().

00556                                                   {
00557     // The position immediatelly after the volume header.
00558     return 3;
00559 }

Here is the caller graph for this function:

bea_VolumeType bea_Volume::GetVolumeType (  ) 

Definition at line 200 of file bea_volume.cpp.

References m_validVolInfo, m_volInfo, ReadVolInfoFromMediumMem(), and bea_VolInfo_t::type.

Referenced by GetBlockSize(), GetPartitionID(), GetPoolID(), GetVolumeID(), Init(), i_BackEndAgent_i::ReadIDs(), and i_BackEndAgent_i::VerifyIDs().

00200                                          {
00201     if (!m_validVolInfo) {
00202         ReadVolInfoFromMediumMem();
00203     }
00204     return m_volInfo.type;
00205 }

Here is the call graph for this function:

Here is the caller graph for this function:

UInt32_t bea_Volume::GetBlockSize (  ) 

Definition at line 209 of file bea_volume.cpp.

References bea_VolInfo_t::blockSize, GetVolumeType(), ie_NOT_SUPPORTED, ivd_Error, log_FUNC_m, m_validVolInfo, m_volInfo, ReadVolInfoFromMediumMem(), and VOL_IVD.

Referenced by bea_FRI::CopyFromDiskToMedium(), bea_FRI::CreateFRI(), bea_DiskVolume::CreateNewFile(), bea_DiskVolume::GetPosition(), bea_MigrationThread::Migrate(), MustDumpFRI(), bea_MigrationThread::PrepareVolume(), bea_FRI::ReadFRI(), bea_FRI::ReadFRIStart(), i_BackEndAgent_i::ReadIDs(), bea_DupReadThread::ReadMedVolume(), bea_DiskVolume::ReadRaw(), bea_RecallThread::Recall(), bea_DiskVolume::SeekBlock(), bea_DiskVolume::SeekEOD(), i_BackEndAgent_i::UpdateVolumeUsed(), bea_FRI::VerifyExistenceOfFileMark(), i_BackEndAgent_i::VerifyIDs(), and bea_MigrationThread::WriteBlock().

00209                                   {
00210     if (!m_validVolInfo) {
00211         ReadVolInfoFromMediumMem();
00212     }
00213     if (GetVolumeType() != VOL_IVD) {
00214         log_FUNC_m(GetBlockSize);
00215         throw ivd_Error(ie_NOT_SUPPORTED, "Volume type is not HSM.");
00216     }
00217 
00218     return m_volInfo.blockSize;
00219 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::SetBlockSize ( UInt32_t  a_blkSize  ) 

Definition at line 223 of file bea_volume.cpp.

References bea_VolInfo_t::blockSize, dbg_LOW, log_DBG_m, log_FUNC_A_m, m_validVolInfo, m_volInfo, bea_VolInfo_t::type, and VOL_IVD.

Referenced by Init(), bea_MigrationThread::PrepareVolume(), bea_RecallThread::Recall(), and bea_DupWriteThread::WriteMedVolume().

00223                                                 {
00224     log_FUNC_A_m(SetBlockSize, "size: " << a_blkSize);
00225 
00226     if (m_validVolInfo) {
00227         log_DBG_m(dbg_LOW, "* OVERRIDING BLOCK SIZE. **");
00228     }
00229     else {
00230         m_validVolInfo = true;
00231         m_volInfo.type = VOL_IVD;
00232     }
00233     m_volInfo.blockSize = a_blkSize;
00234 }

Here is the caller graph for this function:

void bea_Volume::OverrideIDs ( const cmn_UUID_t &  a_volID,
const cmn_UUID_t &  a_poolID,
const cmn_UUID_t &  a_partID 
)

Definition at line 237 of file bea_volume.cpp.

References dbg_LOW, cmn_UUID_t::IsNull(), log_DBG_m, log_FUNC_m, m_validVolInfo, m_volInfo, bea_VolInfo_t::medVolID, bea_VolInfo_t::partID, bea_VolInfo_t::poolID, bea_VolInfo_t::type, and VOL_IVD.

Referenced by bea_MigrationThread::PrepareVolume().

00240                                 {
00241 
00242     log_FUNC_m(OverrideIDs);
00243 
00244     if (!m_volInfo.medVolID.IsNull() ||
00245         !m_volInfo.poolID.IsNull() ||
00246         !m_volInfo.partID.IsNull() ) {
00247 
00248         log_DBG_m(dbg_LOW, "* OVERRIDING EXISTING IDs. **");
00249     }
00250 
00251     m_validVolInfo = true;
00252     m_volInfo.type = VOL_IVD;
00253     m_volInfo.medVolID = a_volID;
00254     m_volInfo.poolID = a_poolID;
00255     m_volInfo.partID = a_partID;
00256 
00257 }

Here is the call graph for this function:

Here is the caller graph for this function:

cmn_UUID_t & bea_Volume::GetVolumeID (  ) 

Definition at line 261 of file bea_volume.cpp.

References GetVolumeType(), ie_NOT_SUPPORTED, ivd_Error, log_FUNC_m, m_validVolInfo, m_volInfo, bea_VolInfo_t::medVolID, ReadVolInfoFromMediumMem(), and VOL_IVD.

Referenced by bea_MigrationThread::CheckFRI(), bea_FRIThread::CheckFRI(), bea_FRI::CloseVolume(), bea_FRI::CloseVolumeInRMDB(), bea_FRI::CopyFromDiskToMedium(), bea_FRI::CreateFRI(), bea_FRI::DeleteFRIOnDisk(), bea_MigrationThread::FRIVolumeEnd(), bea_MigrationThread::FRIVolumeStart(), bea_FRI::MoveFromWorkToFRI(), MustDumpFRI(), bea_MigrationThread::PrepareVolume(), bea_FRIThread::ProcessFromDataVol(), bea_FRIThread::ReadFRI(), i_BackEndAgent_i::ReadIDs(), bea_DupReadThread::ReadMedVolume(), bea_VolumeReader::Run(), bea_FRI::SaveFRIOnError(), i_BackEndAgent_i::UpdateVolumeUsed(), and i_BackEndAgent_i::VerifyIDs().

00261                                     {
00262     if (!m_validVolInfo) {
00263         ReadVolInfoFromMediumMem();
00264     }
00265     if (GetVolumeType() != VOL_IVD) {
00266         log_FUNC_m(GetVolumeID);
00267         throw ivd_Error(ie_NOT_SUPPORTED, "Volume type is not HSM.");
00268     }
00269     return m_volInfo.medVolID;
00270 }

Here is the call graph for this function:

Here is the caller graph for this function:

cmn_UUID_t & bea_Volume::GetPoolID (  ) 

Definition at line 274 of file bea_volume.cpp.

References GetVolumeType(), ie_NOT_SUPPORTED, ivd_Error, log_FUNC_m, m_validVolInfo, m_volInfo, bea_VolInfo_t::poolID, ReadVolInfoFromMediumMem(), and VOL_IVD.

Referenced by bea_FRI::CreateFRI(), bea_MigrationThread::Migrate(), i_BackEndAgent_i::ReadIDs(), and i_BackEndAgent_i::VerifyIDs().

00274                                   {
00275     if (!m_validVolInfo) {
00276         ReadVolInfoFromMediumMem();
00277     }
00278     if (GetVolumeType() != VOL_IVD) {
00279         log_FUNC_m(GetPoolID);
00280         throw ivd_Error(ie_NOT_SUPPORTED, "Volume type is not HSM.");
00281     }
00282     return m_volInfo.poolID;
00283 }

Here is the call graph for this function:

Here is the caller graph for this function:

cmn_UUID_t & bea_Volume::GetPartitionID (  ) 

Definition at line 287 of file bea_volume.cpp.

References GetVolumeType(), ie_NOT_SUPPORTED, ivd_Error, log_FUNC_m, m_validVolInfo, m_volInfo, bea_VolInfo_t::partID, ReadVolInfoFromMediumMem(), and VOL_IVD.

Referenced by bea_FRI::CreateFRI(), bea_MigrationThread::Migrate(), i_BackEndAgent_i::ReadIDs(), and i_BackEndAgent_i::VerifyIDs().

00287                                        {
00288     if (!m_validVolInfo) {
00289         ReadVolInfoFromMediumMem();
00290     }
00291     if (GetVolumeType() != VOL_IVD) {
00292         log_FUNC_m(GetPartitionID);
00293         throw ivd_Error(ie_NOT_SUPPORTED, "Volume type is not HSM.");
00294     }
00295     return m_volInfo.partID;
00296 }

Here is the call graph for this function:

Here is the caller graph for this function:

const bea_VolInfo_t & bea_Volume::GetVolumeInfo (  ) 

Definition at line 300 of file bea_volume.cpp.

References m_validVolInfo, m_volInfo, and ReadVolInfoFromMediumMem().

00300                                                {
00301     if (!m_validVolInfo) {
00302         ReadVolInfoFromMediumMem();
00303     }
00304     return m_volInfo;
00305 }

Here is the call graph for this function:

bool bea_Volume::IsSysVolume (  ) 

Definition at line 309 of file bea_volume.cpp.

References m_validVolInfo, m_volInfo, ReadVolInfoFromMediumMem(), and bea_VolInfo_t::sysVol.

Referenced by bea_FRI::ReadFRI(), and bea_FRIThread::ReadFromSysVol().

00309                              {
00310     if (!m_validVolInfo) {
00311         ReadVolInfoFromMediumMem();
00312     }
00313     return m_volInfo.sysVol;
00314 }

Here is the call graph for this function:

Here is the caller graph for this function:

UInt64_t bea_Volume::GetJobID (  )  const

Definition at line 318 of file bea_volume.cpp.

References bea_Medium::GetJobID(), and m_medium_p.

Referenced by bea_TapeVolume::Rewind(), bea_DiskVolume::Rewind(), bea_VolumeReader::Run(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekEOD(), bea_DiskVolume::SeekEOD(), bea_TapeVolume::SeekFileMark(), bea_DiskVolume::SeekFileMark(), UpdateMediumMem(), bea_TapeVolume::WriteFileMarks(), and bea_DiskVolume::WriteFileMarks().

00318                                     {
00319     return m_medium_p->GetJobID();
00320 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool bea_Volume::DoMediumLogging (  )  const

Definition at line 324 of file bea_volume.cpp.

References bea_Medium::DoMediumLogging(), and m_medium_p.

Referenced by bea_TapeVolume::Rewind(), bea_DiskVolume::Rewind(), bea_VolumeReader::Run(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekEOD(), bea_DiskVolume::SeekEOD(), bea_TapeVolume::SeekFileMark(), bea_DiskVolume::SeekFileMark(), bea_TapeVolume::WriteFileMarks(), and bea_DiskVolume::WriteFileMarks().

00324                                        {
00325     return m_medium_p->DoMediumLogging();
00326 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::ReadVolInfoFromHeader (  ) 

Definition at line 563 of file bea_volume.cpp.

References bea_VolInfo_t::accessNum, bea_VolInfo_t::accessTime, bea_VolInfo_t::appendNum, bea_VolInfo_t::appendTime, df_RecVolHdr_t::blockSize, bea_VolInfo_t::blockSize, cmn_HexDump(), dbg_DETAIL, dbg_LOW, dbg_NORM, df_volFlagSystem_c, df_volFlagSysVolValid_c, df_VOLHDR_REC_SIZE, df_ECMAVolumeLabel_t::ecmaHdr, df_ECMAVolumeLabel_t::first, df_RecVolHdr_t::flags, bea_Medium::GetBarcode(), bea_Medium::GetCurVolNumber(), ivd_BaseException::GetError(), df_BlockScanner::GetVolumeID(), ie_INVALID_ARG, ie_MEDIUM_BLANK, ie_MEDIUM_EOD, ie_MEDIUM_EOM, ie_MEDIUM_FILEMARK, ie_MEDIUM_ILENGTH, df_ECMAFirstVolumeLabel_t::implID, bea_VolInfo_t::implID, ivd_Error, log_DBG_m, log_FUNC_m, log_WRN_m, m_medium_p, m_size, m_validVolInfo, m_volInfo, m_volNumber, bea_VolInfo_t::medVolID, ntoh(), NULL, df_RecVolHdr_t::numAccess, df_RecVolHdr_t::numAppends, df_ECMALblHdr_t::number, df_RecVolHdr_t::numOverwrites, bea_VolInfo_t::owriteNum, bea_VolInfo_t::owriteTime, df_RecVolHdr_t::partID, bea_VolInfo_t::partID, df_RecVolHdr_t::poolID, bea_VolInfo_t::poolID, ReadVolHdr(), Rewind(), bea_VolInfo_t::size, bea_VolInfo_t::sysVol, df_RecVolHdr_t::sysVolIndex, bea_VolInfo_t::sysVolNum, df_RecVolHdr_t::timeAccess, df_RecVolHdr_t::timeOverwrite, df_RecVolHdr_t::timeWrite, bea_VolInfo_t::type, UpdateMediumMem(), VOL_BLANK, VOL_ECMA, VOL_IVD, VOL_IVD_NT, VOL_OTHER, VOL_TAR, df_RecVolHdr_t::volID, and bea_VolInfo_t::volNum.

Referenced by bea_TapeMedium::Format(), Init(), bea_FRIThread::ProcessFromDataVol(), bea_FRIThread::ReadFromSysVol(), and i_BackEndAgent_i::ReadIDs().

00563                                        {
00564     log_FUNC_m(ReadVolInfoFromHeader);
00565 
00566     if (m_medium_p->GetCurVolNumber() != m_volNumber) {
00567         throw ivd_Error(
00568             ie_INVALID_ARG,
00569             "Volume info can only be read for current volume.");
00570     };
00571 
00572     vector<UInt8_t> medVolHdr(df_VOLHDR_REC_SIZE, 0);
00573     df_ECMAVolumeLabel_t    *ecmaHdr_p(NULL);
00574     df_RecVolHdr_t          *ivdHdr_p(NULL);
00575 
00576     { // Init the records
00577         m_validVolInfo = false;
00578         bea_VolInfo_t nilVolInfo;
00579         m_volInfo = nilVolInfo;
00580     }
00581 
00582     m_volInfo.volNum    = m_volNumber;
00583     m_volInfo.size      = m_size;
00584 
00585     try {
00586         Rewind();
00587         ReadVolHdr(&(medVolHdr[0]));
00588 
00589         log_DBG_m(dbg_DETAIL,
00590             "Header hex dump: " << endl <<
00591             cmn_HexDump( &(medVolHdr[0]), 255, 16, true) );
00592     }
00593     catch(ivd_Error &ie) {
00594         if (ie.GetError() == ie_MEDIUM_BLANK ||
00595             ie.GetError() == ie_MEDIUM_EOD ||
00596             ie.GetError() == ie_MEDIUM_EOM ) {
00597 
00598             log_DBG_m(dbg_LOW, "Assuming blank volume. " <<
00599                 endl << "Error: " << ie);
00600 
00601             m_volInfo.type = VOL_BLANK;
00602             m_validVolInfo = true;
00603             return;
00604         }
00605         else if (ie.GetError() == ie_MEDIUM_ILENGTH) {
00606             log_DBG_m(dbg_LOW,
00607                 "Different block size than HSMs. Will try to parse it." <<
00608                 endl << "Error: " << ie);
00609         }
00610         else if (ie.GetError() == ie_MEDIUM_FILEMARK) {
00611             log_DBG_m(dbg_LOW, "Unknown volume type - filemark detected. " <<
00612                 endl << "Error: " << ie);
00613 
00614             m_volInfo.type = VOL_OTHER;
00615             m_validVolInfo = true;
00616             return;
00617         }
00618         else {
00619             log_DBG_m(dbg_LOW,
00620                 "Got ivd_Error during medvol scan. Don't assume anything. " <<
00621                 endl << "Error: " << ie);
00622 
00623             //
00624             // Other errors (media, hardware) are propagated
00625             // to the caller and marked in RMDB.
00626             //
00627             throw;
00628         }
00629     }
00630     catch(ivd_SysError &ie) {
00631         log_DBG_m(dbg_LOW,
00632             "Got ivd_SysError during medvol scan. Unknown volume type. " <<
00633             endl << "Error: " << ie);
00634         throw;
00635     }
00636 
00637     // Successful read. medium is not empty.
00638 
00639     df_BlockScanner::GetVolumeID(&(medVolHdr[0]), ecmaHdr_p, ivdHdr_p);
00640     if (ecmaHdr_p != NULL) {
00641         m_volInfo.sysVol = false;
00642 
00643         log_DBG_m(dbg_NORM, "Got ECMA header.");
00644         m_volInfo.type    = VOL_ECMA;
00645 
00646         // Get the ECMA implementator ID (IVD or other)
00647         if (ecmaHdr_p->ecmaHdr.number == 1) {
00648             m_volInfo.implID = string(
00649                 reinterpret_cast<const char*>(ecmaHdr_p->first.implID),
00650                 sizeof(ecmaHdr_p->first.implID) );
00651         };
00652         if (ivdHdr_p != NULL) {
00653 
00654             log_DBG_m(dbg_NORM, "Got HSM header. Reading parameters.");
00655 
00656             m_volInfo.type         = VOL_IVD;
00657             m_volInfo.medVolID     = ivdHdr_p->volID;
00658             m_volInfo.poolID       = ivdHdr_p->poolID;
00659             m_volInfo.partID       = ivdHdr_p->partID;
00660             m_volInfo.blockSize    = ntoh(ivdHdr_p->blockSize);
00661             m_volInfo.accessNum    = ntoh(ivdHdr_p->numAccess);
00662             m_volInfo.appendNum    = ntoh(ivdHdr_p->numAppends);
00663             m_volInfo.owriteNum    = ntoh(ivdHdr_p->numOverwrites);
00664             m_volInfo.accessTime   = ntoh(ivdHdr_p->timeAccess);
00665             m_volInfo.appendTime   = ntoh(ivdHdr_p->timeWrite);
00666             m_volInfo.owriteTime   = ntoh(ivdHdr_p->timeOverwrite);
00667             if ( (ntoh(ivdHdr_p->flags) & df_volFlagSysVolValid_c) != 0) {
00668                 m_volInfo.sysVolNum = ivdHdr_p->sysVolIndex;
00669                 m_volInfo.sysVol    = (m_volInfo.sysVolNum == m_volNumber);
00670             }
00671             else {
00672                 m_volInfo.sysVol = (ntoh(ivdHdr_p->flags) & df_volFlagSystem_c) != 0;
00673                 log_WRN_m(
00674                     m_medium_p->GetBarcode() << ":" << m_volNumber <<
00675                     ": Detected data format 01.00." <<
00676                     " Can't determine the index of system volume.");
00677             }
00678             UpdateMediumMem(m_volInfo);
00679         };
00680     }
00681     else if (memcmp(&(medVolHdr[257]), "ustar", 5) == 0) {
00682         /*
00683         *  Detect POSIX/GNU tar archives
00684         *    Magic cookie from /usr/share/magic (file command)
00685         */
00686         log_DBG_m(dbg_NORM, "Detected TAR header.");
00687         m_volInfo.type = VOL_TAR;
00688     }
00689     else if(memcmp(&(medVolHdr[0]),
00690             "Infini<Store<<Virtual<<<Disk<<<<Media<<<<<Head_98",
00691             49) == 0) {
00692         /*
00693         *  Detect VOL_IVD_NT media
00694         */
00695         log_DBG_m(dbg_NORM, "Detected IVD-NT header.");
00696         m_volInfo.type = VOL_IVD_NT;
00697     };
00698 
00699     m_validVolInfo = true;
00700 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void bea_Volume::WriteRaw ( const UInt8_t *  a_buf,
UInt32_t  a_size 
) [protected, pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by Write(), and WriteVolHdr().

Here is the caller graph for this function:

virtual void bea_Volume::ReadRaw ( UInt8_t *  a_buf,
UInt32_t  a_size 
) [protected, pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by Read(), and ReadVolHdr().

Here is the caller graph for this function:

virtual void bea_Volume::ReadEstimSizes (  )  [protected, pure virtual]

Implemented in bea_DiskVolume, and bea_TapeVolume.

Referenced by GetEstimRemainingSize(), and GetEstimTotalSize().

Here is the caller graph for this function:

void bea_Volume::SetDeclaredSize ( UInt32_t  a_size  )  [protected]

Definition at line 185 of file bea_volume.cpp.

References log_FUNC_m, log_WRN_m, and m_size.

Referenced by bea_DiskVolume::bea_DiskVolume(), and bea_DiskVolume::ReadVolInfo().

00185                                                 {
00186     if (m_size == a_size) {
00187         return;
00188     }
00189     if (m_size > 0) {
00190         log_FUNC_m(SetDeclaredSize);
00191         log_WRN_m(
00192             "Changing declared volume size from " <<
00193             m_size << " to " << a_size);
00194     }
00195     m_size = a_size;
00196 }

Here is the caller graph for this function:

void bea_Volume::InvalidateSizes (  )  [protected]

Definition at line 172 of file bea_volume.cpp.

References log_FUNC_m, and m_validSizes.

Referenced by bea_TapeVolume::Erase(), bea_DiskVolume::Erase(), bea_TapeVolume::Rewind(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekFileMark(), and bea_TapeVolume::WriteFileMarks().

00172                                  {
00173     log_FUNC_m(InvalidateSizes);
00174     m_validSizes = false;
00175 }

Here is the caller graph for this function:

void bea_Volume::SetEstimatedSizes ( UInt32_t  a_size,
UInt32_t  a_free 
) [protected]

Definition at line 179 of file bea_volume.cpp.

References m_estimFree, m_estimSize, and m_validSizes.

Referenced by bea_TapeVolume::ReadEstimSizes(), and bea_DiskVolume::ReadEstimSizes().

00179                                                                    {
00180     m_validSizes = true, m_estimSize = a_size, m_estimFree = a_free;
00181 }

Here is the caller graph for this function:

void bea_Volume::ReadVolInfoFromMediumMem (  )  [private]

Definition at line 706 of file bea_volume.cpp.

References bea_VolInfo_t::accessNum, bea_VolInfo_t::accessTime, bea_VolInfo_t::appendNum, bea_VolInfo_t::appendTime, df_TCMMediaVolume_t::blockSize, bea_VolInfo_t::blockSize, dbg_LOW, dbg_NORM, df_volFlagSystem_c, df_TCMMediaVolume_t::flags, bea_Medium::GetMediumMem(), bea_Medium::GetVolumeCount(), bea_MediumMemory::GetVolumeRecord(), bea_Medium::IsMediumMemValid(), cmn_UUID_t::IsNull(), log_DBG_m, log_FUNC_m, m_medium_p, m_size, m_validVolInfo, m_volInfo, m_volNumber, bea_VolInfo_t::medVolID, df_TCMMediaVolume_t::numAccesses, df_TCMMediaVolume_t::numAppends, df_TCMMediaVolume_t::numOverwrites, bea_VolInfo_t::owriteNum, bea_VolInfo_t::owriteTime, bea_VolInfo_t::partID, df_TCMMediaVolume_t::partID, bea_VolInfo_t::poolID, df_TCMMediaVolume_t::poolID, bea_VolInfo_t::size, bea_VolInfo_t::sysVol, bea_VolInfo_t::sysVolNum, df_TCMMediaVolume_t::timeAccess, df_TCMMediaVolume_t::timeOverwrite, df_TCMMediaVolume_t::timeWrite, bea_VolInfo_t::type, VOL_IVD, df_TCMMediaVolume_t::volID, and bea_VolInfo_t::volNum.

Referenced by GetBlockSize(), GetPartitionID(), GetPoolID(), GetVolumeID(), GetVolumeInfo(), GetVolumeType(), and IsSysVolume().

00706                                           {
00707     log_FUNC_m(ReadVolInfoFromMediumMem);
00708 
00709     { // Init the records
00710         m_validVolInfo = false;
00711         bea_VolInfo_t nilVolInfo;
00712         m_volInfo = nilVolInfo;
00713     }
00714 
00715     if (!m_medium_p->IsMediumMemValid()) {
00716         return;
00717     }
00718     bea_MediumMemory* mm = m_medium_p->GetMediumMem();
00719 
00720     df_TCMMediaVolume_t medVolNote = mm->GetVolumeRecord(m_volNumber);
00721 
00722     m_volInfo.volNum    = m_volNumber;
00723     m_volInfo.size      = m_size;
00724 
00725     log_DBG_m(dbg_NORM,
00726         "VolID : " << medVolNote.volID << endl <<
00727         "PoolID: " << medVolNote.poolID << endl <<
00728         "PartID: " << medVolNote.partID);
00729 
00730     if (medVolNote.volID.IsNull()  ||
00731         medVolNote.poolID.IsNull() ||
00732         medVolNote.partID.IsNull() ) {
00733 
00734         log_DBG_m(dbg_LOW,
00735             "Failed reading volume info from medium memory: " <<
00736             "One of the UUIDs in MIC is null. ");
00737         return;
00738     };
00739     m_volInfo.type         = VOL_IVD;
00740     m_volInfo.sysVol       = (medVolNote.flags & df_volFlagSystem_c) != 0;
00741     m_volInfo.medVolID     = medVolNote.volID;
00742     m_volInfo.poolID       = medVolNote.poolID;
00743     m_volInfo.partID       = medVolNote.partID;
00744     m_volInfo.blockSize    = medVolNote.blockSize;
00745     m_volInfo.accessNum    = medVolNote.numAccesses;
00746     m_volInfo.appendNum    = medVolNote.numAppends;
00747     m_volInfo.owriteNum    = medVolNote.numOverwrites;
00748     m_volInfo.accessTime   = medVolNote.timeAccess;
00749     m_volInfo.appendTime   = medVolNote.timeWrite;
00750     m_volInfo.owriteTime   = medVolNote.timeOverwrite;
00751     m_volInfo.sysVolNum    = 0; // Assume no system volume.
00752 
00753     for (UInt32_t i = 0; i < m_medium_p->GetVolumeCount(); i++) {
00754         medVolNote = mm->GetVolumeRecord(i+1);
00755         if ( (medVolNote.flags & df_volFlagSystem_c) != 0 ) {
00756             log_DBG_m(dbg_LOW,
00757                 "System volume detected on volume: " << (i+1));
00758             m_volInfo.sysVolNum = i+1;
00759             break;
00760         }
00761     };
00762 
00763     log_DBG_m(dbg_NORM, "Media volume info read from MIC.");
00764     m_validVolInfo = true;
00765 }

Here is the call graph for this function:

Here is the caller graph for this function:

void bea_Volume::UpdateMediumMem ( const bea_VolInfo_t &  a_volInfo  )  [private]

Definition at line 769 of file bea_volume.cpp.

References df_TCMMedium_t::barcode, bea_VolInfo_t::blockSize, df_TCMMediaVolume_t::blockSize, dbg_LOW, dbg_NORM, df_volFlagSystem_c, evt_ERROR, df_TCMMediaVolume_t::flags, bea_Medium::GetBarcode(), ivd_BaseException::GetFriendly(), GetJobID(), bea_Medium::GetMediumMem(), df_TCMMediaVolume_t::initTime, bea_Medium::IsMediumMemDetected(), bea_Medium::IsMediumMemValid(), log_DBG_m, log_FUNC_m, log_WriteEvent(), m_medium_p, m_volNumber, bea_VolInfo_t::medVolID, NULL, df_TCMMediaVolume_t::numAccesses, df_TCMMediaVolume_t::numAppends, df_TCMMediaVolume_t::numOverwrites, bea_VolInfo_t::partID, df_TCMMediaVolume_t::partID, bea_VolInfo_t::poolID, df_TCMMediaVolume_t::poolID, bea_VolInfo_t::sysVol, df_TCMMediaVolume_t::timeAccess, df_TCMMediaVolume_t::timeOverwrite, df_TCMMediaVolume_t::timeWrite, bea_MediumMemory::UpdateMediumRecord(), bea_MediumMemory::UpdateVolumeRecord(), and df_TCMMediaVolume_t::volID.

Referenced by Init(), and ReadVolInfoFromHeader().

00769                                                                {
00770     log_FUNC_m(UpdateMediumMem);
00771 
00772     if (!m_medium_p->IsMediumMemDetected()) {
00773         log_DBG_m(dbg_NORM, "Medium memory not detected. Can't update.");
00774         return;
00775     }
00776 
00777     log_DBG_m(dbg_LOW, "Updating medium memory.");
00778     bea_MediumMemory* mm = m_medium_p->GetMediumMem();
00779     try {
00780         if (!m_medium_p->IsMediumMemValid()) {
00781             log_DBG_m(dbg_LOW, "No medium memory contents on. Creating new.");
00782 
00783             df_TCMMedium_t newMedNote;
00784             memcpy(newMedNote.barcode,
00785                 m_medium_p->GetBarcode().data(),
00786                 m_medium_p->GetBarcode().length() );
00787 
00788             mm->UpdateMediumRecord(newMedNote);
00789         } // if (!m_medium_p->IsMediumMemValid())
00790         else {
00791             log_DBG_m(dbg_LOW, "Medium memory contents is valid!");
00792         };
00793 
00794         df_TCMMediaVolume_t medVolNote;
00795         if (a_volInfo.sysVol) {
00796             medVolNote.flags = df_volFlagSystem_c;
00797         };
00798 
00799         medVolNote.blockSize = a_volInfo.blockSize;
00800         medVolNote.volID = a_volInfo.medVolID;
00801         medVolNote.poolID = a_volInfo.poolID;
00802         medVolNote.partID = a_volInfo.partID;
00803         medVolNote.numAccesses = 0;
00804         medVolNote.numAppends = 0;
00805         medVolNote.numOverwrites = 0;
00806         medVolNote.initTime = (ivd_Time_t)time(NULL);
00807         medVolNote.timeWrite = 0;
00808         medVolNote.timeAccess = 0;
00809         medVolNote.timeOverwrite = 0;
00810 
00811         mm->UpdateVolumeRecord(m_volNumber, medVolNote);
00812     }
00813     catch (ivd_Exception &ie) {
00814         ostringstream sstr;
00815         sstr << "Writing to MIC FAILED (" << ie.GetFriendly() << ").";
00816         log_WriteEvent(
00817             evt_ERROR,
00818             sstr.str(),
00819             "",
00820             GetJobID(),
00821             m_medium_p->GetBarcode());
00822     }
00823     catch(...) {
00824         log_WriteEvent(
00825             evt_ERROR,
00826             "Writing to MIC FAILED.",
00827             "",
00828             GetJobID(),
00829             m_medium_p->GetBarcode());
00830     }
00831 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bea_Medium* const bea_Volume::m_medium_p [protected]

Definition at line 180 of file bea_volume.h.

Referenced by DoMediumLogging(), GetJobID(), GetMedium(), Init(), MustDumpFRI(), bea_TapeVolume::ReadEstimSizes(), bea_DiskVolume::ReadEstimSizes(), ReadVolInfoFromHeader(), ReadVolInfoFromMediumMem(), bea_TapeVolume::Rewind(), bea_DiskVolume::Rewind(), bea_TapeVolume::SeekBlock(), bea_DiskVolume::SeekBlock(), bea_TapeVolume::SeekEOD(), bea_DiskVolume::SeekEOD(), bea_TapeVolume::SeekFileMark(), bea_DiskVolume::SeekFileMark(), UpdateMediumMem(), bea_TapeVolume::WriteFileMarks(), and bea_DiskVolume::WriteFileMarks().

bool bea_Volume::m_atEOD [protected]

Definition at line 181 of file bea_volume.h.

Referenced by bea_DiskVolume::Erase(), InvalidateEOD(), bea_TapeVolume::ReadEstimSizes(), bea_TapeVolume::SeekEOD(), bea_DiskVolume::SeekEOD(), bea_DiskVolume::SeekFileMark(), Write(), bea_TapeVolume::WriteFileMarks(), bea_DiskVolume::WriteFileMarks(), bea_DiskVolume::WriteRaw(), and WriteVolHdr().

bea_Volume::log_CLASSID_m [private]

Reimplemented in bea_DiskVolume, and bea_TapeVolume.

Definition at line 184 of file bea_volume.h.

UInt32_t bea_Volume::m_volNumber [private]

Definition at line 186 of file bea_volume.h.

Referenced by bea_Volume(), GetVolumeNumber(), Init(), ReadVolInfoFromHeader(), ReadVolInfoFromMediumMem(), and UpdateMediumMem().

UInt32_t bea_Volume::m_size [private]

Definition at line 189 of file bea_volume.h.

Referenced by bea_Volume(), GetSize(), ReadVolInfoFromHeader(), ReadVolInfoFromMediumMem(), and SetDeclaredSize().

bool bea_Volume::m_validSizes [private]

Definition at line 192 of file bea_volume.h.

Referenced by GetEstimRemainingSize(), GetEstimTotalSize(), InvalidateSizes(), SetEstimatedSizes(), Write(), and WriteVolHdr().

UInt32_t bea_Volume::m_estimSize [private]

Definition at line 193 of file bea_volume.h.

Referenced by GetEstimTotalSize(), and SetEstimatedSizes().

UInt32_t bea_Volume::m_estimFree [private]

Definition at line 194 of file bea_volume.h.

Referenced by GetEstimRemainingSize(), and SetEstimatedSizes().

bool bea_Volume::m_validVolInfo [private]

Is volume info record valid?

Definition at line 197 of file bea_volume.h.

Referenced by GetBlockSize(), GetPartitionID(), GetPoolID(), GetVolumeID(), GetVolumeInfo(), GetVolumeType(), Init(), IsSysVolume(), OverrideIDs(), ReadVolInfoFromHeader(), ReadVolInfoFromMediumMem(), and SetBlockSize().

bea_VolInfo_t bea_Volume::m_volInfo [private]

Definition at line 198 of file bea_volume.h.

Referenced by GetBlockSize(), GetPartitionID(), GetPoolID(), GetVolumeID(), GetVolumeInfo(), GetVolumeType(), Init(), IsSysVolume(), OverrideIDs(), Read(), ReadVolInfoFromHeader(), ReadVolInfoFromMediumMem(), SetBlockSize(), and Write().

The documentation for this class was generated from the following files:
Generated on Mon Feb 27 19:01:49 2012 for OPENARCHIVE by  doxygen 1.5.6