STDMETHODIMP CNdasUnitImpl::CheckNdasfsCompatibility() { CAutoInstanceLock autolock(this); HRESULT hr; // Unit devices other than disks are not allowed for NDFS if (m_type != NDAS_UNITDEVICE_TYPE_DISK) { return E_FAIL; } // LfsFilter compatibility check. // NDFS Major version should be same WORD wHostNDFSVerMajor; BOOL success = ::LfsFiltCtlGetVersion( NULL, NULL, NULL, NULL, &wHostNDFSVerMajor, NULL ); if (!success) { ATLASSERT(FALSE); hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; return hr; } ATLASSERT( wHostNDFSVerMajor == 0x0006 ); // Primary Host Info is valid for 30 seconds #if 0 DWORD dwMaxTickAllowance = 30 * 1000; if (0 != m_PrimaryHostInfo.NDFSCompatVersion && ::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance) { // primary host info is valid return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion); } #endif // No Primary Host Info is available (IX) // Use HIX to discover CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); success = hixdisc.Initialize(); if (!success) { ATLASSERT(FALSE); hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; return hr; } NDAS_UNITDEVICE_ID ndasUnitId; get_NdasUnitId( &ndasUnitId ); ATLASSERT( ndasUnitId.DeviceId.Reserved == 0 ); DWORD timeout = NdasServiceConfig::Get(nscWriteShareCheckTimeout); success = hixdisc.HixDiscover( ndasUnitId, NHIX_UDA_SHRW_PRIM, 1, timeout ); if (!success) { ATLASSERT(FALSE); hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "hixdisc.Discover failed, hr=0x%X\n", hr); return hr; } DWORD nHosts = hixdisc.GetHostCount(ndasUnitId); if (nHosts == 0) { hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostCount failed, hr=0x%X\n", hr); return hr; } GUID hostGuid; success = hixdisc.GetHostData( ndasUnitId, 0, NULL, &hostGuid, NULL, NULL ); if (!success) { ATLASSERT(FALSE); hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostData failed, hr=0x%X\n", hr); return hr; } CNdasHostInfoCache* phic = pGetNdasHostInfoCache(); XTLASSERT(phic); // phic is not null (by pGetNdasHostInfoCache) const NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid); if (pHostInfo == NULL) { ATLASSERT(FALSE); hr = HRESULT_FROM_WIN32(GetLastError()); hr = SUCCEEDED(hr) ? E_FAIL : hr; XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostInfo failed, hr=0x%X\n", hr); return hr; } // ReservedVerInfo contains NDFS Version Information if (pHostInfo->ReservedVerInfo.VersionMajor != wHostNDFSVerMajor) { NdasUiDbgCall( 1, "Host NDFS %d, Primary NDFS %d failed\n", wHostNDFSVerMajor, pHostInfo->ReservedVerInfo.VersionMajor ); return E_FAIL; } // Primary and this host's NDFS compatible version is same return S_OK; }
STDMETHODIMP CNdasUnitImpl::GetActualHostUsageCount ( LPDWORD lpnROHosts, LPDWORD lpnRWHosts, BOOL bUpdate ) { DWORD nROHosts = 0; DWORD nRWHosts = 0; HRESULT hr = GetHostUsageCount( &nROHosts, &nRWHosts, bUpdate ); if (FAILED(hr)) { return hr; } // Following cases does not need further consideration // - RW = 0, RO any // - RW = 1, RO = 0 // Neither RO or RW is not NDAS_HOST_COUNT_UNKNOWN // Otherwise, we need HIX to discover the actual count if (nRWHosts != NDAS_HOST_COUNT_UNKNOWN && nROHosts == 0) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return S_OK; } DWORD nHosts = (NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts) ? NDAS_MAX_CONNECTION_V11 : nROHosts + nRWHosts; NDAS_UNITDEVICE_ID unitDeviceId; hr = get_NdasUnitId(&unitDeviceId); if (FAILED(hr)) { return hr; } CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); BOOL success = hixdisc.Initialize(); if (!success) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return S_OK; } success = hixdisc.HixDiscover( unitDeviceId, NHIX_UDA_READ_ACCESS, // read bit is set - all hosts nHosts, 2000 ); if (!success) { ATLASSERT(FALSE); *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return S_OK; } if (nRWHosts == NDAS_HOST_COUNT_UNKNOWN || nROHosts == NDAS_HOST_COUNT_UNKNOWN) { DWORD rawROHosts = nROHosts; DWORD rawRWHosts = nRWHosts; // If any host count is unknown, use HIX counter only nROHosts = 0; nRWHosts = 0; DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId); for (DWORD i = 0; i < nRepliedHosts; ++i) { NHIX_UDA uda = 0; success = hixdisc.GetHostData(unitDeviceId,i,&uda); XTLASSERT(success); // index must be valid! if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS || uda == NHIX_UDA_SHARED_READ_WRITE_PRIMARY_ACCESS || uda == NHIX_UDA_READ_WRITE_ACCESS) { ++nRWHosts; } else if (uda == NHIX_UDA_READ_ACCESS) { ++nROHosts; } else { ATLASSERT(FALSE); XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING, "Invalid uda=0x%08X\n", uda); } } // If HIX counter is not available either, we should at least show // the original counter. if (rawRWHosts != NDAS_HOST_COUNT_UNKNOWN && rawRWHosts > nRWHosts) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING, "RWHost adjusted to Raw=%d from HIX=%d\n", rawRWHosts, nRWHosts); nRWHosts = rawRWHosts; } } else { // Otherwise, use SharedRW counter DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId); for (DWORD i = 0; i < nRepliedHosts; ++i) { NHIX_UDA uda = 0; success = hixdisc.GetHostData(unitDeviceId,i,&uda); XTLASSERT(success); // index must be valid! if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS) { --nROHosts; ++nRWHosts; } } } *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; ATLASSERT( *lpnRWHosts != NDAS_HOST_COUNT_UNKNOWN && *lpnROHosts != NDAS_HOST_COUNT_UNKNOWN ); NdasUiDbgCall( 2, "Actual Host Usage Count: RO=%d, RW=%d.\n", *lpnROHosts, *lpnRWHosts ); return S_OK; }
BOOL CNdasUnitDevice::CheckNDFSCompatibility() { ximeta::CAutoLock autolock(this); // // Unit devices other than disks are not allowed for NDFS // if (m_type != NDAS_UNITDEVICE_TYPE_DISK) { return FALSE; } // // LfsFilter compatibility check. // NDFS Major version should be same // WORD wHostNDFSVerMajor; BOOL fSuccess = ::LfsFiltCtlGetVersion( NULL, NULL, NULL, NULL, &wHostNDFSVerMajor, NULL); if (!fSuccess) { DBGPRT_ERR_EX(_FT("Getting LFS Filter Version failed:")); return FALSE; } // // Primary Host Info is valid for 30 seconds // DWORD dwMaxTickAllowance = 30 * 1000; if (0 != m_PrimaryHostInfo.NDFSCompatVersion && ::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance) { // primary host info is valid return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion); } // // No Primary Host Info is available (IX) // Use HIX to discover // CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); fSuccess = hixdisc.Initialize(); if (!fSuccess) { DBGPRT_ERR_EX(_FT("HIXDiscover init failed: ")); return FALSE; } NDAS_UNITDEVICE_ID udid = GetUnitDeviceId(); hixdisc.Discover(udid,NHIX_UDA_SHRW_PRIM,1,1000); DWORD nHosts = hixdisc.GetHostCount(udid); if (0 == nHosts) { DBGPRT_ERR_EX(_FT("GetHostCount failed: ")); return FALSE; } GUID hostGuid; fSuccess = hixdisc.GetHostData(udid,0,NULL,&hostGuid,NULL,NULL); if (!fSuccess) { DBGPRT_ERR_EX(_FT("GetHostData failed: ")); return FALSE; } CNdasHostInfoCache* phic = pGetNdasHostInfoCache(); _ASSERTE(phic); // phic is not null (by pGetNdasHostInfoCache) CONST NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid); if (NULL == pHostInfo) { DBGPRT_ERR_EX(_FT("GetHostInfo failed: ")); return FALSE; } if (pHostInfo->NDASSWVerInfo.VersionMajor != wHostNDFSVerMajor) { DBGPRT_ERR(_FT("Host NDFS %d, Primary NDFS %d failed: "), wHostNDFSVerMajor, pHostInfo->NDASSWVerInfo.VersionMajor); return FALSE; } // // Primary and this host's NDFS compat version is same // return TRUE; }
BOOL CNdasUnitDevice::GetActualHostUsageCount( LPDWORD lpnROHosts, LPDWORD lpnRWHosts, BOOL bUpdate) { ximeta::CAutoLock autolock(this); DWORD nROHosts, nRWHosts; BOOL fSuccess = GetHostUsageCount(&nROHosts, &nRWHosts, bUpdate); if (!fSuccess) { return FALSE; } // // Following cases does not need further consideration // - RW = 0, RO = any // - RW = 1, RO = 0 // Otherwise, we need HIX to discover the actual count // if (nRWHosts == 0 || nROHosts == 0) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } DWORD nHosts = nROHosts + nRWHosts; NDAS_UNITDEVICE_ID unitDeviceId = GetUnitDeviceId(); CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); fSuccess = hixdisc.Initialize(); if (!fSuccess) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } fSuccess = hixdisc.Discover( unitDeviceId, NHIX_UDA_READ_ACCESS, // read bit is set - all hosts nHosts, 2000); if (!fSuccess) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId); for (DWORD i = 0; i < nRepliedHosts; ++i) { NHIX_UDA uda = 0; fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda); _ASSERTE(fSuccess); // index must be valid! if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS) { --nROHosts; ++nRWHosts; } } *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; }
BOOL CNdasUnitDevice::CheckNDFSCompatibility() { InstanceAutoLock autolock(this); // // Unit devices other than disks are not allowed for NDFS // if (m_type != NDAS_UNITDEVICE_TYPE_DISK) { return FALSE; } // // LfsFilter compatibility check. // NDFS Major version should be same // WORD wHostNDFSVerMajor; BOOL fSuccess = ::LfsFiltCtlGetVersion( NULL, NULL, NULL, NULL, &wHostNDFSVerMajor, NULL); if (!fSuccess) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "Getting LFS Filter Version failed, error=0x%X\n", GetLastError()); return FALSE; } // // Primary Host Info is valid for 30 seconds // #if 0 DWORD dwMaxTickAllowance = 30 * 1000; if (0 != m_PrimaryHostInfo.NDFSCompatVersion && ::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance) { // primary host info is valid return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion); } #endif // // No Primary Host Info is available (IX) // Use HIX to discover // CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); fSuccess = hixdisc.Initialize(); if (!fSuccess) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "HIXDiscover init failed, error=0x%X\n", GetLastError()); return FALSE; } NDAS_UNITDEVICE_ID udid = GetUnitDeviceId(); DWORD timeout = NdasServiceConfig::Get(nscWriteShareCheckTimeout); fSuccess = hixdisc.Discover(udid,NHIX_UDA_SHRW_PRIM,1,timeout); if (!fSuccess) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "hixdisc.Discover failed, error=0x%X\n", GetLastError()); return FALSE; } DWORD nHosts = hixdisc.GetHostCount(udid); if (0 == nHosts) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostCount failed, error=0x%X\n", GetLastError()); return FALSE; } GUID hostGuid; fSuccess = hixdisc.GetHostData(udid,0,NULL,&hostGuid,NULL,NULL); if (!fSuccess) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostData failed, error=0x%X\n", GetLastError()); return FALSE; } CNdasHostInfoCache* phic = pGetNdasHostInfoCache(); XTLASSERT(phic); // phic is not null (by pGetNdasHostInfoCache) const NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid); if (NULL == pHostInfo) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "GetHostInfo failed, error=0x%X\n", GetLastError()); return FALSE; } // // ReservedVerInfo contains NDFS Version Information // if (pHostInfo->ReservedVerInfo.VersionMajor != wHostNDFSVerMajor) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR, "Host NDFS %d, Primary NDFS %d failed.\n", wHostNDFSVerMajor, pHostInfo->ReservedVerInfo.VersionMajor); return FALSE; } // // Primary and this host's NDFS compatible version is same // return TRUE; }
BOOL CNdasUnitDevice::GetActualHostUsageCount( LPDWORD lpnROHosts, LPDWORD lpnRWHosts, BOOL bUpdate) { InstanceAutoLock autolock(this); DWORD nROHosts = 0; DWORD nRWHosts = 0; if (!GetHostUsageCount(&nROHosts, &nRWHosts, bUpdate)) { return FALSE; } // // Following cases does not need further consideration // - RW = 0, RO any // - RW = 1, RO = 0 // Neither RO or RW is not NDAS_HOST_COUNT_UNKNOWN // Otherwise, we need HIX to discover the actual count // if ((nRWHosts == 0 || nROHosts == 0) && (NDAS_HOST_COUNT_UNKNOWN != nRWHosts) && (NDAS_HOST_COUNT_UNKNOWN != nROHosts)) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } DWORD nHosts = (NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts) ? NDAS_MAX_CONNECTION_V11 : nROHosts + nRWHosts; NDAS_UNITDEVICE_ID unitDeviceId = GetUnitDeviceId(); // // BUG: Workaround for weird lock // We should unlock the global lock (yes, it's global lock at the moment) // for local HIX server to work! // autolock.Release(); CNdasHIXDiscover hixdisc(pGetNdasHostGuid()); BOOL fSuccess = hixdisc.Initialize(); if (!fSuccess) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } fSuccess = hixdisc.Discover( unitDeviceId, NHIX_UDA_READ_ACCESS, // read bit is set - all hosts nHosts, 2000); if (!fSuccess) { *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; return TRUE; } if (NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts) { DWORD rawROHosts = nROHosts; DWORD rawRWHosts = nRWHosts; // If any host count is unknown, use HIX counter only nROHosts = 0; nRWHosts = 0; DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId); for (DWORD i = 0; i < nRepliedHosts; ++i) { NHIX_UDA uda = 0; fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda); XTLASSERT(fSuccess); // index must be valid! if (NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS == uda || NHIX_UDA_SHARED_READ_WRITE_PRIMARY_ACCESS == uda || NHIX_UDA_READ_WRITE_ACCESS == uda) { ++nRWHosts; } else if (uda == NHIX_UDA_READ_ACCESS) { ++nROHosts; } else { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING, "Invalid uda=0x%08X\n", uda); } } // // If HIX counter is not available either, we should at least show // the original counter. // if (NDAS_HOST_COUNT_UNKNOWN != rawRWHosts && rawRWHosts > nRWHosts) { XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING, "RWHost adjusted to Raw=%d from HIX=%d\n", rawRWHosts, nRWHosts); nRWHosts = rawRWHosts; } } else { // Otherwise, use SharedRW counter DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId); for (DWORD i = 0; i < nRepliedHosts; ++i) { NHIX_UDA uda = 0; fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda); XTLASSERT(fSuccess); // index must be valid! if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS) { --nROHosts; ++nRWHosts; } } } *lpnROHosts = nROHosts; *lpnRWHosts = nRWHosts; XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_INFORMATION, "Actual Host Usage Count: RO=%d, RW=%d.\n", *lpnROHosts, *lpnRWHosts); return TRUE; }