You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2127 lines
69 KiB
2127 lines
69 KiB
|
|
// Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
//+============================================================================
|
|
//
|
|
// volmgr.cxx
|
|
//
|
|
// This file implements the CVolumeManager class. That class maintains
|
|
// a list of CVolume objects.
|
|
//
|
|
//+============================================================================
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
#include "trkwks.hxx"
|
|
#include <dbt.h>
|
|
|
|
#define THIS_FILE_NUMBER VOLMGR_CXX_FILE_NO
|
|
|
|
|
|
void
|
|
CVolumeManager::Initialize(CTrkWksSvc * pTrkWks,
|
|
const CTrkWksConfiguration *pTrkWksConfiguration,
|
|
PLogCallback * pLogCallback,
|
|
SERVICE_STATUS_HANDLE ssh
|
|
#if DBG
|
|
, CTestSync * pTunnelTest
|
|
#endif
|
|
)
|
|
{
|
|
BOOL fReg = FALSE;
|
|
HKEY hKey;
|
|
OBJECT_ATTRIBUTES oa;
|
|
UNICODE_STRING name;
|
|
CSystemSD ssd;
|
|
NTSTATUS Status;
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Initializing the volume list") ));
|
|
|
|
TrkAssert( !_fInitialized );
|
|
|
|
_csVolumeNodeList.Initialize();
|
|
_fInitialized = TRUE;
|
|
|
|
_pTrkWks = pTrkWks;
|
|
_pTrkWksConfiguration = pTrkWksConfiguration;
|
|
_pVolumeNodeListHead = NULL;
|
|
|
|
__try
|
|
{
|
|
// This timer is started when we unexpectedly lose our volume handles.
|
|
// When it fires, we try to reopen them. After a number of such retries,
|
|
// we give up and stop the timer.
|
|
|
|
_timerObjIdIndexReopen.Initialize(
|
|
this,
|
|
NULL, // No name (non-persistent timer)
|
|
VOLTIMER_OBJID_INDEX_REOPEN, // Context ID
|
|
pTrkWksConfiguration->GetObjIdIndexReopen(),
|
|
CNewTimer::RETRY_WITH_BACKOFF,
|
|
pTrkWksConfiguration->GetObjIdIndexReopenRetryMin(),
|
|
pTrkWksConfiguration->GetObjIdIndexReopenRetryMax(),
|
|
pTrkWksConfiguration->GetObjIdIndexReopenLifetime()
|
|
);
|
|
|
|
// Create and register an event that we'll signal when a volume has been unlocked.
|
|
// We have to run this on an IO thread so that the logfile oplock and
|
|
// ReadDirectoryChanges on the objid index will work.
|
|
|
|
_heventVolumeToBeReopened = CreateEvent( NULL, FALSE, FALSE, NULL );
|
|
if( NULL == _heventVolumeToBeReopened )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't create _hVolumeUnlockEvent") ));
|
|
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__, HRESULT_FROM_WIN32(GetLastError()),
|
|
NULL );
|
|
TrkRaiseWin32Error( GetLastError() );
|
|
}
|
|
|
|
_hRegisterWaitForSingleObjectEx
|
|
= TrkRegisterWaitForSingleObjectEx( _heventVolumeToBeReopened, ThreadPoolCallbackFunction,
|
|
static_cast<PWorkItem*>(this), INFINITE,
|
|
WT_EXECUTEINIOTHREAD | WT_EXECUTELONGFUNCTION );
|
|
|
|
if( NULL == _hRegisterWaitForSingleObjectEx )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Failed RegisterWaitForSingleObjectEx in CVolumeManager::Initialize (%lu)"),
|
|
GetLastError() ));
|
|
TrkRaiseLastError();
|
|
}
|
|
|
|
// Create a list of CVolume objects, one for each local NTFS5 volume.
|
|
InitializeVolumeList( pTrkWksConfiguration, pLogCallback, ssh
|
|
#if DBG
|
|
, pTunnelTest
|
|
#endif
|
|
);
|
|
|
|
if( !pTrkWksConfiguration->_fIsWorkgroup )
|
|
{
|
|
InitializeDomainObjects();
|
|
StartDomainTimers();
|
|
}
|
|
|
|
// Set the event that will get us to open the volume handles on an
|
|
// IO thread.
|
|
|
|
OnVolumeToBeReopened();
|
|
|
|
|
|
}
|
|
__finally
|
|
{
|
|
ssd.UnInitialize();
|
|
}
|
|
}
|
|
|
|
void
|
|
CVolumeManager::UnInitialize()
|
|
{
|
|
if( _fInitialized )
|
|
{
|
|
if( NULL != _hRegisterWaitForSingleObjectEx )
|
|
{
|
|
if( !TrkUnregisterWait( _hRegisterWaitForSingleObjectEx ))
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Failed UnregisterWait for CVolumeManager (%lu)"),
|
|
GetLastError() ));
|
|
}
|
|
else
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Unregistered wait CVolumeManager") ));
|
|
|
|
_hRegisterWaitForSingleObjectEx = NULL;
|
|
}
|
|
|
|
if( NULL != _heventVolumeToBeReopened )
|
|
{
|
|
CloseHandle( _heventVolumeToBeReopened );
|
|
_heventVolumeToBeReopened = NULL;
|
|
}
|
|
|
|
UnInitializeDomainObjects();
|
|
_timerObjIdIndexReopen.UnInitialize();
|
|
|
|
CVolumeNode * pVolumeNode = _pVolumeNodeListHead;
|
|
_pVolumeNodeListHead = NULL;
|
|
|
|
while (pVolumeNode)
|
|
{
|
|
CVolumeNode * pNext = pVolumeNode->_pNext;
|
|
|
|
// By this time, all timers and the LPC port are stopped and have unregistered
|
|
// with the thread pool. Therefore, there are no other threads running,
|
|
// and each of the volume should have a ref count of only 1. For robustness,
|
|
// if any volumes have leaked, we release the extra refs here.
|
|
|
|
while( 0 != pVolumeNode->_pVolume->Release() );
|
|
|
|
delete pVolumeNode;
|
|
pVolumeNode = pNext;
|
|
}
|
|
|
|
_fFrequentTaskHesitation = _fInfrequentTaskHesitation = FALSE;
|
|
|
|
_csVolumeNodeList.UnInitialize();
|
|
_fInitialized = FALSE;
|
|
}
|
|
}
|
|
|
|
void
|
|
CVolumeManager::DoWork()
|
|
{
|
|
// One of the volumes has been unlocked. Just try to reopen them all
|
|
// (those that aren't in need of opening will noop).
|
|
|
|
__try
|
|
{
|
|
// These raise if the service is stopping.
|
|
ReopenVolumeHandles();
|
|
|
|
// If a volume has just been re-created, it may be necessary
|
|
// to clean up some object IDs.
|
|
|
|
CleanUpOids();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Ignoring exception %08x in CVolumeManager::DoWork"),
|
|
GetExceptionCode() ));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::InitializeDomainObjects
|
|
//
|
|
// Initialize member objects that we don't use in a workgroup. These
|
|
// objects can come and go without restarting the service (thus we can
|
|
// go between domains or move to/from domain without requiring a reboot).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::InitializeDomainObjects()
|
|
{
|
|
__try
|
|
{
|
|
TrkAssert( !_pTrkWksConfiguration->_fIsWorkgroup );
|
|
|
|
// When this timer fires, we send all our IDs to trksvr so that the entries may
|
|
// be touched (entries that are not touched will be GC-ed by trksvr).
|
|
// Before actuallying doing the refresh, we sleep a random period, in order to
|
|
// avoid too many workstations refreshing at the same time.
|
|
|
|
_timerRefresh.Initialize( this,
|
|
TEXT("NextRefreshTime"), // Name (for persistent timer)
|
|
VOLTIMER_REFRESH, // Context ID
|
|
// Timer period
|
|
_pTrkWksConfiguration->GetRefreshPeriod(),
|
|
CNewTimer::RETRY_RANDOMLY, //Retry values
|
|
_pTrkWksConfiguration->GetRefreshRetryMin(),
|
|
_pTrkWksConfiguration->GetRefreshRetryMax(),
|
|
0 ); // No max lifetime
|
|
_timerRefresh.SetRecurring();
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Refresh timer: %s"),
|
|
(const TCHAR*)CDebugString(_timerRefresh) ));
|
|
|
|
// The Notify timer is set when we receive a move notification from ntos.
|
|
// When it expires we send all unsent notifications up to trksvr.
|
|
|
|
_timerNotify.Initialize( this,
|
|
NULL, // No name (non-persistent timer)
|
|
VOLTIMER_NOTIFY, // Context ID
|
|
_pTrkWksConfiguration->GetParameter( MOVE_NOTIFY_TIMEOUT_CONFIG ),
|
|
CNewTimer::RETRY_WITH_BACKOFF,
|
|
_pTrkWksConfiguration->GetParameter( MIN_MOVE_NOTIFY_RETRY_CONFIG ),
|
|
_pTrkWksConfiguration->GetParameter( MAX_MOVE_NOTIFY_RETRY_CONFIG ),
|
|
_pTrkWksConfiguration->GetParameter( MAX_MOVE_NOTIFY_LIFETIME_CONFIG ) );
|
|
|
|
// The deletions manager watches for files with object IDs to get
|
|
// deleted. When they are, and they're not subsequently tunnelled back,
|
|
// a notification is sent to trksvr so that it can remove that birth ID
|
|
// from the object move table.
|
|
|
|
_deletions.Initialize( _pTrkWksConfiguration );
|
|
|
|
// When this timer fires, we do our ~daily tasks
|
|
|
|
_timerFrequentTasks.Initialize( this,
|
|
TEXT("NextVolFrequentTask"), // Persistent timer
|
|
VOLTIMER_FREQUENT, // Context ID
|
|
_pTrkWksConfiguration->GetVolFrequentTasksPeriod(),
|
|
CNewTimer::NO_RETRY,
|
|
0, 0, 0 ); // Ignored for non-retrying timer
|
|
|
|
// When this timer fires, we do our ~weekly tasks
|
|
|
|
_timerInfrequentTasks.Initialize( this,
|
|
TEXT("NextVolInfrequentTask"),//Persistent timer
|
|
VOLTIMER_INFREQUENT, // Context ID
|
|
_pTrkWksConfiguration->GetVolInfrequentTasksPeriod(),
|
|
CNewTimer::NO_RETRY,
|
|
0, 0, 0 ); // Ignored for non-retrying timer
|
|
|
|
// When this timer fires, we do the initial volume synchronizations.
|
|
// This timer is also used to do slow retries. E.g, if we try to send
|
|
// a move notification and get a busy error, we retry at this slow rate.
|
|
|
|
_timerVolumeInit.Initialize( this,
|
|
NULL, // No name (non-persistent)
|
|
VOLTIMER_INIT, // Context ID
|
|
_pTrkWksConfiguration->GetVolInitInitialDelay(),
|
|
CNewTimer::RETRY_RANDOMLY,
|
|
// Initial retry period
|
|
_pTrkWksConfiguration->GetVolInitRetryDelay1(),
|
|
// Max retry period
|
|
_pTrkWksConfiguration->GetVolInitRetryDelay2(),
|
|
_pTrkWksConfiguration->GetVolInitLifetime() );
|
|
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception %08x in CVolumeManager::InitializeDomainObjects"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::UnInitializeObjects
|
|
//
|
|
// Free the objects that we don't use in a workgroup. This doesn't require
|
|
// stopping the service.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::UnInitializeDomainObjects()
|
|
{
|
|
__try
|
|
{
|
|
_timerRefresh.UnInitialize();
|
|
_timerNotify.UnInitialize();
|
|
|
|
_deletions.UnInitialize( );
|
|
|
|
_timerInfrequentTasks.UnInitialize();
|
|
_timerFrequentTasks.UnInitialize();
|
|
_timerVolumeInit.UnInitialize();
|
|
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception %08x in CVolumeManager::UnInitializeDomainObjects"),
|
|
GetExceptionCode() ));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::StartDomainTimers
|
|
//
|
|
// Start the timers that we don't use in a workgroup.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::StartDomainTimers()
|
|
{
|
|
if( !_pTrkWksConfiguration->_fIsWorkgroup )
|
|
{
|
|
_timerFrequentTasks.SetSingleShot();
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Frequent timer: %s"),
|
|
(const TCHAR*)CDebugString(_timerFrequentTasks) ));
|
|
|
|
_timerInfrequentTasks.SetSingleShot();
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Infrequent timer: %s"),
|
|
(const TCHAR*)CDebugString(_timerInfrequentTasks) ));
|
|
|
|
_timerVolumeInit.SetSingleShot();
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("VolInit timer: %s"),
|
|
(const TCHAR*)CDebugString(_timerVolumeInit) ));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Method: CVolumeManager::RefreshVolumes
|
|
//
|
|
// Refresh the CVolume objects. This gives them the chance to
|
|
// get an updated drive letter, and to delete themselves if the volume
|
|
// they represent is now gone.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
CVolumeManager::RefreshVolumes( PLogCallback *pLogCallback,
|
|
SERVICE_STATUS_HANDLE ssh
|
|
#if DBG
|
|
, CTestSync *pTunnelTest
|
|
#endif
|
|
)
|
|
{
|
|
InitializeVolumeList( _pTrkWksConfiguration, pLogCallback, ssh
|
|
#if DBG
|
|
, pTunnelTest
|
|
#endif
|
|
);
|
|
OnVolumeToBeReopened();
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Method: CVolumeManager::InitializeVolumeList
|
|
//
|
|
// This method initializes the linked list of CVolume objects.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::InitializeVolumeList( const CTrkWksConfiguration *pTrkWksConfiguration,
|
|
PLogCallback *pLogCallback,
|
|
SERVICE_STATUS_HANDLE ssh
|
|
#if DBG
|
|
, CTestSync *pTunnelTest
|
|
#endif
|
|
)
|
|
{
|
|
ULONG cVolumes = 0;
|
|
TCHAR tszVolumeName[ CCH_MAX_VOLUME_NAME + 1 ];
|
|
HANDLE hFindVolume = INVALID_HANDLE_VALUE;
|
|
CVolumeNode *pVolNode = NULL;
|
|
|
|
__try
|
|
{
|
|
// Begin a physical volume enumeration using the mount manager.
|
|
// Volume names represent the root in Win32 format, e.g.
|
|
// \\?\Volume{8baec120-078b-11d2-824b-000000000000}\
|
|
|
|
hFindVolume = FindFirstVolume( tszVolumeName, ELEMENTS(tszVolumeName) );
|
|
if( INVALID_HANDLE_VALUE == hFindVolume )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("FindFirstVolume failed") ));
|
|
TrkRaiseLastError();
|
|
}
|
|
|
|
// For each local NTFS5 volume, create a CVolume, add it to the linked-list,
|
|
// and initialize.
|
|
|
|
cVolumes = 1;
|
|
while( NUM_VOLUMES >= cVolumes )
|
|
{
|
|
CVolume *pvolOpen = NULL;
|
|
TCHAR tszVolumeDeviceName[ MAX_PATH + 1 ];
|
|
ULONG cchVolumeName;
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Initializing volume %s"), tszVolumeName ));
|
|
|
|
// If we already have this volume open, continue on.
|
|
|
|
cchVolumeName = wcslen(tszVolumeName);
|
|
memcpy( tszVolumeDeviceName, tszVolumeName, cchVolumeName*sizeof(TCHAR) );
|
|
tszVolumeDeviceName[ cchVolumeName - 1 ] = TEXT('\0');
|
|
|
|
if( pvolOpen = FindVolume( tszVolumeDeviceName ))
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume already open" ) ));
|
|
pvolOpen->Release();
|
|
cVolumes++;
|
|
}
|
|
|
|
// If this isn't an NTFS5 volume, move on.
|
|
|
|
else if( IsLocalObjectVolume(tszVolumeName) )
|
|
{
|
|
// Alloc a new node for the volume list
|
|
|
|
pVolNode = new CVolumeNode;
|
|
if (pVolNode == NULL)
|
|
{
|
|
TrkRaiseException(E_OUTOFMEMORY);
|
|
}
|
|
|
|
// Put a volume into the node
|
|
|
|
pVolNode->_pVolume = new CVolume();
|
|
if (pVolNode->_pVolume == NULL)
|
|
{
|
|
TrkRaiseException(E_OUTOFMEMORY);
|
|
}
|
|
|
|
|
|
// Initialize the volume. Returns true if successful, raises on error.
|
|
__try
|
|
{
|
|
if( pVolNode->_pVolume->Initialize(tszVolumeName, _pTrkWksConfiguration, this,
|
|
pLogCallback, &_deletions, ssh
|
|
#if DBG
|
|
,pTunnelTest
|
|
#endif
|
|
))
|
|
{
|
|
cVolumes++;
|
|
|
|
// Add this volume node (and its associated CVolume) to the linked list.
|
|
|
|
AddNodeToLinkedList( pVolNode );
|
|
pVolNode = NULL;
|
|
|
|
} // if( pVolNode->_pVolume->Initialize(v, _pTrkWksConfiguration, ...
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
}
|
|
|
|
if( NULL != pVolNode )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume initialization failed, deleting node") ));
|
|
pVolNode->_pVolume->Release();
|
|
delete pVolNode;
|
|
pVolNode = NULL;
|
|
}
|
|
|
|
} // else if( IsLocalObjectVolume(tszVolumeName) )
|
|
#if DBG
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Skipping volume %s"), tszVolumeName ));
|
|
}
|
|
#endif
|
|
|
|
// Move on to the next volume in the system.
|
|
|
|
if( !FindNextVolume( hFindVolume, tszVolumeName, ELEMENTS(tszVolumeName) ))
|
|
{
|
|
if( ERROR_NO_MORE_FILES == GetLastError() )
|
|
// We've enumerated all of the volumes.
|
|
break;
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("FindNextVolume failed") ));
|
|
TrkRaiseLastError();
|
|
}
|
|
}
|
|
|
|
} // while( NUM_VOLUMES >= cVolumes )
|
|
}
|
|
__finally
|
|
{
|
|
if( INVALID_HANDLE_VALUE != hFindVolume )
|
|
FindVolumeClose( hFindVolume );
|
|
|
|
if( NULL != pVolNode )
|
|
delete pVolNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Method: CVolumeManager::AddNodeToLinkedList
|
|
//
|
|
// Adds a CVolumeNode (and its embedded CVolume) to the volume manager's
|
|
// linked list.
|
|
//
|
|
// The CVolumeNode elements in the linked list are kept sorted in
|
|
// increasing address order. This is so a CVolumeEnumerator can handle a
|
|
// node being deleted while such an enumeration is active.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::AddNodeToLinkedList( CVolumeNode *pVolNode )
|
|
{
|
|
TrkAssert( _fInitialized );
|
|
_csVolumeNodeList.Enter();
|
|
__try
|
|
{
|
|
if( NULL == _pVolumeNodeListHead )
|
|
{
|
|
pVolNode->_pNext = NULL;
|
|
_pVolumeNodeListHead = pVolNode;
|
|
}
|
|
else if( pVolNode < _pVolumeNodeListHead )
|
|
{
|
|
pVolNode->_pNext = _pVolumeNodeListHead;
|
|
_pVolumeNodeListHead = pVolNode;
|
|
}
|
|
else
|
|
{
|
|
CVolumeNode *pNode = _pVolumeNodeListHead;
|
|
while( NULL != pNode->_pNext && pNode->_pNext < pVolNode )
|
|
pNode = pNode->_pNext;
|
|
|
|
if( NULL == pNode->_pNext )
|
|
{
|
|
TrkAssert( pNode < pVolNode );
|
|
pNode->_pNext = pVolNode;
|
|
pVolNode->_pNext = NULL;
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( pNode < pVolNode );
|
|
TrkAssert( pNode->_pNext > pVolNode );
|
|
pVolNode->_pNext = pNode->_pNext;
|
|
pNode->_pNext = pVolNode;
|
|
}
|
|
}
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
TrkAssert( !TEXT("Unexpected exception in CVolumeManager::AddNodeToLinkedList") );
|
|
}
|
|
_csVolumeNodeList.Leave();
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Method: CVolumeManager::RemoveVolumeFromLinkedList
|
|
//
|
|
// Removes a volume from the volume manager's linked list.
|
|
// The CVolume is Released (which may or may not make it go away, depending
|
|
// on ref-counts), and the CVolumeNode is deleted.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::RemoveVolumeFromLinkedList( const CVolume *pvol )
|
|
{
|
|
CVolumeNode **ppvolnodePrev = NULL;
|
|
CVolumeNode *pvolnode = NULL;
|
|
|
|
TrkAssert( _fInitialized );
|
|
_csVolumeNodeList.Enter();
|
|
__try
|
|
{
|
|
pvolnode = _pVolumeNodeListHead;
|
|
ppvolnodePrev = &_pVolumeNodeListHead;
|
|
|
|
while( NULL != pvolnode )
|
|
{
|
|
if( pvol == pvolnode->_pVolume )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Removing volume %p from the list"), pvolnode->_pVolume ));
|
|
|
|
CVolumeNode *pvolnodeDel = pvolnode;
|
|
*ppvolnodePrev = pvolnode->_pNext;
|
|
|
|
// Releasing the volume will usually cause it to delete itself, unless
|
|
// someone else is holding a ref on it.
|
|
|
|
pvolnodeDel->_pVolume->Release();
|
|
delete pvolnodeDel;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ppvolnodePrev = &pvolnode->_pNext;
|
|
pvolnode = pvolnode->_pNext;
|
|
}
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
}
|
|
_csVolumeNodeList.Leave();
|
|
|
|
}
|
|
|
|
void
|
|
CVolumeManager::CloseVolumeHandles( HDEVNOTIFY hdnVolume )
|
|
{
|
|
CVolumeEnumerator volEnum = Enum();
|
|
CVolume* vol = volEnum.GetNextVolume();
|
|
|
|
while (vol != NULL)
|
|
{
|
|
__try
|
|
{
|
|
vol->CloseVolumeHandles( hdnVolume );
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in CloseVolumeHandles (%08x)"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
vol->Release();
|
|
vol = volEnum.GetNextVolume();
|
|
}
|
|
}
|
|
|
|
void
|
|
CVolumeManager::CleanUpOids()
|
|
{
|
|
CVolumeEnumerator volEnum = Enum();
|
|
CVolume* vol = volEnum.GetNextVolume();
|
|
|
|
while(vol != NULL)
|
|
{
|
|
if(vol->IsMarkedForMakeAllOidsReborn())
|
|
{
|
|
__try
|
|
{
|
|
if( vol->MakeAllOidsReborn() )
|
|
vol->ClearMarkForMakeAllOidsReborn();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Ignoring exception in CVolumeManager::CleanUpOids") ));
|
|
}
|
|
}
|
|
|
|
vol->Release();
|
|
vol = volEnum.GetNextVolume();
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::SyncVolumes
|
|
//
|
|
// Give each active volume an opportunity to synchronize with trksvr.
|
|
// This allows the volumes to create a new ID, claim an existing ID,
|
|
// etc.
|
|
//
|
|
// Note:: This routine is guaranteed not to raise.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolumeManager::SyncVolumes( EAggressiveness eAggressiveness,
|
|
CFILETIME cftLastDue,
|
|
ULONG ulPeriodInSeconds )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
BOOL fDoRetry = FALSE;
|
|
CAvailableDc adc;
|
|
CVolumeEnumerator volEnum;
|
|
CVolume* pvol;
|
|
BOOL fIsOnlyInstance = FALSE;
|
|
|
|
__try
|
|
{
|
|
|
|
TRKSVR_SYNC_VOLUME rgSyncVolumes[ NUM_VOLUMES ];
|
|
TRKSVR_MESSAGE_UNION Msg;
|
|
ULONG cVolumes = 0;
|
|
const CVolumeId volNULL;
|
|
BOOL fSyncNeeded;
|
|
|
|
// If there's already a thread doing a SyncVolumes, we don't need to
|
|
// do it again simultaneously.
|
|
|
|
fIsOnlyInstance = BeginSingleInstanceTask( &_cSyncVolumesInProgress );
|
|
if( !fIsOnlyInstance )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Skipping SyncVolumes, another instance already in progress") ));
|
|
fSuccess = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
// If we haven't fully initialized the volumes yet, do so now.
|
|
ReopenVolumeHandles();
|
|
|
|
// Start a CVolume enumeration
|
|
|
|
volEnum = Enum();
|
|
pvol = volEnum.GetNextVolume();
|
|
|
|
// Loop through the enumerated volumes.
|
|
// When we're done, cVolumes will show the count of volumes
|
|
// that requested to sync with trksvr (could be zero).
|
|
|
|
while ( NULL != pvol )
|
|
{
|
|
BOOL fFound = FALSE;
|
|
|
|
// Add this volume to the array of volumes needing update with trksvr.
|
|
// If this particular volume turns out not to need an update, we won't
|
|
// increment cVolumes, consequently it will get overwritten on the
|
|
// next pass. If this volume does need an update, we'll addref it.
|
|
|
|
_rgVolumesToUpdate[cVolumes] = pvol;
|
|
|
|
// Call the volume to load the sync-volume request.
|
|
|
|
if(TRUE == pvol->LoadSyncVolume(&rgSyncVolumes[cVolumes], eAggressiveness, &fSyncNeeded))
|
|
{
|
|
// The LoadSyncVolumes request succeeded.
|
|
// Does the volume need a sync with trksvr?
|
|
|
|
if(fSyncNeeded == FALSE)
|
|
{
|
|
// No, the volume doesn't need a sync. It's
|
|
// apparantly neither new nor newly attached.
|
|
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Volume %c is properly ID-ed already"),
|
|
'A'+pvol->GetIndex() ));
|
|
}
|
|
else if(rgSyncVolumes[cVolumes].SyncType == CREATE_VOLUME)
|
|
{
|
|
// This is a newly-formatted volume.
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Having a new ID created for volume %c"),
|
|
TEXT('A')+pvol->GetIndex() ));
|
|
_rgVolumesToUpdate[cVolumes]->AddRef();
|
|
cVolumes++;
|
|
}
|
|
else
|
|
{
|
|
// The volume is new to this machine
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Claiming volume %c"),
|
|
TEXT('A')+pvol->GetIndex() ));
|
|
_rgVolumesToUpdate[cVolumes]->AddRef();
|
|
cVolumes++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The volume needs to be synced but failed for some reason
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Volume %c can not be synced"),
|
|
'A'+pvol->GetIndex() ));
|
|
}
|
|
|
|
// Move on to the next item in the enumeration.
|
|
// If this volumes needs an update, it's addref-ed in
|
|
// _rgVolumesToUpdate.
|
|
|
|
pvol->Release();
|
|
pvol = volEnum.GetNextVolume();
|
|
|
|
} // while ( vol != NULL )
|
|
|
|
|
|
// Were there any volumes in need of a sync with trksvr?
|
|
|
|
if( 0 != cVolumes )
|
|
{
|
|
// Yes, send the sync_volumes request.
|
|
|
|
__try
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Construct the Msg union
|
|
|
|
Msg.MessageType = SYNC_VOLUMES;
|
|
|
|
Msg.Priority = (0 == ulPeriodInSeconds)
|
|
? PRI_6
|
|
: GetSvrMessagePriority( cftLastDue, ulPeriodInSeconds );
|
|
|
|
Msg.SyncVolumes.cVolumes = cVolumes;
|
|
|
|
Msg.SyncVolumes.pVolumes = rgSyncVolumes;
|
|
#ifdef VOL_REPL
|
|
Msg.SyncVolumes.cChanges = 0;
|
|
Msg.SyncVolumes.ppVolumeChanges = NULL;
|
|
#endif
|
|
|
|
// Send the request to trksvr. We pass it under privacy encryption
|
|
// because there could be a volume secret in it.
|
|
// This will raise if there's an error.
|
|
|
|
hr = adc.CallAvailableDc(&Msg, PRIVACY_AUTHENTICATION );
|
|
|
|
// now we've successfully told the DC we should update the
|
|
// DcInformed flags
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("CallAvailableDc returned %d volumes (%08X)"),
|
|
Msg.SyncVolumes.cVolumes, hr ));
|
|
|
|
// See if there were problems and we should do a retry
|
|
// (This gets set in the DcCallback method).
|
|
|
|
if( TRK_S_VOLUME_NOT_SYNCED == hr )
|
|
fDoRetry = TRUE;
|
|
|
|
// Process the responses
|
|
|
|
for( ULONG v = 0; v < Msg.SyncVolumes.cVolumes; v++ )
|
|
{
|
|
// If the problem is server-too-busy, have the caller do
|
|
// a retry. Otherwise (e.g. quota error) ignore the error.
|
|
// E.g. for a quota error, we'll ignore the error, but the
|
|
// volume will still be in a not-created state, and we'll
|
|
// retry the next time the infrequent timer fires.
|
|
|
|
if( TRK_E_SERVER_TOO_BUSY == rgSyncVolumes[v].hr )
|
|
fDoRetry = TRUE;
|
|
|
|
if( _rgVolumesToUpdate[v]->UnloadSyncVolume( &rgSyncVolumes[v] )
|
|
&&
|
|
rgSyncVolumes[v].hr == S_OK
|
|
)
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Volume %c successfully synced with server"),
|
|
'A'+_rgVolumesToUpdate[v]->GetIndex() ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Couldn't sync vol %c with server (%08x, %s)"),
|
|
'A'+_rgVolumesToUpdate[v]->GetIndex(),
|
|
rgSyncVolumes[v].hr, GetErrorString(rgSyncVolumes[v].hr) ));
|
|
}
|
|
} // for( v = 0; v < Msg.SyncVolumes.cVolumes; v++ )
|
|
}
|
|
__finally
|
|
{
|
|
for( ULONG v = 0; v < cVolumes; v++ )
|
|
{
|
|
_rgVolumesToUpdate[v]->Release();
|
|
}
|
|
}
|
|
|
|
} // if( 0 != cVolumes )
|
|
|
|
// If any volids have been changed, make all the existing object IDs
|
|
// reborn.
|
|
|
|
CleanUpOids();
|
|
|
|
fSuccess = TRUE;
|
|
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't sync with server (0x%08x)"), GetExceptionCode() ));
|
|
}
|
|
|
|
if( pvol != NULL )
|
|
{
|
|
pvol->Release();
|
|
}
|
|
|
|
Exit:
|
|
|
|
if( fIsOnlyInstance )
|
|
EndSingleInstanceTask( &_cSyncVolumesInProgress );
|
|
|
|
return fSuccess && !fDoRetry;
|
|
}
|
|
|
|
|
|
void
|
|
CVolumeManager::Append( const CDomainRelativeObjId &droidCurrent,
|
|
const CDomainRelativeObjId &droidNew,
|
|
const CMachineId &mcidNew,
|
|
const CDomainRelativeObjId &droidBirth)
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume* cvolCur = enumerator.GetNextVolume();
|
|
BOOL fVolumeFound = FALSE;
|
|
|
|
__try // __finally
|
|
{
|
|
|
|
while ( cvolCur != NULL )
|
|
{
|
|
if( cvolCur->GetVolumeId() == droidCurrent.GetVolumeId())
|
|
{
|
|
fVolumeFound = TRUE;
|
|
cvolCur->Append(droidCurrent, droidNew, mcidNew, droidBirth);
|
|
break;
|
|
}
|
|
|
|
cvolCur->Release();
|
|
cvolCur = enumerator.GetNextVolume();
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if (cvolCur != NULL)
|
|
{
|
|
cvolCur->Release();
|
|
}
|
|
}
|
|
|
|
if( !fVolumeFound )
|
|
TrkRaiseNtStatus( STATUS_NO_TRACKING_SERVICE );
|
|
}
|
|
|
|
|
|
// search all volumes (and each log) or just the given volume
|
|
//
|
|
// S_OK || TRK_E_NOT_FOUND || TRK_E_REFERRAL
|
|
|
|
HRESULT
|
|
CVolumeManager::Search( DWORD Restrictions,
|
|
const CDomainRelativeObjId & droidBirthLast,
|
|
const CDomainRelativeObjId & droidLast,
|
|
CDomainRelativeObjId * pdroidBirthNext,
|
|
CDomainRelativeObjId * pdroidNext,
|
|
CMachineId * pmcidNext,
|
|
TCHAR * ptszLocalPath )
|
|
{
|
|
NTSTATUS status;
|
|
HRESULT hr = TRK_E_NOT_FOUND;
|
|
CVolumeEnumerator enumerator;
|
|
CVolume* pvol = NULL;
|
|
const CMachineId mcidLocal( MCID_LOCAL );
|
|
BOOL fPotentialFile = FALSE;
|
|
CDomainRelativeObjId droidZero;
|
|
|
|
// Local working stores for what we'll return in pdroidNew & pmcidNew
|
|
// if we have a referral.
|
|
|
|
CDomainRelativeObjId droidBirthNext = droidBirthLast;
|
|
CDomainRelativeObjId droidNext = droidLast;
|
|
CMachineId mcidNext = mcidLocal;
|
|
|
|
__try // __finally
|
|
{
|
|
|
|
g_ptrkwks->RaiseIfStopped();
|
|
|
|
// -------------------------------
|
|
// Search the volumes for the file
|
|
// -------------------------------
|
|
|
|
// Search the last volume first, then search all the volumes.
|
|
// Thus we'll end up searching droidLast.GetVolumeId() twice.
|
|
// This is necessary, though, because there could be multiple
|
|
// local volumes with this volid.
|
|
|
|
if( !(Restrictions & TRK_MEND_DONT_SEARCH_ALL_VOLUMES) )
|
|
enumerator = Enum();
|
|
|
|
if( !(Restrictions & TRK_MEND_DONT_USE_VOLIDS) )
|
|
pvol = FindVolume( droidLast.GetVolumeId() );
|
|
|
|
if( NULL == pvol )
|
|
pvol = enumerator.GetNextVolume();
|
|
|
|
for( ; NULL != pvol; pvol = enumerator.GetNextVolume() )
|
|
{
|
|
status = FindLocalPath( pvol->GetIndex(), droidLast.GetObjId(),
|
|
&droidBirthNext, &ptszLocalPath[2] );
|
|
if( NT_SUCCESS(status) )
|
|
{
|
|
// Is this in the SystemVolumeInformation directory? If so, we'll
|
|
// pretend we didn't find it (it's probably in the System Recovery
|
|
// directory).
|
|
|
|
if( IsSystemVolumeInformation( &ptszLocalPath[2] ))
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MEND,
|
|
TEXT("CVolumeManager::Search ignoring %c:%s"),
|
|
VolChar(pvol->GetIndex()), &ptszLocalPath[2] ));
|
|
}
|
|
|
|
// Or, is this the correct birth ID (or the caller doesn't want us to check)?
|
|
else if( droidBirthLast == droidBirthNext
|
|
||
|
|
droidBirthLast == droidZero )
|
|
{
|
|
// Yes. We've found our file and we're done.
|
|
|
|
// Give the path a drive letter
|
|
TrkAssert( -1 != pvol->GetIndex() );
|
|
ptszLocalPath[0] = VolChar(pvol->GetIndex());
|
|
ptszLocalPath[1] = TEXT(':');
|
|
|
|
// droidBirthNext is already set by FindLocalPath
|
|
droidNext = CDomainRelativeObjId( pvol->GetVolumeId(), droidLast.GetObjId() );
|
|
mcidNext = mcidLocal;
|
|
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MEND, TEXT("CVolumeManager::Search found %s"),
|
|
ptszLocalPath ));
|
|
|
|
hr = S_OK;
|
|
fPotentialFile = FALSE;
|
|
__leave;
|
|
}
|
|
|
|
// Otherwise, is it the first potential hit?
|
|
else if( !fPotentialFile )
|
|
{
|
|
// We found a file with the right object ID, but the wrong birth ID.
|
|
// By rule of law, it's therefore not the right file. However, it could be
|
|
// the right file, but was re-born due to a volid change. So we'll keep
|
|
// it and let the caller (eventually, the user) decide.
|
|
|
|
// Give the path a drive letter
|
|
ptszLocalPath[0] = VolChar(pvol->GetIndex());
|
|
ptszLocalPath[1] = TEXT(':');
|
|
|
|
// droidBirthNext is already set by FindLocalPath
|
|
droidNext = CDomainRelativeObjId( pvol->GetVolumeId(), droidLast.GetObjId() );
|
|
mcidNext = mcidLocal;
|
|
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MEND,
|
|
TEXT("CVolumeManager::Search found *potential* %s"),
|
|
ptszLocalPath ));
|
|
|
|
fPotentialFile = TRUE;
|
|
}
|
|
}
|
|
|
|
pvol->Release(); pvol = NULL;
|
|
|
|
} // for( ; NULL != pvol, pvol = enumerator.GetNextVolume() );
|
|
enumerator.UnInitialize();
|
|
|
|
// We didn't find the file on any of the volumes, let's search the logs
|
|
// to see if they know where it went.
|
|
|
|
// ---------------------
|
|
// Search the local logs
|
|
// ---------------------
|
|
|
|
if( Restrictions & TRK_MEND_DONT_USE_LOG )
|
|
__leave;
|
|
|
|
// Start by searching the log of the last volume, then enumerate through all the
|
|
// volume logs. Again we'll end up searching the last volume twice, because
|
|
// there could be dup volids.
|
|
|
|
if( !(Restrictions & TRK_MEND_DONT_SEARCH_ALL_VOLUMES) )
|
|
enumerator = Enum();
|
|
|
|
if( !(Restrictions & TRK_MEND_DONT_USE_VOLIDS) )
|
|
pvol = FindVolume( droidLast.GetVolumeId() );
|
|
|
|
if( NULL == pvol )
|
|
pvol = enumerator.GetNextVolume();
|
|
|
|
for( ; NULL != pvol; pvol = enumerator.GetNextVolume() )
|
|
{
|
|
CDomainRelativeObjId droidNextT, droidBirthT;
|
|
CMachineId mcidNextT;
|
|
|
|
if (pvol->Search( droidLast, &droidNextT, &mcidNextT, &droidBirthT ))
|
|
{
|
|
// We found a match in the log.
|
|
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MEND, TEXT("Referral on vol %c: %s\n => %s:%s"),
|
|
VolChar(pvol->GetVolIndex()),
|
|
(const TCHAR*)CDebugString(droidLast.GetObjId()),
|
|
(const TCHAR*)CDebugString(mcidNextT),
|
|
(const TCHAR*)CDebugString(droidNextT) ));
|
|
|
|
// If the volid is useful (it's non-NULL and non-local), keep these IDs
|
|
// as the best to return.
|
|
|
|
if( CVolumeId() != droidNextT.GetVolumeId()
|
|
&&
|
|
( !IsLocal( droidNextT.GetVolumeId() )
|
|
||
|
|
droidLast.GetObjId() != droidNextT.GetObjId()
|
|
||
|
|
(Restrictions & TRK_MEND_DONT_SEARCH_ALL_VOLUMES)
|
|
)
|
|
)
|
|
{
|
|
hr = TRK_E_REFERRAL;
|
|
droidBirthNext = droidBirthLast;
|
|
droidNext = droidNextT;
|
|
mcidNext = mcidNextT;
|
|
|
|
fPotentialFile = FALSE;
|
|
break;
|
|
}
|
|
|
|
// Or, if the mcid is useful (not this machine), keep the IDs as the
|
|
// best to return
|
|
|
|
else if( CMachineId() != mcidNextT
|
|
&&
|
|
( mcidLocal != mcidNextT
|
|
||
|
|
(Restrictions & TRK_MEND_DONT_SEARCH_ALL_VOLUMES)
|
|
)
|
|
)
|
|
{
|
|
hr = TRK_E_REFERRAL;
|
|
droidBirthNext = droidBirthLast;
|
|
mcidNext = mcidNextT;
|
|
droidNext = droidNextT;
|
|
|
|
fPotentialFile = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pvol->Release(); pvol = NULL;
|
|
|
|
} // for( ; NULL != pvol, pvol = enumerator.GetNextVolume() );
|
|
|
|
} // __try
|
|
_finally
|
|
{
|
|
if( NULL != pvol )
|
|
{
|
|
pvol->Release();
|
|
pvol = NULL;
|
|
}
|
|
|
|
enumerator.UnInitialize();
|
|
}
|
|
|
|
// If we didn't find the file or a referral, but did find a potential hit,
|
|
// return that potential hit.
|
|
|
|
if( TRK_E_NOT_FOUND == hr && fPotentialFile )
|
|
hr = TRK_E_POTENTIAL_FILE_FOUND;
|
|
|
|
if( SUCCEEDED(hr) || TRK_E_REFERRAL == hr || TRK_E_POTENTIAL_FILE_FOUND == hr )
|
|
{
|
|
*pdroidBirthNext = droidBirthNext;
|
|
*pmcidNext = mcidNext;
|
|
*pdroidNext = droidNext;
|
|
}
|
|
|
|
return( hr );
|
|
}
|
|
|
|
PTimerCallback::TimerContinuation
|
|
CVolumeManager::Timer( DWORD dwTimerId )
|
|
{
|
|
PTimerCallback::TimerContinuation continuation = CONTINUE_TIMER;
|
|
|
|
__try
|
|
{
|
|
switch ( dwTimerId )
|
|
{
|
|
case VOLTIMER_OBJID_INDEX_REOPEN:
|
|
TrkAssert( _timerObjIdIndexReopen.IsRecurring() );
|
|
|
|
if( ReopenVolumeHandles() ) // Raises if service is stopped
|
|
continuation = BREAK_TIMER;
|
|
else
|
|
continuation = RETRY_TIMER;
|
|
|
|
break;
|
|
|
|
case VOLTIMER_FREQUENT:
|
|
case VOLTIMER_INFREQUENT:
|
|
case VOLTIMER_INIT:
|
|
|
|
TrkAssert( !_timerFrequentTasks.IsRecurring() );
|
|
TrkAssert( !_timerInfrequentTasks.IsRecurring() );
|
|
TrkAssert( !_timerVolumeInit.IsRecurring() );
|
|
|
|
continuation = OnVolumeTimer( dwTimerId );
|
|
break;
|
|
|
|
// Time to send MoveNotifies to the DC
|
|
case VOLTIMER_NOTIFY:
|
|
|
|
TrkAssert( !_timerNotify.IsRecurring() );
|
|
TrkAssert( CNewTimer::RETRY_WITH_BACKOFF == _timerNotify.GetRetryType() );
|
|
|
|
__try
|
|
{
|
|
continuation = _pTrkWks->OnMoveBatchTimeout();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
// If there was an unexpected error, instead of retrying the
|
|
// MoveNotify timer, use the slower (thus DC-friendlier) VolInit
|
|
// timer.
|
|
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Server to busy to receive move notifications, starting VolInit timer") ));
|
|
continuation = BREAK_TIMER;
|
|
SetVolInitTimer();
|
|
}
|
|
|
|
break;
|
|
|
|
// Time to refresh the DC with all our active IDs
|
|
case VOLTIMER_REFRESH:
|
|
|
|
// The first time we're called, we hesitate for a random amount of time.
|
|
// This hesitation is implemented by setting a flag, then resetting the timer.
|
|
// When the timer fires again a little later, we'll do the real work.
|
|
|
|
if( !_fRefreshHesitation )
|
|
{
|
|
// This is the first time we've been called.
|
|
|
|
ULONG ulHesitation = 0;
|
|
|
|
// Delay a random number of seconds within an interval
|
|
|
|
_fRefreshHesitation = TRUE;
|
|
|
|
ulHesitation = QuasiRandomDword()
|
|
%
|
|
( 1 + _pTrkWksConfiguration->GetRefreshHesitation() );
|
|
|
|
TrkLog(( TRKDBG_LOG, TEXT("Hesitating %d seconds before executing refresh"), ulHesitation ));
|
|
_timerRefresh.ReInitialize( ulHesitation );
|
|
continuation = CONTINUE_TIMER;
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( _timerRefresh.IsRecurring() );
|
|
continuation = _pTrkWks->OnRefreshTimeout(
|
|
_timerRefresh.QueryOriginalDueTime(),
|
|
_pTrkWksConfiguration->GetRefreshPeriod() );
|
|
|
|
if( CONTINUE_TIMER == continuation )
|
|
{
|
|
_timerRefresh.ReInitialize( _pTrkWksConfiguration->GetRefreshPeriod() );
|
|
_fRefreshHesitation = FALSE;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
TrkAssert( 0 && "invalid timer id" );
|
|
break;
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Ignoring exception %08x in CVolumeManager::Timer"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
|
|
return( continuation );
|
|
}
|
|
|
|
|
|
BOOL
|
|
CVolumeManager::ReopenVolumeHandles()
|
|
{
|
|
BOOL fAllOk = TRUE;
|
|
|
|
// If there's another thread already executing this routine, we'll just skip out.
|
|
// This is a reasonable idea, but really shouldn't be necessary; the volumes
|
|
// can protect themselves, and one thread should basically noop. However,
|
|
// there was an iostress break where these two threads got each other into
|
|
// a deadly embrace. This was due to the fact that the win32 thread pool
|
|
// has the tendency to put multiple IO work items on the same thread (since
|
|
// it queues to IO threads using APCs). So as a workaround, don't run
|
|
// this method more than once at a time.
|
|
|
|
if( !BeginSingleInstanceTask( &_cReopenVolumeHandles ))
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Skipping ReopenVolumeHandles, another instance is already in progress") ));
|
|
return FALSE;
|
|
}
|
|
|
|
// Get a volume enumerator. After initialization, none of the volumes
|
|
// have yet been opened. Ordinarily the Enum method gives us nothing until
|
|
// they've been opened once. But this routine is the one that originally does
|
|
// the opens, so we need the enumerator to give us everything.
|
|
|
|
CVolumeEnumerator enumerator = Enum( ENUM_UNOPENED_VOLUMES );
|
|
|
|
TrkLog(( TRKDBG_OBJID_DELETIONS, TEXT("\nAttempting to reopen all volume handles") ));
|
|
|
|
for( CVolume* pVol = enumerator.GetNextVolume();
|
|
pVol != NULL;
|
|
pVol = enumerator.GetNextVolume())
|
|
{
|
|
__try
|
|
{
|
|
if( !pVol->ReopenVolumeHandles() )
|
|
fAllOk = FALSE;
|
|
}
|
|
__except(BreakOnDebuggableException())
|
|
{
|
|
fAllOk = FALSE;
|
|
}
|
|
pVol->Release();
|
|
}
|
|
|
|
// Show that at least an attempt has been made to open all
|
|
// volume handles. This is checked in Enum().
|
|
_fVolumesHaveBeenOpenedOnce = TRUE;
|
|
|
|
// Show that we're done with this method.
|
|
EndSingleInstanceTask( &_cReopenVolumeHandles );
|
|
|
|
TrkLog(( TRKDBG_OBJID_DELETIONS,
|
|
fAllOk ? TEXT("All volume handles are open") : TEXT("Not all volume handles are open") ));
|
|
return( fAllOk );
|
|
}
|
|
|
|
|
|
void
|
|
CVolumeManager::VolumeDeviceEvent( HDEVNOTIFY hdnVolume, EVolumeDeviceEvent eVolumeDeviceEvent )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
BOOL fAllOk = TRUE;
|
|
|
|
for( CVolume* pVol = enumerator.GetNextVolume();
|
|
pVol != NULL;
|
|
pVol = enumerator.GetNextVolume() )
|
|
{
|
|
__try
|
|
{
|
|
switch( eVolumeDeviceEvent )
|
|
{
|
|
case ON_VOLUME_LOCK:
|
|
pVol->OnVolumeLock( hdnVolume );
|
|
break;
|
|
case ON_VOLUME_UNLOCK:
|
|
pVol->OnVolumeUnlock( hdnVolume );
|
|
break;
|
|
case ON_VOLUME_LOCK_FAILED:
|
|
pVol->OnVolumeLockFailed( hdnVolume );
|
|
break;
|
|
|
|
case ON_VOLUME_MOUNT:
|
|
pVol->OnVolumeMount( hdnVolume );
|
|
break;
|
|
case ON_VOLUME_DISMOUNT:
|
|
pVol->OnVolumeDismount( hdnVolume );
|
|
break;
|
|
|
|
case ON_VOLUME_DISMOUNT_FAILED:
|
|
pVol->OnVolumeDismountFailed( hdnVolume );
|
|
break;
|
|
|
|
default:
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Invalid event to OnVolumeDeviceEvent (%d)"),
|
|
eVolumeDeviceEvent ));
|
|
TrkAssert( !TEXT("Invalid event to OnVolumeDeviceEvent") );
|
|
break;
|
|
|
|
} // switch( eVolumeDeviceEvent )
|
|
}
|
|
__except(BreakOnDebuggableException())
|
|
{
|
|
}
|
|
pVol->Release();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::OnEntriesAvailable
|
|
//
|
|
// The CLog calls this routine when it has new data available
|
|
// for us to read. We don't read it right away, but start the Notify timer.
|
|
// When it goes off, we'll upload all notifications to the DC that haven't
|
|
// yet been sent.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::OnEntriesAvailable()
|
|
{
|
|
if( !_pTrkWksConfiguration->_fIsWorkgroup )
|
|
{
|
|
_timerNotify.SetSingleShot();
|
|
|
|
TrkLog(( TRKDBG_MOVE | TRKDBG_WKS,
|
|
TEXT("log called CVolumeManager::OnEntriesAvailable(), %s"),
|
|
(const TCHAR*)CDebugString(_timerNotify) ));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::ForceVolumeClaims
|
|
//
|
|
// Put all of the volumes in the not-owned state so that they will
|
|
// try to do a claim.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::ForceVolumeClaims()
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
|
|
TrkLog(( TRKDBG_OBJID_DELETIONS, TEXT("Force volume claims") ));
|
|
|
|
for( CVolume* pVol = enumerator.GetNextVolume();
|
|
pVol != NULL;
|
|
pVol = enumerator.GetNextVolume())
|
|
{
|
|
__try
|
|
{
|
|
pVol->SetState(CVolume::VOL_STATE_NOTOWNED);
|
|
}
|
|
__except(BreakOnDebuggableException())
|
|
{
|
|
}
|
|
pVol->Release();
|
|
}
|
|
|
|
// Do a SyncVolumes so that the volumes can all send up a
|
|
// volume-claim request. If it fails, just start the volinit
|
|
// timer to have it called again later.
|
|
|
|
if( !SyncVolumes( AGGRESSIVE )) // Doesn't raise
|
|
SetVolInitTimer();
|
|
}
|
|
|
|
PTimerCallback::TimerContinuation
|
|
CVolumeManager::OnVolumeTimer( DWORD dwTimerId )
|
|
{
|
|
ULONG ulTimerResetPeriod = 0;
|
|
BOOL fTimerRetry = FALSE;
|
|
CNewTimer * ptimer;
|
|
PTimerCallback::TimerContinuation continuation = CONTINUE_TIMER;
|
|
|
|
__try
|
|
{
|
|
switch( static_cast<VOLTIMERID>(dwTimerId) )
|
|
{
|
|
|
|
// Initialization tasks
|
|
// This timer is started during initialization, and then usually stops after
|
|
// one iteration. It can be restarted, however, if a MoveNotify gets a
|
|
// TRK_E_SERVER_TOO_BUSY error.
|
|
|
|
case VOLTIMER_INIT:
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("VolInit timer has fired") ));
|
|
|
|
ptimer = &_timerVolumeInit;
|
|
TrkAssert( CNewTimer::RETRY_RANDOMLY == ptimer->GetRetryType() );
|
|
TrkAssert( !ptimer->IsRecurring() );
|
|
|
|
// Create/claim volumes as necessary.
|
|
|
|
fTimerRetry = TRUE;
|
|
if( SyncVolumes( PASSIVE,
|
|
_timerVolumeInit.QueryOriginalDueTime(),
|
|
_timerVolumeInit.QueryPeriodInSeconds() )) // Doesn't raise
|
|
fTimerRetry = FALSE;
|
|
|
|
// If we have a new volid, make the existing object IDs reborn.
|
|
CleanUpOids();
|
|
|
|
// Give each of the volumes an opportunity to upload any pending
|
|
// MoveNotifies.
|
|
|
|
// BUGBUG: Move the MoveBatchTimeout controlling code into CVolumeManager,
|
|
// so that all such control is in one place.
|
|
|
|
__try
|
|
{
|
|
continuation = g_ptrkwks->OnMoveBatchTimeout();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkAssert( TRK_E_SERVER_TOO_BUSY == GetExceptionCode() );
|
|
TrkLog(( TRKDBG_ERROR, TEXT("VolInit timer caught %08x during MoveNotify"), GetExceptionCode() ));
|
|
fTimerRetry = TRUE;
|
|
}
|
|
|
|
break;
|
|
|
|
// Frequent tasks (i.e. ~daily)
|
|
|
|
case VOLTIMER_FREQUENT:
|
|
ptimer = &_timerFrequentTasks;
|
|
|
|
if( _fFrequentTaskHesitation )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Executing frequent tasks") ));
|
|
_fFrequentTaskHesitation = FALSE;
|
|
ulTimerResetPeriod = _pTrkWksConfiguration->GetVolFrequentTasksPeriod() + 1;
|
|
SyncVolumes( PASSIVE ); // Doesn't raise
|
|
ReopenVolumeHandles();
|
|
}
|
|
else
|
|
{
|
|
// Delay a random number of seconds within an interval
|
|
|
|
_fFrequentTaskHesitation = TRUE;
|
|
ulTimerResetPeriod = QuasiRandomDword()
|
|
%
|
|
(1+_pTrkWksConfiguration->GetVolPeriodicTasksHesitation());
|
|
ulTimerResetPeriod++;
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Hesitating %d seconds before executing frequent tasks"), ulTimerResetPeriod ));
|
|
}
|
|
|
|
break;
|
|
|
|
// Infrequent tasks (i.e. ~weekly)
|
|
|
|
case VOLTIMER_INFREQUENT:
|
|
ptimer = &_timerInfrequentTasks;
|
|
|
|
if( _fInfrequentTaskHesitation )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Executing infrequent tasks") ));
|
|
_fInfrequentTaskHesitation = FALSE;
|
|
ulTimerResetPeriod = _pTrkWksConfiguration->GetVolInfrequentTasksPeriod() + 1;
|
|
CheckSequenceNumbers();
|
|
|
|
// Be aggressive about the sync; if we have not-created volumes, try
|
|
// to create them again even if the last time we got a vol-quota-exceeded
|
|
// error.
|
|
|
|
SyncVolumes( AGGRESSIVE ); // Doesn't raise
|
|
|
|
// Give each of the volumes an opportunity to upload any pending
|
|
// MoveNotifies. Again, be aggressive about it in the face of previous
|
|
// quota errors.
|
|
|
|
g_ptrkwks->OnMoveBatchTimeout( AGGRESSIVE );
|
|
|
|
}
|
|
else
|
|
{
|
|
// Delay a random number of seconds within an interval
|
|
|
|
_fInfrequentTaskHesitation = TRUE;
|
|
ulTimerResetPeriod = QuasiRandomDword()
|
|
%
|
|
(1+_pTrkWksConfiguration->GetVolPeriodicTasksHesitation());
|
|
ulTimerResetPeriod++;
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Hesitating %d seconds before executing infrequent tasks"), ulTimerResetPeriod ));
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
TrkAssert( FALSE && TEXT("Invalid timerID in CVolumeManager::Timer") );
|
|
break;
|
|
|
|
} // switch
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in CVolumeManager::OnVolumeTimer %08x"), GetExceptionCode() ));
|
|
}
|
|
|
|
if( fTimerRetry )
|
|
continuation = RETRY_TIMER;
|
|
else if( 0 != ulTimerResetPeriod )
|
|
{
|
|
ptimer->ReInitialize( ulTimerResetPeriod );
|
|
ptimer->SetSingleShot();
|
|
continuation = CONTINUE_TIMER;
|
|
}
|
|
|
|
return( continuation );
|
|
}
|
|
|
|
ULONG
|
|
CVolumeManager::GetVolumeIds( CVolumeId * pVolumeIds, ULONG cMax )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume* pvol = enumerator.GetNextVolume();
|
|
ULONG cVolumes;
|
|
CVolumeId volidZero;
|
|
|
|
__try
|
|
{
|
|
for( cVolumes = 0;
|
|
cVolumes < cMax && NULL != pvol;
|
|
pvol = enumerator.GetNextVolume()
|
|
)
|
|
{
|
|
*pVolumeIds = pvol->GetVolumeId();
|
|
if (*pVolumeIds != volidZero)
|
|
{
|
|
pVolumeIds ++;
|
|
cVolumes ++;
|
|
}
|
|
pvol->Release();
|
|
pvol = NULL;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
enumerator.UnInitialize();
|
|
if(pvol)
|
|
{
|
|
pvol->Release();
|
|
pvol = NULL;
|
|
}
|
|
}
|
|
|
|
return(cVolumes);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CVolumeManager::OnRestore()
|
|
{
|
|
return( E_NOTIMPL );
|
|
#if 0
|
|
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume* pvol = enumerator.GetNextVolume();
|
|
HRESULT hr = S_OK;
|
|
HRESULT hrRet = S_OK;
|
|
|
|
__try
|
|
{
|
|
for(; NULL != pvol; pvol = enumerator.GetNextVolume())
|
|
{
|
|
hr = pvol->OnRestore();
|
|
if(hr != S_OK && hrRet == S_OK)
|
|
// Return the hr from the first failed volume.
|
|
{
|
|
hrRet = hr;
|
|
}
|
|
pvol->Release();
|
|
pvol = NULL;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
enumerator.UnInitialize();
|
|
if(pvol)
|
|
{
|
|
pvol->Release();
|
|
pvol = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
return hr;
|
|
|
|
#endif // #if 0
|
|
|
|
}
|
|
|
|
BOOL
|
|
CVolumeManager::CheckSequenceNumbers()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
HRESULT hr = S_OK;
|
|
CAvailableDc adc;
|
|
CVolume* rgVolsToCheck[ NUM_VOLUMES ];
|
|
ULONG cVolumes = 0;
|
|
|
|
__try
|
|
{
|
|
TRKSVR_SYNC_VOLUME rgQueryVolumes[ NUM_VOLUMES ];
|
|
ULONG v;
|
|
const CVolumeId volNULL;
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume* cvolCur = enumerator.GetNextVolume();
|
|
|
|
for(; cvolCur != NULL; cvolCur = enumerator.GetNextVolume())
|
|
{
|
|
rgVolsToCheck[cVolumes] = cvolCur;
|
|
if(cvolCur->LoadQueryVolume(&rgQueryVolumes[cVolumes]))
|
|
{
|
|
cVolumes++;
|
|
}
|
|
else
|
|
{
|
|
cvolCur->Release();
|
|
}
|
|
}
|
|
|
|
if( 0 != cVolumes )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE, TEXT("Verifying sequence numbers on %d volumes"), cVolumes ));
|
|
|
|
_pTrkWks->CallDcSyncVolumes(cVolumes, rgQueryVolumes);
|
|
|
|
|
|
for( v = 0; v < cVolumes; v++ )
|
|
{
|
|
if( rgVolsToCheck[v]->UnloadQueryVolume( &rgQueryVolumes[v] )
|
|
&&
|
|
S_OK == rgQueryVolumes[ v ].hr )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Seq number for volume %c should be %d"),
|
|
'A'+rgVolsToCheck[v]->GetIndex(),
|
|
rgQueryVolumes[v].seq ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_ERROR,
|
|
TEXT("Couldn't verify the seq number on vol %c"),
|
|
'A'+rgVolsToCheck[v]->GetIndex() ));
|
|
|
|
}
|
|
} // for( v = 0; v < cVolumes; v++ )
|
|
|
|
fSuccess = TRUE;
|
|
|
|
} // if( cVolumes != 0 )
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Couldn't check sequence numbers against server"), GetExceptionCode() ));
|
|
}
|
|
|
|
for( ULONG v = 0; v < cVolumes; v++ )
|
|
{
|
|
rgVolsToCheck[v]->Release();
|
|
} // for( v = 0; v < cVolumes; v++ )
|
|
|
|
return( fSuccess );
|
|
|
|
}
|
|
|
|
void
|
|
CVolumeManager::SetReopenVolumeHandlesTimer()
|
|
{
|
|
CFILETIME ft;
|
|
|
|
// Start the timer (if it's not already running).
|
|
_timerObjIdIndexReopen.SetRecurring();
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("ReOpen timer: %s"),
|
|
(const TCHAR*)CDebugString(_timerObjIdIndexReopen) ));
|
|
}
|
|
|
|
CVolumeEnumerator
|
|
CVolumeManager::Enum( EEnumType eEnumType )
|
|
{
|
|
CVolumeEnumerator volenum;
|
|
|
|
if( _fVolumesHaveBeenOpenedOnce
|
|
||
|
|
_fInitialized
|
|
&&
|
|
ENUM_UNOPENED_VOLUMES == eEnumType )
|
|
{
|
|
volenum = CVolumeEnumerator( &_pVolumeNodeListHead, &_csVolumeNodeList );
|
|
}
|
|
|
|
return( volenum );
|
|
}
|
|
|
|
CVolume *
|
|
CVolumeManager::FindVolume( const CVolumeId &vol )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume *pvol = enumerator.GetNextVolume();
|
|
|
|
for(; pvol != NULL; pvol = enumerator.GetNextVolume())
|
|
{
|
|
if( pvol->GetVolumeId() == vol )
|
|
{
|
|
break;
|
|
}
|
|
pvol->Release();
|
|
} // for(; pvol != NULL; pvol = enumerator.GetNextVolume())
|
|
|
|
return( pvol );
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::FlushAllVolumes
|
|
//
|
|
// Flush all of the volumes.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::FlushAllVolumes( BOOL fServiceShutdown )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume *pvol = enumerator.GetNextVolume();
|
|
|
|
for(; pvol != NULL; pvol = enumerator.GetNextVolume())
|
|
{
|
|
__try
|
|
{
|
|
pvol->Flush( fServiceShutdown );
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
}
|
|
pvol->Release();
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::FindVolume
|
|
//
|
|
// Find a volume in the linked-list, given it's device name,
|
|
// and return its CVolume*.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
CVolume *
|
|
CVolumeManager::FindVolume( const TCHAR *ptszVolumeDeviceName )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume *pvol = enumerator.GetNextVolume();
|
|
|
|
for(; pvol != NULL; pvol = enumerator.GetNextVolume())
|
|
{
|
|
if( 0 == _tcscmp( pvol->GetVolumeDeviceName(), ptszVolumeDeviceName ))
|
|
{
|
|
break;
|
|
}
|
|
pvol->Release();
|
|
} // for(; pvol != NULL; pvol = enumerator.GetNextVolume())
|
|
|
|
return( pvol );
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::IsDuplicatevolId
|
|
//
|
|
// Check to see if there is a volume, aside from the caller, that
|
|
// has a particular volume ID. This should never happen, so this
|
|
// method allows a volume to check for it and respond appropriately.
|
|
//
|
|
// When checking another volume's volid, we can't take its lock.
|
|
// See the description in CVolume::GetVolumeId.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
CVolume *
|
|
CVolumeManager::IsDuplicateVolId( CVolume *pvolCheck, const CVolumeId &volid )
|
|
{
|
|
CVolumeNode *pVolNode = NULL;
|
|
CVolume *pvol = NULL;
|
|
|
|
_csVolumeNodeList.Enter();
|
|
__try
|
|
{
|
|
|
|
pVolNode = _pVolumeNodeListHead;
|
|
while( NULL != pVolNode )
|
|
{
|
|
if( NULL != pVolNode->_pVolume
|
|
&&
|
|
volid == pVolNode->_pVolume->GetVolumeId() // Doesn't take lock.
|
|
&&
|
|
pvolCheck != pVolNode->_pVolume )
|
|
{
|
|
pvol = pVolNode->_pVolume;
|
|
pvol->AddRef();
|
|
__leave;
|
|
}
|
|
|
|
pVolNode = pVolNode->_pNext;
|
|
TrkAssert( pVolNode != _pVolumeNodeListHead );
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_WARNING, TEXT("Ignoring exception in IsDuplicateVolId") ));
|
|
}
|
|
_csVolumeNodeList.Leave();
|
|
|
|
return pvol;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::IsLocal
|
|
//
|
|
// Determine if a given volume ID represents a local volume. Note that
|
|
// if it's not in the linked list of volumes, we'll return false, though
|
|
// the volume may in fact exist on the system (since we don't respond
|
|
// to new volumes after service start).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolumeManager::IsLocal( const CVolumeId &vol )
|
|
{
|
|
CVolume *pvol = FindVolume( vol );
|
|
|
|
if( NULL == pvol )
|
|
return FALSE;
|
|
else
|
|
{
|
|
pvol->Release();
|
|
return( TRUE );
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::Seek
|
|
//
|
|
// Seek the specified volume's log to the specified sequence number.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolumeManager::Seek( CVolumeId vol, SequenceNumber seq )
|
|
{
|
|
CVolumeEnumerator enumerator = Enum();
|
|
CVolume* cvolCur = enumerator.GetNextVolume();
|
|
|
|
for(; cvolCur != NULL; cvolCur = enumerator.GetNextVolume())
|
|
{
|
|
if( cvolCur->GetVolumeId() == vol )
|
|
{
|
|
cvolCur->Seek( seq );
|
|
cvolCur->Release();
|
|
return;
|
|
}
|
|
cvolCur->Release();
|
|
} // for( ULONG i = 0; i < 26; i++ )
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeEnumerator::GetNextVolume
|
|
//
|
|
// Get the next CVolume* in the enumeration.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
CVolume *
|
|
CVolumeEnumerator::GetNextVolume()
|
|
{
|
|
CVolume *pVol = NULL;
|
|
|
|
if( NULL == _ppVolumeNodeListHead )
|
|
return( NULL );
|
|
|
|
TrkAssert( NULL != _pcs );
|
|
|
|
_pcs->Enter();
|
|
__try
|
|
{
|
|
|
|
if( NULL == *_ppVolumeNodeListHead )
|
|
{
|
|
// There are no volumes in the list
|
|
pVol = NULL;
|
|
}
|
|
else if( NULL == _pVolNodeLast )
|
|
{
|
|
// This is a new enumeration. Pass back the first volume
|
|
pVol = (*_ppVolumeNodeListHead)->_pVolume;
|
|
_pVolNodeLast = *_ppVolumeNodeListHead;
|
|
}
|
|
else
|
|
{
|
|
// Find the next volume in the list, the one that's
|
|
// just beyond _pVolNodeLast.
|
|
// If we terminate this while loop because pVolNode goes to
|
|
// NULL, it means that there are no more volumes left to
|
|
// enumerate.
|
|
|
|
CVolumeNode *pVolNode = *_ppVolumeNodeListHead;
|
|
while( NULL != pVolNode )
|
|
{
|
|
if( pVolNode > _pVolNodeLast )
|
|
{
|
|
pVol = pVolNode->_pVolume;
|
|
_pVolNodeLast = pVolNode;
|
|
break;
|
|
}
|
|
|
|
pVolNode = pVolNode->_pNext;
|
|
}
|
|
}
|
|
|
|
if( NULL != pVol )
|
|
pVol->AddRef();
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
TrkAssert( !TEXT("Unexpected exception in GetNextVolume") );
|
|
}
|
|
|
|
_pcs->Leave();
|
|
return( pVol );
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolumeManager::DcCallback
|
|
// StubLnkSvrMessageCallback
|
|
//
|
|
// When we RPC to trksvr to do a create volume (in the SyncVolumes method),
|
|
// trksvr does an RPC callback on that connection to StubLnkSvrMessageCallback,
|
|
// which in turn calls the DcCallback method. This was done so that
|
|
// we can verify that the volid actually gets to the volume before taking
|
|
// the hit of writing it into the DS. (At one point, the request to trksvr
|
|
// was being received, the entry was being put into the DS, but then the
|
|
// response back to trkwks was getting an RPC error, so trkwks would retry
|
|
// the create, etc.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
HRESULT CVolumeManager::DcCallback(ULONG cVolumes, TRKSVR_SYNC_VOLUME* rgVolumes)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fSuccess = TRUE;
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Dc Callback with %d volumes"), cVolumes ));
|
|
for( ULONG v = 0; v < cVolumes; v++ )
|
|
{
|
|
if( _rgVolumesToUpdate[v]->UnloadSyncVolume( &rgVolumes[v] )
|
|
&&
|
|
rgVolumes[v].hr == S_OK )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME | TRKDBG_MOVE,
|
|
TEXT("Volume %c successfully synced with server"),
|
|
'A'+_rgVolumesToUpdate[v]->GetIndex() ));
|
|
}
|
|
else
|
|
{
|
|
fSuccess = FALSE;
|
|
TrkLog(( TRKDBG_ERROR | TRKDBG_MOVE,
|
|
TEXT("Couldn't sync vol %c with server (%08x, %s)"),
|
|
'A'+_rgVolumesToUpdate[v]->GetIndex(),
|
|
rgVolumes[v].hr, GetErrorString(rgVolumes[v].hr) ));
|
|
}
|
|
} // for( v = 0; v < cVolumes; v++ )
|
|
|
|
|
|
if( S_OK == hr )
|
|
return fSuccess ? S_OK : TRK_S_VOLUME_NOT_SYNCED;
|
|
else
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// DC callback function. When calling CAvailableDc::CallAvailableDc, DC will callback to the
|
|
// trkwks service to set the volume ids on the volumes.
|
|
HRESULT StubLnkSvrMessageCallback(TRKSVR_MESSAGE_UNION* pMsg)
|
|
{
|
|
return g_ptrkwks->_volumes.DcCallback(pMsg->SyncVolumes.cVolumes, pMsg->SyncVolumes.pVolumes);
|
|
}
|