|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation 1997-1998
//
// File: cidump.cxx
//
// Contents: CI catalog dump utility
//
// History: 09-Apr-97 SitaramR Created
//
//----------------------------------------------------------------------------
#define _OLE32_
#define __QUERY__
extern "C"{ #include <nt.h>
#include <ntioapi.h>
#include <ntrtl.h>
#include <nturtl.h>
}
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <malloc.h>
#include <math.h>
#include <memory.h>
#include <stddef.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <imagehlp.h>
#include <lmcons.h>
#define _DCOM_
#define _CAIROSTG_
#include <cidebnot.h>
#include <cierror.h>
#define OLEDBVER 0x0250 // enable ICommandTree interface
#include <oleext.h>
#include <oledberr.h>
#include <oledb.h>
#include <query.h>
#include <stgprop.h>
#include <filter.h>
#include <filterr.h>
#include <vquery.hxx>
#include <restrict.hxx>
//
// Base services
//
#include <ciexcpt.hxx>
#include <smart.hxx>
#include <tsmem.hxx>
#include <xolemem.hxx>
#include <dynarray.hxx>
#include <dynstack.hxx>
#include <dblink.hxx>
#include <cisem.hxx>
#include <thrd32.hxx>
#include <readwrit.hxx>
#include <ci.h>
//
// Debug files from
//
#include <cidebug.hxx>
#include <vqdebug.hxx>
//
// CI-specific
//
#include <align.hxx>
#include <memser.hxx>
#include <memdeser.hxx>
#include <tgrow.hxx>
#include <funypath.hxx>
#include <params.hxx>
#include <key.hxx>
#include <keyarray.hxx>
#include <irest.hxx>
#include <cursor.hxx>
#include <idxids.hxx>
#include <dberror.hxx>
// property-related macros and includes
#include <propapi.h>
#include <propstm.hxx>
extern UNICODECALLOUTS UnicodeCallouts;#define DebugTrace( x, y, z )
#ifdef PROPASSERTMSG
#undef PROPASSERTMSG
#endif
#define PROPASSERTMSG( x, y )
#include <rcstrmhd.hxx>
#include <xact.hxx>
#include <pidxtbl.hxx>
#include "cistore.hxx"
#include "physidx.hxx"
#include "pcomp.hxx"
#include "cidir.hxx"
DECLARE_INFOLEVEL(ci)//DECLARE_INFOLEVEL(vq)
//extern BOOL ExceptDllMain( HANDLE hDll, DWORD dwReason, LPVOID lpReserved );
unsigned fVerbose = 0; // Verbose mode dumps all keys, wids and occurrences
unsigned fStats = 0; // Just dump wid/occ counts.
unsigned fFullStats = 0; // Just dump wid/occ counts.
unsigned fKeys = 0; // Key info
unsigned fDistribution = 0; // Key distribution info
unsigned fOccurrences = 0; // Occurrence distribution info
extern "C" GUID CLSID_CTextIFilter = CLSID_TextIFilter;
DWORD Bytes( BitOffset & boff ){ return ( boff.Page() * CI_PAGE_SIZE ) + ( ( boff.Offset() + 7 ) / 8 );}
ULONGLONG BitDistance( BitOffset & b1, BitOffset & b2 ){ ULONGLONG bA = ((ULONGLONG) b1.Page() * (ULONGLONG) ( CI_PAGE_SIZE * 8) ) + b1.Offset(); ULONGLONG bB = ((ULONGLONG) b2.Page() * (ULONGLONG) ( CI_PAGE_SIZE * 8) ) + b2.Offset();
return ( bB - bA );}
//+---------------------------------------------------------------------------
//
// Function: LocaleToCodepage
//
// Purpose: Returns a codepage from a locale
//
// Arguments: [lcid] -- Locale
//
// History: 09-Apr-97 SitaramR Created
//
//----------------------------------------------------------------------------
ULONG LocaleToCodepage( LCID lcid ){ const BUFFER_LENGTH = 10; WCHAR wcsCodePage[BUFFER_LENGTH];
int cwc = GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE, wcsCodePage, BUFFER_LENGTH );
//
// If error, return Ansi code page
//
if ( cwc == 0 ) { ciDebugOut(( DEB_ERROR, "GetLocaleInfoW for lcid %d returned %d\n", lcid, GetLastError() ));
return CP_ACP; }
return wcstoul( wcsCodePage, 0 , 10 );}
void Usage(){ printf( "Usage: cidump <catalog path> [-e indexid] [-d] [-s] [-f] [-v] [-w workid]\n" " -d : Distribution of keys in documents (key, wid, occ)\n" " -e : Exclude this index\n" " -k : Print keys with #files, #occ, pid, size\n" " -s : Stats only\n" " -f : Full Stats only (for all keys)\n" " -v : Verbose (full occurrence information)\n" " -w : Data for this workid only\n\n" "Example: cidump e:\\testdump\\catalog.wci\n" );}
void DumpDirectoryKey( unsigned i, CDirectoryKey & Key ){ BitOffset bo; Key.Offset( bo ); printf( " key %d cb 0x%x, PropId 0x%x, opage 0x%x, obits 0x%x\n", i, Key.Count(), Key.PropId(), bo.Page(), bo.Offset() );} //DumpDirectoryKey
//+---------------------------------------------------------------------------
//
// Function: main
//
// Purpose: Main dump routine
//
// History: 09-Apr-97 SitaramR Created
// 02-Nov-98 KLam Passed disk space to leave to CiStorage
//
//----------------------------------------------------------------------------
int __cdecl main( int argc, char * argv[] ){ char * pszCatDir = argv[1]; WORKID widTarget = 0xFFFFFFFF;
INDEXID aExclude[100]; unsigned cExclude = 0;
if ( argc < 2 ) { Usage(); return 0; }
for ( int i = 1; i < argc; i++ ) { if ( argv[i][0] == '-' ) { switch ( argv[i][1] ) { case 'e': case 'E': i++; aExclude[cExclude] = strtoul( argv[i], 0, 16 ); cExclude++; break;
case 's': case 'S': fStats = 1; break;
case 'd': case 'D': fDistribution = 1; break;
case 'f': case 'F': fFullStats = 1; break;
case 'k': case 'K': fKeys = 1; break;
case 'o': case 'O': fOccurrences = 1; break;
case 'v': case 'V': fVerbose = 1; break;
case 'w': case 'W': i++; widTarget = strtoul( argv[i], 0, 10 ); break;
default: Usage(); return 0; } } else pszCatDir = argv[i]; }
if ( fKeys ) { fFullStats = 0; fStats = 0; fVerbose = 0; }
if ( fDistribution ) { fFullStats = 0; fStats = 0; fVerbose = 0; fKeys = 0; fOccurrences = 0; }
if ( fOccurrences ) { fFullStats = 0; fStats = 0; fVerbose = 0; fKeys = 0; fDistribution = 0; }
if ( (pszCatDir[0] != '\\' || pszCatDir[1] != '\\') && (pszCatDir[0] == '\0' || pszCatDir[1] != ':' || pszCatDir[2] != '\\') ) { printf("Use full path name for catalog path!\n\n"); Usage(); return 1; }
WCHAR wszCatDir[MAX_PATH];
LocaleToCodepage( GetSystemDefaultLCID() );
ULONG cwcActual = MultiByteToWideChar( LocaleToCodepage( GetSystemDefaultLCID() ), 0, pszCatDir, strlen( pszCatDir ) + 1, wszCatDir, MAX_PATH );
if ( 0 == cwcActual ) { Usage(); return 1; }
//
// Keep stats on where we are when we die...
//
CIndexRecord recCrash; CKeyBuf keyCrash; BitOffset boffCrash;
ULONG maxOccCounts = 1024;
TRY { ULONGLONG * aOccCounts = new ULONGLONG[ maxOccCounts ]; ULONGLONG * acbOccCounts = new ULONGLONG[ maxOccCounts ];
CTransaction xact; XPtr<CiStorage> xStorage( new CiStorage( wszCatDir, *((ICiCAdviseStatus *)0), CI_MIN_DISK_SPACE_TO_LEAVE_DEFAULT ) );
XPtr<PIndexTable> xIndexTable( xStorage->QueryIndexTable( xact ) );
SIndexTabIter xIndexIter( xIndexTable->QueryIterator() );
if ( xIndexIter->Begin() ) { CIndexRecord record;
while ( xIndexIter->NextRecord( record ) ) { if ( record.Type() == itMaster || record.Type() == itShadow ) { //
// Do we want to skip this one?
//
for ( unsigned i = 0; i < cExclude; i++ ) { if ( aExclude[i] == record.Iid() ) break; }
if ( i < cExclude ) continue;
recCrash = record; boffCrash.Init( 0, 0 );
if ( !fKeys && !fDistribution && !fOccurrences ) { if ( record.Type() == itMaster ) printf( "Index master: " ); else printf( "Index shadow: " );
printf( "Object id = 0x%x, Index id = 0x%x, MaxWorkid = 0x%x\n", record.ObjectId(), record.Iid(), record.MaxWorkId() ); }
ULONG maxWid = record.MaxWorkId();
SStorageObject xStorageObj( xStorage->QueryObject( record.ObjectId() ) );
PMmStream * pStream = xStorage->QueryExistingIndexStream( xStorageObj.GetObj(), PStorage::eOpenForRead ); XPtr<PMmStream> xStream( pStream ); CPhysIndex *pPhysIndex = new CPhysIndex ( *xStorage.GetPointer(), xStorageObj.GetObj(), record.ObjectId(), PStorage::eOpenForRead, xStream ); Win4Assert( 0 == xStream.GetPointer() );
XPtr<CPhysIndex> xPhysIndex( pPhysIndex );
CiDirectory *pDir = (CiDirectory *) xStorage->QueryExistingDirectory( xStorageObj.GetObj(), PStorage::eOpenForRead ); XPtr<CiDirectory> xDir( pDir);
unsigned cLevel1 = xDir->Level1Count(); unsigned cLevel2 = xDir->Level2Count();
if ( !fKeys && !fDistribution && !fOccurrences ) { printf( "directory has %d level 1 and %d level 2 keys\n", cLevel1, cLevel2 );
if ( fVerbose ) { for ( unsigned i = 0; i < cLevel1; i++ ) DumpDirectoryKey( i, xDir->GetLevel1Key( i ) );
for ( i = 0; i < cLevel2; i++ ) DumpDirectoryKey( i, xDir->GetLevel2Key( i ) ); } }
ULONGLONG cOccInIndex = 0; ULONGLONG cWidsWithOneOcc = 0; ULONGLONG cWidsWith5OrLessOcc = 0; ULONGLONG cWidsWithOcc = 0; ULONG cKeysWithOneWid = 0; ULONG cKeysInIndex = 0; ULONG cbMinimumKey = 100000; ULONG cbMaximumKey = 0; ULONGLONG cBitsForOcc = 0; ULONGLONG cBitsForWid = 0; ULONGLONG cBitsForKey = 0; ULONG cKeysInMoreThanHalfWids = 0; ULONG cOccMinOverall = 0xffffffff; ULONG cOccMaxOverall = 0;
ZeroMemory( aOccCounts, sizeof( ULONGLONG ) * maxOccCounts ); ZeroMemory( acbOccCounts, sizeof( ULONGLONG ) * maxOccCounts );
CPersDeComp *pDecomp = new CPersDeComp( *xDir.GetPointer(), record.Iid(), *xPhysIndex.GetPointer(), record.MaxWorkId(), TRUE, TRUE ); XPtr<CPersDeComp> xDecomp( pDecomp );
const CKeyBuf *pKey; BitOffset off; xDecomp->GetOffset( off );
BitOffset boffBefore; boffBefore.Init( 0, 0 );
for ( pKey = xDecomp->GetKey(); pKey != NULL; pKey = xDecomp->GetNextKey() ) { BitOffset boAfterKey; xDecomp->GetOffset( boAfterKey ); cBitsForKey += BitDistance( boffBefore, boAfterKey );
cKeysInIndex++;
keyCrash = *pKey; xDecomp->GetOffset( boffCrash ); BOOL fFirst = TRUE;
unsigned cWid = 0; unsigned cOccTotal = 0; unsigned cOccMin = 0xFFFFFFFF; unsigned cOccMax = 0;
BitOffset boBeforeWid; xDecomp->GetOffset( boBeforeWid );
if ( fDistribution ) printf( "%ws", pKey->GetStr() );
for ( WORKID wid = xDecomp->WorkId(); wid != widInvalid; wid = xDecomp->NextWorkId() ) { BitOffset boAfterWid; xDecomp->GetOffset( boAfterWid ); cBitsForWid += BitDistance( boBeforeWid, boAfterWid );
cWidsWithOcc++;
xDecomp->GetOffset( boffCrash ); cWid++; if ( fFirst ) { if ( fVerbose || fFullStats || wid == widTarget ) { printf( " Key size = 0x%x, pid = 0x%x, buffer = %ws, " "near page %u (0x%x), bit offset %u (0x%x) --> File offset 0x%x\n", pKey->Count(), pKey->Pid(), pKey->GetStr(), boffCrash.Page(), boffCrash.Page(), boffCrash.Offset(), boffCrash.Offset(), boffCrash.Page() * CI_PAGE_SIZE + (boffCrash.Offset() + 7)/8 );
if ( !fKeys ) fFirst = FALSE; } }
if ( (fVerbose && 0 == widTarget) || wid == widTarget ) printf( "\t wid = 0x%x, MaxOcc = 0x%x, OccCount = 0x%x, " "near page %u (0x%x), bit offset %u (0x%x) --> File offset 0x%x, " "\n\t Occurrences = ", wid, xDecomp->MaxOccurrence(), xDecomp->OccurrenceCount(), boffCrash.Page(), boffCrash.Page(), boffCrash.Offset(), boffCrash.Offset(), boffCrash.Page() * CI_PAGE_SIZE + (boffCrash.Offset() + 7)/8 );
unsigned cOcc = 0;
BitOffset bo1; xDecomp->GetOffset( bo1 );
for ( OCCURRENCE occ = xDecomp->Occurrence(); occ != OCC_INVALID; occ = xDecomp->NextOccurrence() ) { xDecomp->GetOffset( boffCrash ); cOcc++;
if ( (fVerbose && 0 == widTarget) || wid == widTarget ) printf( "0x%x ", occ ); }
if ( cOcc >= maxOccCounts ) { ULONG newMax = cOcc * 2;
ULONGLONG *a1 = new ULONGLONG[ newMax ]; ULONGLONG *a2 = new ULONGLONG[ newMax ];
ZeroMemory( a1, sizeof( ULONGLONG ) * newMax ); ZeroMemory( a2, sizeof( ULONGLONG ) * newMax );
RtlCopyMemory( a1, aOccCounts, sizeof( ULONGLONG ) * maxOccCounts ); RtlCopyMemory( a2, acbOccCounts, sizeof( ULONGLONG ) * maxOccCounts );
delete [] aOccCounts; delete [] acbOccCounts; aOccCounts = a1; acbOccCounts = a2;
maxOccCounts = newMax; }
#if 0
if ( cOcc >= 500 ) { printf( "cocc %d in wid %d, pid %#x, len %d, %ws\n", cOcc, wid, pKey->Pid(), pKey->StrLen(), pKey->GetStr() );
printf( " cb %d: ", pKey->Count() ); BYTE const * pb = pKey->GetBuf(); for ( ULONG i = 0; i < pKey->Count(); i++ ) printf( " %#x", pb[i] ); printf( "\n" ); }#endif
BitOffset bo2; xDecomp->GetOffset( bo2 ); ULONG cDelta = (ULONG) BitDistance( bo1, bo2 ); cBitsForOcc += cDelta;
aOccCounts[ cOcc ]++; acbOccCounts[ cOcc ] += cDelta;
// if ( fOccurrences )
// printf( "%d, %d\n", cOcc, cDelta );
cOccInIndex += cOcc;
if ( 1 == cOcc ) cWidsWithOneOcc++;
if ( cOcc <= 5 ) cWidsWith5OrLessOcc++;
if ( (fVerbose && 0 == widTarget) || wid == widTarget ) printf( "\n" );
cOccTotal += cOcc;
if ( cOcc > cOccMax ) cOccMax = cOcc;
if ( cOcc < cOccMin ) cOccMin = cOcc;
xDecomp->GetOffset( boBeforeWid ); }
if ( 1 == cWid ) cKeysWithOneWid++;
if ( cWid >= ( maxWid/2 ) ) { printf( "key with >= half wids (%u):\n", cWid );
printf( " pid %#x, len %d, %ws\n", pKey->Pid(), pKey->StrLen(), pKey->GetStr() );
printf( " cb %d: ", pKey->Count() ); BYTE const * pb = pKey->GetBuf(); for ( ULONG i = 0; i < pKey->Count(); i++ ) printf( " %#x", pb[i] ); printf( "\n" );
cKeysInMoreThanHalfWids++; }
BitOffset boffAfter; xDecomp->GetOffset( boffAfter );
DWORD b = Bytes( boffAfter ) - Bytes( boffBefore );
if ( b < cbMinimumKey ) cbMinimumKey = b;
if ( b > cbMaximumKey ) cbMaximumKey = b;
// Print this data:
// # of files with the key
// # of occurrences of key in all files
// property id
// # of bytes taken by this key in the index
// string form of the key
//
if ( fKeys ) printf( "%7u %10u %4u %7u %ws\n", cWid, cOccTotal, pKey->Pid(), b, pKey->GetStr() );
boffBefore = boffAfter;
if ( cOccMin < cOccMinOverall ) cOccMinOverall = cOccMin;
if ( cOccMax > cOccMaxOverall ) cOccMaxOverall = cOccMax;
if ( fFullStats ) printf( "%u Workid(s), Total Occ = %u, Min Occ = %u, Max Occ = %u\n", cWid, cOccTotal, cOccMin, cOccMax );
if ( fDistribution ) printf( "! %d! %d\n", cWid, cOccTotal ); }
BitOffset boEnd; xDecomp->GetOffset( boEnd ); BitOffset boStart;
if ( fOccurrences ) for ( ULONG i = 0; i <= cOccMaxOverall; i++ ) { printf( "%I64u, ", aOccCounts[ i ] ); printf( "%I64u\n", acbOccCounts[ i ] / 8 ); }
if ( !fDistribution && !fKeys ) { printf( "cWidsWithOcc %I64u\n", cWidsWithOcc ); printf( "bytes in index: %I64u\n", BitDistance( boStart, boEnd ) / 8 );
printf( "max workid %d\n", maxWid ); printf( "cKeysInIndex: %d\n", cKeysInIndex ); printf( "cOccInIndex %I64u\n", cOccInIndex ); printf( "cWidsWithOneOcc %I64u\n", cWidsWithOneOcc ); printf( "cWidsWith5OrLessOcc %I64u\n", cWidsWith5OrLessOcc ); printf( "cKeysWithOneWid %d\n", cKeysWithOneWid ); printf( "cKeysInMoreThanHalfWids %d\n", cKeysInMoreThanHalfWids );
printf( "cOccMaxOverall %d\n", cOccMaxOverall ); printf( "cOccMinOverall %d\n", cOccMinOverall );
printf( "maximum key bytes %d\n", cbMaximumKey ); printf( "minimum key bytes %d\n", cbMinimumKey ); printf( "bytes for occ data: %I64u\n", ( cBitsForOcc / 8 ) ); printf( "bytes for key data: %I64u\n", ( cBitsForKey / 8 ) ); printf( "bytes for wid data: %I64u\n", ( cBitsForWid / 8 ) );
printf( "total for o+k+w data: %I64u\n", ( cBitsForOcc/8 + cBitsForKey/8 + cBitsForWid/8 ) ); } } else if ( !fKeys && !fDistribution && !fOccurrences ) { switch ( record.Type() ) { case itZombie: printf( "Zombie: " ); break;
case itDeleted: printf( "Deleted: " ); break;
case itPartition: printf( "Partition: " ); break;
case itChangeLog: printf( "ChangeLog: " ); break;
case itFreshLog: printf( "FreshLog: " ); break;
case itPhraseLat: printf( "Phrase Lat: " ); break;
case itKeyList: printf( "Key List: " ); break;
case itMMLog: printf( "MM Log: " ); break;
case itNewMaster: printf( "New Master: " ); break;
case itMMKeyList: printf( "MM Key List: " ); break; } // switch
printf( "Object id = 0x%x, Index id = 0x%x, MaxWorkid = 0x%x\n", record.ObjectId(), record.Iid(), record.MaxWorkId() ); } // if
} // while
} // if
else printf( "0 records found in index table\n" );
delete [] aOccCounts; delete [] acbOccCounts; } CATCH( CException, e ) { if ( HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION) == e.GetErrorCode() ) { printf("Sharing violation -- Is cisvc running?\n"); } else { printf( "Caught exception 0x%x in %s 0x%x\n", e.GetErrorCode(), ( recCrash.Type() == itMaster ) ? "master index" : "shadow index", recCrash.Iid() );
printf( "\tProcessing key: %ws (pid = 0x%x)\n", keyCrash.GetStr(), keyCrash.Pid() );
printf( "\tNear page %u (0x%x), bit offset %u (0x%x) --> File offset 0x%x\n", boffCrash.Page(), boffCrash.Page(), boffCrash.Offset(), boffCrash.Offset(), boffCrash.Page() * CI_PAGE_SIZE + (boffCrash.Offset() + 7)/8 ); } } END_CATCH
return 0;}
|
