void
CNdasServiceStringConfig::Set(
NDASSVC_CONFIG_STRING_TYPE Type,
LPCTSTR Value)
{
SIZE_T i = (SIZE_T) Type;
XTLASSERT(i < DEF_SIZE);
if (i >= DEF_SIZE) return;
WriteLock();
LPCTSTR RegValueName = NSCONFIG_STRING_DEF[i].RegValueName;
BOOL fSuccess = _NdasSystemCfg.SetValueEx(
SubContainer,
RegValueName,
Value);
XTLASSERT(fSuccess);
HRESULT hr = ::StringCchCopyN(
m_data[i], MAX_STRING_VALUE_LEN,
Value, MAX_STRING_VALUE_LEN);
if (!m_cached[i])
{
m_cached[i] = true;
}
WriteUnlock();
return;
}
BOOL
CNdasUnitDevice::GetHostUsageCount(
LPDWORD lpnROHosts,
LPDWORD lpnRWHosts,
BOOL fUpdate)
{
InstanceAutoLock autolock(this);
XTLASSERT(!IsBadWritePtr(lpnROHosts, sizeof(DWORD)));
XTLASSERT(!IsBadWritePtr(lpnRWHosts, sizeof(DWORD)));
CNdasDevicePtr pParentDevice(m_pParentDevice);
if (fUpdate)
{
BOOL fSuccess = pParentDevice->UpdateStats();
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Update device status failed, error=0x%X\n", GetLastError());
return FALSE;
}
}
const NDAS_DEVICE_STAT& dstat = pParentDevice->GetStats();
*lpnROHosts = dstat.UnitDevices[m_unitDeviceId.UnitNo].ROHostCount;
*lpnRWHosts = dstat.UnitDevices[m_unitDeviceId.UnitNo].RWHostCount;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_INFORMATION,
"Host Usage Count: RO=%d, RW=%d.\n",
*lpnROHosts, *lpnRWHosts);
return TRUE;
}
void
CNdasServiceBoolConfig::Set(
NDASSVC_CONFIG_BOOL_TYPE Type,
BOOL Value)
{
SIZE_T i = (SIZE_T) Type;
XTLASSERT(i < DEF_SIZE);
if (i >= DEF_SIZE) return;
WriteLock();
LPCTSTR RegValueName = NSCONFIG_BOOL_DEF[i].RegValueName;
BOOL fSuccess = _NdasSystemCfg.SetValueEx(
SubContainer,
RegValueName,
Value);
XTLASSERT(fSuccess);
m_data[i] = Value;
if (!m_cached[i])
{
m_cached[i] = true;
}
WriteUnlock();
return;
}
STDMETHODIMP
CNdasLogicalUnitManager::UnregisterNdasLocation(
NDAS_LOCATION location,
INdasLogicalUnit* pNdasLogicalUnit)
{
CAutoLock autolock(this);
XTLTRACE2(NDASSVC_NDASLOGDEVMANAGER, TRACE_LEVEL_INFORMATION,
"Unregistering NdasLocation, slot=%d\n",
location);
LocationMap::iterator itr = m_NdasLocationMap.find(location);
XTLASSERT(m_NdasLocationMap.end() != itr);
if (m_NdasLocationMap.end() == itr)
{
XTLTRACE2(NDASSVC_NDASLOGDEVMANAGER, TRACE_LEVEL_ERROR,
"NdasLocation not registered, slot=%d",
location);
return E_FAIL;
}
XTLASSERT(itr->second == pNdasLogicalUnit);
m_NdasLocationMap.erase(itr);
return S_OK;
}
BOOL GetLocalLpxAddressList(
IN SOCKET s,
IN DWORD cbBuffer,
OUT LPSOCKET_ADDRESS_LIST lpBuffer,
OUT LPDWORD pcbBytesReturned)
{
XTLASSERT(INVALID_SOCKET != s);
XTLASSERT(!IsBadWritePtr(lpBuffer, cbBuffer));
INT iError = WSAIoctl(
s,
SIO_ADDRESS_LIST_QUERY,
NULL,
0,
lpBuffer,
cbBuffer,
pcbBytesReturned,
NULL,
NULL);
if (iError != 0) {
XTLTRACE2(NDASSVC_LPXCOMM, TRACE_LEVEL_ERROR,
"SIO_ADDRESS_LIST_QUERY failed, error=0x%X\n", GetLastError());
return FALSE;
}
return TRUE;
}
DWORD
CNdasAutoRegister::ThreadStart(HANDLE hStopEvent)
{
CCoInitialize coinit(COINIT_MULTITHREADED);
XTLASSERT(!m_hSemQueue.IsInvalid() && "Don't forget to call initialize().");
// Queue Semaphore, Terminating Thread, Pipe Instances(MAX...)
HANDLE hWaitHandles[2] = { hStopEvent, m_hSemQueue };
CNdasDeviceHeartbeatListener& listener = pGetNdasDeviceHeartbeatListener();
COMVERIFY(listener.Advise(this));
do
{
DWORD waitResult = ::WaitForMultipleObjects(
RTL_NUMBER_OF(hWaitHandles),
hWaitHandles,
FALSE, INFINITE);
if (WAIT_OBJECT_0 == waitResult)
{
break;
}
else if (WAIT_OBJECT_0 + 1 == waitResult)
{
while (TRUE)
{
m_queueLock.LockInstance();
if (m_queue.empty())
{
m_queueLock.UnlockInstance();
break;
}
QUEUE_ENTRY entry = m_queue.front();
m_queue.pop();
m_queueLock.UnlockInstance();
(VOID) ProcessRegister(entry.deviceID, entry.access);
}
}
else
{
XTLASSERT(FALSE);
// ERROR
}
} while (TRUE);
COMVERIFY(listener.Unadvise(this));
return 0;
}
DWORD
CNdasIXBcast::ThreadStart(HANDLE hStopEvent)
{
if (0 == m_NDFSVersion.wMajor && 0 == m_NDFSVersion.wMinor)
{
return 1;
}
HANDLE waitHandles[] = {
hStopEvent,
m_sockAddrChangeNotifier.GetChangeEvent()};
const DWORD nWaitHandles = RTL_NUMBER_OF(waitHandles);
// CTask::Initialized called?
XTLASSERT(NULL != waitHandles[0]);
// m_sockAddrChangeNotifier is initialized?
XTLASSERT(NULL != waitHandles[1]);
//
// Initial bind
//
ResetBind(hStopEvent);
//
// initial LPX socket address list is attained
//
DWORD dwTimeout = 1000; // broadcast interval
while (TRUE)
{
DWORD waitResult = ::WaitForMultipleObjects(
nWaitHandles, waitHandles, FALSE, dwTimeout);
if (WAIT_OBJECT_0 == waitResult)
{
return 0;
}
else if (WAIT_OBJECT_0 + 1 == waitResult)
{
// reset bind
ResetBind(hStopEvent);
}
else if (WAIT_TIMEOUT == waitResult)
{
BroadcastStatus();
}
else
{
XTLTRACE2(NDASSVC_IX, TRACE_LEVEL_ERROR,
"WaitForMultipleObject failed, waitResult=%d.\n", waitResult);
XTLASSERT(FALSE);
}
}
}
static
VOID
pGetOSVersion(LPDWORD lpdwMajorVersion, LPDWORD lpdwMinorVersion)
{
XTLASSERT(!IsBadWritePtr(lpdwMajorVersion, sizeof(DWORD)));
XTLASSERT(!IsBadWritePtr(lpdwMinorVersion, sizeof(DWORD)));
OSVERSIONINFOEX osvi;
::ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
BOOL fSuccess = ::GetVersionEx((OSVERSIONINFO*) &osvi);
_ASSERT(fSuccess);
*lpdwMajorVersion = osvi.dwMajorVersion;
*lpdwMinorVersion = osvi.dwMinorVersion;
}
BOOL
CNdasDeviceComm::GetUnitDeviceInformation(PNDAS_UNITDEVICE_HARDWARE_INFO pUnitDevInfo)
{
XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected");
XTLASSERT(pUnitDevInfo != NULL);
BOOL fSuccess = NdasCommGetUnitDeviceHardwareInfo(m_hNdas, pUnitDevInfo);
if (!fSuccess)
{
DBGPRT_ERR_EX(_FT("NdasCommGetUnitDeviceInfo failed: "));
return FALSE;
}
return TRUE;
}
DWORD
CNdasNullUnitDevice::
GetLDSequence() const
{
XTLASSERT(FALSE);
return 0;
}
NDASVOL_LINKAGE
HRESULT
NDASVOL_CALL
NdasIsNdasPathA(
IN LPCSTR FilePath)
{
if (IsBadStringPtrA(FilePath, UINT_PTR(-1)))
{
XTLTRACE2(NdasVolTrace, TRACE_LEVEL_ERROR,
"Invalid path, path=%hs\n", FilePath);
return E_INVALIDARG;
}
XTLTRACE2(NdasVolTrace, 4, "NdasIsNdasPathA(%hs)\n", FilePath);
int nChars = MultiByteToWideChar(CP_ACP, 0, FilePath, -1, NULL, 0);
++nChars; // additional terminating NULL char
XTL::AutoProcessHeapPtr<WCHAR> wszFilePath = reinterpret_cast<LPWSTR>(
::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, nChars * sizeof(WCHAR)));
if (wszFilePath.IsInvalid())
{
return E_OUTOFMEMORY;
}
nChars = MultiByteToWideChar(CP_ACP, 0, FilePath, -1, wszFilePath, nChars);
XTLASSERT(nChars > 0);
return NdasIsNdasPathW(wszFilePath);
}
BOOL
CNdasUnitDeviceCreator::IsConsistentDIB(
CONST NDAS_DIB_V2* pDIBv2)
{
XTLASSERT(!IsBadReadPtr(pDIBv2, sizeof(NDAS_DIB_V2)));
BOOL bConsistent = FALSE;
const NDAS_DEVICE_ID& deviceID = m_pDevice->GetDeviceId();
const DWORD unitNo = m_dwUnitNo;
for (DWORD i = 0; i < pDIBv2->nDiskCount + pDIBv2->nSpareCount && i < NDAS_MAX_UNITS_IN_V2; ++i)
{
C_ASSERT(
sizeof(deviceID.Node) ==
sizeof(pDIBv2->UnitDisks[i].MACAddr));
if (0 == memcmp(
deviceID.Node,
pDIBv2->UnitDisks[i].MACAddr,
sizeof(deviceID.Node)) &&
unitNo == pDIBv2->UnitDisks[i].UnitNumber)
{
bConsistent = TRUE;
}
}
return bConsistent;
}
DWORD
CNdasCommandServer::CommandProcessStart(HANDLE hStopEvent)
{
// 'Param' should be a copy of the 'Param' supplied by the caller
// If the initiating thread has been abandoned already, Param will
// be invalidated if it is an automatic object.
// increment the work item count or
// check if stop event is signaled already
HANDLE waitHandles[] = {hStopEvent, m_hProcSemaphore};
const DWORD nWaitHandles = RTL_NUMBER_OF(waitHandles);
DWORD waitResult = ::WaitForMultipleObjects(nWaitHandles, waitHandles, FALSE, INFINITE);
if (WAIT_OBJECT_0 == waitResult)
{
return 0xFFFFFFFF; // stopped without actually starting a work
}
else if (WAIT_OBJECT_0 + 1 == waitResult)
{
// incremented work item count
// execute the actual work item
DWORD ret = ServiceCommand(hStopEvent);
// decrement the work item count
XTLVERIFY( ::ReleaseSemaphore(m_hProcSemaphore, 1, NULL) );
return ret;
}
else
{
XTLASSERT(FALSE);
return 0x0000FFFF;
}
}
const NDAS_LOGICALDEVICE_GROUP&
CNdasNullUnitDevice::
GetLDGroup() const
{
XTLASSERT(FALSE);
return NDAS_LOGICALDEVICE_GROUP_NONE;
}
ACCESS_MASK
CNdasNullUnitDevice::
GetAllowingAccess()
{
XTLASSERT(FALSE && "Null unit device do not have this property");
return 0;
}
LPCGUID
pGetNdasHostGuid()
{
static LPGUID pHostGuid = NULL;
static GUID hostGuid;
if (NULL != pHostGuid)
{
return pHostGuid;
}
BOOL fSuccess = _NdasSystemCfg.GetValueEx(
_T("Host"),
_T("HostID"),
&hostGuid,
sizeof(GUID));
if (!fSuccess) {
HRESULT hr = ::CoCreateGuid(&hostGuid);
XTLASSERT(SUCCEEDED(hr));
fSuccess = _NdasSystemCfg.SetValueEx(
_T("Host"),
_T("HostID"),
REG_BINARY,
&hostGuid,
sizeof(GUID));
}
pHostGuid = &hostGuid;
return pHostGuid;
}
void
CNdasServiceDeviceEventHandler::
OnDeviceArrival(
PDEV_BROADCAST_HDR pdbhdr)
{
XTLASSERT(m_bInitialized);
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_INFORMATION,
"OnDeviceArrival: Type %x\n", pdbhdr->dbch_devicetype);
if (DBT_DEVTYP_DEVICEINTERFACE == pdbhdr->dbch_devicetype)
{
PDEV_BROADCAST_DEVICEINTERFACE pdbcc =
reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE>(pdbhdr);
if (::IsEqualGUID(GUID_DEVINTERFACE_STORAGEPORT, pdbcc->dbcc_classguid))
{
OnStoragePortDeviceInterfaceArrival(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_VOLUME, pdbcc->dbcc_classguid))
{
OnVolumeDeviceInterfaceArrival(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_DISK, pdbcc->dbcc_classguid))
{
OnDiskDeviceInterfaceArrival(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_CDROM, pdbcc->dbcc_classguid))
{
OnCdRomDeviceInterfaceArrival(pdbcc);
}
}
}
DWORD
pReadMaxRequestBlockLimitConfig(DWORD hardwareVersion)
{
const LPCTSTR MAX_REQUEST_BLOCK_LIMIT_KEY = _T("MaxRequestBlockLimit");
const DWORD MAX_REQUEST_BLOCK_LIMIT_DEFAULT = 128;
BOOL fSuccess;
DWORD dwMaxRequestBlockLimit;
TCHAR szMaxRequestBlockLimitKey[64];
HRESULT hr = ::StringCchPrintf(
szMaxRequestBlockLimitKey,
RTL_NUMBER_OF(szMaxRequestBlockLimitKey),
_T("%s.%d"),
MAX_REQUEST_BLOCK_LIMIT_KEY,
hardwareVersion);
XTLASSERT(SUCCEEDED(hr));
fSuccess = _NdasSystemCfg.GetValueEx(
_T("ndassvc"),
szMaxRequestBlockLimitKey,
&dwMaxRequestBlockLimit);
if (!fSuccess || 0 == dwMaxRequestBlockLimit)
{
// MaxRequestBlockLimit.{Version} is not specified
// Locate MaxRequestBlockLimit
fSuccess = _NdasSystemCfg.GetValueEx(
_T("ndassvc"),
MAX_REQUEST_BLOCK_LIMIT_KEY,
&dwMaxRequestBlockLimit);
if (!fSuccess || 0 == dwMaxRequestBlockLimit)
{
dwMaxRequestBlockLimit = MAX_REQUEST_BLOCK_LIMIT_DEFAULT;
}
}
return dwMaxRequestBlockLimit;
}
UINT64
CNdasNullUnitDevice::
GetPhysicalBlockCount()
{
XTLASSERT(FALSE && "Null unit device do not have this property");
return 0;
}
STDMETHODIMP
CNdasUnitImpl::get_HardwareInfo(__out PNDAS_UNITDEVICE_HARDWARE_INFO HardwareInfo)
{
XTLASSERT(!IsBadWritePtr(HardwareInfo, sizeof(NDAS_UNITDEVICE_HARDWARE_INFO)));
CAutoInstanceLock autolock(this);
CopyMemory(HardwareInfo, &m_udinfo, sizeof(NDAS_UNITDEVICE_HARDWARE_INFO));
return S_OK;
}
CNdasDeviceComm::~CNdasDeviceComm()
{
if (m_hNdas)
{
BOOL fSuccess = Disconnect();
XTLASSERT(fSuccess && "Disconnect should succeed");
}
}
HRESULT
CNdasDeviceComm::GetNdasUnitInfo(PNDAS_UNITDEVICE_HARDWARE_INFO pUnitDevInfo)
{
XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected");
XTLASSERT(pUnitDevInfo != NULL);
BOOL success = NdasCommGetUnitDeviceHardwareInfo(m_hNdas, pUnitDevInfo);
if (!success)
{
HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
XTLTRACE2(NDASSVC_NDASCOMM, TRACE_LEVEL_ERROR,
"NdasCommGetUnitDeviceHardwareInfo failed, hr=0x%X\n", hr);
return hr;
}
return S_OK;
}
void
CNdasServiceDeviceEventHandler::
OnDeviceRemoveComplete(
PDEV_BROADCAST_HDR pdbhdr)
{
XTLASSERT(m_bInitialized);
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_INFORMATION,
"OnDeviceRemoveComplete: Type %x\n", pdbhdr->dbch_devicetype);
//
// RemoveComplete events are reported to
// both Device Interface and Device Handle
//
// We prefer to handling them in Device Handle
//
if (DBT_DEVTYP_DEVICEINTERFACE == pdbhdr->dbch_devicetype)
{
PDEV_BROADCAST_DEVICEINTERFACE pdbcc =
reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE>(pdbhdr);
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_INFORMATION,
"OnDeviceRemoveComplete : Interface %ls\n",
ximeta::CGuid(&pdbcc->dbcc_classguid).ToString());
if (::IsEqualGUID(GUID_DEVINTERFACE_STORAGEPORT, pdbcc->dbcc_classguid))
{
OnStoragePortDeviceInterfaceRemoveComplete(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_VOLUME, pdbcc->dbcc_classguid))
{
OnVolumeDeviceInterfaceRemoveComplete(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_DISK, pdbcc->dbcc_classguid))
{
OnDiskDeviceInterfaceRemoveComplete(pdbcc);
}
else if (::IsEqualGUID(GUID_DEVINTERFACE_CDROM, pdbcc->dbcc_classguid))
{
OnCdRomDeviceInterfaceRemoveComplete(pdbcc);
}
}
else if (DBT_DEVTYP_HANDLE == pdbhdr->dbch_devicetype)
{
PDEV_BROADCAST_HANDLE pdbch =
reinterpret_cast<PDEV_BROADCAST_HANDLE>(pdbhdr);
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_INFORMATION,
"OnDeviceRemoveComplete: Handle %p, Notify Handle %p\n",
pdbch->dbch_handle, pdbch->dbch_hdevnotify);
OnDeviceHandleRemoveComplete(pdbch);
}
// TODO: Set Logical Device Status (LDS_UNMOUNTED)
}
CNdasService*
CNdasService::CreateInstance()
{
WSADATA wsaData;
XTLVERIFY(SOCKET_ERROR != WSAStartup(MAKEWORD(2,2),&wsaData) );
XTLASSERT(NULL == CNdasService::instance);
CNdasService::instance = new CNdasService();
return CNdasService::instance;
}
void
CNdasUnitDevice::GetHardwareInfo(PNDAS_UNITDEVICE_HARDWARE_INFO pudinfo)
{
XTLASSERT(!IsBadWritePtr(pudinfo, sizeof(NDAS_UNITDEVICE_HARDWARE_INFO)));
{
InstanceAutoLock autolock(this);
::CopyMemory(pudinfo, &m_udinfo, sizeof(NDAS_UNITDEVICE_HARDWARE_INFO));
}
}
STDMETHODIMP
CNdasUnitImpl::GetHostUsageCount (
LPDWORD lpnROHosts,
LPDWORD lpnRWHosts,
BOOL fUpdate
)
{
XTLASSERT(!IsBadWritePtr(lpnROHosts, sizeof(DWORD)));
XTLASSERT(!IsBadWritePtr(lpnRWHosts, sizeof(DWORD)));
CComPtr<INdasDevice> pNdasDevice = m_pParentNdasDevice;
if (fUpdate) {
HRESULT hr = pNdasDevice->UpdateStats();
if (FAILED(hr)) {
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Update device status failed, hr=0x%X\n", hr);
return hr;
}
}
NDAS_DEVICE_STAT dstat;
HRESULT hr = pNdasDevice->get_DeviceStat(&dstat);
if (FAILED(hr)) {
return hr;
}
*lpnROHosts = dstat.UnitDevices[m_unitDeviceId.UnitNo].RoHostCount;
*lpnRWHosts = dstat.UnitDevices[m_unitDeviceId.UnitNo].RwHostCount;
NdasUiDbgCall( 2, "Host Usage Count: RO=%d, RW=%d.\n", *lpnROHosts, *lpnRWHosts );
ATLASSERT( *lpnRWHosts != NDAS_HOST_COUNT_UNKNOWN );
ATLASSERT( *lpnRWHosts != NDAS_HOST_COUNT_UNKNOWN );
return S_OK;
}
BOOL
CNdasDeviceComm::ReadDiskBlock(PBYTE pBlockBuffer, INT64 i64DiskBlock, INT32 i32BlockSize)
{
XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected");
XTLASSERT(pBlockBuffer != NULL);
XTLASSERT(i32BlockSize >= 1 && i32BlockSize <= 128);
XTLASSERT(!::IsBadWritePtr(pBlockBuffer, i32BlockSize * 512));
BOOL fSuccess = NdasCommBlockDeviceRead(
m_hNdas, i64DiskBlock, i32BlockSize, pBlockBuffer);
if (!fSuccess)
{
DBGPRT_ERR_EX(_FT("NdasCommBlockDeviceRead failed: "));
return FALSE;
}
return TRUE;
}
CNdasHostInfoCache*
pGetNdasHostInfoCache()
{
static CNdasHostInfoCache* phi = NULL;
if (NULL != phi) {
return phi;
}
phi = new CNdasHostInfoCache();
XTLASSERT(NULL != phi);
return phi;
}
BOOL
CNdasDeviceComm::GetDiskInfoBlock(PNDAS_DIB pDiskInfoBlock)
{
XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected");
XTLASSERT(pDiskInfoBlock != NULL && "INVALID PARAMETER");
//
// Read Last Sector for NDAS_UNITDISK_INFORMATION_BLOCK
//
BOOL fSuccess = NdasCommBlockDeviceRead(
m_hNdas, -1, 1,
reinterpret_cast<LPBYTE>(pDiskInfoBlock));
if (!fSuccess)
{
DBGPRT_ERR_EX(_FT("NdasCommBlockDeviceRead failed: "));
return FALSE;
}
return TRUE;
}
void
CNdasEventMonitor::OnLogicalDeviceAlarmedByPnP(
__in INdasLogicalUnit* pNdasLogicalUnit,
__in ULONG NewAdapterStatus)
{
NDAS_LOCATION ndasLocation;
COMVERIFY(pNdasLogicalUnit->get_Id(&ndasLocation));
XTLTRACE2(NDASSVC_EVENTMON, TRACE_LEVEL_INFORMATION,
"Alarm Event, ndasLocation=%08X, logicalUnit=%p\n",
ndasLocation, pNdasLogicalUnit);
if (0 == ndasLocation)
{
XTLTRACE2(NDASSVC_EVENTMON, TRACE_LEVEL_ERROR,
"Invalid SCSI Location\n");
XTLASSERT(FALSE);
return;
}
XTLTRACE2(NDASSVC_EVENTMON, TRACE_LEVEL_INFORMATION,
"Logical device alarmed by PnP, ndasLocation=%08X, adapterStatus=%08X.\n",
ndasLocation, NewAdapterStatus);
// Determine whether an alarm will be issued.
// Only viable alarm will be published
ULONG currentAdapterStatus;
COMVERIFY(pNdasLogicalUnit->get_AdapterStatus(¤tAdapterStatus));
if (pIsViableAlarmStatus(currentAdapterStatus, NewAdapterStatus))
{
CNdasEventPublisher& epub = pGetNdasEventPublisher();
if (ADAPTERINFO_ISSTATUS(NewAdapterStatus, NDASSCSI_ADAPTER_STATUS_STOPPED) &&
ADAPTERINFO_ISSTATUSFLAG(NewAdapterStatus, NDAS_DEVICE_ALARM_STATUSFLAG_ABNORMAL_TERMINAT))
{
//
// Notify abnormal removal of the LU device.
//
OnLogicalDeviceDisconnected(pNdasLogicalUnit);
}
else
{
NDAS_LOGICALDEVICE_ID logicalUnitId;
COMVERIFY(pNdasLogicalUnit->get_Id(&logicalUnitId));
(void) epub.LogicalDeviceAlarmed(
logicalUnitId,
pGetSignificantAlarm(currentAdapterStatus, NewAdapterStatus));
}
}
COMVERIFY(pNdasLogicalUnit->put_AdapterStatus(NewAdapterStatus));
}
