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.
2753 lines
85 KiB
2753 lines
85 KiB
|
|
// Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
//+============================================================================
|
|
//
|
|
// vol.cxx
|
|
//
|
|
// This file implements the CVolume class. This class maintains all activities
|
|
// for a volume, such as the the log, log file, and deletions manager classes.
|
|
//
|
|
//+============================================================================
|
|
|
|
|
|
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
#include "trkwks.hxx"
|
|
#include <dbt.h>
|
|
|
|
#define THIS_FILE_NUMBER VOL_CXX_FILE_NO
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::AddRef
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
ULONG
|
|
CVolume::AddRef()
|
|
{
|
|
long cNew;
|
|
cNew = InterlockedIncrement( &_lRef );
|
|
//TrkLog(( TRKDBG_VOLUME, TEXT("+++ Vol %c: refs => %d"), VolChar(_iVol), cNew ));
|
|
return( cNew );
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Release
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
ULONG
|
|
CVolume::Release()
|
|
{
|
|
long cNew;
|
|
cNew = InterlockedDecrement( &_lRef );
|
|
//TrkLog(( TRKDBG_VOLUME, TEXT("--- Vol %c: refs => %d"), VolChar(_iVol), cNew ));
|
|
if( 0 == cNew )
|
|
delete this;
|
|
|
|
return( cNew >= 0 ? cNew : 0 );
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Initialize
|
|
//
|
|
// Initialize CVolume and open a handle to the volume itself, but nothing
|
|
// more (e.g. don't open the log or verify volume IDs). The remainder of
|
|
// the initialization will occur later the first time ReopenVolumeHandles
|
|
// is called. This gets that heavy IO work out of the service initialization
|
|
// path.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::Initialize( TCHAR *ptszVolumeName,
|
|
const CTrkWksConfiguration * pTrkWksConfiguration,
|
|
CVolumeManager *pVolMgr,
|
|
PLogCallback * pLogCallback,
|
|
PObjIdIndexChangedCallback * pObjIdIndexChangedCallback,
|
|
SERVICE_STATUS_HANDLE ssh
|
|
#if DBG
|
|
, CTestSync * pTunnelTest
|
|
#endif
|
|
)
|
|
{
|
|
HANDLE hFile = NULL;
|
|
// const CVolumeId volNULL;
|
|
// CVolumeId volidVolume;
|
|
NTSTATUS status;
|
|
BOOL fSuccess = FALSE;
|
|
|
|
_iVol = -1;
|
|
memset( &_volinfo, 0, sizeof(_volinfo) );
|
|
|
|
// Save the volume name, without the trailing whack
|
|
// Volume names are in the form \\?\Volume{guid}\
|
|
|
|
_tcscpy( _tszVolumeDeviceName, ptszVolumeName );
|
|
TrkAssert( TEXT('\\') == _tszVolumeDeviceName[ _tcslen(_tszVolumeDeviceName)-1 ] );
|
|
_tszVolumeDeviceName[ _tcslen(_tszVolumeDeviceName)-1 ] = TEXT('\0');
|
|
|
|
// Save the inputs
|
|
|
|
_pTrkWksConfiguration = pTrkWksConfiguration;
|
|
_pVolMgr = pVolMgr;
|
|
_pLogCallback = pLogCallback;
|
|
_ssh = ssh;
|
|
_hdnVolumeLock = NULL;
|
|
_fVolumeDismounted = _fVolumeLocked = FALSE;
|
|
|
|
IFDBG( _pTunnelTest = pTunnelTest; )
|
|
|
|
__try // __except
|
|
{
|
|
|
|
// Create critical sections
|
|
|
|
_csVolume.Initialize();
|
|
_csHandles.Initialize();
|
|
_fInitialized = TRUE;
|
|
|
|
|
|
Lock();
|
|
|
|
__try // __finally
|
|
{
|
|
_VolQuotaReached.Initialize();
|
|
|
|
// Open the volume (not a directory in the volume, but the volume itself).
|
|
// We'll use this to do relative-opens by object ID
|
|
|
|
status = OpenVolume( _tszVolumeDeviceName, &_hVolume );
|
|
if (!NT_SUCCESS(status))
|
|
TrkRaiseNtStatus(status);
|
|
|
|
// Initialize, but don't start, the objid index change notifier. When started,
|
|
// this will watch for adds/deletes/tunnels/etc. in the index.
|
|
|
|
_ObjIdIndexChangeNotifier.Initialize( _tszVolumeDeviceName,
|
|
pObjIdIndexChangedCallback,
|
|
this );
|
|
|
|
|
|
fSuccess = TRUE;
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
}
|
|
__except ( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Failed initializaion of volume %s (%08x)"),
|
|
ptszVolumeName, GetExceptionCode() ));
|
|
|
|
if( TRK_E_VOLUME_NOT_DRIVE != GetExceptionCode() )
|
|
{
|
|
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__,
|
|
GetExceptionCode(), TRKREPORT_LAST_PARAM );
|
|
}
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::SetLocallyGeneratedVolId
|
|
//
|
|
// Generate a volume ID and set it on the volume. If we're in a domain,
|
|
// this will later get replaced with a volume ID from trksvr.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::SetLocallyGeneratedVolId()
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
// Ensure the volume is writeable
|
|
RaiseIfWriteProtectedVolume();
|
|
|
|
_fDirty = TRUE;
|
|
|
|
// Create the ID
|
|
|
|
// Call _volinfo.volid.UuidCreate()
|
|
RPC_STATUS rpc_status = GenerateVolumeIdInVolInfo();
|
|
if( RPC_S_OK != rpc_status )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't create a local volid for new volume") ));
|
|
TrkRaiseWin32Error(rpc_status);
|
|
}
|
|
|
|
// Set the ID on the volume.
|
|
status = SetVolIdOnVolume( _volinfo.volid );
|
|
g_ptrkwks->_entropy.Put();
|
|
|
|
if( NT_SUCCESS(status) )
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Locally generated a new volid for %c:, %s"),
|
|
VolChar(_iVol), (const TCHAR*)CDebugString(_volinfo.volid) ));
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't set new volid on %c: (%08x)"), VolChar(_iVol), status ));
|
|
TrkRaiseNtStatus(status);
|
|
}
|
|
|
|
// Get rid of the log and existing object IDs since we have a new volid.
|
|
DeleteAndReinitializeLog();
|
|
MarkForMakeAllOidsReborn();
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::VolumeSanityCheck
|
|
//
|
|
// This routine is called when the volume handles are opened,
|
|
// The caller is responsible for calling CLogFile::Initialize and
|
|
// CLog::Initialize. The caller must ensure that _volinfo is
|
|
// properly loaded prior to the call.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
const GUID s_guidInvalidVolId = { /* {d2a2ac27-b89a-11d2-9335-00805ffe11b8} */
|
|
0xd2a2ac27, 0xb89a, 0x11d2,
|
|
{0x93, 0x35, 0x00, 0x80, 0x5f, 0xfe, 0x11, 0xb8} };
|
|
|
|
|
|
void
|
|
CVolume::VolumeSanityCheck( BOOL fVolIndexSetAlready )
|
|
{
|
|
NTSTATUS status;
|
|
CVolumeId volidVolume;
|
|
const CVolumeId volNULL;
|
|
const CMachineId mcidLocal( MCID_LOCAL );
|
|
TCHAR tszVolumeName[ CCH_MAX_VOLUME_NAME + 1 ];
|
|
|
|
// Get the volume name that the mount manager has associated with this
|
|
// volume.
|
|
|
|
LONG iVolOld = _iVol;
|
|
|
|
if( !fVolIndexSetAlready )
|
|
{
|
|
_iVol = MapVolumeDeviceNameToIndex( _tszVolumeDeviceName );
|
|
if( -1 == _iVol )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume %s does not appear any longer to have a drive letter (was %c:)"),
|
|
_tszVolumeDeviceName, VolChar( iVolOld ) ));
|
|
MarkSelfForDelete();
|
|
TrkRaiseException( TRK_E_VOLUME_NOT_DRIVE );
|
|
}
|
|
else if( iVolOld != _iVol )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume %c: is now %c:"), VolChar(iVolOld), VolChar(_iVol) ));
|
|
}
|
|
}
|
|
|
|
|
|
// Get the filesystem-maintained volume ID
|
|
|
|
TCHAR tszRoot[ MAX_PATH ];
|
|
_tcscpy( tszRoot, _tszVolumeDeviceName );
|
|
_tcscat( tszRoot, TEXT("\\") );
|
|
status = QueryVolumeId(tszRoot, &volidVolume);
|
|
g_ptrkwks->_entropy.Put();
|
|
|
|
if( !NT_SUCCESS(status) && STATUS_OBJECT_NAME_NOT_FOUND != status )
|
|
{
|
|
// For some reason we couldn't read the NTFS volid
|
|
// (e.g. it's been dismounted).
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Couldn't get filesys volid for %c:"), VolChar(_iVol) ));
|
|
TrkRaiseNtStatus(status);
|
|
}
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("VolId (from NTFS) for %c: is %s"),
|
|
VolChar(_iVol), (const TCHAR*)CDebugString(volidVolume) ));
|
|
|
|
|
|
// Compare the volume IDs from the filesystem (volume) and from
|
|
// the VolInfo structure we keep in the log file. If one is
|
|
// set but not the other, then we'll adopt the one that's set.
|
|
// If they're both set, but to different values, then we'll
|
|
// take the one from NTFS.
|
|
|
|
if( volNULL == volidVolume && volNULL != _volinfo.volid )
|
|
{
|
|
// Assume the volid in the VolInfo structure is correct.
|
|
// This scenario occurs after a volume is formatted while the service
|
|
// is running. In that case, we have the volume info in memory and think
|
|
// it's not dirty, but in fact the log file is gone. So, just to be safe,
|
|
// we'll go dirty, and the flush at the end will put the latest state out
|
|
// to the file.
|
|
|
|
RaiseIfWriteProtectedVolume();
|
|
_fDirty = TRUE;
|
|
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Duping the volid from the logfile to the volume for %c:"),
|
|
VolChar(_iVol) ));
|
|
status = SetVolIdOnVolume(_volinfo.volid);
|
|
g_ptrkwks->_entropy.Put();
|
|
if(!NT_SUCCESS(status))
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't set a volume ID on %c:"), VolChar(_iVol) ));
|
|
TrkRaiseNtStatus(status);
|
|
}
|
|
|
|
SetState( VOL_STATE_NOTOWNED );
|
|
|
|
}
|
|
else if( volidVolume != _volinfo.volid || volNULL == volidVolume)
|
|
{
|
|
// Either the two volids don't match, or they're both NULL.
|
|
|
|
if( volNULL != volidVolume && s_guidInvalidVolId != volidVolume )
|
|
{
|
|
// Assume the volid on the volume (NTFS) is correct.
|
|
|
|
// If the log has a different volid, it may have invalid move entries.
|
|
// So we delete it.
|
|
if( volNULL != _volinfo.volid )
|
|
DeleteAndReinitializeLog();
|
|
|
|
_volinfo.Initialize();
|
|
|
|
// Set _volinfo.volid = volidVolume
|
|
SetVolIdInVolInfo( volidVolume );
|
|
|
|
_volinfo.machine = mcidLocal;
|
|
|
|
SetState( VOL_STATE_NOTOWNED );
|
|
}
|
|
else
|
|
{
|
|
// Both the volume and the _volinfo (the log) are null. We're going to
|
|
// go into the not-created state, but first put on a volid so that we
|
|
// never have a volume with no ID.
|
|
|
|
_volinfo.Initialize();
|
|
_volinfo.machine = mcidLocal;
|
|
|
|
// Create a new ID and put it on the volume.
|
|
|
|
SetLocallyGeneratedVolId(); // Updates _volinfo.volid
|
|
|
|
// Put ourselves in the not-created state.
|
|
|
|
TrkAssert( VOL_STATE_OWNED == GetState() );
|
|
SetState( VOL_STATE_NOTCREATED );
|
|
}
|
|
}
|
|
|
|
// If the machine ID in the log isn't the current machine, then go into
|
|
// the not-created state so that we'll re-claim the volume.
|
|
|
|
if( mcidLocal != _volinfo.machine )
|
|
SetState( VOL_STATE_NOTOWNED );
|
|
|
|
// See if this volume duplicates any other on this system.
|
|
|
|
CVolume *pvolDuplicate = _pVolMgr->IsDuplicateVolId( this, GetVolumeId() );
|
|
if( NULL != pvolDuplicate )
|
|
{
|
|
// This should never happen; there should never be two
|
|
// volumes on the same machine with the same ID.
|
|
// When this happens on different machines it gets caught during
|
|
// CheckSequenceNumbers, but on the same machine this doesn't work,
|
|
// because TrkSvr accepts the Claim of both machines.
|
|
|
|
TrkLog(( TRKDBG_WARNING,
|
|
TEXT("Volume %c: and %c: have duplicate volume IDs. Resetting %c:"),
|
|
VolChar(GetIndex()),
|
|
VolChar(pvolDuplicate->GetIndex()),
|
|
VolChar(GetIndex()) ));
|
|
TrkReportEvent( EVENT_TRK_SERVICE_DUPLICATE_VOLIDS, EVENTLOG_INFORMATION_TYPE,
|
|
static_cast<const TCHAR*>(CStringize( VolChar(GetIndex()))),
|
|
static_cast<const TCHAR*>(CStringize( VolChar(pvolDuplicate->GetIndex()) )),
|
|
TRKREPORT_LAST_PARAM );
|
|
|
|
SetLocallyGeneratedVolId(); // Updates _volinfo.volid
|
|
SetState( CVolume::VOL_STATE_NOTCREATED );
|
|
|
|
pvolDuplicate->SetState( CVolume::VOL_STATE_NOTOWNED );
|
|
pvolDuplicate->Release();
|
|
}
|
|
|
|
// If anything's dirty, flush it now. In the normal initialization path,
|
|
// this will have no effect.
|
|
|
|
Flush();
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Refresh
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::Refresh()
|
|
{
|
|
HANDLE hVolume = NULL;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
status = OpenVolume( _tszVolumeDeviceName, &hVolume );
|
|
|
|
if( NT_SUCCESS(status) )
|
|
_iVol = MapVolumeDeviceNameToIndex( _tszVolumeDeviceName );
|
|
else if( !IsErrorDueToLockedVolume(status) )
|
|
_iVol = -1;
|
|
|
|
if( -1 == _iVol )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Drive not found in CVolume::Refresh") ));
|
|
MarkSelfForDelete();
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
}
|
|
|
|
// Unlock before calling NtClose, since during stress that
|
|
// could raise.
|
|
|
|
Unlock();
|
|
|
|
if( NULL != hVolume )
|
|
NtClose( hVolume );
|
|
|
|
|
|
} // CVolume::Refresh
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::MarkSelfForDelete
|
|
//
|
|
// Mark this CVolume to be deleted (not the volume, but the class). The
|
|
// delete will actually occur when this object is completely released
|
|
// and unlocked. We do, however, as part of this method remove ourself
|
|
// from the volume manager's list.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::MarkSelfForDelete()
|
|
{
|
|
AssertLocked();
|
|
|
|
if( !_fDeleteSelfPending )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Marking %c: for delete"), VolChar(_iVol) ));
|
|
|
|
// Show that we need to be deleted. We can't actually delete now, because there
|
|
// may be threads active in the object.
|
|
|
|
_fDeleteSelfPending = TRUE;
|
|
|
|
// On the final UnLock, Release will be called to counter this AddRef and
|
|
// cause the actual delete.
|
|
|
|
AddRef();
|
|
|
|
// Take this object out of the Volume Manager's linked list (which will do
|
|
// a Release, thus the need for the above AddRef);
|
|
|
|
_pVolMgr->RemoveVolumeFromLinkedList( this );
|
|
}
|
|
else
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("%c: is already marked for delete"), VolChar(_iVol) ));
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::RegisterPnpVolumeNotification
|
|
//
|
|
// Register to receive PNP notifications for this volume. If already
|
|
// registered, register again (since the volume handle against which
|
|
// we'd previously registered may no longer exist).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
CVolume::RegisterPnPVolumeNotification()
|
|
{
|
|
DEV_BROADCAST_HANDLE dbchFilter;
|
|
HDEVNOTIFY hdnVolumeLock = _hdnVolumeLock;
|
|
|
|
dbchFilter.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
|
|
dbchFilter.dbch_devicetype = DBT_DEVTYP_HANDLE;
|
|
dbchFilter.dbch_handle = _ObjIdIndexChangeNotifier._hDir; // _hVolume;
|
|
|
|
__try
|
|
{
|
|
// Register against the oid index handle (as a representative of
|
|
// the volume).
|
|
hdnVolumeLock = RegisterDeviceNotification((HANDLE)_ssh,
|
|
&dbchFilter,
|
|
DEVICE_NOTIFY_SERVICE_HANDLE);
|
|
if(hdnVolumeLock == NULL)
|
|
{
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Can't register for volume notifications, %08x"), GetLastError()));
|
|
TrkRaiseLastError();
|
|
}
|
|
|
|
// Get rid of our old registration, if we had one.
|
|
|
|
UnregisterPnPVolumeNotification();
|
|
|
|
// Keep the new registration.
|
|
|
|
_hdnVolumeLock = hdnVolumeLock;
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Registered for volume lock/unlock notification on %c: (%p)"),
|
|
VolChar(_iVol), _hdnVolumeLock ));
|
|
}
|
|
__except(BreakOnDebuggableException())
|
|
{
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Can't register for volume notification, %08x"), GetExceptionCode()));
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::UnregisterPnpVolumeNotification
|
|
//
|
|
// Unregister the device notification handle for this volume (if we have
|
|
// one).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::UnregisterPnPVolumeNotification()
|
|
{
|
|
if(_hdnVolumeLock)
|
|
{
|
|
if( !UnregisterDeviceNotification(_hdnVolumeLock)) {
|
|
TrkLog(( TRKDBG_ERROR, TEXT("UnregisterDeviceNotification failed: %lu"), GetLastError() ));
|
|
}
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Unregistered for volume lock/unlock notification on %c: (%p)"),
|
|
VolChar(_iVol), _hdnVolumeLock ));
|
|
|
|
_hdnVolumeLock = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::DeleteAndReinitializeLog
|
|
//
|
|
// Delete the volume log and reinitialize it.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::DeleteAndReinitializeLog()
|
|
{
|
|
// Delete and reinitialize the log
|
|
|
|
__try
|
|
{
|
|
RaiseIfWriteProtectedVolume();
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("DeleteAndReinitializeLog (%s)"),
|
|
_tszVolumeDeviceName ));
|
|
|
|
if( IsHandsOffVolumeMode() )
|
|
// Volume is locked
|
|
TrkRaiseNtStatus( STATUS_ACCESS_DENIED );
|
|
|
|
// Delete the log
|
|
|
|
_cLogFile.Delete();
|
|
|
|
// Reinitialize the log file, then the log itself.
|
|
|
|
_cLogFile.Initialize( NULL, NULL, NULL, VolChar(_iVol) );
|
|
_cLog.Initialize( _pLogCallback, _pTrkWksConfiguration, &_cLogFile );
|
|
}
|
|
__except( IsErrorDueToLockedVolume( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// If the volume is locked, start the reopen timer and abort.
|
|
CloseVolumeHandles(); // Never raises
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::DeleteLogAndReInitializeVolume
|
|
//
|
|
// Delete and reinit the log, then reinitialize the rest of the volume.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::DeleteLogAndReInitializeVolume()
|
|
{
|
|
AssertLocked();
|
|
|
|
// There's the remote possibility that the VolumeSanityCheck
|
|
// call below will call this routine. Just to be paranoid, we
|
|
// add protection against an infinite recursion.
|
|
|
|
if( _fDeleteLogAndReInitializeVolume )
|
|
TrkRaiseWin32Error( ERROR_OPEN_FAILED );
|
|
_fDeleteLogAndReInitializeVolume = TRUE;
|
|
|
|
__try
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Re-initializing volume %c:"), VolChar(_iVol) ));
|
|
|
|
// Re-initialize the CLogFile.
|
|
DeleteAndReinitializeLog();
|
|
|
|
// Recreate the volinfo in the new log's header
|
|
_fDirty = TRUE; // Force a flush
|
|
VolumeSanityCheck();
|
|
}
|
|
__finally
|
|
{
|
|
_fDeleteLogAndReInitializeVolume = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::UnInitialize
|
|
//
|
|
// Unregister our PNP handle, free critical sections, etc.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::UnInitialize()
|
|
{
|
|
if( _fInitialized )
|
|
{
|
|
IFDBG( _cLocks++; )
|
|
|
|
UnregisterPnPVolumeNotification();
|
|
_ssh = NULL;
|
|
|
|
if (_hVolume != NULL)
|
|
NtClose(_hVolume);
|
|
|
|
__try
|
|
{
|
|
_cLogFile.UnInitialize();
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER ) // BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in CVolume::UnInitialize after _cLogFile.UnInitialize for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
}
|
|
|
|
|
|
_fInitialized = FALSE;
|
|
_csHandles.UnInitialize();
|
|
_csVolume.UnInitialize();
|
|
|
|
IFDBG( _cLocks--; )
|
|
|
|
TrkAssert( 0 == _cLocks );
|
|
}
|
|
_ObjIdIndexChangeNotifier.UnInitialize();
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Flush
|
|
//
|
|
// Flush the volinfo structure, the log, and the logfile. In the process,
|
|
// mark the logfile header to show a proper shutdown. If we're in the middle
|
|
// of a service shutdown, and there's a problem with the log, don't run
|
|
// the recovery code.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::Flush(BOOL fServiceShutdown)
|
|
{
|
|
Lock();
|
|
__try
|
|
{
|
|
if( _fDirty )
|
|
SaveVolInfo();
|
|
|
|
__try
|
|
{
|
|
_cLog.Flush( ); // Flushes to CLogFile
|
|
_cLogFile.SetShutdown( TRUE ); // Causes a flush to disk if necessary
|
|
}
|
|
__except( !fServiceShutdown
|
|
&&
|
|
0 == _cHandleLocks
|
|
&&
|
|
IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Note that we don't handle this exception if the _cHandleLocks is non-zero.
|
|
// In this case we're in fast-path and must complete quickly, and the following
|
|
// calls could be too time consuming. We must complete quickly because
|
|
// CloseVolumeHandles uses that lock, and that call might be called on the
|
|
// SCM thread (for e.g. a volume lock event). The SCM thread is shared by
|
|
// all services in the process, so we must fast-path anything on it.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
_cLog.Flush();
|
|
_cLogFile.SetShutdown( TRUE );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::OpenFile
|
|
//
|
|
// Open a file on this volume, given the file's object ID.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::OpenFile( const CObjId &objid,
|
|
ACCESS_MASK AccessMask,
|
|
ULONG ShareAccess,
|
|
HANDLE *ph)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
status = OpenFileById( _tszVolumeDeviceName, objid, AccessMask, ShareAccess, 0, ph );
|
|
|
|
if( NT_SUCCESS(status) )
|
|
return TRUE;
|
|
else if( STATUS_OBJECT_NAME_NOT_FOUND == status )
|
|
return FALSE;
|
|
else
|
|
TrkRaiseNtStatus( status );
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return( FALSE );
|
|
|
|
} // CVolume::OpenFile()
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::LoadSyncVolume
|
|
//
|
|
// Load the TRKSVR_SYNC_VOLUME message request for this volume, if necessary.
|
|
// The call of this message to trksvr is actually sent by the caller. On
|
|
// return of that request, UnloadSyncVolume method will be called.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::LoadSyncVolume( TRKSVR_SYNC_VOLUME *pSyncVolume, EAggressiveness eAggressiveness, BOOL* pfSyncNeeded )
|
|
{
|
|
CVOL_STATE state = GetState();
|
|
BOOL fSuccess = FALSE;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
if( !_fVolInfoInitialized )
|
|
TrkRaiseException( E_UNEXPECTED );
|
|
|
|
memset( pSyncVolume, 0, sizeof(*pSyncVolume) );
|
|
if(pfSyncNeeded)
|
|
{
|
|
*pfSyncNeeded = FALSE;
|
|
}
|
|
|
|
// See if it's time to transition from not-owned to not-created.
|
|
|
|
if( NotOwnedExpired() )
|
|
SetState( state = VOL_STATE_NOTCREATED );
|
|
|
|
// Load the message request, if necessary, based on our current state.
|
|
|
|
if(state == VOL_STATE_NOTCREATED)
|
|
{
|
|
// Ordinarily, if we were unable to create this volume due to volume
|
|
// quota, we won't try again. But if we're told to be aggressive,
|
|
// we'll try anyway.
|
|
|
|
if( PASSIVE == eAggressiveness && _VolQuotaReached.IsSet() )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Not attempting to create new volume ID on %c:; quota reached"),
|
|
VolChar(_iVol) ));
|
|
}
|
|
else
|
|
{
|
|
// Generate a new secret for authentication of this volume.
|
|
|
|
g_ptrkwks->_entropy.Put();
|
|
|
|
if( !g_ptrkwks->_entropy.InitializeSecret( & _tempSecret ) )
|
|
{
|
|
// This should never happen - even if there hasn't been enough
|
|
// entropy yet, more will be generated.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't generate secret for volume %c:"), VolChar(_iVol) ));
|
|
goto Exit;
|
|
}
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Generated secret %s for volume %c"),
|
|
(const TCHAR*)CDebugString(_tempSecret), VolChar( _iVol )));
|
|
|
|
// Put the secret in the request, and set the request type to "create"
|
|
|
|
pSyncVolume->secret = _tempSecret;
|
|
pSyncVolume->SyncType = CREATE_VOLUME;
|
|
|
|
// Show that we put data into the request that should be sent
|
|
// to trksvr.
|
|
|
|
if (pfSyncNeeded != NULL)
|
|
*pfSyncNeeded = TRUE;
|
|
}
|
|
|
|
} // case CREATE_VOLUME
|
|
|
|
else if(state == VOL_STATE_NOTOWNED)
|
|
{
|
|
// Attempt to claim this volume.
|
|
|
|
pSyncVolume->volume = _volinfo.volid;
|
|
pSyncVolume->secretOld = _volinfo.secret;
|
|
pSyncVolume->SyncType = CLAIM_VOLUME;
|
|
|
|
// Generate a new secret.
|
|
|
|
if( !g_ptrkwks->_entropy.InitializeSecret( &_tempSecret ) )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't generate secret for volume %c:"), VolChar(_iVol) ));
|
|
goto Exit;
|
|
}
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Generated secret %s for volume %c"),
|
|
(const TCHAR*)CDebugString(_tempSecret), VolChar( _iVol )));
|
|
pSyncVolume->secret = _tempSecret;
|
|
|
|
// Show that the request should be sent.
|
|
|
|
if (pfSyncNeeded != NULL)
|
|
*pfSyncNeeded = TRUE;
|
|
|
|
} // case CLAIM_VOLUME
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in LoadSyncVolume for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
goto Exit;
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
Unlock();
|
|
return( fSuccess );
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::OnRestore
|
|
//
|
|
// Not currently implemented.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
HRESULT
|
|
CVolume::OnRestore()
|
|
{
|
|
return( E_NOTIMPL );
|
|
|
|
#if 0
|
|
HRESULT hr = E_FAIL;
|
|
CVolumeId volidVolume;
|
|
const CMachineId mcidLocal( MCID_LOCAL );
|
|
NTSTATUS status;
|
|
|
|
memset( &_volinfo, 0, sizeof(_volinfo) );
|
|
hr = S_OK;
|
|
|
|
Lock();
|
|
__try // __finally
|
|
{
|
|
__try
|
|
{
|
|
|
|
// Get volume id from two different places: in the log file, and on
|
|
// the volume. If the two
|
|
// disagree, use the object id in the log file, overwrite the other
|
|
// one. Put the volume into NOTOWNED state.
|
|
|
|
TrkLog(( TRKDBG_VOLUME,
|
|
TEXT("Checking for recorded id's on volume %c:"),
|
|
VolChar(_iVol) ));
|
|
|
|
LoadVolInfo();
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("volume id in log file ---- (%s) %c:"),
|
|
CDebugString(_volinfo.volid)._tsz, VolChar(_iVol) ));
|
|
|
|
status = QueryVolumeId(_tszVolumeDeviceName, &volidVolume);
|
|
if(!NT_SUCCESS(status) && status != STATUS_OBJECT_NAME_NOT_FOUND)
|
|
{
|
|
TrkLog((TRKDBG_ERROR, TEXT("Can't get id from volume %c"), VolChar(_iVol)));
|
|
SetState(VOL_STATE_NOTCREATED);
|
|
}
|
|
// if no id is set on the volume, adopt from the log file
|
|
if(volidVolume == CVolumeId() && _volinfo.volid != CVolumeId())
|
|
{
|
|
status = SetVolIdOnVolume(_volinfo.volid);
|
|
g_ptrkwks->_entropy.Put();
|
|
if(!NT_SUCCESS(status))
|
|
{
|
|
TrkRaiseNtStatus(status);
|
|
}
|
|
SetState( VOL_STATE_NOTOWNED );
|
|
}
|
|
else if(volidVolume != _volinfo.volid)
|
|
// The log file could have been copied or moved before the restore
|
|
// happened, in order to be safe we trash the volume.
|
|
{
|
|
SetState(VOL_STATE_NOTCREATED);
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
__except (BreakOnDebuggableException())
|
|
{
|
|
TrkLog((TRKDBG_ERROR, TEXT("OnRestore failed")));
|
|
hr = GetExceptionCode();
|
|
}
|
|
|
|
// If an un-recoverable log error was raised, re-initialize everything
|
|
|
|
if( TRK_E_CORRUPT_LOG == hr )
|
|
{
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
__try
|
|
{
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
__except( BreakOnDebuggableException())
|
|
{
|
|
hr = GetExceptionCode();
|
|
}
|
|
}
|
|
else if( IsErrorDueToLockedVolume(hr) )
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
TrkRaiseException( hr );
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return hr;
|
|
|
|
#endif // #if 0
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::LoadQueryVolume
|
|
//
|
|
// Load a TRKSVR_SYNC_VOLUME request for this volume, if necessary. If we
|
|
// load it, the caller will send it to trksvr. On return of that request,
|
|
// UnloadQueryVolume method will be called.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::LoadQueryVolume( TRKSVR_SYNC_VOLUME *pQueryVolume )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
// Don't do anything we're not even in trksvr.
|
|
|
|
if(GetState() == VOL_STATE_NOTCREATED)
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Put our volid & log sequence number into the request.
|
|
|
|
memset( pQueryVolume, 0, sizeof(*pQueryVolume) );
|
|
|
|
pQueryVolume->SyncType = QUERY_VOLUME;
|
|
pQueryVolume->volume = _volinfo.volid;
|
|
pQueryVolume->seq = _cLog.GetNextSeqNumber(); // Never raises
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in LoadQueryVolume for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
goto Exit;
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
Unlock();
|
|
return( fSuccess );
|
|
}
|
|
|
|
// Originally, trkwks bundle up volume requests (sync, claim, create) and call the DC. After the
|
|
// DC returns, this function is called to put necessary information back on the volume. Now the
|
|
// DC callback mechanism is added. When there are create volume requests, the DC will callback and
|
|
// this function is called by the DC callback function. The DC needs to know if each create volume
|
|
// request is successfully finished by the trkwks, so this function has to put an HRESULT to
|
|
// indicate that in the hr field of the TRKSVR_SYNC_VOLUME structure.
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::UnloadSyncVolume
|
|
//
|
|
// A sync-volume request was loaded in LoadSyncVolume, sent to trksvr, and
|
|
// we now need to interpret the result. If we successfully completed
|
|
// a create or claim, we'll go into the owned state.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::UnloadSyncVolume( TRKSVR_SYNC_VOLUME *pSyncVolume )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
BOOL fWrite = FALSE;
|
|
CMachineId mcidLocal( MCID_LOCAL );
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
if( !_fVolInfoInitialized )
|
|
TrkRaiseException( E_UNEXPECTED );
|
|
|
|
if(pSyncVolume->hr == S_OK)
|
|
{
|
|
// Clear the bit that indicates we've reported a vol quota event.
|
|
// That way, the next time we get a volume quota error, we'll report
|
|
// to the event log.
|
|
_VolQuotaReached.Clear();
|
|
|
|
switch( pSyncVolume->SyncType )
|
|
{
|
|
case CREATE_VOLUME:
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
// Write the volume ID to the volume meta-data.
|
|
|
|
status = SetVolIdOnVolume( pSyncVolume->volume );
|
|
g_ptrkwks->_entropy.Put();
|
|
if( !NT_SUCCESS(status) )
|
|
__leave;
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Newly-created vol id = %s, %c:"),
|
|
(const TCHAR*)CDebugString(pSyncVolume->volume),
|
|
VolChar(_iVol) ));
|
|
|
|
// Create a fresh log
|
|
DeleteAndReinitializeLog();
|
|
|
|
// Update _volinfo
|
|
|
|
_fDirty = TRUE;
|
|
_volinfo.cftLastRefresh = pSyncVolume->ftLastRefresh;
|
|
|
|
// Set _volinfo.volid = pSyncVolume->volume
|
|
|
|
SetVolIdInVolInfo( pSyncVolume->volume );
|
|
|
|
_volinfo.machine = mcidLocal;
|
|
_volinfo.secret = _tempSecret;
|
|
|
|
// And update our state.
|
|
|
|
SetState( VOL_STATE_OWNED ); // Flushes _volinfo
|
|
TrkAssert( VOL_STATE_OWNED == GetState() );
|
|
|
|
TrkReportEvent( EVENT_TRK_SERVICE_VOLUME_CREATE, EVENTLOG_INFORMATION_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
static_cast<const TCHAR*>( CStringize( _volinfo.volid )),
|
|
NULL );
|
|
} // case CREATE_VOLUME
|
|
|
|
break;
|
|
|
|
case CLAIM_VOLUME:
|
|
{
|
|
RaiseIfWriteProtectedVolume();
|
|
_fDirty = TRUE;
|
|
|
|
_volinfo.machine = mcidLocal;
|
|
_volinfo.cftLastRefresh = pSyncVolume->ftLastRefresh;
|
|
_volinfo.secret = _tempSecret;
|
|
|
|
SetState( VOL_STATE_OWNED ); // Flushes _volinfo
|
|
TrkAssert( VOL_STATE_OWNED == GetState() );
|
|
Seek( pSyncVolume->seq );
|
|
|
|
TrkReportEvent( EVENT_TRK_SERVICE_VOLUME_CLAIM, EVENTLOG_INFORMATION_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
static_cast<const TCHAR*>( CStringize( _volinfo.volid )),
|
|
TRKREPORT_LAST_PARAM );
|
|
|
|
} // case CLAIM_VOLUME
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
TrkAssert( FALSE && TEXT("Invalid SyncType given to CVolume::Serialize") );
|
|
break;
|
|
|
|
} // switch
|
|
|
|
fSuccess = TRUE;
|
|
|
|
} // if(pSyncVolume->hr == S_OK)
|
|
|
|
else
|
|
{
|
|
// If this is a quota error, log it (but only log it once
|
|
// per machine per transition).
|
|
if( TRK_E_VOLUME_QUOTA_EXCEEDED == pSyncVolume->hr )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Vol quota reached") ));
|
|
if( !_VolQuotaReached.IsSet() )
|
|
{
|
|
_VolQuotaReached.Set();
|
|
TrkReportEvent( EVENT_TRK_SERVICE_VOL_QUOTA_EXCEEDED, EVENTLOG_WARNING_TYPE,
|
|
TRKREPORT_LAST_PARAM );
|
|
}
|
|
|
|
// We'll call this success so that we don't retry. We'll try again
|
|
// later when the infrequent timer goes off.
|
|
fSuccess = TRUE;
|
|
}
|
|
|
|
SetState(VOL_STATE_NOTOWNED);
|
|
__leave;
|
|
}
|
|
|
|
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in UnloadSyncVolume for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
}
|
|
|
|
|
|
|
|
if( !fSuccess && pSyncVolume->SyncType == CREATE_VOLUME )
|
|
{
|
|
__try
|
|
{
|
|
CVolumeSecret ToReturn = _tempSecret;
|
|
_tempSecret = CVolumeSecret();
|
|
g_ptrkwks->_entropy.ReturnUnusedSecret( &ToReturn );
|
|
|
|
if( SUCCEEDED(pSyncVolume->hr) )
|
|
pSyncVolume->hr = E_FAIL;
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception (2) in UnloadSyncVolume for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
}
|
|
}
|
|
|
|
Unlock();
|
|
return( fSuccess );
|
|
|
|
} // CVolume::UnloadSyncVolume
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::UnloadQueryVolume
|
|
//
|
|
// The volume manager called LoadQueryVolume, sent the request to trskvr,
|
|
// and is now giving us the result.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::UnloadQueryVolume( const TRKSVR_SYNC_VOLUME *pQueryVolume )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
// Was the request successful?
|
|
|
|
if(pQueryVolume->hr == S_OK)
|
|
{
|
|
// Go into the owned state, if we're not there
|
|
// already.
|
|
|
|
SetState( VOL_STATE_OWNED );
|
|
|
|
// Seek the log to match what trksvr expects. If this causes the
|
|
// seek pointer to be backed up, it will set the timer to trigger
|
|
// a new move-notification to trksvr.
|
|
|
|
Seek( pQueryVolume->seq );
|
|
}
|
|
else // DC didn't return VOLUME_OK
|
|
{
|
|
TrkLog((TRKDBG_VOLUME, TEXT("DC returned %s for QueryVolume of volume %s (%c:) -> VOL_STATE_NOTOWNED"),
|
|
GetErrorString(pQueryVolume->hr),
|
|
(const TCHAR*)CDebugString(pQueryVolume->volume),
|
|
VolChar(_iVol) ));
|
|
|
|
// If there was a problem, go into the not-owned state.
|
|
|
|
SetState(VOL_STATE_NOTOWNED);
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in UnloadQueryVolume for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
goto Exit;
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
Unlock();
|
|
return( fSuccess );
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Append
|
|
//
|
|
// Append a move notification to the end of this volume's log.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::Append( const CDomainRelativeObjId &droidCurrent,
|
|
const CDomainRelativeObjId &droidNew,
|
|
const CMachineId &mcidNew,
|
|
const CDomainRelativeObjId &droidBirth)
|
|
{
|
|
//TrkLog((TRKDBG_VOL_REFCNT, TEXT("CVolume(%08x)::Append refcnt=%d (should be 2, sometimes >2)"), this, _lRef));
|
|
|
|
Lock();
|
|
__try // __finally
|
|
{
|
|
// Validate the IDs
|
|
|
|
const CVolumeId volidZero;
|
|
const CObjId objidZero;
|
|
|
|
if( volidZero == droidCurrent.GetVolumeId()
|
|
||
|
|
objidZero == droidCurrent.GetObjId()
|
|
||
|
|
volidZero == droidNew.GetVolumeId()
|
|
||
|
|
objidZero == droidNew.GetObjId()
|
|
||
|
|
volidZero == droidBirth.GetVolumeId()
|
|
||
|
|
objidZero == droidBirth.GetObjId() )
|
|
{
|
|
// In the append path, we only raise NTSTATUS errors, not HRESULTs
|
|
TrkRaiseException( STATUS_OBJECT_NAME_INVALID );
|
|
}
|
|
|
|
__try // __except
|
|
{
|
|
_cLog.Append( droidCurrent.GetVolumeId(), droidCurrent.GetObjId(), droidNew, mcidNew, droidBirth );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// We had a potentially recoverable exception. Try to handle it
|
|
// and retry the append.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ) )
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
// The log is corrupted. Re-initialize, then attempt the Append again.
|
|
// If this raises, it's an unrecoverable exception, so we just pass
|
|
// it up.
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
|
|
// Retry the Append, which could raise again, but this time we won't catch it.
|
|
_cLog.Append( droidCurrent.GetVolumeId(), droidCurrent.GetObjId(), droidNew, mcidNew, droidBirth );
|
|
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Read
|
|
//
|
|
// Read one or more entries from the log, from the current seek position.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::Read(CObjId *pobjidCurrent,
|
|
CDomainRelativeObjId *pdroidBirth,
|
|
CDomainRelativeObjId *pdroidNew,
|
|
SequenceNumber *pseqFirst,
|
|
ULONG *pcRead)
|
|
{
|
|
|
|
Lock();
|
|
__try // __finally
|
|
{
|
|
__try
|
|
{
|
|
_cLog.Read( pobjidCurrent, pdroidBirth, pdroidNew,
|
|
pseqFirst, pcRead );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Try to recover from this error and if possible retry
|
|
// the read.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
|
|
// Retry the read, which could raise again, but this time we won't
|
|
// catch it.
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Retrying CLog::Read") ));
|
|
_cLog.Read( pobjidCurrent, pdroidBirth, pdroidNew,
|
|
pseqFirst, pcRead );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
// The log is corrupted. Re-initialize, then pass up the error.
|
|
DeleteLogAndReInitializeVolume();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Search
|
|
//
|
|
// Search the log for a move-notification (from droidCurrent).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::Search( const CDomainRelativeObjId & droidCurrent, CDomainRelativeObjId * pdroidNew,
|
|
CMachineId *pmcidNew, CDomainRelativeObjId * pdroidBirth )
|
|
{
|
|
BOOL fFound = FALSE;
|
|
|
|
Lock();
|
|
__try // __finally
|
|
{
|
|
__try
|
|
{
|
|
// Perfbug: Don't hold the log locked during the whole search such that
|
|
// it locks out Appends.
|
|
fFound = _cLog.Search( droidCurrent.GetObjId(), pdroidNew, pmcidNew, pdroidBirth );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Try to recover from this error and retry the search.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
|
|
// Retry the search, which could raise again, but this time we won't catch it.
|
|
fFound = _cLog.Search( droidCurrent.GetObjId(), pdroidNew, pmcidNew, pdroidBirth );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
// The log is corrupted. Re-initialize, and pass up the error.
|
|
DeleteLogAndReInitializeVolume();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return( fFound );
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Seek
|
|
//
|
|
// Seek the log to a particular sequence number.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::Seek( SequenceNumber seq )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
__try
|
|
{
|
|
fSuccess = _cLog.Seek( seq );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Try to recover from this error and retry the seek.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
|
|
// Retry the Seek, which could raise again, but this time we won't catch it.
|
|
fSuccess = _cLog.Seek( seq );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
// The log is corrupted. Re-initialize and pass up the error.
|
|
DeleteLogAndReInitializeVolume();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
if( fSuccess )
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Log on %c: sought to seq %d"),
|
|
VolChar(_iVol), seq ));
|
|
else
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Log on %c: couldn't be sought to seq %d"),
|
|
VolChar(_iVol), seq ));
|
|
|
|
return( fSuccess );
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::Seek
|
|
//
|
|
// Seek to a relative (e.g. back up 2) or absolute (e.g. first) position.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::Seek( int origin, int iSeek )
|
|
{
|
|
Lock();
|
|
__try // __finally
|
|
{
|
|
__try
|
|
{
|
|
_cLog.Seek( origin, iSeek );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Attempt to recover from this error and retry the seek.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles(); // Reopen might fail
|
|
|
|
// Retry the Seek, which could raise again, but this time we won't catch it.
|
|
_cLog.Seek( origin, iSeek );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
|
|
// The log is corrupted. Re-initialize and pass up the error.
|
|
DeleteLogAndReInitializeVolume();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::GetVolumeId
|
|
//
|
|
// Get the volume ID without taking the lock. This was done
|
|
// so that CVolumeManager::IsDuplicateID can check the volid
|
|
// of other volumes without deadlocking. Otherwise we run the
|
|
// risk of one volume holding its locks and trying to get
|
|
// another volume's lock (using GetVolumeId on that volume)
|
|
// while another thread is in that volume doing the same for
|
|
// this volume.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
const CVolumeId
|
|
CVolume::GetVolumeId()
|
|
{
|
|
CVolumeId volid;
|
|
ULONG cAttempts = 0;
|
|
|
|
// Spin until we get a good volid.
|
|
|
|
while( TRUE )
|
|
{
|
|
// Get the update counter before and after reading
|
|
// from the volid. (This assumes that
|
|
// reading the long is atomic.)
|
|
|
|
LONG lVolidUpdatesBefore = _lVolidUpdates;
|
|
|
|
volid = _volinfo.volid;
|
|
|
|
LONG lVolidUpdatesAfter = _lVolidUpdates;
|
|
|
|
// When the _volinfo is updated, the _lVolidUpdates is
|
|
// incremented before and after the update. So if there
|
|
// was an update in progress when we started, it will
|
|
// be an odd number.
|
|
//
|
|
// Ensure there was no update in progress when we read
|
|
// the volid, and there was no update started while we
|
|
// were reading the volid.
|
|
|
|
|
|
if( (lVolidUpdatesBefore & 1)
|
|
||
|
|
lVolidUpdatesBefore != lVolidUpdatesAfter )
|
|
{
|
|
// Check for timeout (30 seconds)
|
|
if( 3000 < ++cAttempts )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Failed spin in GetVolumeId") ));
|
|
TrkRaiseWin32Error( WAIT_TIMEOUT );
|
|
}
|
|
|
|
// Wait for the update to complete then try again.
|
|
Sleep( 10 );
|
|
continue;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
return( volid );
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::GetState
|
|
//
|
|
// Get the current state of this volume (owned, not-owned, or not-created).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
CVolume::CVOL_STATE
|
|
CVolume::GetState()
|
|
{
|
|
CVolumeId volNULL;
|
|
CVOL_STATE state = VOL_STATE_UNKNOWN;
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
|
|
if( _volinfo.fNotCreated )
|
|
{
|
|
state = VOL_STATE_NOTCREATED;
|
|
}
|
|
|
|
// If the time we entered the not-owned state is non-zero, then
|
|
// we're certainly in the not-owned state. Also, if the machine ID
|
|
// in the _volinfo header doesn't match the local machine, we're
|
|
// not owned.
|
|
|
|
else if(_volinfo.cftEnterNotOwned != 0
|
|
||
|
|
_volinfo.machine != CMachineId(MCID_LOCAL)
|
|
)
|
|
{
|
|
// Is this the first time that we realized we're not owned?
|
|
if( !IsWriteProtectedVolume() && 0 == _volinfo.cftEnterNotOwned )
|
|
{
|
|
_volinfo.cftEnterNotOwned.SetToUTC();
|
|
_fDirty = TRUE;
|
|
Flush();
|
|
}
|
|
|
|
state = VOL_STATE_NOTOWNED;
|
|
}
|
|
|
|
// Otherwise, we must be properly owned.
|
|
|
|
else
|
|
{
|
|
state = VOL_STATE_OWNED;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::SetState
|
|
//
|
|
// Change the current state of the volume. This checks for valid transitions.
|
|
// For example, you can't transition from not-created to not-owned (such
|
|
// a request is silently ignored). This alleviates the caller from having
|
|
// to perform this logic.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::SetState(CVOL_STATE volstateTarget)
|
|
{
|
|
CVOL_STATE volstateCurrent = GetState();
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
VolumePersistentInfo volinfoNew = _volinfo;
|
|
BOOL fDirtyNew = _fDirty;
|
|
|
|
// Make sure the volume is writeable
|
|
RaiseIfWriteProtectedVolume();
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
switch( volstateTarget )
|
|
{
|
|
|
|
case VOL_STATE_NOTOWNED:
|
|
|
|
// We can only go to not-owned from owned.
|
|
|
|
if( VOL_STATE_OWNED == volstateCurrent )
|
|
{
|
|
TrkAssert( !volinfoNew.fNotCreated );
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Entering not-owned state on vol %c:"), VolChar(_iVol) ));
|
|
|
|
RaiseIfWriteProtectedVolume();
|
|
fDirtyNew = TRUE;
|
|
volinfoNew.cftEnterNotOwned.SetToUTC();
|
|
}
|
|
break;
|
|
|
|
case VOL_STATE_NOTCREATED:
|
|
|
|
// We can always go to not-created.
|
|
|
|
if( volstateCurrent != VOL_STATE_NOTCREATED )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Entering not-created state on vol %c:"), VolChar(_iVol) ));
|
|
|
|
RaiseIfWriteProtectedVolume();
|
|
fDirtyNew = TRUE;
|
|
volinfoNew.fNotCreated = TRUE;
|
|
volinfoNew.cftEnterNotOwned = CFILETIME(0);
|
|
}
|
|
|
|
break;
|
|
|
|
case VOL_STATE_OWNED:
|
|
|
|
if( VOL_STATE_NOTCREATED == volstateCurrent )
|
|
{
|
|
// We're going from not-created to owned, so we need to make
|
|
// all our OIDs reborn.
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Entering owned state (from not-created) on vol %c:"), VolChar(_iVol) ));
|
|
|
|
RaiseIfWriteProtectedVolume();
|
|
fDirtyNew = TRUE;
|
|
volinfoNew.fNotCreated = FALSE;
|
|
TrkAssert( CFILETIME(0) == volinfoNew.cftEnterNotOwned );
|
|
|
|
// Since we now have a new volid, we must give all the existing
|
|
// files new object IDs.
|
|
|
|
//MarkForMakeAllOidsReborn();
|
|
volinfoNew.fDoMakeAllOidsReborn = TRUE;
|
|
}
|
|
else if( VOL_STATE_NOTOWNED == volstateCurrent )
|
|
{
|
|
// We're going from not-owned to owned.
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Entering owned state (from not-owned) on vol %c:"), VolChar(_iVol) ));
|
|
TrkAssert( !volinfoNew.fNotCreated );
|
|
|
|
RaiseIfWriteProtectedVolume();
|
|
fDirtyNew = TRUE;
|
|
volinfoNew.cftEnterNotOwned = CFILETIME(0);
|
|
}
|
|
|
|
TrkAssert( CVolumeId() != _volinfo.volid );
|
|
break;
|
|
|
|
default:
|
|
TrkAssert( !TEXT("Bad target state in CVolume::SetState") );
|
|
|
|
} // switch( volstateTarget )
|
|
|
|
// If we modified the volinfo, write it back out.
|
|
|
|
_volinfo = volinfoNew;
|
|
_fDirty |= fDirtyNew;
|
|
|
|
Flush();
|
|
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::NotOwnedExpired
|
|
//
|
|
// Have we been in the not-owned state for long enough that we should be
|
|
// in the not-created state?
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::NotOwnedExpired()
|
|
{
|
|
Lock();
|
|
__try
|
|
{
|
|
if(_volinfo.cftEnterNotOwned != 0)
|
|
{
|
|
CFILETIME cftDiff = CFILETIME() - _volinfo.cftEnterNotOwned;
|
|
ULONG SecondsDiff = static_cast<ULONG>((LONGLONG)cftDiff/10000000);
|
|
|
|
if(SecondsDiff > _pTrkWksConfiguration->GetVolNotOwnedExpireLimit())
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::MakeAllOidsReborn
|
|
//
|
|
// Reset (zero out) the birth IDs (actually, all 48 extended bytes) of
|
|
// all the files on this volume. That makes the file no longer a link source,
|
|
// so we won't try to track it. If someone subsequently makes a link
|
|
// to it, NTFS will fill in a new birth ID.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::MakeAllOidsReborn()
|
|
{
|
|
CObjIdEnumerator oie;
|
|
BOOL fSuccess = FALSE;
|
|
CObjId objid;
|
|
CDomainRelativeObjId droidBirth;
|
|
NTSTATUS status;
|
|
CVolumeId vidNull;
|
|
BOOL fLocked = FALSE;
|
|
|
|
__try
|
|
{
|
|
// Give all the files with object IDs a fresh birth ID, as if the
|
|
// file had first been linked to on this volume.
|
|
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Making OIDs reborn on volume %c:"), VolChar(_iVol) ));
|
|
|
|
if(oie.Initialize(_tszVolumeDeviceName))
|
|
{
|
|
if(oie.FindFirst(&objid, &droidBirth))
|
|
{
|
|
do
|
|
{
|
|
g_ptrkwks->RaiseIfStopped();
|
|
|
|
// If this has what looks like an invalid birth ID, ignore it.
|
|
|
|
if( CObjId() == droidBirth.GetObjId() )
|
|
continue;
|
|
|
|
// We only take the lock directly around the make-reborn
|
|
// call, since with the sleep below we could be in this routine
|
|
// for a while.
|
|
|
|
Lock(); fLocked = TRUE;
|
|
TrkAssert( 1 == _cLocks );
|
|
MakeObjIdReborn( _tszVolumeDeviceName, objid );
|
|
Unlock(); fLocked = FALSE;
|
|
|
|
Sleep( 100 ); // don't hog the machine
|
|
} while(oie.FindNext(&objid, &droidBirth));
|
|
}
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
__try
|
|
{
|
|
if( TRK_E_CORRUPT_LOG == GetExceptionCode() )
|
|
{
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
BreakIfRequested();
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
else if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles();
|
|
TrkRaiseException( GetExceptionCode() );
|
|
}
|
|
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception in CVolume::MakeAllOidsReborn for %c: %08x"),
|
|
VolChar(_iVol), GetExceptionCode() ));
|
|
}
|
|
__finally
|
|
{
|
|
if( fLocked )
|
|
Unlock();
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
fSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
oie.UnInitialize();
|
|
|
|
if(!fSuccess)
|
|
{
|
|
TrkLog((TRKDBG_ERROR,
|
|
TEXT("Can't delete all object ids on volume %c:"),
|
|
VolChar(_iVol) ));
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::OnHandlesMustClose
|
|
//
|
|
// This routine is called from CLogFile if it discovers that the log file
|
|
// needs to be closed (an oplock break). We close all handles on the volume
|
|
// and start the reopen timer.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::OnHandlesMustClose()
|
|
{
|
|
CloseVolumeHandles(); // Doesn't raise
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::FileActionIdNotTunnelled
|
|
//
|
|
// This method is called as an event notification, indicating that NTFS has
|
|
// notified us that a file could not be tunnelled. We do the tunnelling manually
|
|
// here.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
#define ON_NOT_TUNNELLED_DELAY 500 // .5 seconds
|
|
|
|
void
|
|
CVolume::FileActionIdNotTunnelled( FILE_OBJECTID_INFORMATION * poi )
|
|
{
|
|
ULONG ulMillisecondsSleptSoFar = 0;
|
|
HANDLE hFile = NULL;
|
|
|
|
// We don't take the volume lock here. So don't attempt to
|
|
// do anything other than simple I/O. We don't take the lock because
|
|
// we want to ensure that tunnelling is resolved quickly without
|
|
// getting blocked.
|
|
|
|
//
|
|
// Open the file being "tunnelled from" by OBJECTID
|
|
// Delete the object id
|
|
// Close
|
|
// Open the file being "tunnelled to" by FileReference
|
|
// Set the object id and extra data
|
|
// Close
|
|
|
|
// Test hook
|
|
IFDBG( _pTunnelTest->ReleaseAndWait() );
|
|
|
|
__try
|
|
{
|
|
if (_hVolume == NULL)
|
|
{
|
|
// Couldn't reopen the volume
|
|
__leave;
|
|
}
|
|
|
|
NTSTATUS Status;
|
|
|
|
OBJECT_ATTRIBUTES oa;
|
|
UNICODE_STRING uId;
|
|
IO_STATUS_BLOCK ios;
|
|
CObjId objid( FOI_OBJECTID, *poi );
|
|
int i;
|
|
|
|
// Ignore if this isn't a link tracking (e.g. it's an NTFRS) object ID.
|
|
|
|
if( CObjId() == CObjId(FOI_BIRTHID, *poi) )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Ignoring not-tunneled notification for %s"),
|
|
(const TCHAR*)CDebugString( objid ) ));
|
|
__leave;
|
|
}
|
|
|
|
uId.Length = sizeof(poi->ObjectId);
|
|
uId.MaximumLength = sizeof(poi->ObjectId);
|
|
uId.Buffer = (PWSTR) poi->ObjectId;
|
|
|
|
InitializeObjectAttributes( &oa, &uId, OBJ_CASE_INSENSITIVE, _hVolume, NULL );
|
|
|
|
// -----------------
|
|
// Open the old file
|
|
// -----------------
|
|
|
|
// Some kind of write access, along with restore privelege, is required
|
|
// for set/delete OID calls.
|
|
|
|
EnableRestorePrivilege();
|
|
Status = NtCreateFile(
|
|
&hFile,
|
|
SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
|
|
&oa,
|
|
&ios,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
FILE_OPEN,
|
|
FILE_OPEN_BY_FILE_ID | FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_NO_RECALL
|
|
| FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
|
|
// ------------------------------
|
|
// Delete the OID on the old file
|
|
// ------------------------------
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Status = NtFsControlFile(
|
|
hFile,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ios,
|
|
FSCTL_DELETE_OBJECT_ID,
|
|
NULL, // in buffer
|
|
0, // in buffer size
|
|
NULL, // Out buffer
|
|
0); // Out buffer size
|
|
|
|
NtClose( hFile );
|
|
hFile = NULL;
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
TrkLog((TRKDBG_TUNNEL, TEXT("Tunnelling objid %s - deleted from old file"),
|
|
(const TCHAR*)CDebugString(objid) ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog((TRKDBG_TUNNEL, TEXT("Tunnelling objid %c:%s - couldn't FSCTL_DELETE_OBJECT_ID ntstatus=%08x"),
|
|
VolChar(_iVol),
|
|
(const TCHAR*)CDebugString(objid),
|
|
Status ));
|
|
}
|
|
} // if (NT_SUCCESS(Status))
|
|
|
|
else
|
|
{
|
|
// We couldn't open the old file, so we'll ignore it and try to set the
|
|
// object ID.
|
|
TrkLog((TRKDBG_TUNNEL, TEXT("Tunnelling objid %c:%s - couldn't open old file %08x"),
|
|
VolChar(_iVol),
|
|
(const TCHAR*)CDebugString(objid),
|
|
Status));
|
|
}
|
|
|
|
if( Status == STATUS_INVALID_DEVICE_REQUEST ||
|
|
IsErrorDueToLockedVolume( Status ) )
|
|
{
|
|
// If we get STATUS_INVALID_DEVICE_REQUEST, then _hVolume is
|
|
// broken.
|
|
|
|
CloseVolumeHandles();
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer();
|
|
__leave;
|
|
}
|
|
|
|
// -----------------
|
|
// Open the new file
|
|
// -----------------
|
|
|
|
uId.Length = sizeof(poi->FileReference);
|
|
uId.MaximumLength = sizeof(poi->FileReference);
|
|
uId.Buffer = (PWSTR) &poi->FileReference;
|
|
|
|
Status = NtCreateFile(
|
|
&hFile,
|
|
SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
|
|
&oa,
|
|
&ios,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
FILE_OPEN,
|
|
FILE_OPEN_BY_FILE_ID | FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_NO_RECALL
|
|
| FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0 );
|
|
|
|
// ---------------------------
|
|
// Set the OID on the new file
|
|
// ---------------------------
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Status = NtFsControlFile(
|
|
hFile,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ios,
|
|
FSCTL_SET_OBJECT_ID,
|
|
poi->ObjectId,
|
|
sizeof(FILE_OBJECTID_BUFFER),
|
|
NULL, // Out buffer
|
|
0); // Out buffer size
|
|
NtClose(hFile);
|
|
hFile = NULL;
|
|
|
|
TrkLog((TRKDBG_TUNNEL, TEXT("Tunnelling objid %s: FSCTL_SET_OBJECT_ID %s %08x"),
|
|
(const TCHAR*)CDebugString(objid),
|
|
NT_SUCCESS(Status) ? TEXT("succeeded") : TEXT("failed"),
|
|
Status ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog((TRKDBG_TUNNEL, TEXT("Tunnelling objid %c:%s - couldn't OpenByFileReference ntstatus=%08x"),
|
|
VolChar(_iVol),
|
|
(const TCHAR*)CDebugString(objid),
|
|
Status ));
|
|
}
|
|
|
|
if(Status == STATUS_INVALID_DEVICE_REQUEST ||
|
|
IsErrorDueToLockedVolume( Status ) )
|
|
{
|
|
// If we get STATUS_INVALID_DEVICE_REQUEST, then _hVolume is
|
|
// broken.
|
|
|
|
CloseVolumeHandles();
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer();
|
|
__leave;
|
|
}
|
|
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Exception %08x in CVolume::FileActionIdNotTunnelled"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
if( NULL != hFile )
|
|
NtClose( hFile );
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::NotifyAddOrDelete
|
|
//
|
|
// This method is called as an event notification, indicating that NTFS has
|
|
// notified us that the volume ID has been modified. We use this to ensure
|
|
// the volume ID doesn't get incorrectly modified.
|
|
//
|
|
// If you watch the object ID notification queue while someone sets the
|
|
// volume ID directly in NTFS, you'll see:
|
|
// * a remove of the old ID (setting a new ID shows up as a remove/add),
|
|
// * an add of the bogus ID,
|
|
// * a remove of the bogus ID (part of the SetVolid that we do in this routine),
|
|
// * an add of the correct ID.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
CVolume::NotifyAddOrDelete( ULONG Action, const CObjId & objid )
|
|
{
|
|
// Not supported
|
|
return;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::LoadVolInfo
|
|
//
|
|
// Load the _volinfo member from the log.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::LoadVolInfo()
|
|
{
|
|
AssertLocked();
|
|
TrkAssert( CVOLUME_HEADER_LENGTH == sizeof(_volinfo) );
|
|
|
|
// Read _volinfo from the extended header portion of the log.
|
|
|
|
__try
|
|
{
|
|
_cLogFile.ReadExtendedHeader( CVOLUME_HEADER_START, &_volinfo, sizeof(_volinfo) );
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Attempt to recover from this error and retry the read.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ))
|
|
{
|
|
CloseAndReopenVolumeHandles();
|
|
_cLogFile.ReadExtendedHeader( CVOLUME_HEADER_START, &_volinfo, sizeof(_volinfo) );
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::SaveVolInfo
|
|
//
|
|
// Write the _volinfo structure to the extended header portion of the log.
|
|
// Clear _fDirty if successful.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::SaveVolInfo( )
|
|
{
|
|
AssertLocked();
|
|
|
|
__try
|
|
{
|
|
_cLogFile.WriteExtendedHeader( CVOLUME_HEADER_START, &_volinfo, sizeof(_volinfo) );
|
|
_fDirty = FALSE;
|
|
}
|
|
__except( IsRecoverableDiskError( GetExceptionCode() )
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
// Attempt to recover from this error and retry the write.
|
|
|
|
if( IsErrorDueToLockedVolume( GetExceptionCode() ) )
|
|
{
|
|
CloseAndReopenVolumeHandles();
|
|
_cLogFile.WriteExtendedHeader( CVOLUME_HEADER_START, &_volinfo, sizeof(_volinfo) );
|
|
_fDirty = FALSE;
|
|
}
|
|
else
|
|
{
|
|
TrkAssert( TRK_E_CORRUPT_LOG == GetExceptionCode() );
|
|
TrkReportEvent( EVENT_TRK_SERVICE_CORRUPT_LOG, EVENTLOG_ERROR_TYPE,
|
|
static_cast<const TCHAR*>( CStringize( VolChar(_iVol) )),
|
|
NULL );
|
|
DeleteLogAndReInitializeVolume();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::CloseVolumeHandles
|
|
//
|
|
// This method close all handle that this object maintains on the volume.
|
|
// This will allow e.g. format or chkdsk /f to run successfully.
|
|
// We don't take the volume critsec, so we're guaranteed to run quickly
|
|
// and not block.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::CloseVolumeHandles( HDEVNOTIFY hdnVolume, EHandleChangeReason eHandleChangeReason )
|
|
{
|
|
HANDLE hVolToClose = NULL;
|
|
|
|
// This routine never raises
|
|
|
|
// Is this notification intended for everyone, or specifically
|
|
// for us?
|
|
if( hdnVolume != NULL && hdnVolume != _hdnVolumeLock )
|
|
// No, it's just for another volume.
|
|
return;
|
|
|
|
// Are we already in a CloseVolumeHandles somewhere?
|
|
// If so, there's no need to continue, and worse yet if we were
|
|
// to continue we could deadlock (scenario: one thread is in
|
|
// _cLogFile.Close below unregistering the oplock wait, which is
|
|
// blocking, and another thread is executing an oplock break).
|
|
|
|
if( !BeginSingleInstanceTask( &_cCloseVolumeHandlesInProgress ) )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Skipping CloseVolumeHandles, another instance already in progress") ));
|
|
return;
|
|
}
|
|
|
|
|
|
// We don't want this method to take the normal _csVolume lock, because
|
|
// we're called from threads that must not block (such as the service control handler
|
|
// thread). So we just take the limited lock that's used in this method
|
|
// and in ReopenVolumeHandles.
|
|
|
|
LockHandles();
|
|
__try
|
|
{
|
|
BOOL fAlreadyLockedOrDismounted = _fVolumeLocked || _fVolumeDismounted;
|
|
|
|
TrkLog(( TRKDBG_WARNING, TEXT("Closing volume handles on %c:"), VolChar(_iVol) ));
|
|
|
|
// If this notification is specifically for us, then remember
|
|
// if we're locked/dismounted.
|
|
|
|
if( hdnVolume != NULL )
|
|
{
|
|
if( VOLUME_LOCK_CHANGE == eHandleChangeReason )
|
|
_fVolumeLocked = TRUE;
|
|
else if( VOLUME_MOUNT_CHANGE == eHandleChangeReason )
|
|
_fVolumeDismounted = TRUE;
|
|
}
|
|
|
|
// Is this volume already locked or dismounted?
|
|
if( fAlreadyLockedOrDismounted )
|
|
{
|
|
TrkAssert( NULL == _hVolume );
|
|
__leave;
|
|
}
|
|
|
|
// Close the object ID index directory handle.
|
|
|
|
_ObjIdIndexChangeNotifier.StopListeningAndClose();
|
|
|
|
// Close the log.
|
|
|
|
_cLogFile.Close(); // Doesn't raise
|
|
|
|
// Prepare to close the volume handle.
|
|
|
|
if (_hVolume != NULL)
|
|
{
|
|
hVolToClose = _hVolume;
|
|
_hVolume = NULL;
|
|
}
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Volume %c: closed"), VolChar(_iVol)));
|
|
}
|
|
|
|
__except( EXCEPTION_EXECUTE_HANDLER ) // BreakThenReturn( EXCEPTION_EXECUTE_HANDLER ))
|
|
{
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring unexpected exception in CVolume::CloseVolumeHandles (%08x)"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
UnlockHandles();
|
|
EndSingleInstanceTask( &_cCloseVolumeHandlesInProgress );
|
|
|
|
if( NULL != hVolToClose )
|
|
{
|
|
NtClose( hVolToClose );
|
|
TrkLog((TRKDBG_VOLUME, TEXT("(Volume %c: fully closed)"), VolChar(_iVol)));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::ReopenVolumeHandles
|
|
//
|
|
// Reopen the handles that we maintain on the volume. This is synchronized
|
|
// with CloseVolumeHandles using the handle critsec. This method does
|
|
// nothing if the volume is locked (as indicated by _fVolumeLocked),
|
|
// or if the volume handles are already opened.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CVolume::ReopenVolumeHandles()
|
|
{
|
|
NTSTATUS status;
|
|
BOOL fHandlesLocked = FALSE;
|
|
BOOL fHandlesOpen = FALSE;
|
|
BOOL fReopenedLog = FALSE;
|
|
BOOL fStartedListening = FALSE;
|
|
|
|
|
|
// Don't open if the service is stopping.
|
|
g_ptrkwks->RaiseIfStopped();
|
|
|
|
TrkLog(( TRKDBG_WARNING, TEXT("\nReopenVolumeHandles called on %c:"), VolChar(_iVol) ));
|
|
|
|
// This method must acquire the _csVolumes critical section like every other
|
|
// public method (via the Lock call). It must also acquire the _csHandles
|
|
// lock, in order to coordinate with the CloseVolumeHandles and SetUnlockVolume
|
|
// methods, which have special needs.
|
|
|
|
Lock();
|
|
__try
|
|
{
|
|
LockHandles(); fHandlesLocked = TRUE;
|
|
|
|
// Are we supposed to reopen?
|
|
if( IsHandsOffVolumeMode() )
|
|
{
|
|
// Don't open yet, wait until we get an UnLock notification.
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Didn't open handles on %c:, it's %s"),
|
|
VolChar(_iVol),
|
|
_fVolumeLocked
|
|
? ( _fVolumeDismounted ? TEXT("locked & dismounted") : TEXT("locked") )
|
|
: TEXT("dismounted") ));
|
|
__leave;
|
|
}
|
|
|
|
// Open the main volume handle.
|
|
if( NULL == _hVolume )
|
|
{
|
|
status = OpenVolume(_tszVolumeDeviceName, &_hVolume);
|
|
if(!NT_SUCCESS(status))
|
|
{
|
|
if( STATUS_OBJECT_NAME_NOT_FOUND == status )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume not found in ReopenVolumeHandles, deleting CVolume") ));
|
|
MarkSelfForDelete();
|
|
}
|
|
|
|
TrkRaiseNtStatus(status);
|
|
}
|
|
}
|
|
|
|
|
|
// Start listening for objid index change notifications
|
|
__try
|
|
{
|
|
fStartedListening = _ObjIdIndexChangeNotifier.AsyncListen( );
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
// We should never get a path-not-found error, because meta-files always exist
|
|
// on a good NTFS5 volume. If we get one, it's probably because an NTFS5
|
|
// volume has been reformatted as a FAT volume.
|
|
|
|
HRESULT hr = GetExceptionCode();
|
|
if( HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("ObjId Index not found in ReopenVolumeHandles, deleting CVolume") ));
|
|
MarkSelfForDelete();
|
|
}
|
|
|
|
TrkRaiseException( hr );
|
|
|
|
}
|
|
|
|
// Register for PNP notifications. We don't hold the handle lock because this
|
|
// call can take a while, and we don't want to block the service control
|
|
// handler thread from doing a CloseVolumeHandles.
|
|
|
|
if( fStartedListening )
|
|
{
|
|
|
|
#if DBG
|
|
TrkVerify( 0 == UnlockHandles() );
|
|
#else
|
|
UnlockHandles();
|
|
#endif
|
|
fHandlesLocked = FALSE;
|
|
RegisterPnPVolumeNotification();
|
|
LockHandles(); fHandlesLocked = TRUE;
|
|
}
|
|
|
|
// If CloseVolumeHandles came in after we released the handle lock just now,
|
|
// then abort.
|
|
|
|
if( NULL == _hVolume )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Aborting ReopenVolumeHandles") ));
|
|
TrkRaiseException( E_FAIL );
|
|
}
|
|
|
|
// Open the log
|
|
|
|
if( !_cLogFile.IsOpen() )
|
|
{
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
__try
|
|
{
|
|
_cLogFile.Initialize( _tszVolumeDeviceName, _pTrkWksConfiguration, this, VolChar(_iVol) );
|
|
_cLog.Initialize( _pLogCallback, _pTrkWksConfiguration, &_cLogFile );
|
|
}
|
|
__except( (0 == i && TRK_E_CORRUPT_LOG == GetExceptionCode())
|
|
? EXCEPTION_EXECUTE_HANDLER
|
|
: EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
BreakIfRequested();
|
|
|
|
// Get rid of the corrupt file
|
|
_cLogFile.Delete();
|
|
|
|
// Loop back and try again.
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
fReopenedLog = TRUE;
|
|
}
|
|
|
|
// If we've never read in the volinfo, do so now.
|
|
|
|
if( !_fVolInfoInitialized )
|
|
{
|
|
LoadVolInfo();
|
|
_fVolInfoInitialized = TRUE;
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("VolId (from log file) for %c: is %s"),
|
|
VolChar(_iVol), (const TCHAR*)CDebugString(_volinfo.volid) ));
|
|
}
|
|
|
|
|
|
|
|
|
|
if( fReopenedLog )
|
|
{
|
|
// Reconcile our volinfo with the log.
|
|
// BUGBUG (removable media): We haven't re-read the volinfo out of the log, we're still
|
|
// using what we already had in memory. This won't work for removeable
|
|
// media, so we need to add some extra checking here.
|
|
|
|
VolumeSanityCheck();
|
|
|
|
// Start the move notify timer; we may have been trying to send
|
|
// notifies when we discovered that the volume handles were bad.
|
|
|
|
g_ptrkwks->OnEntriesAvailable();
|
|
}
|
|
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Volume %c open"), VolChar(_iVol)));
|
|
fHandlesOpen = TRUE;
|
|
}
|
|
__finally
|
|
{
|
|
// __try
|
|
{
|
|
// We either open everything, or open nothing
|
|
if( AbnormalTermination() )
|
|
{
|
|
CloseVolumeHandles();
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer(); // Try again later
|
|
}
|
|
}
|
|
// __finally
|
|
{
|
|
if( fHandlesLocked )
|
|
UnlockHandles();
|
|
|
|
Unlock();
|
|
}
|
|
}
|
|
|
|
return( fHandlesOpen );
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::CloseAndReopenVolumeHandles
|
|
//
|
|
// One or more of the handles maintained on the volume are bad (for example,
|
|
// the handle may have been broken by a dismount). Close all of them, and
|
|
// attempt to reopen new ones.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::CloseAndReopenVolumeHandles()
|
|
{
|
|
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
// There's the remote possibility that the ReopenVolumeHandles
|
|
// call below will call this routine. Just to be paranoid, we
|
|
// add protection against an infinite recursion.
|
|
|
|
if( _fCloseAndReopenVolumeHandles )
|
|
TrkRaiseWin32Error( ERROR_OPEN_FAILED );
|
|
_fCloseAndReopenVolumeHandles = TRUE;
|
|
|
|
// Close then reopen the handles
|
|
|
|
CloseVolumeHandles();
|
|
ReopenVolumeHandles();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog((TRKDBG_VOLUME, TEXT("Immediate reopen of volume handle failed, set the reopen timer")));
|
|
g_ptrkwks->SetReopenVolumeHandlesTimer();
|
|
}
|
|
|
|
_fCloseAndReopenVolumeHandles = FALSE;
|
|
Unlock();
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CVolume::PrepareToReopenVolumeHandles
|
|
//
|
|
// The handles to the volume were closed at some point, but they may now
|
|
// be reopened. Call CVolumeManager::OnVolumeToBeReopened, so that it can
|
|
// call us in ReopenVolumeHandles on a worker thread (right now we're on
|
|
// the services handler thread, which is shared by all of services.exe).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CVolume::PrepareToReopenVolumeHandles( HDEVNOTIFY hdnVolume, EHandleChangeReason eHandleChangeReason )
|
|
{
|
|
// It is important that this method does not take any lock.
|
|
// This method is called during the volume unlock notification
|
|
// that we receive in CTrkWksSvc::ServiceHandler, and we can
|
|
// never allow that thread to hang.
|
|
// Fortunately, the flags touched in this routine are only
|
|
// touched in a single-threaded manner, because they're only
|
|
// touched as a result of a message from the service controller,
|
|
// for which there's a single thread in the process.
|
|
|
|
__try
|
|
{
|
|
if( _hdnVolumeLock == hdnVolume )
|
|
{
|
|
if( VOLUME_LOCK_CHANGE == eHandleChangeReason )
|
|
_fVolumeLocked = FALSE;
|
|
else if( VOLUME_MOUNT_CHANGE == eHandleChangeReason )
|
|
_fVolumeDismounted = FALSE;
|
|
|
|
if( !_fVolumeLocked && !_fVolumeDismounted )
|
|
{
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("Volume %c: is to be reopened"), VolChar(_iVol) ));
|
|
_pVolMgr->OnVolumeToBeReopened();
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|