OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/inetsrv/query/cicat/usnmgr.cxx

2649 lines
88 KiB
C++
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997-1999.
//
// File: usnmgr.cxx
//
// Contents: Usn manager
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <eventlog.hxx>
#include <cievtmsg.h>
#include <smatch.hxx>
#include <cifrmcom.hxx>
#include "cicat.hxx"
#include "notifmgr.hxx"
#include "usnmgr.hxx"
#include "usntree.hxx"
//
// Local constants
//
unsigned const USN_LOG_DANGER_THRESHOLD = 50;
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::CUsnMgr
//
// Synopsis: Constructor
//
// Arguments: [cicat] -- Catalog
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
CUsnMgr::CUsnMgr( CiCat & cicat )
: _cicat(cicat),
_fAbort(FALSE),
_fBatch(FALSE),
#pragma warning( disable : 4355 ) // this used in base initialization
_thrUsn(UsnThread, this, TRUE),
#pragma warning( default : 4355 )
_fUpdatesDisabled(FALSE),
_fDoingRenameTraverse( FALSE ),
_waitForMultObj(1+RTL_MAX_DRIVE_LETTERS), // 1 for _evtUsn + RTL_MAX_DRIVE_LETTERS drives (a: to z: + few special chars)
_fWaitingForUpdates( FALSE )
{
_evtUsn.Reset();
_thrUsn.SetPriority(THREAD_PRIORITY_BELOW_NORMAL);
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::~CUsnMgr
//
// Synopsis: Destructor
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
CUsnMgr::~CUsnMgr()
{
InitiateShutdown();
WaitForShutdown();
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::GetMaxUSNs, public
//
// Synopsis: Updates or adds entries to flushInfoList to reflect the max
// usn processed for the volumes.
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::GetMaxUSNs( CUsnFlushInfoList & flushInfoList )
{
for ( CUsnVolumeIter usnVolIter( _usnVolumesToMonitor );
!_usnVolumesToMonitor.AtEnd( usnVolIter );
_usnVolumesToMonitor.Advance( usnVolIter ) )
{
//
// Look for the volume and store the highest usn if found.
//
BOOL fFound = FALSE;
for ( unsigned i = 0; i < flushInfoList.Count(); i++ )
{
CUsnFlushInfo & info = * ( flushInfoList.Get( i ) );
if ( usnVolIter->VolumeId() == info.volumeId )
{
ciDebugOut(( DEB_ITRACE,
"GetMaxUSNs updating vol %wc from %#I64x to %#I64x\n",
usnVolIter->DriveLetter(),
info.usnHighest,
usnVolIter->MaxUsnRead() ));
info.usnHighest = usnVolIter->MaxUsnRead();
fFound = TRUE;
break;
}
}
//
// If the volume isn't in the list yet, add it.
//
if ( !fFound )
{
ciDebugOut(( DEB_ITRACE,
"GetMaxUSNs adding vol %wc %#I64x\n",
usnVolIter->DriveLetter(),
usnVolIter->MaxUsnRead() ));
XPtr<CUsnFlushInfo> xInfo( new CUsnFlushInfo( usnVolIter->VolumeId(),
usnVolIter->MaxUsnRead() ) );
flushInfoList.Add( xInfo.GetPointer(), i );
xInfo.Acquire();
}
}
} //GetMaxUSNs
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::AddScope
//
// Synopsis: Scans scope and then monitors scope for usn notifications
//
// Arguments: [pwcsScope] -- Scope
// [volumeId] -- Volume id
// [fDoDeletions] -- Should delete processing be done ?
// [usnStart] -- "High water mark" of previous activity
// [fFullScan] -- TRUE if we should start over from scratch
// [fUserInitiatedScan] -- TRUE if the user asked for the scan
// [fNewScope] -- TRUE if scope was just added to the catalog
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::AddScope( WCHAR const *pwcsScope,
VOLUMEID volumeId,
BOOL fDoDeletions,
USN const & usnStart,
BOOL fFullScan,
BOOL fUserInitiatedScan,
BOOL fNewScope )
{
Win4Assert( wcslen(pwcsScope) < MAX_PATH );
XPtr<CCiScanInfo> xScanInfo( QueryScanInfo( pwcsScope,
volumeId,
usnStart,
fDoDeletions,
fUserInitiatedScan,
fNewScope ) );
xScanInfo->SetScan();
if ( fFullScan )
xScanInfo->SetFullUsnScan();
ScanScope( xScanInfo, FALSE );
} //AddScope
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::MonitorScope
//
// Synopsis: Monitors scope for usn notifications, i.e. no scan is done
//
// Arguments: [pwcsScope] - Scope
// [volumeId] - Volume id
// [usnStart] - Usn to start monitoring from
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::MonitorScope( WCHAR const *pwcsScope,
VOLUMEID volumeId,
USN usnStart )
{
Win4Assert( wcslen(pwcsScope) < MAX_PATH );
XPtr<CCiScanInfo> xScanInfo( QueryScanInfo( pwcsScope,
volumeId,
usnStart,
FALSE ) );
xScanInfo->SetMonitorOnly();
ScanScope( xScanInfo, FALSE );
} //MonitorScope
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::RemoveScope
//
// Synopsis: Removes usn path from catalog
//
// Arguments: [pwscScope] - Scope to be removed
// [volumeId] - Volume id
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::RemoveScope( WCHAR const *pwcsScope, VOLUMEID volumeId )
{
//
// If the given scope is in the list of paths being currently
// scanned, we must mark it deleted.
//
BOOL fRemoved = FALSE;
{
CLock lock(_mutex);
if ( _fAbort || _fUpdatesDisabled )
return;
for ( CFwdScanInfoIter scanInfoIter1( _usnScansToDo );
!_usnScansToDo.AtEnd( scanInfoIter1 );
_usnScansToDo.Advance( scanInfoIter1 ) )
{
WCHAR const * pwcsPath = scanInfoIter1->GetPath();
if ( AreIdenticalPaths( pwcsScope, pwcsPath ) )
{
fRemoved = TRUE;
if ( !scanInfoIter1->LokIsDelScope() )
scanInfoIter1->LokSetDelScope();
}
}
if ( !fRemoved )
{
LokScheduleRemove( pwcsScope, volumeId );
fRemoved = TRUE;
}
{
CLock lock(_mutex);
if ( !_fBatch )
_evtUsn.Set(); // wake up the usn thread.
}
Win4Assert( fRemoved );
}
} //RemoveScope
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ScanScope
//
// Synopsis: Scan the given scopes and then start monitoring for usn
// notifications
//
// Arguments: [xScanInfo] - Scan info
// [fRefiled] - Is this a refiled scan ?
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::ScanScope( XPtr<CCiScanInfo> & xScanInfo,
BOOL fRefiled )
{
CLock lock(_mutex);
#if CIDBG==1
//
// Debug code to track down the cause of _fUsnTreeScan assert
//
if ( xScanInfo->LokIsInScan() )
_cicat.CheckUsnTreeScan( xScanInfo->GetPath() );
#endif
ciDebugOut(( DEB_ITRACE, "CUsnMgr::ScanScope, retries %d\n",
xScanInfo->GetRetries() ));
if ( xScanInfo->GetRetries() > CCiScanInfo::MAX_RETRIES )
{
//
// Log event that scan failed, cleanup and then return
//
CEventLog eventLog( NULL, wcsCiEventSource );
CEventItem item( EVENTLOG_ERROR_TYPE,
CI_SERVICE_CATEGORY,
MSG_CI_CONTENTSCAN_FAILED,
1 );
item.AddArg( xScanInfo->GetPath() );
eventLog.ReportEvent( item );
CCiScanInfo * pScanInfo = xScanInfo.Acquire();
delete pScanInfo;
return;
}
if ( LokIsScanScheduled( xScanInfo ) )
{
ciDebugOut(( DEB_ITRACE, "CUsnMgr::ScanScope scan was already scheduled\n" ));
CCiScanInfo * pScanInfo = xScanInfo.Acquire();
delete pScanInfo;
}
else
{
Win4Assert( !xScanInfo->LokIsInFinalState() );
Win4Assert( xScanInfo->LokIsInScan()
|| xScanInfo->LokIsInFullUsnScan()
|| xScanInfo->LokIsDelScope()
|| xScanInfo->LokIsRenameDir()
|| xScanInfo->LokIsMonitorOnly() );
ciDebugOut(( DEB_ITRACE,
"CUsnMgr::ScanScope scan wasn't already scheduled, fRefiled: %d\n",
fRefiled ));
if ( fRefiled )
{
//
// A scan that has been refiled should be done before new scans to
// ensure that all scans are done in FIFO order
//
_usnScansToDo.Push( xScanInfo.GetPointer() );
}
else
_usnScansToDo.Queue( xScanInfo.GetPointer() );
xScanInfo.Acquire();
if ( !_fBatch )
_evtUsn.Set();
}
} //ScanScope
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::LokIsScanScheduled
//
// Synopsis: Tests if the given scope is already scheduled for a scan.
//
// Arguments: [xScanInfo] - Smart pointer to scaninfo
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
BOOL CUsnMgr::LokIsScanScheduled( const XPtr<CCiScanInfo> & xScanInfo )
{
WCHAR const * pwszNewScope = xScanInfo->GetPath();
unsigned lenNewScope = wcslen( pwszNewScope );
for ( CFwdScanInfoIter scanInfoIter(_usnScansToDo);
!_usnScansToDo.AtEnd(scanInfoIter);
_usnScansToDo.Advance(scanInfoIter) )
{
if ( xScanInfo->LokGetWorkType() == scanInfoIter->LokGetWorkType() )
{
WCHAR const * pwszPath = scanInfoIter->GetPath();
CScopeMatch scope( pwszPath, wcslen(pwszPath) );
if (scope.IsInScope( pwszNewScope, lenNewScope ))
{
ciDebugOut(( DEB_WARN,
"Usn scan already scheduled for (%ws)\n",
pwszNewScope ));
return TRUE;
}
}
}
return FALSE;
} //LokIsScanScheduled
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::QueryScanInfo, private
//
// Synopsis: Returns a new instance of CCiScanInfo
//
// Arguments: [pwcsScope] -- Scope
// [volumeId] -- Volume id
// [usnStart] -- Start usn
// [fDoDeletions] -- Shoud deletions be done ?
// [fUserInitiatedScan] -- TRUE if the user asked for the scan
// [fNewScope] -- TRUE if scope was just added to the catalog
//
// History: 05-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
CCiScanInfo * CUsnMgr::QueryScanInfo( WCHAR const * pwcsScope,
VOLUMEID volumeId,
USN usnStart,
BOOL fDoDeletions,
BOOL fUserInitiatedScan,
BOOL fNewScope )
{
Win4Assert( 0 != pwcsScope );
//
// Check for remote path
//
Win4Assert( pwcsScope[0] != L'\\' );
ULONG len = wcslen( pwcsScope );
Win4Assert( pwcsScope[len-1] == L'\\' );
XArray<WCHAR> xPath( len+1 );
WCHAR * pwcsLocal = xPath.Get();
RtlCopyMemory( pwcsLocal, pwcsScope, (len+1)*sizeof(WCHAR) );
CCiScanInfo * pScanInfo = new CCiScanInfo( xPath,
1,
UPD_FULL,
fDoDeletions,
volumeId,
usnStart,
fUserInitiatedScan,
fNewScope );
return pScanInfo;
} //QueryScanInfo
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::DisableUpdates
//
// Synopsis: Disables all usn updates
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::DisableUpdates()
{
CLock lock( _mutex );
_fUpdatesDisabled = TRUE;
_evtUsn.Set();
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::EnableUpdates
//
// Synopsis: Enables usn updates
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::EnableUpdates()
{
CLock lock( _mutex );
if ( _fUpdatesDisabled )
{
_fUpdatesDisabled = FALSE;
_evtUsn.Set();
}
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::InitiateShutdown
//
// Synopsis: Initiates the shutdown process
//
// History: 05-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::InitiateShutdown()
{
CLock lock(_mutex);
_fAbort = TRUE;
_fUpdatesDisabled = TRUE;
_usnScansToDo.Clear();
_evtUsn.Set();
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::WaitForShutdown
//
// Synopsis: Waits for shutdown to complete
//
// History: 05-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::WaitForShutdown()
{
//
// If we never started running, then just bail out.
//
if ( _thrUsn.IsRunning() )
{
ciDebugOut(( DEB_ITRACE, "Waiting for death of usn thread\n" ));
_thrUsn.WaitForDeath();
}
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::LokEmptyInProgressScans
//
// Synopsis: Removes all the scans from the "in-progress stack" and either
// deletes them or re-schedules them. If the scan is in its
// "terminal state", the scan is deleted. If there is a retry
// it will be re-scheduled.
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::LokEmptyInProgressScans()
{
//
// Refile any scopes that still need to be worked on
//
while ( _usnScansInProgress.Count() > 0 )
{
if ( _fAbort )
break;
XPtr<CCiScanInfo> xScanInfo( _usnScansInProgress.RemoveLast() );
if ( _fUpdatesDisabled )
{
CCiScanInfo * pScanInfo = xScanInfo.Acquire();
delete pScanInfo;
}
else if ( xScanInfo->LokIsInFinalState() )
{
//
// Scan of scope completed successfully, so start monitoring
//
LokAddScopeForUsnMonitoring( xScanInfo );
}
else
{
#if CIDBG==1
if ( xScanInfo->LokIsDelScope() )
{
ciDebugOut(( DEB_ITRACE,
"Requeing scope (%ws) for removal\n",
xScanInfo->GetPath() ));
}
else
{
ciDebugOut(( DEB_ITRACE,
"Requeuing scope (%ws) for scan\n",
xScanInfo->GetPath() ));
}
#endif // CIDBG==1
ScanScope( xScanInfo, TRUE ); // It's a refiled scan
}
}
} //LokEmptyInProgressScans
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::LokScheduleRemove
//
// Synopsis: Schedules a usn path for removal
//
// Arguments: [pwscScope] - Scope to be removed
// [volumeId] - Volume id
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::LokScheduleRemove( WCHAR const * pwcsScope,
VOLUMEID volumeId )
{
CCiScanInfo * pScanInfo = QueryScanInfo( pwcsScope,
volumeId,
0,
TRUE );
XPtr<CCiScanInfo> xScanInfo( pScanInfo );
pScanInfo->LokSetDelScope();
ScanScope( xScanInfo, FALSE );
}
//+---------------------------------------------------------------------------
//
// Member: CUnsMgr::UsnThread
//
// Synopsis: Usn thread start routine
//
// Arguments: [self] - This pointer
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
DWORD CUsnMgr::UsnThread( void * self )
{
SCODE sc = CoInitializeEx( 0, COINIT_MULTITHREADED );
((CUsnMgr *) self)->DoUsnProcessing();
CoUninitialize();
ciDebugOut(( DEB_ITRACE, "Terminating usn thread\n" ));
return 0;
} //UsnThread
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::DoUsnProcessing
//
// Synopsis: Main loop of usn thread
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::DoUsnProcessing()
{
CImpersonateSystem impersonate;
while ( TRUE )
{
//
// Don't do any work until the system has booted
//
while ( GetTickCount() < _cicat.GetRegParams()->GetStartupDelay() )
{
Sleep( 200 );
if ( _fAbort )
break;
}
NTSTATUS status = STATUS_SUCCESS;
TRY
{
XPtr<CCiScanInfo> xScanInfo;
//--------------------------------------------------------------------
{
CLock lock( _mutex );
if ( _fAbort )
break;
if ( !_fBatch )
{
//
// If requests are being batched, then don't process
// requests until the _fBatch flag is cleared.
//
// Refile any incomplete paths that could not be processed due to
// low resources
//
if ( _usnScansInProgress.Count() > 0 )
LokEmptyInProgressScans();
while ( _usnScansToDo.Count() > 0 )
{
xScanInfo.Set( _usnScansToDo.Pop() );
if ( _fUpdatesDisabled )
{
delete xScanInfo.Acquire();
break;
}
else
{
Win4Assert( !xScanInfo->LokIsInFinalState() );
_usnScansInProgress.Queue( xScanInfo.GetPointer() );
xScanInfo.Acquire();
}
}
if ( _fUpdatesDisabled )
{
//
// Empty usn lists, because usns notifications
// are not needed until updates are enabled.
//
_usnScansToDo.Clear();
_usnScansInProgress.Clear();
_usnVolumesToMonitor.Clear();
}
_evtUsn.Reset();
}
}
//--------------------------------------------------------------------
if ( _usnScansInProgress.Count() > 0 )
{
DoUsnScans();
Win4Assert( _usnScansInProgress.Count() == 0
|| _fAbort
|| _fUpdatesDisabled );
}
//
// ProcessUsnNotifications waits for usn notifications and processes
// them, or it waits until evtUsn is set. Only do this if there
// are no more scans to do.
//
if ( 0 == _usnScansToDo.Count() )
ProcessUsnNotifications();
}
CATCH (CException, e)
{
ciDebugOut(( DEB_ERROR,
"CUsnMgr::DoUsnProcessing, caught exception 0x%X\n",
e.GetErrorCode() ));
status = e.GetErrorCode();
}
END_CATCH
if ( status == CI_CORRUPT_CATALOG || status == CI_CORRUPT_DATABASE )
{
//
// Disable further updates until corruption is cleared
//
CLock lock( _mutex );
_fUpdatesDisabled = TRUE;
}
}
} //DoUsnProcessing
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::DoUsnScans
//
// Synopsis: Does tree walk for any usn scopes that were added
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::DoUsnScans()
{
//
// No need for a lock because only this thread modifies _usnScansInProgress
//
for ( CFwdScanInfoIter scanInfoIter(_usnScansInProgress);
!_usnScansInProgress.AtEnd(scanInfoIter);
_usnScansInProgress.Advance(scanInfoIter) )
{
if ( _fAbort || _fUpdatesDisabled )
break;
CCiScanInfo *pScanInfo = scanInfoIter.GetEntry();
Win4Assert( pScanInfo->GetRetries() <= CCiScanInfo::MAX_RETRIES );
NTSTATUS status = STATUS_SUCCESS;
TRY
{
ICiManager *pCiManager = _cicat.CiManager();
if ( pScanInfo->LokIsDelScope() )
{
_cicat.RemovePathsFromCiCat( pScanInfo->GetPath(), eUsnsArray );
if ( !_fAbort && !_fUpdatesDisabled )
{
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
pScanInfo->LokSetDone();
}
}
else if ( pScanInfo->LokIsMonitorOnly() )
{
//
// The scope needs to be monitored only and so set it to done
//
pScanInfo->LokSetDone();
}
else
{
//
// A starting USN from 0 means this is a first scan, or a
// complete recovery. A starting USN > 0 means we are
// looking for items changed by NT4 and not recorded in
// the USN log.
//
USN usnStart = 0;
//
// A full scan is executed after a volume has been reformatted.
// We first wipe all existing data (which will have incorrect
// fileid <--> wid mappings) and then do the scan.
//
if ( pScanInfo->LokIsInFullUsnScan() )
{
_cicat.RemovePathsFromCiCat( pScanInfo->GetPath(),
eUsnsArray );
if ( !_fAbort && !_fUpdatesDisabled )
{
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
}
}
else
usnStart = pScanInfo->UsnStart();
ciDebugOut(( DEB_ITRACE, "scan usnstart: %#I64x\n",
pScanInfo->UsnStart() ));
//
// Use the end of the usn log or the last usn processed by
// CI for this volume if available.
//
USN usnMax = FindCurrentMaxUsn( pScanInfo->GetPath() );
{
ciDebugOut(( DEB_ITRACE,
"usn scan looking for better maxusn than %#I64x\n",
usnMax ));
for ( CUsnVolumeIter usnVolIter( _usnVolumesToMonitor );
!_usnVolumesToMonitor.AtEnd( usnVolIter );
_usnVolumesToMonitor.Advance( usnVolIter ) )
{
if ( usnVolIter->VolumeId() == pScanInfo->VolumeId() )
{
ciDebugOut(( DEB_ITRACE,
"usn scan using %#I64x instead of %#I64x\n",
usnVolIter->MaxUsnRead(),
usnMax ));
usnMax = usnVolIter->MaxUsnRead();
break;
}
}
}
pScanInfo->SetStartUsn( usnMax );
CLowerFunnyPath lcaseFunnyPath;
lcaseFunnyPath.SetPath( pScanInfo->GetPath() );
CUsnTreeTraversal usnTreeTrav( _cicat,
*this,
*pCiManager,
lcaseFunnyPath,
pScanInfo->IsDoDeletions(),
_fUpdatesDisabled,
TRUE, // Process root
pScanInfo->VolumeId(),
usnStart,
usnMax,
pScanInfo->IsUserInitiated() );
usnTreeTrav.EndProcessing();
//
// Flush updates, because we will be writing usnMax as the
// restart usn for this scope, and we want to make sure that
// all updates with usn of 0 are serialized before writing
// the restart usn.
//
if ( !_fAbort && !_fUpdatesDisabled )
{
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
_cicat.SetUsnTreeScanComplete( pScanInfo->GetPath(), usnMax );
//
// Make SetUsnTreeScanComplete info persistent by
// serializing the scope table.
//
_cicat.ScheduleSerializeChanges();
pScanInfo->LokSetDone();
}
}
}
CATCH( CException, e)
{
ciDebugOut(( DEB_ERROR, "Exception 0x%x caught in CUsnMgr::DoUsnScans\n", e.GetErrorCode() ));
status = e.GetErrorCode();
}
END_CATCH
if ( status != STATUS_SUCCESS )
{
_cicat.HandleError( status );
break;
}
}
//
// Requeue failed usn scans
//
while ( _usnScansInProgress.Count() > 0 )
{
XPtr<CCiScanInfo> xScanInfo( _usnScansInProgress.RemoveLast() );
if ( _fUpdatesDisabled )
{
continue;
}
else if ( xScanInfo->LokIsInFinalState() )
{
if ( xScanInfo->LokIsDelScope() )
{
CLock lock( _mutex );
LokRemoveScopeFromUsnMonitoring( xScanInfo );
//
// All processing for a delete scope has been completed
//
CCiScanInfo *pScanInfo = xScanInfo.Acquire();
delete pScanInfo;
}
else
{
//
// Start monitoring for changes on this scope
//
CLock lock( _mutex );
LokAddScopeForUsnMonitoring( xScanInfo );
}
}
else
{
//
// We couldn't complete the scan for this, and so refile
//
xScanInfo->SetStartUsn( 0 );
xScanInfo->IncrementRetries();
xScanInfo->SetDoDeletions();
ScanScope( xScanInfo, TRUE );
}
}
} //DoUsnScans
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::LokAddScopeForUsnMonitoring
//
// Synopsis: Registers a scope for usn notifications
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::LokAddScopeForUsnMonitoring( XPtr<CCiScanInfo> & xScanInfo )
{
WCHAR const *pwszPath = xScanInfo->GetPath();
TRY
{
//
// Check that it is not a remote path
//
Win4Assert( pwszPath[0] != L'\\' );
for ( CUsnVolumeIter usnVolIter(_usnVolumesToMonitor);
!_usnVolumesToMonitor.AtEnd(usnVolIter);
_usnVolumesToMonitor.Advance(usnVolIter) )
{
if ( usnVolIter->DriveLetter() == pwszPath[0] )
{
//
// Add the scope to the list of scopes being monitored
// on this drive, if it is not already being monitored.
//
CScanInfoList & usnScopeList = usnVolIter->GetUsnScopesList();
for ( CFwdScanInfoIter scanIter1(usnScopeList);
!usnScopeList.AtEnd(scanIter1);
usnScopeList.Advance(scanIter1) )
{
if ( AreIdenticalPaths( scanIter1->GetPath(), xScanInfo->GetPath() ) )
return;
CScopeMatch superScope( scanIter1->GetPath(), wcslen( scanIter1->GetPath() ) );
if ( superScope.IsInScope( xScanInfo->GetPath(), wcslen( xScanInfo->GetPath() ) ) )
return;
}
//
// Remove subscopes as an optimization
//
CScopeMatch superScope( xScanInfo->GetPath(), wcslen( xScanInfo->GetPath() ) );
CFwdScanInfoIter scanIter2(usnScopeList);
while ( !usnScopeList.AtEnd(scanIter2) )
{
CCiScanInfo *pScanInfo = scanIter2.GetEntry();
usnScopeList.Advance(scanIter2);
if ( superScope.IsInScope( pScanInfo->GetPath(), wcslen( pScanInfo->GetPath() ) ) )
{
usnScopeList.RemoveFromList( pScanInfo );
delete pScanInfo;
}
}
if ( xScanInfo->UsnStart() < usnVolIter->MaxUsnRead() )
{
usnVolIter->SetMaxUsnRead( xScanInfo->UsnStart() );
//
// Cancel pending fsctl (if any) to pick up earlier usn
// notifications
//
usnVolIter->CancelFsctl();
}
usnScopeList.Push( xScanInfo.Acquire() );
return;
}
}
CUsnVolume *pUsnVolume = new CUsnVolume( pwszPath[0], xScanInfo->VolumeId() );
pUsnVolume->SetMaxUsnRead( xScanInfo->UsnStart() );
_usnVolumesToMonitor.Push( pUsnVolume );
CScanInfoList &usnScopeList = pUsnVolume->GetUsnScopesList();
usnScopeList.Push( xScanInfo.Acquire() );
}
CATCH( CException, e )
{
ciDebugOut(( DEB_ERROR, "Error 0x%x trying to monitor USN scope %wc.\n", e.GetErrorCode(), xScanInfo->VolumeId() ));
HandleError( pwszPath[0], e.GetErrorCode() );
}
END_CATCH
} //LokAddScopeForUsnMonitoring
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::LokRemoveScopeFromUsnMonitoring
//
// Synopsis: Deregisters a scope from usn notifications
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::LokRemoveScopeFromUsnMonitoring( XPtr<CCiScanInfo> & xScanInfo )
{
WCHAR const *pwszPath = xScanInfo->GetPath();
//
// Check that it is not a remote path
//
Win4Assert( pwszPath[0] != L'\\' );
for ( CUsnVolumeIter usnVolIter(_usnVolumesToMonitor);
!_usnVolumesToMonitor.AtEnd(usnVolIter);
_usnVolumesToMonitor.Advance(usnVolIter) )
{
if ( usnVolIter->DriveLetter() == pwszPath[0] )
{
CScanInfoList & usnScopeList = usnVolIter->GetUsnScopesList();
CFwdScanInfoIter scanInfoIter(usnScopeList);
while ( !usnScopeList.AtEnd(scanInfoIter) )
{
CCiScanInfo *pScanInfo = scanInfoIter.GetEntry();
usnScopeList.Advance(scanInfoIter);
if ( AreIdenticalPaths( pScanInfo->GetPath(), xScanInfo->GetPath() ) )
{
usnScopeList.RemoveFromList( pScanInfo );
delete pScanInfo;
break;
}
}
//
// If no more scopes on this usn volume then remove the entry from the
// list of volumes being monitored.
//
if ( usnScopeList.Count() == 0 )
{
CUsnVolume *pUsnVolume = usnVolIter.GetEntry();
_usnVolumesToMonitor.RemoveFromList( pUsnVolume );
delete pUsnVolume;
break;
}
}
}
} //LokRemoveScopeFromUsnMonitoring
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ProcessNotifications
//
// Synopsis: Wait for usn notifications, and then process them
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::ProcessUsnNotifications()
{
//
// No need for a lock because only this thread modifies _usnVolumesToMonitor
//
for (;;)
{
//
// Loop by waiting for usn notifications and processing them.
// Loop returns when _evtUsn is signalled.
//
BOOL fWait; // TRUE --> Every volume is now waiting. (assigned below)
BOOL fLowResource;
do
{
_waitForMultObj.ResetCount();
//
// _evtUsn is the first handle, and so it gets priority if more
// than one event is signalled.
//
_waitForMultObj.AddEvent( _evtUsn.GetHandle() );
CUsnVolumeIter usnVolIter(_usnVolumesToMonitor);
//
// Are we in a high i/o state? If so, don't read the USN Journal
//
fLowResource = IsLowResource();
fWait = TRUE;
while ( !_usnVolumesToMonitor.AtEnd(usnVolIter) )
{
if ( _fAbort || _fUpdatesDisabled )
return;
CUsnVolume *pUsnVolume = usnVolIter.GetEntry();
_usnVolumesToMonitor.Advance(usnVolIter);
if ( !pUsnVolume->IsOnline() )
continue;
ciDebugOut(( DEB_ITRACE, "Drive %wc: %u%% read\n", pUsnVolume->DriveLetter(), pUsnVolume->PercentRead() ));
if ( fLowResource && pUsnVolume->PercentRead() >= USN_LOG_DANGER_THRESHOLD )
continue;
//
// Does this volume have something to do now?
//
if ( pUsnVolume->FFsctlPending() && WAIT_TIMEOUT != pUsnVolume->WaitFsctl( 0 ) )
pUsnVolume->ResetFsctlPending();
if ( pUsnVolume->FFsctlPending() )
_waitForMultObj.AddEvent( pUsnVolume->GetFsctlEvent() );
else
{
NTSTATUS status = ProcessUsnNotificationsFromVolume( pUsnVolume );
switch( status )
{
case STATUS_PENDING:
pUsnVolume->SetFsctlPending();
_waitForMultObj.AddEvent( pUsnVolume->GetFsctlEvent() );
break;
case STATUS_JOURNAL_ENTRY_DELETED:
break;
case STATUS_SUCCESS:
fWait = FALSE; // More to do, processing bailed to enable round-robin
break;
default:
Win4Assert( !NT_SUCCESS( status ) );
HandleError( pUsnVolume, status );
break;
}
}
}
} while( !fWait );
if ( _fAbort )
return;
//
// Wait for evtUsn to be signaled or for an usn notification
//
DWORD dwTimeout = _cicat.GetRegParams()->GetUsnReadTimeout() * 1000;
//
// But only wait forever if we're actually watching notifications...
//
if ( 0 == dwTimeout )
{
if ( fLowResource )
dwTimeout = 60 * 1000;
else
dwTimeout = INFINITE;
}
//
// If we're in a low resource situation, this is a good place to flush
// the working set.
//
if ( fLowResource && _cicat.GetRegParams()->GetMinimizeWorkingSet() )
SetProcessWorkingSetSize( GetCurrentProcess(), ~0, ~0 );
_fWaitingForUpdates = TRUE;
DWORD dwIndex = _waitForMultObj.Wait( dwTimeout );
_fWaitingForUpdates = FALSE;
if ( _fAbort || _fUpdatesDisabled )
return;
if ( WAIT_FAILED == dwIndex )
{
Win4Assert( !"Waitformultipleobjects failed" );
ciDebugOut(( DEB_ERROR, "WaitForMultipleObjects failed, 0x%x", GetLastError() ));
THROW( CException( ) );
}
if ( WAIT_OBJECT_0 == dwIndex )
{
//
// _evtUsn has been signaled -- cancel pending requests
//
CUsnVolumeIter usnVolIter( _usnVolumesToMonitor );
while ( !_usnVolumesToMonitor.AtEnd(usnVolIter) )
{
CUsnVolume *pUsnVolume = usnVolIter.GetEntry();
_usnVolumesToMonitor.Advance(usnVolIter);
pUsnVolume->CancelFsctl();
}
return;
}
else if ( WAIT_TIMEOUT != dwIndex )
{
//
// Process usn notifications from the volume that was signaled.
// GetIth does a linear lookup, it can be optimized to index
// directly into an array of pUsnVolumes.
//
unsigned i = dwIndex - WAIT_OBJECT_0 - 1;
CUsnVolume *pUsnVolume = _usnVolumesToMonitor.GetIth( i );
//
// We know the volume is at least the Ith volume, but it may be
// farther if some volumes were skipped.
//
i++; // Account for control event
while ( pUsnVolume->GetFsctlEvent() != _waitForMultObj.Get(i) )
pUsnVolume = (CUsnVolume *)pUsnVolume->Next();
pUsnVolume->ResetFsctlPending();
ciDebugOut(( DEB_ITRACE, "PENDING COMPLETED #1 (0x%x)\n", pUsnVolume ));
if ( !fLowResource || pUsnVolume->PercentRead() < USN_LOG_DANGER_THRESHOLD )
ProcessUsnLogRecords( pUsnVolume );
if ( _fAbort || _fUpdatesDisabled )
return;
}
if ( 0 != dwTimeout && !fLowResource )
{
//
// Check to see if there is anything that's sat in the buffer too long.
//
LONGLONG ftExpired;
GetSystemTimeAsFileTime( (FILETIME *)&ftExpired );
ftExpired -= _cicat.GetRegParams()->GetUsnReadTimeout() * 10000i64;
CUsnVolumeIter usnVolIter(_usnVolumesToMonitor);
while( !_usnVolumesToMonitor.AtEnd(usnVolIter) )
{
if ( _fAbort || _fUpdatesDisabled )
break;
CUsnVolume *pUsnVolume = usnVolIter.GetEntry();
_usnVolumesToMonitor.Advance(usnVolIter);
if ( !pUsnVolume->IsOnline() )
continue;
if ( pUsnVolume->FFsctlPending() && pUsnVolume->PendingTime() <= ftExpired )
{
pUsnVolume->CancelFsctl();
ciDebugOut(( DEB_ITRACE, "PENDING CANCELLED #1 (0x%x)\n", pUsnVolume ));
NTSTATUS status = ProcessUsnNotificationsFromVolume( pUsnVolume, TRUE ); // TRUE --> Immediate
switch( status )
{
case STATUS_PENDING:
pUsnVolume->SetFsctlPending();
break;
case STATUS_JOURNAL_ENTRY_DELETED:
break;
case STATUS_SUCCESS:
fWait = FALSE; // More to do, processing bailed to enable round-robin
break;
default:
Win4Assert( !NT_SUCCESS( status ) );
HandleError( pUsnVolume, status );
break;
}
}
}
}
}
} //ProcessUsnNotifications
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ProcessUsnNotificationsFromVolume
//
// Synopsis: Process usn notifications from given volume
//
// Arguments: [pUsnVolume] -- Usn volume
// [fImmediate] -- If TRUE, look for *any* new data in log,
// no matter how little.
// [fWait] -- If TRUE, wait for data if fImmediate is TRUE
// and no data is available.
//
//
// Returns: STATUS_PENDING when there are no more usn notifications to be
// processed, or STATUS_JOURNAL_ENTRY_DELETED when usn records
// have been removed from log due to shrink from front.
//
// History: 05-Jul-97 SitaramR Created
//
//----------------------------------------------------------------------------
NTSTATUS CUsnMgr::ProcessUsnNotificationsFromVolume( CUsnVolume * pUsnVolume,
BOOL fImmediate,
BOOL fWait )
{
Win4Assert( pUsnVolume->IsOnline() );
//
// No need for a lock because only this thread modifies _usnVolumesToMonitor
//
Win4Assert( !pUsnVolume->FFsctlPending() );
NTSTATUS status;
unsigned cRetries = 0; // Unsuccessful read attempts
unsigned cTries = 0; // Successful read attempts
READ_USN_JOURNAL_DATA usnReadData;
usnReadData.UsnJournalID = pUsnVolume->JournalId();
usnReadData.StartUsn = pUsnVolume->MaxUsnRead();
usnReadData.ReasonMask = ~(USN_REASON_RENAME_OLD_NAME | USN_REASON_COMPRESSION_CHANGE);
usnReadData.ReturnOnlyOnClose = TRUE;
usnReadData.Timeout = 0;
do
{
if ( _fAbort || _fUpdatesDisabled )
{
//
// Doesn't matter what status we return because all notifications
// will be turned off soon.
//
return STATUS_TOO_LATE;
}
//
// In immediate mode, read *any* data, else read as requested by client.
//
if ( fImmediate )
usnReadData.BytesToWaitFor = 1;
else
usnReadData.BytesToWaitFor = _cicat.GetRegParams()->GetUsnReadMinSize();
#if CIDBG == 1
RtlFillMemory( pUsnVolume->GetBuffer(), pUsnVolume->GetBufferSize(), 0x11 );
#endif
ciDebugOut(( DEB_ITRACE, "READ #1 (0x%x)\n", pUsnVolume ));
Win4Assert( !pUsnVolume->FFsctlPending() );
ciDebugOut(( DEB_ITRACE, "reading usns from %#I64x\n", usnReadData.StartUsn ));
status = NtFsControlFile( pUsnVolume->VolumeHandle(),
pUsnVolume->GetFsctlEvent(),
NULL,
NULL,
pUsnVolume->IoStatusBlock(),
FSCTL_READ_USN_JOURNAL,
&usnReadData,
sizeof(usnReadData),
pUsnVolume->GetBuffer(),
pUsnVolume->GetBufferSize() );
if ( fImmediate )
{
if ( fWait )
fImmediate = FALSE;
//
// STATUS_PENDING --> nothing in the log. Go back to regular waits.
//
if ( STATUS_PENDING == status )
{
ciDebugOut(( DEB_ITRACE, "PENDING CANCELLED #2 (0x%x)\n", pUsnVolume ));
pUsnVolume->SetFsctlPending();
pUsnVolume->CancelFsctl();
// If no journal entries are available and we're not supposed
// to wait, return now.
if ( !fWait )
return STATUS_SUCCESS;
continue;
}
}
if ( STATUS_PENDING == status )
break;
if ( NT_SUCCESS( status ) )
status = pUsnVolume->IoStatusBlock()->Status;
if ( NT_SUCCESS( status ) )
{
ciDebugOut(( DEB_ITRACE, "IMMEDIATE COMPLETED #1 (0x%x)\n", pUsnVolume ));
ProcessUsnLogRecords( pUsnVolume );
usnReadData.StartUsn = pUsnVolume->MaxUsnRead();
Win4Assert( usnReadData.ReasonMask == ~(USN_REASON_RENAME_OLD_NAME | USN_REASON_COMPRESSION_CHANGE) );
Win4Assert( usnReadData.ReturnOnlyOnClose == TRUE );
//
// Don't read a single volume too long...
//
cTries++;
if ( cTries > 5 )
{
ciDebugOut(( DEB_ITRACE, "Stopping read on drive %wc: to support round-robin\n", pUsnVolume->DriveLetter() ));
break;
}
else
continue;
}
else if ( STATUS_JOURNAL_ENTRY_DELETED == status )
{
ciDebugOut(( DEB_ERROR, "STATUS_JOURNAL_ENTRY_DELETED #1 fWait %d, (drive %wc:)\n",
fWait, pUsnVolume->DriveLetter() ));
// Already doing a scan due to missed notifications.
if ( !fWait )
return STATUS_JOURNAL_ENTRY_DELETED;
//
// STATUS_JOURNAL_ENTRY_DELETED is returned when usn records have
// been deallocated from the usn journal. This means that we have to
// do a scan before continuing usn monitoring. Even if some other
// error code has been returned, the simplest recovery is to restart
// monitoring.
//
XBatchUsnProcessing xBatchUsns( *this );
CScanInfoList & usnScopeList = pUsnVolume->GetUsnScopesList();
while ( usnScopeList.Count() > 0 )
{
XPtr<CCiScanInfo> xScanInfo( usnScopeList.Pop() );
xScanInfo->SetStartState();
xScanInfo->SetScan();
ciDebugOut(( DEB_ERROR, "journal_entry_deleted, filing a scan for %ws\n",
xScanInfo->GetPath() ));
xScanInfo->SetStartUsn( pUsnVolume->MaxUsnRead() );
xScanInfo->SetDoDeletions();
_cicat.InitUsnTreeScan( xScanInfo->GetPath() );
ScanScope( xScanInfo, TRUE );
}
_usnVolumesToMonitor.RemoveFromList( pUsnVolume );
delete pUsnVolume;
return STATUS_JOURNAL_ENTRY_DELETED;
}
else
{
ciDebugOut(( DEB_WARN, "Usn read fsctl returned 0x%x\n", status ));
cRetries++;
if ( cRetries > 10 )
{
ciDebugOut(( DEB_WARN, "Giving up on USN read.\n" ));
break;
}
// the fsctl failed -- so try again
continue;
}
} while ( status != STATUS_PENDING );
return status;
} //ProcessUsnNotificationsFromVolume
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ProcessUsnLogRecords
//
// Synopsis: Process usn notifications from usn records in buffer
//
// Arguments: [pUsnVolume] -- Usn volume that contains the buffer
//
// History: 05-Jul-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::ProcessUsnLogRecords( CUsnVolume *pUsnVolume )
{
Win4Assert( pUsnVolume->IsOnline() );
//
// No need for a lock because only this thread modifies _usnVolumesToMonitor
//
USN usnNextStart;
USN_RECORD * pUsnRec = 0;
ciDebugOut(( DEB_ITRACE, "process usns, Status 0x%x, Bytes %d\n",
pUsnVolume->IoStatusBlock()->Status,
pUsnVolume->IoStatusBlock()->Information ));
if ( !NT_SUCCESS( pUsnVolume->IoStatusBlock()->Status ) )
{
//
// If we cancelled the notification request (usually because
// we're going into a mode where we wait for a lot of bytes instead
// of just 1 byte), just ignore processing the request.
//
if ( STATUS_CANCELLED != pUsnVolume->IoStatusBlock()->Status )
{
ciDebugOut(( DEB_WARN, "Error 0x%x reading USN Journal\n", pUsnVolume->IoStatusBlock()->Status ));
Win4Assert( STATUS_INVALID_PARAMETER != pUsnVolume->IoStatusBlock()->Status );
}
return;
}
DWORD dwByteCount = (DWORD)pUsnVolume->IoStatusBlock()->Information;
if ( dwByteCount != 0 )
{
usnNextStart = *(USN *)pUsnVolume->GetBuffer();
pUsnRec = (USN_RECORD *)((PCHAR)pUsnVolume->GetBuffer() + sizeof(USN));
dwByteCount -= sizeof(USN);
}
if ( 0 == pUsnRec )
return;
ICiManager *pCiManager = _cicat.CiManager();
Win4Assert( pCiManager );
while ( dwByteCount != 0 )
{
if ( _fAbort || _fUpdatesDisabled )
return;
//
// Check that usn's from journal are greater than the start usn
//
#if CIDBG == 1
if ( pUsnRec->Usn < pUsnVolume->MaxUsnRead() )
{
ciDebugOut(( DEB_ERROR,
"volume %wc pUsnRec = 0x%x, USN = %#I64x, Max USN = %#I64x\n",
pUsnVolume->VolumeId(), pUsnRec, pUsnRec->Usn,
pUsnVolume->MaxUsnRead() ));
Win4Assert( pUsnRec->Usn >= pUsnVolume->MaxUsnRead() );
Sleep( 30 * 1000 );
}
Win4Assert( pUsnRec->Usn >= pUsnVolume->MaxUsnRead() );
if ( pUsnRec->RecordLength > 10000 )
{
ciDebugOut(( DEB_ERROR, "pUsnRec = 0x%x, RecordLength = %u\n", pUsnRec, pUsnRec->RecordLength ));
}
Win4Assert( pUsnRec->RecordLength <= 10000 );
#endif
if ( 0 == (pUsnRec->SourceInfo & (USN_SOURCE_AUXILIARY_DATA | USN_SOURCE_DATA_MANAGEMENT)) &&
( 0 == (pUsnRec->FileAttributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) ||
0 != (pUsnRec->Reason & USN_REASON_INDEXABLE_CHANGE) ) )
{
//
// Indexable bit==0 means index the file, because the bit is set to 0
// by default on an upgrade from Ntfs 4.0 to Ntfs 5.0. We want the
// the default behavior to be index-all-files to ensure backward
// compatibility.
//
if ( pUsnRec->Reason & USN_REASON_RENAME_NEW_NAME )
{
CLowerFunnyPath lcaseFunnyOldPath;
BOOL fOldPathInScope;
_cicat.FileIdToPath( pUsnRec->FileReferenceNumber,
pUsnVolume,
lcaseFunnyOldPath,
fOldPathInScope );
CLowerFunnyPath lcaseFunnyNewPath;
BOOL fNewPathInScope;
WORKID widParent;
#if CIDBG == 1
widParent = widUnused;
#endif
//
// Try hard to find a parent directory, since it may
// not be in the index if it is marked as not-indexed.
//
_cicat.UsnRecordToPathUsingParentId( pUsnRec,
pUsnVolume,
lcaseFunnyNewPath,
fNewPathInScope,
widParent,
TRUE );
Win4Assert( widUnused != widParent );
if ( pUsnRec->FileAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
//
// Directory rename or add or delete. Directory operations are
// (re)tried a certain number of times, after which a failure
// event is logged.
//
const MAX_RETRIES = 5;
XGrowable<WCHAR> xFileName;
for (unsigned i=0; i<MAX_RETRIES; i++)
{
TRY
{
if ( fOldPathInScope )
{
if ( fNewPathInScope )
{
ciDebugOut(( DEB_USN, "Renaming directory %ws to %ws\n", lcaseFunnyOldPath.GetPath(), lcaseFunnyNewPath.GetPath() ));
CRenameDir( _cicat,
lcaseFunnyOldPath,
lcaseFunnyNewPath,
_fUpdatesDisabled,
pUsnVolume->VolumeId() );
_cicat.Update( lcaseFunnyNewPath,
pUsnRec->FileReferenceNumber,
widParent,
pUsnRec->Usn,
pUsnVolume,
FALSE );
break;
}
else
{
CLowcaseBuf lcaseOldPath( lcaseFunnyOldPath.GetActualPath() );
lcaseOldPath.AppendBackSlash();
ciDebugOut(( DEB_USN, "Removing directory %ws\n", lcaseOldPath.Get() ));
_cicat.RemovePathsFromCiCat( lcaseOldPath.Get(), eUsnsArray );
if ( _fAbort || _fUpdatesDisabled )
{
return;
}
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
break;
}
}
else
{
if ( fNewPathInScope )
{
lcaseFunnyNewPath.AppendBackSlash();
ciDebugOut(( DEB_USN, "Adding directory %ws\n", lcaseFunnyNewPath.GetPath() ));
_fDoingRenameTraverse = TRUE;
CUsnTreeTraversal usnTreeTrav( _cicat,
*this,
*pCiManager,
lcaseFunnyNewPath,
FALSE, // No deletions
_fUpdatesDisabled,
TRUE, // Process root
pUsnVolume->VolumeId() );
usnTreeTrav.EndProcessing();
_fDoingRenameTraverse = FALSE;
if ( _fAbort || _fUpdatesDisabled )
return;
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
break;
}
else
{
//
// Both old and new paths are out of scope. We *still* have to
// determine whether this rename caused a top-level indexed scope
// to either exist or cease to exist.
//
CheckTopLevelChange( pUsnVolume, pUsnRec->FileReferenceNumber );
break;
}
}
}
CATCH( CException, e )
{
_fDoingRenameTraverse = FALSE;
#if CIDBG==1
//
// pUsnRec->FileName is not null terminated, so copy
// and null terminate.
//
unsigned cbFileNameLen = pUsnRec->FileNameLength;
xFileName.SetSizeInBytes( cbFileNameLen + 2 );
RtlCopyMemory( xFileName.Get(),
(WCHAR *)(((BYTE *)pUsnRec) + pUsnRec->FileNameOffset),
cbFileNameLen );
xFileName[cbFileNameLen/sizeof(WCHAR)] = 0;
ciDebugOut(( DEB_ERROR,
"Exception 0x%x while doing directory rename/add/delete of %ws\n",
e.GetErrorCode(),
xFileName.Get() ));
#endif
}
END_CATCH
} // for
if ( i == MAX_RETRIES )
{
CEventLog eventLog( NULL, wcsCiEventSource );
CEventItem item( EVENTLOG_ERROR_TYPE,
CI_SERVICE_CATEGORY,
MSG_CI_CONTENTSCAN_FAILED,
1 );
//
// pUsnRec->FileName is not null terminated, so copy
// and null terminate.
//
unsigned cbFileNameLen = pUsnRec->FileNameLength;
xFileName.SetSizeInBytes( cbFileNameLen + 2 );
RtlCopyMemory( xFileName.Get(),
(WCHAR *)(((BYTE *)pUsnRec) + pUsnRec->FileNameOffset),
cbFileNameLen );
xFileName[cbFileNameLen/sizeof(WCHAR)] = 0;
item.AddArg( xFileName.Get() );
eventLog.ReportEvent( item );
}
}
else // if reason & FILE_ATTRIBUTE_DIRECTORY
{
//
// File rename or add or delete
//
if ( fOldPathInScope )
{
if ( fNewPathInScope )
{
ciDebugOut(( DEB_USN, "Renaming file %ws to %ws\n",
lcaseFunnyOldPath.GetActualPath(), lcaseFunnyNewPath.GetActualPath() ));
_cicat.RenameFile( lcaseFunnyOldPath,
lcaseFunnyNewPath,
pUsnRec->FileAttributes,
pUsnVolume->VolumeId(),
pUsnRec->FileReferenceNumber,
widParent );
_cicat.Update( lcaseFunnyNewPath,
pUsnRec->FileReferenceNumber,
widParent,
pUsnRec->Usn,
pUsnVolume,
FALSE );
}
else
{
_cicat.Update( lcaseFunnyOldPath,
pUsnRec->FileReferenceNumber,
widParent,
pUsnRec->Usn,
pUsnVolume,
TRUE );
}
}
else
{
if ( fNewPathInScope )
{
_cicat.Update( lcaseFunnyNewPath,
pUsnRec->FileReferenceNumber,
widParent,
pUsnRec->Usn,
pUsnVolume,
FALSE );
}
else
{
//
// Both old and new paths are out of scope, so do nothing
//
}
}
}
}
else
{
Win4Assert( pUsnRec->Reason & USN_REASON_CLOSE );
if ( 0 != (pUsnRec->Reason & ~(USN_REASON_CLOSE | USN_REASON_COMPRESSION_CHANGE | USN_REASON_RENAME_OLD_NAME ) ) )
{
CLowerFunnyPath lcaseFunnyPath;
BOOL fPathInScope = FALSE;
WORKID widParent = widInvalid;
CReleasableLock lock( _cicat.GetMutex() );
WORKID wid = _cicat.FileIdToWorkId( pUsnRec->FileReferenceNumber,
pUsnVolume->VolumeId() );
if ( 0 != ( pUsnRec->Reason & USN_REASON_FILE_DELETE ) ||
0 != ( pUsnRec->FileAttributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED ) )
{
//
// File delete. Don't delete directories that go from
// indexed to non-indexed since there may be files
// below them that are indexed.
//
if ( ( widInvalid != wid ) )
{
CDocumentUpdateInfo docInfo( wid,
pUsnVolume->VolumeId(),
pUsnRec->Usn,
TRUE );
pCiManager->UpdateDocument( &docInfo );
if ( ! ( ( pUsnRec->FileAttributes & FILE_ATTRIBUTE_DIRECTORY ) &&
( pUsnRec->Reason & USN_REASON_INDEXABLE_CHANGE ) ) )
{
_cicat.LokMarkForDeletion( pUsnRec->FileReferenceNumber,
wid );
}
else
{
ciDebugOut(( DEB_ITRACE, "usn notify not deleting a ni directory\n" ));
}
}
}
else
{
//
// File create or modify
//
Win4Assert( pUsnRec->Reason & USN_REASON_CLOSE );
if ( widInvalid == wid )
{
_cicat.UsnRecordToPathUsingParentId( pUsnRec,
pUsnVolume,
lcaseFunnyPath,
fPathInScope,
widParent,
( 0 != ( pUsnRec->Reason & USN_REASON_INDEXABLE_CHANGE ) ) );
if ( fPathInScope )
_cicat.Update( lcaseFunnyPath,
pUsnRec->FileReferenceNumber,
widParent,
pUsnRec->Usn,
pUsnVolume,
FALSE, // not a delete
&lock ); // guaranteed new file
else if ( pUsnRec->FileAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
//
// This might be a top-level directory. No parent id to
// look up, but still the root of the tree.
//
lock.Release();
CheckTopLevelChange( pUsnVolume, pUsnRec->FileReferenceNumber );
}
}
else
{
lock.Release();
CDocumentUpdateInfo docInfo( wid,
pUsnVolume->VolumeId(),
pUsnRec->Usn,
FALSE );
pCiManager->UpdateDocument( &docInfo );
}
} // if fPathInScope
} // if reason is one we care about
} // if-else reason & reason_new_name
} // pUsnRec->fileattr & file_attr_content_indexed
if ( pUsnRec->RecordLength <= dwByteCount )
{
dwByteCount -= pUsnRec->RecordLength;
//#if CIDBG == 1
#if 0
ULONG cb = pUsnRec->RecordLength;
RtlFillMemory( pUsnRec, cb, 0xEE );
pUsnRec = (USN_RECORD *) ((PCHAR) pUsnRec + cb );
#else
pUsnRec = (USN_RECORD *) ((PCHAR) pUsnRec + pUsnRec->RecordLength );
#endif
}
else
{
Win4Assert( !"Bogus dwByteCount" );
ciDebugOut(( DEB_ERROR,
"Usn read fsctl returned bogus dwByteCount, 0x%x\n",
dwByteCount ));
THROW( CException( STATUS_UNSUCCESSFUL ) );
}
}
pUsnVolume->SetMaxUsnRead( usnNextStart );
} //ProcessUsnLogRecords
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::FindCurrentMaxUsn
//
// Synopsis: Find the current max usn for the volume with pwcsScope
//
// Arguments: [pwcsScope] - Scope
//
// History: 07-May-97 SitaramR Created
//
//----------------------------------------------------------------------------
USN CUsnMgr::FindCurrentMaxUsn( WCHAR const * pwcsScope )
{
Win4Assert( pwcsScope );
WCHAR wszVolumePath[] = L"\\\\.\\a:";
wszVolumePath[4] = pwcsScope[0];
HANDLE hVolume = CreateFile( wszVolumePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL );
if ( hVolume == INVALID_HANDLE_VALUE )
THROW( CException( STATUS_UNSUCCESSFUL ) );
SWin32Handle xHandleVolume( hVolume );
IO_STATUS_BLOCK iosb;
USN_JOURNAL_DATA UsnJournalInfo;
NTSTATUS Status = NtFsControlFile( hVolume,
NULL,
NULL,
NULL,
&iosb,
FSCTL_QUERY_USN_JOURNAL,
0,
0,
&UsnJournalInfo,
sizeof(UsnJournalInfo) );
Win4Assert( STATUS_PENDING != Status );
if ( NT_SUCCESS(Status) )
Status = iosb.Status;
if ( NT_ERROR(Status) )
{
//
// Usn journal should have been created already
//
ciDebugOut(( DEB_ERROR,
"Usn read fsctl returned 0x%x\n",
Status ));
THROW( CException( Status ) );
}
return UsnJournalInfo.NextUsn;
} //FindCurrentMaxUsn
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::SetBatch
//
// Synopsis: Sets the batch flag, which means that the usn thread will not
// be signalled to start processing requests until the batch
// flag is cleared.
//
// History: 27-Jun-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::SetBatch()
{
CLock lock(_mutex);
_fBatch = TRUE;
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ClearBatch
//
// Synopsis: Clears the batch processing flag and wakes up the usn
// thread and the accumulated scans processed.
//
// History: 27-Jun-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CUsnMgr::ClearBatch()
{
CLock lock(_mutex);
_fBatch = FALSE;
_evtUsn.Set();
}
struct SVolumeUsn
{
VOLUMEID volumeId;
USN usn;
};
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::ProcessUsnLog, public
//
// Synopsis: Processes all records in the USN log for all volumes.
// This is so that we don't have to rescan when a scan
// completes
//
// Arguments: [fAbort] -- Bail if TRUE
// [volScan] -- Volume Id of volume current being scanned (will
// be added to volumes processed).
// [usnScan] -- USN on [volScan] at which monitoring will commence
// when scan is complete.
//
// History: 28-May-98 dlee Created
//
//----------------------------------------------------------------------------
void CUsnMgr::ProcessUsnLog( BOOL & fAbort, VOLUMEID volScan, USN & usnScan )
{
if ( _fDoingRenameTraverse )
return;
CDynArrayInPlace<SVolumeUsn> aVolumeUsns;
//
// Add the volume actively being scanned. No point in monitoring others with
// pending scans, since they will be scanned anyway.
//
aVolumeUsns[0].volumeId = volScan;
aVolumeUsns[0].usn = usnScan;
//
// Add all the volumes being monitored
//
{ // Save stack, by overloading usnVolIter
for ( CUsnVolumeIter usnVolIter(_usnVolumesToMonitor); // with the one farther down the function...
!_usnVolumesToMonitor.AtEnd(usnVolIter);
_usnVolumesToMonitor.Advance(usnVolIter) )
{
Win4Assert( !usnVolIter->FFsctlPending() );
VOLUMEID volumeId = usnVolIter->VolumeId();
USN usn = usnVolIter->MaxUsnRead();
for ( unsigned i = 0; i < aVolumeUsns.Count(); i++ )
{
if ( aVolumeUsns[i].volumeId == volumeId )
{
aVolumeUsns[i].usn = __min( aVolumeUsns[i].usn, usn );
break;
}
}
if ( i == aVolumeUsns.Count() )
{
aVolumeUsns[ i ].volumeId = volumeId;
aVolumeUsns[ i ].usn = usn;
}
}
}
//
// Take this list, and create temporary volume objects.
//
CUsnVolumeList usnVolumesToProcess;
for ( unsigned i = 0; i < aVolumeUsns.Count(); i++ )
{
CUsnVolume * pusnVolume = new CUsnVolume( (WCHAR) aVolumeUsns[i].volumeId, aVolumeUsns[i].volumeId );
pusnVolume->SetMaxUsnRead( aVolumeUsns[i].usn );
usnVolumesToProcess.Push( pusnVolume );
}
//
// Process USNs for the volumes until they are all out of danger
//
BOOL fSomethingChanged = FALSE;
int priOriginal;
unsigned cInDanger = 0;
BOOL fFirst = TRUE;
do
{
cInDanger = 0;
for ( CUsnVolumeIter usnVolIter(usnVolumesToProcess);
!usnVolumesToProcess.AtEnd(usnVolIter);
usnVolumesToProcess.Advance(usnVolIter) )
{
CUsnVolume *pUsnVolume = usnVolIter.GetEntry();
// Process the usn notifications for the volume.
ULONG ulPct = pUsnVolume->PercentRead();
// If the journal is entirely empty, it's not in danger.
if ( !fFirst && ( 0 == ulPct ) && ( 0 == pUsnVolume->MaxUsnRead() ) )
continue;
// If we're in danger of a log overflow, process records.
if ( ulPct < (fSomethingChanged ? USN_LOG_DANGER_THRESHOLD + 5 : USN_LOG_DANGER_THRESHOLD ) )
{
ciDebugOut(( DEB_ITRACE, "Drive %wc: in danger (%u%%)\n",
pUsnVolume->DriveLetter(), pUsnVolume->PercentRead() ));
cInDanger++;
if ( !fSomethingChanged )
{
//
// Boost the priority to try and catch up before we fall farther behind.
// Normally, this thread runs at below normal priority.
//
priOriginal = GetThreadPriority( GetCurrentThread() );
SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_HIGHEST );
fSomethingChanged = TRUE;
}
// TRUE == immediate processing
// FALSE == don't wait for notifications
NTSTATUS Status = ProcessUsnNotificationsFromVolume( pUsnVolume, TRUE, FALSE );
Win4Assert( STATUS_PENDING != Status );
//
// Even if this is STATUS_JOURNAL_ENTRY_DELETED, we might as
// well abort the scan. Another will have been scheduled.
//
if ( !NT_SUCCESS(Status) )
{
ciDebugOut(( DEB_ERROR, "Error %#x from ProcessUsnNotificationsFromVolume during scan\n", Status ));
THROW( CException( Status ) );
}
}
fFirst = FALSE;
ciDebugOut(( DEB_ITRACE, "Drive %wc: %u%% read (scan)\n",
pUsnVolume->DriveLetter(), ulPct ));
}
} while ( !fAbort && cInDanger > 0 );
//
// Update the max USNs
//
if ( fSomethingChanged )
{
//
// Reset thread priority.
//
if ( THREAD_PRIORITY_ERROR_RETURN != priOriginal )
SetThreadPriority( GetCurrentThread(), priOriginal );
for ( CUsnVolumeIter usnVolIter(usnVolumesToProcess);
!usnVolumesToProcess.AtEnd(usnVolIter);
usnVolumesToProcess.Advance(usnVolIter) )
{
//
// Patch the USN for the scan
//
if ( volScan == usnVolIter->VolumeId() )
usnScan = usnVolIter->MaxUsnRead();
for ( CFwdScanInfoIter scanInfoIter(_usnScansInProgress);
!_usnScansInProgress.AtEnd(scanInfoIter);
_usnScansInProgress.Advance(scanInfoIter) )
{
CCiScanInfo & scanInfo = * scanInfoIter.GetEntry();
if ( scanInfo.VolumeId() == usnVolIter->VolumeId() )
{
ciDebugOut(( DEB_ITRACE,
"usn updating scan usn on %wc: from %#I64x to %#I64x\n",
(WCHAR)scanInfo.VolumeId(),
scanInfo.UsnStart(),
usnVolIter->MaxUsnRead() ));
scanInfo.SetStartUsn( usnVolIter->MaxUsnRead() );
}
}
// Patch the USN for the monitored volume
for ( CUsnVolumeIter usnVolIter2(_usnVolumesToMonitor);
!_usnVolumesToMonitor.AtEnd(usnVolIter2);
_usnVolumesToMonitor.Advance(usnVolIter2) )
{
if ( usnVolIter->VolumeId() == usnVolIter2->VolumeId() )
{
ciDebugOut(( DEB_ITRACE,
"usn updating monitor volume %wc: from %#I64x to %#I64x\n",
usnVolIter->DriveLetter(),
usnVolIter->MaxUsnRead(),
usnVolIter->MaxUsnRead() ));
usnVolIter2->SetMaxUsnRead( usnVolIter->MaxUsnRead() );
}
}
}
}
} //ProcessUsnLog
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::HandleError, public
//
// Synopsis: Error reporting / handling for USN log read errors.
//
// Arguments: [pUsnVolume] -- Volume which could not be read.
// [Status] -- Failure code.
//
// History: 04-Jun-1998 KyleP Created
//
//----------------------------------------------------------------------------
void CUsnMgr::HandleError( CUsnVolume * pUsnVolume, NTSTATUS Status )
{
HandleError( pUsnVolume->DriveLetter(), Status );
if ( STATUS_TOO_LATE != Status )
pUsnVolume->MarkOffline();
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::HandleError, public
//
// Synopsis: Error reporting / handling for USN log read errors.
//
// Arguments: [wcDrive] -- Volume which could not be read.
// [Status] -- Failure code.
//
// History: 04-Jun-1998 KyleP Created
//
//----------------------------------------------------------------------------
void CUsnMgr::HandleError( WCHAR wcDrive, NTSTATUS Status )
{
Win4Assert( STATUS_SUCCESS != Status );
if ( STATUS_TOO_LATE != Status )
{
CEventLog eventLog( NULL, wcsCiEventSource );
CEventItem item( EVENTLOG_WARNING_TYPE,
CI_SERVICE_CATEGORY,
MSG_CI_USN_LOG_UNREADABLE,
2 );
WCHAR wszDrive[] = L"A:";
wszDrive[0] = wcDrive;
item.AddArg( wszDrive );
item.AddError( Status );
eventLog.ReportEvent( item );
}
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::IsPathIndexed, public
//
// Synopsis: Returns TRUE if the path is being indexed on a USN volume.
//
// Arguments: [pUsnVolume] -- The volume to use when checking
// [lcaseFunnyPath] -- The path to check
//
// Returns: TRUE if the path is in a current scan or in pUsnVolume.
//
// History: 12-Jun-98 dlee Created
//
//----------------------------------------------------------------------------
BOOL CUsnMgr::IsPathIndexed(
CUsnVolume * pUsnVolume,
CLowerFunnyPath & lcaseFunnyPath )
{
//
// First check the volume object given
//
CScanInfoList & usnScopeList = pUsnVolume->GetUsnScopesList();
for ( CFwdScanInfoIter iter( usnScopeList );
!usnScopeList.AtEnd(iter);
usnScopeList.Advance(iter) )
{
CScopeMatch scopeMatch( iter->GetPath(),
wcslen( iter->GetPath() ) );
if ( scopeMatch.IsInScope( lcaseFunnyPath.GetActualPath(), lcaseFunnyPath.GetActualLength() ) )
return TRUE;
}
//
// Check the scans in progress list
//
for ( CFwdScanInfoIter scanInfoIter(_usnScansInProgress);
!_usnScansInProgress.AtEnd(scanInfoIter);
_usnScansInProgress.Advance(scanInfoIter) )
{
CCiScanInfo & scanInfo = * scanInfoIter.GetEntry();
WCHAR const * pwcScanPath = scanInfo.GetPath();
CScopeMatch scopeMatch( pwcScanPath, wcslen( pwcScanPath ) );
if ( scopeMatch.IsInScope( lcaseFunnyPath.GetActualPath(), lcaseFunnyPath.GetActualLength() ) )
return TRUE;
}
return FALSE;
} //IsPathIndexed
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::IsLowResource, private
//
// Synopsis: Determine if either memory or i/o resources are low.
//
// Returns: TRUE if in a low resource condition.
//
// History: 22-Jun-1998 KyleP Created
//
//----------------------------------------------------------------------------
BOOL CUsnMgr::IsLowResource()
{
if ( _cicat.GetRegParams()->DelayUsnReadOnLowResource() )
{
CI_STATE State;
State.cbStruct = sizeof( State );
SCODE sc = _cicat.CiState( State );
if ( SUCCEEDED( sc ) )
return ( 0 != (State.eState & ( CI_STATE_HIGH_IO |
CI_STATE_LOW_MEMORY |
CI_STATE_USER_ACTIVE ) ) );
}
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::AnyInitialScans
//
// Synopsis: Checks if any scans are the result of a new scope
//
// Returns: TRUE if any scans are for new scopes
//
// History: 3-Aug-98 dlee Created
//
//----------------------------------------------------------------------------
BOOL CUsnMgr::AnyInitialScans()
{
for ( CFwdScanInfoIter iter1( _usnScansToDo );
!_usnScansToDo.AtEnd( iter1 );
_usnScansToDo.Advance( iter1 ) )
{
if ( iter1->IsNewScope() )
return TRUE;
}
for ( CFwdScanInfoIter iter2( _usnScansInProgress );
!_usnScansInProgress.AtEnd( iter2 );
_usnScansInProgress.Advance( iter2 ) )
{
if ( iter2->IsNewScope() )
return TRUE;
}
return FALSE;
} //AnyInitialScans
//+---------------------------------------------------------------------------
//
// Member: CUsnMgr::CheckTopLevelChange, private
//
// Synopsis: Checks if renames or creates *above* top level scopes need
// processing (because they affect top level).
//
// Arguments: [pUsnVolume] -- USN volume change affects
// [FileReferenceNumber] -- File ID of changing file
//
// History: 08-Jan-1999 KyleP Created
//
//----------------------------------------------------------------------------
void CUsnMgr::CheckTopLevelChange( CUsnVolume * pUsnVolume,
ULONGLONG & FileReferenceNumber )
{
//
// Convert file ID to path.
//
CLowerFunnyPath fpRenamed;
if ( 0 != _cicat.FileIdToPath( FileReferenceNumber, pUsnVolume->VolumeId(), fpRenamed ) )
{
CScopeMatch SMatch( fpRenamed.GetActualPath(), fpRenamed.GetActualLength() );
//
// Iterate through the top level scopes for this volume.
//
CScanInfoList & Scopes = pUsnVolume->GetUsnScopesList();
for ( CFwdScanInfoIter ScopesIter( Scopes );
!Scopes.AtEnd( ScopesIter );
Scopes.Advance( ScopesIter ) )
{
if ( _fAbort || _fUpdatesDisabled )
return;
WCHAR const * pwcsPath = ScopesIter->GetPath();
unsigned ccPath = wcslen(pwcsPath);
//
// Any top level scope that is underneath the rename must not have been
// read before, so we need to add all the files.
//
if ( SMatch.IsInScope( pwcsPath, ccPath ) )
{
ICiManager *pCiManager = _cicat.CiManager();
CLowerFunnyPath fpNew( pwcsPath, ccPath, TRUE );
fpNew.AppendBackSlash();
ciDebugOut(( DEB_USN, "Adding directory %ws\n", fpNew.GetActualPath() ));
_fDoingRenameTraverse = TRUE;
CUsnTreeTraversal usnTreeTrav( _cicat,
*this,
*pCiManager,
fpNew,
FALSE, // No deletions
_fUpdatesDisabled,
TRUE, // Process root
pUsnVolume->VolumeId() );
usnTreeTrav.EndProcessing();
_fDoingRenameTraverse = FALSE;
if ( _fAbort || _fUpdatesDisabled )
return;
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
}
//
// Conversely, if the top level scope no longer exists, files must be
// removed from the catalog. The LokIsInFinalState check is to keep
// us from retrying the same delete > once.
//
WIN32_FIND_DATA ffData;
if ( !GetFileAttributesEx( pwcsPath, GetFileExInfoStandard, &ffData ) &&
ScopesIter->LokIsInFinalState() )
{
ScopesIter->SetStartState();
CLowerFunnyPath fpOld( pwcsPath, ccPath, TRUE );
fpOld.AppendBackSlash();
ICiManager *pCiManager = _cicat.CiManager();
ciDebugOut(( DEB_USN, "Removing directory %ws\n", fpOld.GetActualPath() ));
_cicat.RemovePathsFromCiCat( fpOld.GetActualPath(), eUsnsArray );
if ( _fAbort || _fUpdatesDisabled )
return;
SCODE sc = pCiManager->FlushUpdates();
if ( FAILED(sc) )
THROW( CException( sc ) );
}
}
}
} //CheckTopLevelChange
Copy Permalink