/****************************************************************************
Desc: Prints the web page for an SCACHEMGR struct
(The URL for this page requires no parameters since there is only
one SCACHE_MGR per copy of FLAIM.)
****************************************************************************/
RCODE F_SCacheMgrPage::display(
FLMUINT uiNumParams,
const char ** ppszParams)
{
RCODE rc = FERR_OK;
SCACHE_MGR LocalSCacheMgr;
FLMBOOL bAutoRefresh;
#define NUM_CACHE_REQ_STRINGS 4
char * pszSCacheRequestString[ NUM_CACHE_REQ_STRINGS];
char szOffsetTable[12][6];
char szAddressTable[2][20];
FLMBOOL bHighlight = FALSE;
char * pszTemp = NULL;
FLMUINT uiLoop;
// Note: The SCacheBlock requests need the following params:
// "BlockAddress", "File", "LowTransID" and "HighTransID"
// ex: <A href="SCacheBlock?BlockAddress=100?File=5?LowTransID=30?HighTransID=100"> pMRUCache </A>
if( RC_BAD( rc = f_alloc( 200, &pszTemp)))
{
printErrorPage( rc, TRUE, (char *)"Failed to allocate temporary buffer");
goto Exit;
}
// First thing that we need to do is grab a local copy of gv_FlmSysData.SCacheMgr,
// and of the data for the three SCache blocks that it has pointers to...
for (uiLoop = 0; uiLoop < NUM_CACHE_REQ_STRINGS; uiLoop++)
{
if( RC_BAD( rc = f_alloc( 150,
&pszSCacheRequestString[ uiLoop])))
{
printErrorPage( rc, TRUE, (char *)"Failed to allocate temporary buffer");
goto Exit;
}
}
f_mutexLock( gv_FlmSysData.hShareMutex);
f_memcpy (&LocalSCacheMgr, &gv_FlmSysData.SCacheMgr, sizeof (LocalSCacheMgr));
flmBuildSCacheBlockString( pszSCacheRequestString[0], LocalSCacheMgr.pMRUCache);
flmBuildSCacheBlockString( pszSCacheRequestString[1], LocalSCacheMgr.pLRUCache);
flmBuildSCacheBlockString( pszSCacheRequestString[2], LocalSCacheMgr.pFirstFree);
flmBuildSCacheBlockString( pszSCacheRequestString[3], LocalSCacheMgr.pLastFree);
f_mutexUnlock( gv_FlmSysData.hShareMutex);
bAutoRefresh = DetectParameter( uiNumParams, ppszParams, "Refresh");
// Now - are we being asked to display the usage stats? Or is this a regular page...
if (DetectParameter( uiNumParams, ppszParams, "Usage"))
{
// There's a function to handle display the usage info (because both
// RCacheMgr and SCacheMgr have usage stats).
writeUsage( &LocalSCacheMgr.Usage, bAutoRefresh,
"/SCacheMgr?Usage",
"Usage Statistics for the SCache");
}
else // This is a regular SCacheMgr page...
{
// Determine if we are being requested to refresh this page or not.
stdHdr();
fnPrintf( m_pHRequest, HTML_DOCTYPE "<HTML>\n");
if (bAutoRefresh)
{
// Send back the page with a refresh command in the header
fnPrintf( m_pHRequest,
"<HEAD>"
"<META http-equiv=\"refresh\" content=\"5; url=%s/SCacheMgr?Refresh\">"
"<TITLE>gv_FlmSysData.SCacheMgr</TITLE>\n", m_pszURLString);
printStyle();
popupFrame(); //Spits out a Javascript function that will open a new window..
fnPrintf( m_pHRequest, "\n</HEAD>\n<body>\n");
f_sprintf( (char *)pszTemp,
"<A HREF=%s/SCacheMgr>Stop Auto-refresh</A>", m_pszURLString);
}
else // bAutoRefresh == FALSE
{
// Send back a page without the refresh command
fnPrintf( m_pHRequest,
"<HEAD>"
"<TITLE>gv_FlmSysData.SCacheMgr</TITLE>\n");
printStyle();
popupFrame(); //Spits out a Javascript function that will open a new window..
fnPrintf( m_pHRequest, "\n</HEAD>\n<body>\n");
f_sprintf( (char *)pszTemp,
"<A HREF=%s/SCacheMgr?Refresh>Start Auto-refresh (5 sec.)</A>",
m_pszURLString);
}
// Write out the table headings
printTableStart( "SCache Manager Structure", 4);
printTableRowStart();
printColumnHeading( "", JUSTIFY_LEFT, FLM_IMON_COLOR_PUTTY_1, 4, 1, FALSE);
fnPrintf( m_pHRequest, "<A HREF=%s/SCacheMgr>Refresh</A>, %s\n", m_pszURLString, pszTemp);
printColumnHeadingClose();
printTableRowEnd();
// Write out the table headings.
printTableRowStart();
printColumnHeading( "Byte Offset (hex)");
printColumnHeading( "Field Name");
printColumnHeading( "Field Type");
printColumnHeading( "Value");
printTableRowEnd();
//Now - we have three rows in the table that may or may not have hyperlinks in them.
printTableRowStart( bHighlight = ~bHighlight);
flmPrintCacheLine(m_pHRequest, pszSCacheRequestString[0], "pMRUCache", &LocalSCacheMgr, &LocalSCacheMgr.pMRUCache);
printTableRowStart( bHighlight = ~bHighlight);
flmPrintCacheLine(m_pHRequest, pszSCacheRequestString[1], "pLRUCache", &LocalSCacheMgr, &LocalSCacheMgr.pLRUCache);
printTableRowStart( bHighlight = ~bHighlight);
flmPrintCacheLine(m_pHRequest, pszSCacheRequestString[2], "pFirstFree", &LocalSCacheMgr, &LocalSCacheMgr.pFirstFree);
printTableRowStart( bHighlight = ~bHighlight);
flmPrintCacheLine(m_pHRequest, pszSCacheRequestString[3], "pLastFree", &LocalSCacheMgr, &LocalSCacheMgr.pLastFree);
//Format the strings that are displayed in the Offset column on of the table
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.ppHashTbl, szOffsetTable[0]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.Usage, szOffsetTable[1]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.bAutoCalcMaxDirty, szOffsetTable[2]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiMaxDirtyCache, szOffsetTable[3]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiLowDirtyCache, szOffsetTable[4]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiTotalUses, szOffsetTable[5]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiBlocksUsed, szOffsetTable[6]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiPendingReads, szOffsetTable[7]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiIoWaits, szOffsetTable[8]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiHashTblSize, szOffsetTable[9]);
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.uiHashTblBits, szOffsetTable[10]);
#ifdef FLM_DEBUG
printOffset(&LocalSCacheMgr, &LocalSCacheMgr.bDebug, szOffsetTable[11]);
#endif
printAddress( LocalSCacheMgr.ppHashTbl, szAddressTable[0]);
printAddress( &LocalSCacheMgr.Usage, szAddressTable[1]);
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s
"<td><A HREF=\"%s/SCacheHashTable?Start=0\">ppHashTbl</A></td>\n"
"<td>SCACHE **</td>\n"
"<td><A href=\"%s/SCacheHashTbl\">%s</A></td>\n",
szOffsetTable[0], m_pszURLString, m_pszURLString, szAddressTable[0]);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s
"<td><A href=\"javascript:openPopup('%s/SCacheMgr?Usage')\">Usage</A></td>\n"
"<td>FLM_CACHE_USAGE</td>\n"
"<td><A href=\"javascript:openPopup('%s/SCacheMgr?Usage')\">%s</A></td>\n",
szOffsetTable[1], m_pszURLString, m_pszURLString, szAddressTable[1]);
printTableRowEnd();
// uiFreeCount
printHTMLUint(
(char *)"uiFreeCount",
(char *)"FLMUINT",
(void *)&LocalSCacheMgr,
(void *)&LocalSCacheMgr.uiFreeCount,
LocalSCacheMgr.uiFreeCount,
(bHighlight = ~bHighlight));
// uiFreeBytes
printHTMLUint(
(char *)"uiFreeBytes",
(char *)"FLMUINT",
(void *)&LocalSCacheMgr,
(void *)&LocalSCacheMgr.uiFreeBytes,
LocalSCacheMgr.uiFreeBytes,
(bHighlight = ~bHighlight));
// uiReplaceableCount
printHTMLUint(
(char *)"uiReplaceableCount",
(char *)"FLMUINT",
(void *)&LocalSCacheMgr,
(void *)&LocalSCacheMgr.uiReplaceableCount,
LocalSCacheMgr.uiReplaceableCount,
(bHighlight = ~bHighlight));
// uiReplaceableBytes
printHTMLUint(
(char *)"uiReplaceableBytes",
(char *)"FLMUINT",
(void *)&LocalSCacheMgr,
(void *)&LocalSCacheMgr.uiReplaceableBytes,
LocalSCacheMgr.uiReplaceableBytes,
(bHighlight = ~bHighlight));
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>bAutoCalcMaxDirty</td>\n"
"<td>FLMBOOL</td>\n" TD_i, szOffsetTable[2],
LocalSCacheMgr.bAutoCalcMaxDirty);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiMaxDirtyCache</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[3],
LocalSCacheMgr.uiMaxDirtyCache);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiLowDirtyCache</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[4],
LocalSCacheMgr.uiLowDirtyCache);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiTotalUses</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[5],
LocalSCacheMgr.uiTotalUses);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiBlocksUsed</td> <td>FLMUINT</td>\n"
TD_lu, szOffsetTable[6], LocalSCacheMgr.uiBlocksUsed);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiPendingReads</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[7],
LocalSCacheMgr.uiPendingReads);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiIoWaits</td>\n <td>FLMUINT</td>\n" TD_lu,
szOffsetTable[8], LocalSCacheMgr.uiIoWaits);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiHashTableSize</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[9],
LocalSCacheMgr.uiHashTblSize);
printTableRowEnd();
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>uiHashTableBits</td>\n"
"<td>FLMUINT</td>\n" TD_lu, szOffsetTable[10],
LocalSCacheMgr.uiHashTblBits);
printTableRowEnd();
#ifdef FLM_DEBUG
printTableRowStart( bHighlight = ~bHighlight);
fnPrintf( m_pHRequest, TD_s "<td>bDebug</td>\n" "<td>FLMBOOL</td>\n"
TD_i, szOffsetTable[11], LocalSCacheMgr.bDebug);
printTableRowEnd();
#endif
printTableEnd();
fnPrintf( m_pHRequest, "</BODY></HTML>\n");
fnEmit();
}
Exit:
if (pszTemp)
{
f_free( &pszTemp);
}
for (uiLoop = 0; uiLoop < NUM_CACHE_REQ_STRINGS; uiLoop++)
{
if( pszSCacheRequestString[uiLoop])
{
f_free( &pszSCacheRequestString[uiLoop]);
}
}
return( rc);
}
/****************************************************************************
Desc: This procedure generates the HTML page to display
the contents of the FFile structure
****************************************************************************/
void F_FFilePage::write_data(
FFILE * pFile,
void * pvFFileAddress,
DATASTRUCT * pDataStruct)
{
char szFormattedTime[13];
char szTemp[100];
char szAddress[20];
char szFFileAddress[20];
FLMBOOL bHighlight = FALSE;
F_UNREFERENCED_PARM( fnPrintf);
if (pFile == NULL)
{
flmAssert(0);
return;
}
else
{
printAddress( pvFFileAddress, szFFileAddress);
// pNext
if ( pFile->pNext)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pNext?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pNext",
"FFILE *",
(void *)pFile,
(void *)&pFile->pNext,
(void *)pFile->pNext,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPrev - previous file in hash bucket.
if (pFile->pPrev)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pPrev?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pPrev",
"FFILE *",
(void *)pFile,
(void *)&pFile->pPrev,
(void *)pFile->pPrev,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiZeroUseCountTime - Time Use Count went to zero
FormatTime(pFile->uiZeroUseCountTime, szFormattedTime);
printHTMLString(
"uiZeroUseCountTime",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiZeroUseCountTime,
(char *)szFormattedTime,
(bHighlight = ~bHighlight));
// uiInternalUseCount - Internal Use Count
printHTMLUint(
"uiInternalUseCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiInternalUseCount,
pFile->uiInternalUseCount,
(bHighlight = ~bHighlight));
// uiUseCount - Current Use Count
printHTMLUint(
"uiUseCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiUseCount,
pFile->uiUseCount,
(bHighlight = ~bHighlight));
// pFirstDb
if (pFile->pFirstDb)
{
char szFDBAddr[20];
printAddress( pFile->pFirstDb, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf( (char *)szTemp,
"%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstDb",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstDb,
(void *)pFile->pFirstDb,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pszDbPath - Database File Name
printHTMLString(
"pszDbPath",
"FLMBYTE *",
(void *)pFile,
(void *)&pFile->pszDbPath,
(char *)(pFile->pszDbPath ? (char *)pFile->pszDbPath : "Null"),
(bHighlight = ~bHighlight));
// pszDataDir
printHTMLString(
"pszDataDir",
"FLMBYTE *",
(void *)pFile,
(void *)&pFile->pszDataDir,
(char *)(pFile->pszDataDir ? (char *)pFile->pszDataDir : "Null"),
(bHighlight = ~bHighlight));
// pNextNUFile - Next Not Used File
if (pFile->pNextNUFile)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pNextNUFile?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pNextNUFile",
"FFILE *",
(void *)pFile,
(void *)&pFile->pNextNUFile,
(void *)pFile->pNextNUFile,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPrevNUFile - Previous Not Used File
if (pFile->pPrevNUFile)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pPrevNUFile?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pPrevNUFile",
"FFILE *",
(void *)pFile,
(void *)&pFile->pPrevNUFile,
(void *)pFile->pPrevNUFile,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pSCacheList - Shared Cache Blocks
if (pFile->pSCacheList)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->SCacheBlkAddress,
szFFileAddress,
pDataStruct->SCacheLowTransID,
pDataStruct->SCacheHighTransID);
}
printHTMLLink(
"pSCacheList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pSCacheList,
(void *)pFile->pSCacheList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPendingWriteList
if (pFile->pPendingWriteList)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->PendingWriteBlkAddress,
szFFileAddress,
pDataStruct->PendingWriteLowTransID,
pDataStruct->PendingWriteHighTransID);
}
printHTMLLink(
"pPendingWriteList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pPendingWriteList,
(void *)pFile->pPendingWriteList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastDirtyBlk
if (pFile->pLastDirtyBlk)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->LastDirtyBlkAddress,
szFFileAddress,
pDataStruct->LastDirtyLowTransID,
pDataStruct->LastDirtyHighTransID);
}
printHTMLLink(
"pLastDirtyBlk",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pLastDirtyBlk,
(void *)pFile->pLastDirtyBlk,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiDirtyCacheCount
printHTMLUint(
"uiDirtyCacheCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiDirtyCacheCount,
pFile->uiDirtyCacheCount,
(bHighlight = ~bHighlight));
// uiLogCacheCount
printHTMLUint(
"uiLogCacheCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiLogCacheCount,
pFile->uiLogCacheCount,
(bHighlight = ~bHighlight));
// pFirstRecord - First Record Cache Block
// **Do we need to rework this by passing in the Container, Drn, pFile & LowTransId? ** //
if (pFile->pFirstRecord)
{
f_sprintf( (char *)szTemp,
"%s/RCache?Container=%lu?DRN=%lu?File=%s?Version=%lu",
m_pszURLString,
pDataStruct->FirstRecordContainer,
pDataStruct->FirstRecordDrn,
szFFileAddress,
pDataStruct->FirstRecordLowTransId);
}
printHTMLLink(
"pFirstRecord",
"RCACHE_p",
(void *)pFile,
(void *)&pFile->pFirstRecord,
(void *)pFile->pFirstRecord,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastRecord - Last Record Cache Block
if (pFile->pLastRecord)
{
f_sprintf( (char *)szTemp,
"%s/RCache?Container=%lu?DRN=%lu?File=%s?Version=%lu",
m_pszURLString,
pDataStruct->LastRecordContainer,
pDataStruct->LastRecordDrn,
szFFileAddress,
pDataStruct->LastRecordLowTransId);
}
printHTMLLink(
"pLastRecord",
"RCACHE_p",
(void *)pFile,
(void *)&pFile->pLastRecord,
(void *)pFile->pLastRecord,
(char *)szTemp,
(bHighlight = ~bHighlight));
// ppBlocksDone - List of blocks to be written to the Rollback
if (pFile->ppBlocksDone)
{
f_sprintf( (char *)szTemp,
"%s/SCache?From=FFile?Link=ppBlocksDone?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"ppBlocksDone",
"SCACHE **",
(void *)pFile,
(void *)&pFile->ppBlocksDone,
(void *)pFile->ppBlocksDone,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiBlocksDoneArraySize
printHTMLUint(
"uiBlocksDoneArraySize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBlocksDoneArraySize,
pFile->uiBlocksDoneArraySize,
(bHighlight = ~bHighlight));
// uiBlocksDone - Number of Blocks in Blocks Done Array
printHTMLUint(
"uiBlocksDone",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBlocksDone,
pFile->uiBlocksDone,
(bHighlight = ~bHighlight));
// pTransLogList - Shared Cache Log List
if (pFile->pTransLogList != NULL)
{
f_sprintf( (char *)szTemp,
"%s/SCache?From=FFile?Link=pTransLogList?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pTransLogList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pTransLogList,
(void *)pFile->pTransLogList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pOpenNotifies - Open Notifies Threads
if (pFile->pOpenNotifies != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?Link=pOpenNotifies?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pOpenNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pOpenNotifies,
(void *)pFile->pOpenNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCloseNotifies
if (pFile->pCloseNotifies != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?Link=pCloseNotifies?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCloseNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pCloseNotifies,
(void *)pFile->pCloseNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pDictList - Dictionaries List
if (pFile->pDictList != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FDICT?From=FFile?Link=pDictList?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pDictList",
"FDICT *",
(void *)pFile,
(void *)&pFile->pDictList,
(void *)pFile->pDictList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// krefPool - Kref pool
printAddress( &pFile->krefPool, szAddress);
printHTMLString(
"krefPool",
"POOL",
(void *)pFile,
(void *)&pFile->krefPool,
(char *)szAddress,
(bHighlight = ~bHighlight));
// FileHdr - File Header
f_sprintf( (char *)szTemp,
"%s/FILE_HDR?From=FFile?Link=FileHdr?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
printHTMLLink(
"FileHdr",
"FILE_HDR",
(void *)pFile,
(void *)&pFile->FileHdr,
(void *)&pFile->FileHdr,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiMaxFileSize - Maximum File Size
printHTMLUint(
"uiMaxFileSize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiMaxFileSize,
pFile->uiMaxFileSize,
(bHighlight = ~bHighlight));
// uiFileExtendSize - File Extend Size
printHTMLUint(
"uiFileExtendSize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFileExtendSize,
pFile->uiFileExtendSize,
(bHighlight = ~bHighlight));
// uiUpdateTransID - Update Transaction Id
printHTMLUint(
"uiUpdateTransID",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiUpdateTransID,
pFile->uiUpdateTransID,
(bHighlight = ~bHighlight));
// pRfl - Roll Forward Log Object
if (pFile->pRfl)
{
f_sprintf( (char *)szTemp,
"%s/Rfl?From=FFile?Link=pRfl?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pRfl",
"F_Rfl *",
(void *)pFile,
(void *)&pFile->pRfl,
(void *)pFile->pRfl,
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucLastCommittedLogHdr - Last Committed Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?"
"Link=ucLastCommittedLogHdr?"
"Address=%s?Bucket=%ld",
m_pszURLString,
szFFileAddress, pFile->uiBucket);
printHTMLLink(
"ucLastCommittedLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucLastCommittedLogHdr[0],
(void *)&pFile->ucLastCommittedLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucCheckpointLogHdr - Checkpoint Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?"
"Link=ucCheckpointLogHdr?"
"Address=%s?Bucket=%ld",
m_pszURLString,
szFFileAddress, pFile->uiBucket);
printHTMLLink(
"ucCheckpointLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucCheckpointLogHdr[0],
(void *)&pFile->ucCheckpointLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucUncommittedLogHdr - Uncommitted Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?Link=ucUncommittedLogHdr?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
printHTMLLink(
"ucUncommittedLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucUncommittedLogHdr[0],
(void *)&pFile->ucUncommittedLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// pBufferMgr
f_sprintf( (char *)szTemp,
"%s/F_IOBufferMgr?From=FFile?"
"Link=pBufferMgr?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
printHTMLLink(
"pBufferMgr",
"F_IOBufferMgr *",
(void *)pFile,
(void *)&pFile->pBufferMgr,
(void *)pFile->pBufferMgr,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCurrLogBuffer
f_sprintf( (char *)szTemp,
"%s/F_IOBuffer?From=FFile?"
"Link=pCurrLogBuffer?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
printHTMLLink(
"pCurrLogBuffer",
"F_IOBuffer *",
(void *)pFile,
(void *)&pFile->pCurrLogBuffer,
(void *)pFile->pCurrLogBuffer,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiCurrLogWriteOffset
printHTMLUint(
"uiCurrLogWriteOffset",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiCurrLogWriteOffset,
pFile->uiCurrLogWriteOffset,
(bHighlight = ~bHighlight));
// uiCurrLogBlkAddr
printHTMLUint(
"uiCurrLogBlkAddr",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiCurrLogBlkAddr,
pFile->uiCurrLogBlkAddr,
(bHighlight = ~bHighlight));
// pFileLockObj - File Locking Object
if (pFile->pFileLockObj)
{
f_sprintf( (char *)szTemp,
"%s/ServerLockObject?From=FFile?"
"Link=pFileLockObj?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pFileLockObj",
"ServerLockObject_p",
(void *)pFile,
(void *)&pFile->pFileLockObj,
(void *)pFile->pFileLockObj,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pWriteLockObj
if (pFile->pWriteLockObj)
{
f_sprintf( (char *)szTemp,
"%s/ServerLockObject?From=FFile?"
"Link=pWriteLockObj?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pWriteLockObj",
"ServerLockObject_p",
(void *)pFile,
(void *)&pFile->pWriteLockObj,
(void *)pFile->pWriteLockObj,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLockFileHdl - File Lock Handle (3.x Db)
if (pFile->pLockFileHdl)
{
f_sprintf( (char *)szTemp,
"%s/F_FileHdl?From=FFile?"
"Link=pLockFileHdl?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pLockFileHdl",
"F_FileHdl_p",
(void *)pFile,
(void *)&pFile->pLockFileHdl,
(void *)pFile->pLockFileHdl,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLockNotifies - Notifies List
if (pFile->pLockNotifies)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?"
"Link=pLockNotifies?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pLockNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pLockNotifies,
(void *)pFile->pLockNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// bBeingLocked - File being locked
printHTMLString(
"bBeingLocked",
"FLMBOOL",
(void *)pFile,
(void *)&pFile->bBeingLocked,
(char *)(pFile->bBeingLocked ? "Yes" : "No"),
(bHighlight = ~bHighlight));
// pFirstReadTrans - First Read Transaction
if (pFile->pFirstReadTrans)
{
char szFDBAddr[20];
printAddress( pFile->pFirstReadTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf( (char *)szTemp,
"%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstReadTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstReadTrans,
(void *)pFile->pFirstReadTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastReadTrans - Last Read Transaction
if (pFile->pLastReadTrans)
{
char szFDBAddr[20];
printAddress( pFile->pLastReadTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf(
(char *)szTemp, "%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pLastReadTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pLastReadTrans,
(void *)pFile->pLastReadTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pFirstKilledTrans - First Killed Transaction
if (pFile->pFirstKilledTrans)
{
char szFDBAddr[20];
printAddress( pFile->pFirstKilledTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf(
(char *)szTemp, "%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstKilledTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstKilledTrans,
(void *)pFile->pFirstKilledTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiFirstLogBlkAddress
printHTMLUint(
"uiFirstLogBlkAddress",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFirstLogBlkAddress,
pFile->uiFirstLogBlkAddress,
(bHighlight = ~bHighlight));
// uiFirstLogCPBlkAddress - First Log Checkpoint Block Address
printHTMLUint(
"uiFirstLogCPBlkAddress",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFirstLogCPBlkAddress,
pFile->uiFirstLogCPBlkAddress,
(bHighlight = ~bHighlight));
// uiLastCheckpointTime - Last Checkpoint Time
FormatTime( pFile->uiLastCheckpointTime, szFormattedTime);
printHTMLString(
"uiLastCheckpointTime",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiLastCheckpointTime,
(char *)szFormattedTime,
(bHighlight = ~bHighlight));
// pCPThrd
if (pFile->pCPThrd)
{
f_sprintf( (char *)szTemp,
"%s/F_Thread?From=FFile?"
"Link=pCPThrd?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCPThrd",
"F_Thread *",
(void *)pFile,
(void *)&pFile->pCPThrd,
(void *)pFile->pCPThrd,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCPInfo - Checkpoint Info Buffer
if (pFile->pCPInfo)
{
f_sprintf( (char *)szTemp,
"%s/CP_INFO?From=FFile?Link=pCPInfo?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCPInfo",
"CP_INFO_p",
(void *)pFile,
(void *)&pFile->pCPInfo,
(void *)pFile->pCPInfo,
(char *)szTemp,
(bHighlight = ~bHighlight));
// CheckpointRc - Last Checkpoint Return Code
printHTMLUint(
"CheckpointRc",
"FLMUINT",
(void *)pFile,
(void *)&pFile->CheckpointRc,
pFile->CheckpointRc,
(bHighlight = ~bHighlight));
// uiBucket - Hash Table Bucket
printHTMLUint(
"uiBucket",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBucket,
pFile->uiBucket,
(bHighlight = ~bHighlight));
// uiFlags - Flags
if (pFile->uiFlags)
{
FLMBOOL bTest = FALSE;
char * pTemp = (char *)szTemp;
f_sprintf( (char *)szTemp, "%08X<br>", (unsigned)pFile->uiFlags);
pTemp += 12;
if (pFile->uiFlags & DBF_BEING_OPENED)
{
f_sprintf(pTemp, "Being Opened");
pTemp += f_strlen("Being Opened");
bTest=TRUE;
}
if (pFile->uiFlags & DBF_IN_NU_LIST)
{
if (bTest)
{
f_sprintf(pTemp, "<br>");
pTemp += f_strlen("<br>");
}
f_sprintf(pTemp, "In Not Used List");
pTemp += f_strlen("In Not Used List");
bTest = TRUE;
}
if (pFile->uiFlags & DBF_BEING_CLOSED)
{
if (bTest)
{
f_sprintf(pTemp, "<br>");
pTemp += f_strlen("<br>");
}
f_sprintf(pTemp, "Being Closed");
pTemp += f_strlen("Being Closed");
}
}
else
{
f_sprintf( (char *)szTemp, "%08X<br>Normal", (unsigned)pFile->uiFlags);
}
printHTMLString(
"uiFlags",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFlags,
(char *)szTemp,
(bHighlight = ~bHighlight));
// bBackupActive - Backup Active
printHTMLString(
"bBackupActive",
"FLMBOOL",
(void *)pFile,
(void *)&pFile->bBackupActive,
(char *)(pFile->bBackupActive ? "Yes" : "No"),
(bHighlight = ~bHighlight));
printTableEnd();
}
}
