double CAAInterpolate::LagrangeInterpolate(double X, int n, double* pX, double* pY)
{
//Validate our parameters
assert(pX);
assert(pY);
#ifdef __analysis_assume
__analysis_assume(pX);
__analysis_assume(pY);
#endif
double V = 0;
for (int i=1; i<=n; i++)
{
double C = 1;
for (int j=1; j<=n; j++)
{
if (j != i)
C = C*(X - pX[j-1]) / (pX[i-1] - pX[j-1]);
}
V += C*pY[i - 1];
}
return V;
}
OpLayoutTypeAsmJs OpCodeUtilAsmJs::GetOpCodeLayout(OpCodeAsmJs op)
{
if ((uint)op <= (uint)Js::OpCodeAsmJs::MaxByteSizedOpcodes)
{
Assert(op < _countof(OpCodeAsmJsLayouts));
__analysis_assume(op < _countof(OpCodeAsmJsLayouts));
return OpCodeAsmJsLayouts[(uint)op];
}
uint opIndex = op - (Js::OpCodeAsmJs::MaxByteSizedOpcodes + 1);
Assert(opIndex < _countof(ExtendedOpCodeAsmJsLayouts));
__analysis_assume(opIndex < _countof(ExtendedOpCodeAsmJsLayouts));
return ExtendedOpCodeAsmJsLayouts[opIndex];
}
SWITCH_DECLARE(int) switch_vasprintf(char **ret, const char *fmt, va_list ap)
{
#ifdef HAVE_VASPRINTF
return vasprintf(ret, fmt, ap);
#else
char *buf;
int len;
size_t buflen;
va_list ap2;
char *tmp = NULL;
#ifdef _MSC_VER
#if _MSC_VER >= 1500
/* hack for incorrect assumption in msvc header files for code analysis */
__analysis_assume(tmp);
#endif
ap2 = ap;
#else
va_copy(ap2, ap);
#endif
len = vsnprintf(tmp, 0, fmt, ap2);
if (len > 0 && (buf = malloc((buflen = (size_t) (len + 1)))) != NULL) {
len = vsnprintf(buf, buflen, fmt, ap);
*ret = buf;
} else {
*ret = NULL;
len = -1;
}
va_end(ap2);
return len;
#endif
}
VOID
RamDiskEvtIoWrite(
IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t Length
)
/*++
Routine Description:
This event is invoked when the framework receives IRP_MJ_WRITE request.
Arguments:
Queue - Handle to the framework queue object that is associated with the
I/O request.
Request - Handle to a framework request object.
Length - Length of the data buffer associated with the request.
The default property of the queue is to not dispatch
zero length read & write requests to the driver and
complete is with status success. So we will never get
a zero length request.
Return Value:
VOID
--*/
{
PDEVICE_EXTENSION devExt = QueueGetExtension(Queue)->DeviceExtension;
NTSTATUS Status = STATUS_INVALID_PARAMETER;
WDF_REQUEST_PARAMETERS Parameters;
LARGE_INTEGER ByteOffset;
WDFMEMORY hMemory;
__analysis_assume(Length > 0);
WDF_REQUEST_PARAMETERS_INIT(&Parameters);
WdfRequestGetParameters(Request, &Parameters);
ByteOffset.QuadPart = Parameters.Parameters.Write.DeviceOffset;
if (RamDiskCheckParameters(devExt, ByteOffset, Length)) {
Status = WdfRequestRetrieveInputMemory(Request, &hMemory);
if(NT_SUCCESS(Status)){
Status = WdfMemoryCopyToBuffer(hMemory, // Source
0, // offset in Source memory where the copy has to start
devExt->DiskImage + ByteOffset.LowPart, // destination
Length);
}
}
WdfRequestCompleteWithInformation(Request, Status, (ULONG_PTR)Length);
}
wchar_t const * OpCodeUtilAsmJs::GetOpCodeName(OpCodeAsmJs op)
{
if (op <= Js::OpCodeAsmJs::MaxByteSizedOpcodes)
{
Assert(op < _countof(OpCodeAsmJsNames));
__analysis_assume(op < _countof(OpCodeAsmJsNames));
return OpCodeAsmJsNames[(int)op];
}
else if (op < Js::OpCodeAsmJs::ByteCodeLast)
{
uint opIndex = op - (Js::OpCodeAsmJs::MaxByteSizedOpcodes + 1);
Assert(opIndex < _countof(ExtendedOpCodeAsmJsNames));
__analysis_assume(opIndex < _countof(ExtendedOpCodeAsmJsNames));
return ExtendedOpCodeAsmJsNames[opIndex];
}
return L"<NotAvail>";
}
StackSym *
LinearScanMD::EnsureSpillSymForXmmReg(RegNum reg, Func *func, IRType type)
{
Assert(REGNUM_ISXMMXREG(reg));
__analysis_assume(reg - RegXMM0 >= 0 && reg - RegXMM0 < XMM_REGCOUNT);
StackSym *sym;
if (type == TyFloat32)
{
sym = this->xmmSymTable32[reg - RegXMM0];
}
else if (type == TyFloat64)
{
sym = this->xmmSymTable64[reg - RegXMM0];
}
else
{
Assert(IRType_IsSimd128(type));
sym = this->xmmSymTable128[reg - RegXMM0];
}
if (sym == NULL)
{
sym = StackSym::New(type, func);
func->StackAllocate(sym, TySize[type]);
__analysis_assume(reg - RegXMM0 < XMM_REGCOUNT);
if (type == TyFloat32)
{
this->xmmSymTable32[reg - RegXMM0] = sym;
}
else if (type == TyFloat64)
{
this->xmmSymTable64[reg - RegXMM0] = sym;
}
else
{
Assert(IRType_IsSimd128(type));
this->xmmSymTable128[reg - RegXMM0] = sym;
}
}
return sym;
}
static VOID NTAPI
i8042KbdDpcRoutine(
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2)
{
PI8042_KEYBOARD_EXTENSION DeviceExtension;
PPORT_DEVICE_EXTENSION PortDeviceExtension;
ULONG KeysTransferred = 0;
ULONG KeysInBufferCopy;
KIRQL Irql;
UNREFERENCED_PARAMETER(Dpc);
UNREFERENCED_PARAMETER(SystemArgument1);
UNREFERENCED_PARAMETER(SystemArgument2);
__analysis_assume(DeferredContext != NULL);
DeviceExtension = DeferredContext;
PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
if (HandlePowerKeys(DeviceExtension))
{
DeviceExtension->KeyComplete = FALSE;
return;
}
i8042PacketDpc(PortDeviceExtension);
if (!DeviceExtension->KeyComplete)
return;
/* We got the interrupt as it was being enabled, too bad */
if (!PortDeviceExtension->HighestDIRQLInterrupt)
return;
Irql = KeAcquireInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt);
DeviceExtension->KeyComplete = FALSE;
KeysInBufferCopy = DeviceExtension->KeysInBuffer;
KeReleaseInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt, Irql);
TRACE_(I8042PRT, "Send a key\n");
if (!DeviceExtension->KeyboardData.ClassService)
return;
INFO_(I8042PRT, "Sending %lu key(s)\n", KeysInBufferCopy);
(*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->KeyboardData.ClassService)(
DeviceExtension->KeyboardData.ClassDeviceObject,
DeviceExtension->KeyboardBuffer,
DeviceExtension->KeyboardBuffer + KeysInBufferCopy,
&KeysTransferred);
KeAcquireInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt);
DeviceExtension->KeysInBuffer -= KeysTransferred;
KeReleaseInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt, Irql);
}
StackSym *
LinearScanMD::EnsureSpillSymForVFPReg(RegNum reg, Func *func)
{
Assert(REGNUM_ISVFPREG(reg));
__analysis_assume(reg - RegD0 < VFP_REGCOUNT);
StackSym *sym = this->vfpSymTable[reg - RegD0];
if (sym == nullptr)
{
sym = StackSym::New(TyFloat64, func);
func->StackAllocate(sym, MachRegDouble);
__analysis_assume(reg - RegD0 < VFP_REGCOUNT);
this->vfpSymTable[reg - RegD0] = sym;
}
return sym;
}
wchar_t const * OpCodeUtil::GetOpCodeName(OpCode op)
{
if (op <= Js::OpCode::MaxByteSizedOpcodes)
{
Assert((uint)op < _countof(OpCodeNames));
__analysis_assume((uint)op < _countof(OpCodeNames));
return OpCodeNames[(uint)op];
}
else if (op < Js::OpCode::ByteCodeLast)
{
uint opIndex = op - (Js::OpCode::MaxByteSizedOpcodes + 1);
Assert(opIndex < _countof(ExtendedOpCodeNames));
__analysis_assume(opIndex < _countof(ExtendedOpCodeNames));
return ExtendedOpCodeNames[opIndex];
}
uint opIndex = op - (Js::OpCode::ByteCodeLast + 1);
Assert(opIndex < _countof(BackendOpCodeNames));
__analysis_assume(opIndex < _countof(BackendOpCodeNames));
return BackendOpCodeNames[opIndex];
}
static VOID
#pragma prefast(suppress:6262) // Function uses '1036' bytes of stack: exceeds /analyze:stacksize'1024'
__Log(
IN const CHAR *Format,
IN ...
)
{
TCHAR Buffer[MAXIMUM_BUFFER_SIZE];
va_list Arguments;
size_t Length;
SP_LOG_TOKEN LogToken;
DWORD Category;
DWORD Flags;
HRESULT Result;
va_start(Arguments, Format);
Result = StringCchVPrintf(Buffer, MAXIMUM_BUFFER_SIZE, Format, Arguments);
va_end(Arguments);
if (Result != S_OK && Result != STRSAFE_E_INSUFFICIENT_BUFFER)
return;
Result = StringCchLength(Buffer, MAXIMUM_BUFFER_SIZE, &Length);
if (Result != S_OK)
return;
LogToken = SetupGetThreadLogToken();
Category = TXTLOG_VENDOR;
Flags = TXTLOG_WARNING;
SetupWriteTextLog(LogToken, Category, Flags, Buffer);
Length = __min(MAXIMUM_BUFFER_SIZE - 1, Length + 2);
__analysis_assume(Length < MAXIMUM_BUFFER_SIZE);
__analysis_assume(Length >= 2);
Buffer[Length] = '\0';
Buffer[Length - 1] = '\n';
Buffer[Length - 2] = '\r';
OutputDebugString(Buffer);
}
static NTSTATUS NTAPI
ForwardIrpAndWaitCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
{
UNREFERENCED_PARAMETER(DeviceObject);
__analysis_assume(Context != NULL);
if (Irp->PendingReturned)
KeSetEvent(Context, IO_NO_INCREMENT, FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
}
// targetAddr: target address
// targetStartAddr: target start address, some fied might reference to middle of another data chunk, like outParamOffsets
// startAddress: current data start address
// addrToFixup: address that currently pointing to dataAddr, which need to be updated
void
NativeCodeData::AddFixupEntry(void* targetAddr, void* targetStartAddr, void* addrToFixup, void* startAddress, DataChunk * chunkList)
{
Assert(addrToFixup >= startAddress);
Assert(((__int64)addrToFixup) % sizeof(void*) == 0);
if (targetAddr == nullptr)
{
return;
}
Assert(targetStartAddr);
unsigned int inDataOffset = (unsigned int)((char*)targetAddr - (char*)targetStartAddr);
DataChunk* targetChunk = NativeCodeData::GetDataChunk(targetStartAddr);
Assert(targetChunk->len >= inDataOffset);
#if DBG
bool foundTargetChunk = false;
while (chunkList)
{
foundTargetChunk |= (chunkList == targetChunk);
chunkList = chunkList->next;
}
AssertMsg(foundTargetChunk, "current pointer is not allocated with NativeCodeData allocator?"); // change to valid check instead of assertion?
#endif
DataChunk* chunk = NativeCodeData::GetDataChunk(startAddress);
NativeDataFixupEntry* entry = (NativeDataFixupEntry*)midl_user_allocate(sizeof(NativeDataFixupEntry));
if (!entry)
{
Js::Throw::OutOfMemory();
}
__analysis_assume(entry);
entry->addrOffset = (unsigned int)((__int64)addrToFixup - (__int64)startAddress);
Assert(entry->addrOffset <= chunk->len - sizeof(void*));
entry->targetTotalOffset = targetChunk->offset + inDataOffset;
entry->next = chunk->fixupList;
chunk->fixupList = entry;
#if DBG
if (PHASE_TRACE1(Js::NativeCodeDataPhase))
{
Output::Print(L"NativeCodeData Add Fixup: %p(%p+%d, chunk:%p) --> %p(chunk:%p) %S\n",
addrToFixup, startAddress, entry->addrOffset, (void*)chunk, targetAddr, (void*)targetChunk, chunk->dataType);
}
#endif
}
void
NativeCodeData::AddFixupEntryForPointerArray(void* startAddress, DataChunk * chunkList)
{
DataChunk* chunk = NativeCodeData::GetDataChunk(startAddress);
Assert(chunk->len % sizeof(void*) == 0);
for (unsigned int i = 0; i < chunk->len / sizeof(void*); i++)
{
size_t offset = i * sizeof(void*);
void* targetAddr = *(void**)((char*)startAddress + offset);
if (targetAddr == nullptr)
{
continue;
}
DataChunk* targetChunk = NativeCodeData::GetDataChunk(targetAddr);
#if DBG
bool foundTargetChunk = false;
DataChunk* chunk1 = chunkList;
while (chunk1 && !foundTargetChunk)
{
foundTargetChunk = (chunk1 == targetChunk);
chunk1 = chunk1->next;
}
AssertMsg(foundTargetChunk, "current pointer is not allocated with NativeCodeData allocator?"); // change to valid check instead of assertion?
#endif
NativeDataFixupEntry* entry = (NativeDataFixupEntry*)midl_user_allocate(sizeof(NativeDataFixupEntry));
if (!entry)
{
Js::Throw::OutOfMemory();
}
__analysis_assume(entry);
entry->addrOffset = (unsigned int)offset;
entry->targetTotalOffset = targetChunk->offset;
entry->next = chunk->fixupList;
chunk->fixupList = entry;
#if DBG
if (PHASE_TRACE1(Js::NativeCodeDataPhase))
{
Output::Print(L"NativeCodeData Add Fixup: %p[%d](+%d, chunk:%p) --> %p(chunk:%p) %S\n",
startAddress, i, entry->addrOffset, (void*)chunk, targetAddr, (void*)targetChunk, chunk->dataType);
}
#endif
}
}
IdentPtr HashTbl::PidFromTk(tokens token)
{
Assert(token > tkNone && token < tkID);
__analysis_assume(token > tkNone && token < tkID);
// Create a pid so we can create a name node
IdentPtr rpid = m_rpid[token];
if (nullptr == rpid)
{
StaticSym const * sym = s_reservedWordInfo[token].sym;
Assert(sym != nullptr);
rpid = this->PidHashNameLenWithHash(sym->sz, sym->cch, sym->luHash);
rpid->SetTk(token, s_reservedWordInfo[token].grfid);
m_rpid[token] = rpid;
}
return rpid;
}
//
// FUNCTION: InitializeFramework(HWND)
//
// PURPOSE: Initialize the Ribbon framework and bind a Ribbon to the application.
//
// COMMENTS:
//
// To get a Ribbon to display, the Ribbon framework must be initialized.
// This involves three important steps:
// 1) Instantiating the Ribbon framework object (CLSID_UIRibbonFramework).
// 2) Passing the host HWND and IUIApplication object to the framework.
// 3) Loading the binary markup compiled by UICC.exe.
//
//
__checkReturn bool InitializeFramework(HWND hWnd)
{
// Here we instantiate the Ribbon framework object.
HRESULT hr = CoCreateInstance(CLSID_UIRibbonFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&g_pFramework));
if (FAILED(hr))
{
return false;
}
// Next, we create the application object and call the framework Initialize method.
// passing the application object and the host HWND that the Ribbon will attach itself to.
hr = CApplication::CreateInstance(&g_pApplication, hWnd);
if (FAILED(hr))
{
return false;
}
IUIApplication *pApplication = NULL;
__analysis_assume(g_pApplication != NULL);
hr = g_pApplication->QueryInterface(IID_PPV_ARGS(&pApplication));
if (SUCCEEDED(hr))
{
// Passing the application object and the host HWND that the Ribbon will attach itself to.
hr = g_pFramework->Initialize(hWnd, pApplication);
pApplication->Release();
}
if (FAILED(hr))
{
return false;
}
// Finally, we load the binary markup. This will initiate callbacks to the IUIApplication object
// that was provided to the framework earlier, allowing command handlers to be bound to individual
// commands.
hr = g_pFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_RIBBON");
if (FAILED(hr))
{
return false;
}
return true;
}
//------------------------------------------------------------------------
// BorderRect
//
// It draws a rectangle which is not filled by using the current brush.
// This is difference from GDI API 'Rectangle'
//
// Remarks:
//
// 1) The LineTo function draws a line from the current position up to,
// but not including, the specified point !!! This is the reason why +1
// should be added to end position.
// 2) If LineTo succeeds, the current position is set to the specified
// ending point. Then it is not necessary to move position after each
// drawing.
//------------------------------------------------------------------------
void BorderRect(HDC hDC, LPRECT lpRect, COLORREF clrPenColor)
{
ASSERT(lpRect);
__analysis_assume(lpRect);
// create GDI objects
HPEN hPen = CreatePen(PS_SOLID, 1, clrPenColor);
HPEN hOldPen = (HPEN)SelectObject(hDC, hPen);
// upper line
MoveToEx(hDC, lpRect->left, lpRect->top, NULL);
LineTo(hDC, lpRect->right, lpRect->top);
// right line
LineTo(hDC, lpRect->right, lpRect->bottom);
// bottom line
LineTo(hDC, lpRect->left, lpRect->bottom);
// left line
LineTo(hDC, lpRect->left, lpRect->top-1); // +1 see above !!!
// free GDI objects
SelectObject(hDC, hOldPen);
DeleteObject((HGDIOBJ)hPen);
}
/*****************************************************************************
* CListItem::Remove()
*****************************************************************************
* Remove the given list item from the list.
*/
CListItem* CListItem::Remove(CListItem *pItem)
{
CListItem *li,*prev;
if(pItem==this)
return m_pNext;
prev=NULL;
for(li=this; li!=NULL && li!=pItem ; li=li->m_pNext)
prev=li;
if(li==NULL) // item not found in list
return this;
// here it is guaranteed that prev is non-NULL since we checked for
// that condition at the very beginning
ASSERT(prev != li->m_pNext);
__analysis_assume(prev != NULL);
prev->SetNext(li->m_pNext);
li->SetNext(NULL);
return this;
}
void
FileMonitor::initialiseDosNameMap()
{
UCHAR buffer[1024];
PFILTER_VOLUME_BASIC_INFORMATION volumeBuffer = (PFILTER_VOLUME_BASIC_INFORMATION)buffer;
HANDLE volumeIterator = INVALID_HANDLE_VALUE;
ULONG volumeBytesReturned;
WCHAR driveLetter[15];
HRESULT hResult = FilterVolumeFindFirst( FilterVolumeBasicInformation,
volumeBuffer,
sizeof(buffer)-sizeof(WCHAR), //save space to null terminate name
&volumeBytesReturned,
&volumeIterator );
if (volumeIterator != INVALID_HANDLE_VALUE) {
do {
assert((FIELD_OFFSET(FILTER_VOLUME_BASIC_INFORMATION,FilterVolumeName) + volumeBuffer->FilterVolumeNameLength) <= (sizeof(buffer)-sizeof(WCHAR)));
__analysis_assume((FIELD_OFFSET(FILTER_VOLUME_BASIC_INFORMATION,FilterVolumeName) + volumeBuffer->FilterVolumeNameLength) <= (sizeof(buffer)-sizeof(WCHAR)));
volumeBuffer->FilterVolumeName[volumeBuffer->FilterVolumeNameLength/sizeof( WCHAR )] = UNICODE_NULL;
if(SUCCEEDED( FilterGetDosName(volumeBuffer->FilterVolumeName,
driveLetter,
sizeof(driveLetter)/sizeof(WCHAR) )
))
{
wstring dLetter = driveLetter;
dosNameMap.insert(DosPair(volumeBuffer->FilterVolumeName, dLetter));
}
} while (SUCCEEDED( hResult = FilterVolumeFindNext( volumeIterator,
FilterVolumeBasicInformation,
volumeBuffer,
sizeof(buffer)-sizeof(WCHAR), //save space to null terminate name
&volumeBytesReturned ) ));
}
if (INVALID_HANDLE_VALUE != volumeIterator) {
FilterVolumeFindClose( volumeIterator );
}
}
reference operator*() const
{ // return designated object
#if _ITERATOR_DEBUG_LEVEL == 2
if (this->_Getcont() == 0
|| this->_Ptr == 0
|| this->_Ptr < ((_Myvec *)this->_Getcont())->_Myfirst
|| ((_Myvec *)this->_Getcont())->_Mylast <= this->_Ptr)
{ // report error
_DEBUG_ERROR("vector iterator not dereferencable");
_SCL_SECURE_OUT_OF_RANGE;
}
#elif _ITERATOR_DEBUG_LEVEL == 1
_SCL_SECURE_VALIDATE(this->_Getcont() != 0);
_SCL_SECURE_VALIDATE_RANGE(
this->_Ptr != 0
&& ((_Myvec *)this->_Getcont())->_Myfirst <= this->_Ptr
&& this->_Ptr < ((_Myvec *)this->_Getcont())->_Mylast);
#endif /* _ITERATOR_DEBUG_LEVEL */
__analysis_assume(this->_Ptr != 0);
return (*this->_Ptr);
}
NTSTATUS
SingleCompEvtDeviceAdd(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by UMDF in response to AddDevice call from
the PnP manager.
Arguments:
Driver - Handle to the UMDF driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
An NTSTATUS value representing success or failure of the function.
--*/
{
NTSTATUS status;
WDFDEVICE device;
WDFQUEUE queue;
WDF_IO_QUEUE_CONFIG queueConfig;
FDO_DATA *fdoContext = NULL;
WDF_OBJECT_ATTRIBUTES objectAttributes;
WDF_PNPPOWER_EVENT_CALLBACKS pnpCallbacks;
UNREFERENCED_PARAMETER(Driver);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&objectAttributes, FDO_DATA);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpCallbacks);
pnpCallbacks.EvtDeviceD0Entry = SingleCompEvtDeviceD0Entry;
pnpCallbacks.EvtDeviceD0Exit = SingleCompEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpCallbacks);
status = WdfDeviceCreate(&DeviceInit, &objectAttributes, &device);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"%!FUNC! - WdfDeviceCreate failed with %!status!.",
status);
goto exit;
}
fdoContext = FdoGetContext(device);
//
// Our initial state is active
//
fdoContext->IsActive = TRUE;
//
// Create a power-managed queue for IOCTL requests.
//
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchParallel);
queueConfig.EvtIoDeviceControl = SingleCompEvtIoDeviceControl;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests or
// forward them to other drivers. This driver completes the requests
// directly in the queue's handlers. If the EvtIoStop callback is not
// implemented, the framework waits for all driver-owned requests to be
// done before moving in the Dx/sleep states or before removing the
// device, which is the correct behavior for this type of driver.
// If the requests were taking an indeterminate amount of time to complete,
// or if the driver forwarded the requests to a lower driver/another stack,
// the queue should have an EvtIoStop/EvtIoResume.
//
__analysis_assume(queueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue);
__analysis_assume(queueConfig.EvtIoStop == 0);
if (FALSE == NT_SUCCESS (status)) {
Trace(TRACE_LEVEL_ERROR,
"%!FUNC! - WdfIoQueueCreate for IoDeviceControl failed with %!status!.",
status);
goto exit;
}
status = WdfDeviceConfigureRequestDispatching(device,
queue,
WdfRequestTypeDeviceControl);
if (FALSE == NT_SUCCESS (status)) {
Trace(TRACE_LEVEL_ERROR,
"%!FUNC! - WdfDeviceConfigureRequestDispatching for "
"WdfRequestTypeDeviceControl failed with %!status!.",
status);
goto exit;
}
status = AssignS0IdleSettings(device);
if (!NT_SUCCESS(status)) {
goto exit;
}
//
// Create a device interface so that applications can open a handle to this
// device.
//
status = WdfDeviceCreateDeviceInterface(device,
&GUID_DEVINTERFACE_POWERFX,
NULL /* ReferenceString */);
if (FALSE == NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"%!FUNC! - WdfDeviceCreateDeviceInterface failed with %!status!.",
status);
goto exit;
}
//
// Initialize the hardware simulator
//
status = HwSimInitialize(device);
if (FALSE == NT_SUCCESS(status)) {
goto exit;
}
exit:
return status;
}
HRESULT Helpers::LoadBinaryFile(LPCSTR filename, LPCSTR& contents, UINT& lengthBytes, bool printFileOpenError)
{
HRESULT hr = S_OK;
contents = nullptr;
lengthBytes = 0;
size_t result;
FILE * file;
//
// Open the file as a binary file to prevent CRT from handling encoding, line-break conversions,
// etc.
//
if (fopen_s(&file, filename, "rb") != 0)
{
if (printFileOpenError)
{
fprintf(stderr, "Error in opening file '%s' ", filename);
#ifdef _WIN32
DWORD lastError = GetLastError();
char16 wszBuff[MAX_URI_LENGTH];
wszBuff[0] = 0;
if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
lastError,
0,
wszBuff,
_countof(wszBuff),
nullptr))
{
fwprintf(stderr, _u(": %s"), wszBuff);
}
#endif
fprintf(stderr, "\n");
}
return E_FAIL;
}
// file will not be nullptr if _wfopen_s succeeds
__analysis_assume(file != nullptr);
//
// Determine the file length, in bytes.
//
fseek(file, 0, SEEK_END);
lengthBytes = ftell(file);
fseek(file, 0, SEEK_SET);
contents = (LPCSTR)HeapAlloc(GetProcessHeap(), 0, lengthBytes);
if (nullptr == contents)
{
fwprintf(stderr, _u("out of memory"));
IfFailGo(E_OUTOFMEMORY);
}
//
// Read the entire content as a binary block.
//
result = fread((void*)contents, sizeof(char), lengthBytes, file);
if (result != lengthBytes)
{
fwprintf(stderr, _u("Read error"));
IfFailGo(E_FAIL);
}
Error:
fclose(file);
if (contents && FAILED(hr))
{
HeapFree(GetProcessHeap(), 0, (void*)contents);
contents = nullptr;
}
return hr;
}
void lpc10_voicing(lpc10_encode_state_t *s,
int32_t vwin[],
float *inbuf,
float *lpbuf,
const int32_t buflim[],
int32_t half,
float *minamd,
float *maxamd,
int32_t *mintau,
float ivrc[],
int32_t obound[])
{
static const float vdc[100] =
{
0.0f, 1714.0f, -110.0f, 334.0f, -4096.0f, -654.0f, 3752.0f, 3769.0f, 0.0f, 1181.0f,
0.0f, 874.0f, -97.0f, 300.0f, -4096.0f, -1021.0f, 2451.0f, 2527.0f, 0.0f, -500.0f,
0.0f, 510.0f, -70.0f, 250.0f, -4096.0f, -1270.0f, 2194.0f, 2491.0f, 0.0f, -1500.0f,
0.0f, 500.0f, -10.0f, 200.0f, -4096.0f, -1300.0f, 2.0e3f, 2.0e3f, 0.0f, -2.0e3f,
0.0f, 500.0f, 0.0f, 0.0f, -4096.0f, -1300.0f, 2.0e3f, 2.0e3f, 0.0f, -2500.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
};
static const int nvdcl = 5;
static const float vdcl[10] =
{
600.0f, 450.0f, 300.0f, 200.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
};
int32_t inbuf_offset;
int32_t lpbuf_offset;
int32_t i1;
float r1;
float r2;
float ar_b;
float ar_f;
int32_t snrl;
int32_t i;
float value[9];
int32_t zc;
int ot;
float qs;
int32_t vstate;
float rc1;
int32_t fbe;
int32_t lbe;
float snr2;
#if (_MSC_VER >= 1400)
__analysis_assume(half >= 0 && half < 2);
#endif
inbuf_offset = 0;
lpbuf_offset = 0;
if (inbuf)
{
inbuf_offset = buflim[0];
inbuf -= inbuf_offset;
}
if (lpbuf)
{
lpbuf_offset = buflim[2];
lpbuf -= lpbuf_offset;
}
/* Voicing Decision Parameter vector (* denotes zero coefficient): */
/* * MAXMIN */
/* LBE/LBVE */
/* ZC */
/* RC1 */
/* QS */
/* IVRC2 */
/* aR_B */
/* aR_F */
/* * LOG(LBE/LBVE) */
/* Define 2-D voicing decision coefficient vector according to the voicing */
/* parameter order above. Each row (VDC vector) is optimized for a specific */
/* SNR. The last element of the vector is the constant. */
/* E ZC RC1 Qs IVRC2 aRb aRf c */
/* The VOICE array contains the result of the linear discriminant function*/
/* (analog values). The VOIBUF array contains the hard-limited binary */
/* voicing decisions. The VOICE and VOIBUF arrays, according to FORTRAN */
/* memory allocation, are addressed as: */
/* (half-frame number, future-frame number) */
/* | Past | Present | Future1 | Future2 | */
/* | 1,0 | 2,0 | 1,1 | 2,1 | 1,2 | 2,2 | 1,3 | 2,3 | ---> time */
/* Update linear discriminant function history each frame: */
if (half == 0)
{
s->voice[0][0] = s->voice[1][0];
s->voice[0][1] = s->voice[1][1];
s->voice[1][0] = s->voice[2][0];
s->voice[1][1] = s->voice[2][1];
s->maxmin = *maxamd / max(*minamd, 1.0f);
}
/* Calculate voicing parameters twice per frame */
vparms(vwin,
&inbuf[inbuf_offset],
&lpbuf[lpbuf_offset],
buflim,
half,
&s->dither,
mintau,
&zc,
&lbe,
&fbe,
&qs,
&rc1,
&ar_b,
&ar_f);
/* Estimate signal-to-noise ratio to select the appropriate VDC vector. */
/* The SNR is estimated as the running average of the ratio of the */
/* running average full-band voiced energy to the running average */
/* full-band unvoiced energy. SNR filter has gain of 63. */
r1 = (s->snr + s->fbve/(float) max(s->fbue, 1))*63/64.0f;
s->snr = (float) lfastrintf(r1);
snr2 = s->snr*s->fbue/max(s->lbue, 1);
/* Quantize SNR to SNRL according to VDCL thresholds. */
i1 = nvdcl - 1;
for (snrl = 0; snrl < i1; snrl++)
{
if (snr2 > vdcl[snrl])
break;
}
/* (Note: SNRL = NVDCL here) */
/* Linear discriminant voicing parameters: */
value[0] = s->maxmin;
value[1] = (float) lbe/max(s->lbve, 1);
value[2] = (float) zc;
value[3] = rc1;
value[4] = qs;
value[5] = ivrc[1];
value[6] = ar_b;
value[7] = ar_f;
/* Evaluation of linear discriminant function: */
s->voice[2][half] = vdc[snrl*10 + 9];
for (i = 0; i < 8; i++)
s->voice[2][half] += vdc[snrl*10 + i]*value[i];
/* Classify as voiced if discriminant > 0, otherwise unvoiced */
/* Voicing decision for current half-frame: 1 = Voiced; 0 = Unvoiced */
s->voibuf[3][half] = (s->voice[2][half] > 0.0f) ? 1 : 0;
/* Skip voicing decision smoothing in first half-frame: */
/* Give a value to VSTATE, so that trace statements below will print */
/* a consistent value from one call to the next when HALF .EQ. 1. */
/* The value of VSTATE is not used for any other purpose when this is */
/* true. */
vstate = -1;
if (half != 0)
{
/* Voicing decision smoothing rules (override of linear combination): */
/* Unvoiced half-frames: At least two in a row. */
/* -------------------- */
/* Voiced half-frames: At least two in a row in one frame. */
/* ------------------- Otherwise at least three in a row. */
/* (Due to the way transition frames are encoded) */
/* In many cases, the discriminant function determines how to smooth. */
/* In the following chart, the decisions marked with a * may be overridden. */
/* Voicing override of transitions at onsets: */
/* If a V/UV or UV/V voicing decision transition occurs within one-half */
/* frame of an onset bounding a voicing window, then the transition is */
/* moved to occur at the onset. */
/* P 1F */
/* ----- ----- */
/* 0 0 0 0 */
/* 0 0 0* 1 (If there is an onset there) */
/* 0 0 1* 0* (Based on 2F and discriminant distance) */
/* 0 0 1 1 */
/* 0 1* 0 0 (Always) */
/* 0 1* 0* 1 (Based on discriminant distance) */
/* 0* 1 1 0* (Based on past, 2F, and discriminant distance) */
/* 0 1* 1 1 (If there is an onset there) */
/* 1 0* 0 0 (If there is an onset there) */
/* 1 0 0 1 */
/* 1 0* 1* 0 (Based on discriminant distance) */
/* 1 0* 1 1 (Always) */
/* 1 1 0 0 */
/* 1 1 0* 1* (Based on 2F and discriminant distance) */
/* 1 1 1* 0 (If there is an onset there) */
/* 1 1 1 1 */
/* Determine if there is an onset transition between P and 1F. */
/* OT (Onset Transition) is true if there is an onset between */
/* P and 1F but not after 1F. */
ot = ((obound[0] & 2) != 0 || obound[1] == 1) && (obound[2] & 1) == 0;
/* Multi-way dispatch on voicing decision history: */
vstate = (s->voibuf[1][0] << 3) + (s->voibuf[1][1] << 2) + (s->voibuf[2][0] << 1) + s->voibuf[2][1];
switch (vstate + 1)
{
case 2:
if (ot && s->voibuf[3][0] == 1)
s->voibuf[2][0] = 1;
break;
case 3:
if (s->voibuf[3][0] == 0 || s->voice[1][0] < -s->voice[1][1])
s->voibuf[2][0] = 0;
else
s->voibuf[2][1] = 1;
break;
case 5:
s->voibuf[1][1] = 0;
break;
case 6:
if (s->voice[0][1] < -s->voice[1][0])
s->voibuf[1][1] = 0;
else
s->voibuf[2][0] = 1;
break;
case 7:
if (s->voibuf[0][0] == 1 || s->voibuf[3][0] == 1 || s->voice[1][1] > s->voice[0][0])
s->voibuf[2][1] = 1;
else
s->voibuf[1][0] = 1;
break;
case 8:
if (ot)
s->voibuf[1][1] = 0;
break;
case 9:
if (ot)
s->voibuf[1][1] = 1;
break;
case 11:
if (s->voice[1][0] < -s->voice[0][1])
s->voibuf[2][0] = 0;
else
s->voibuf[1][1] = 1;
break;
case 12:
s->voibuf[1][1] = 1;
break;
case 14:
if (s->voibuf[3][0] == 0 && s->voice[1][1] < -s->voice[1][0])
s->voibuf[2][1] = 0;
else
s->voibuf[2][0] = 1;
break;
case 15:
if (ot && s->voibuf[3][0] == 0)
s->voibuf[2][0] = 0;
break;
}
}
/* During unvoiced half-frames, update the low band and full band unvoiced*/
/* energy estimates (LBUE and FBUE) and also the zero crossing */
/* threshold (DITHER). (The input to the unvoiced energy filters is */
/* restricted to be less than 10dB above the previous inputs of the */
/* filters.) */
/* During voiced half-frames, update the low-pass (LBVE) and all-pass */
/* (FBVE) voiced energy estimates. */
if (s->voibuf[3][half] == 0)
{
r1 = (s->sfbue*63 + (min(fbe, s->ofbue*3) << 3))/64.0f;
s->sfbue = lfastrintf(r1);
s->fbue = s->sfbue/8;
s->ofbue = fbe;
r1 = (s->slbue*63 + (min(lbe, s->olbue*3) << 3))/64.0f;
s->slbue = lfastrintf(r1);
s->lbue = s->slbue/8;
s->olbue = lbe;
}
else
{
s->lbve = lfastrintf((s->lbve*63 + lbe)/64.0f);
s->fbve = lfastrintf((s->fbve*63 + fbe)/64.0f);
}
/* Set dither threshold to yield proper zero crossing rates in the */
/* presence of low frequency noise and low level signal input. */
/* NOTE: The divisor is a function of REF, the expected energies. */
/* Computing MIN */
/* Computing MAX */
r2 = sqrtf((float) (s->lbue*s->lbve))*64/3000;
r1 = max(r2, 1.0f);
s->dither = min(r1, 20.0f);
/* Voicing decisions are returned in VOIBUF. */
}
NTSTATUS
Bus_EvtDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Bus_EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a device object to
represent a new instance of toaster bus.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_CHILD_LIST_CONFIG config;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
NTSTATUS status;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG queueConfig;
PNP_BUS_INFORMATION busInfo;
//PFDO_DEVICE_DATA deviceData;
WDFQUEUE queue;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE ();
KdPrint(("Bus_EvtDeviceAdd: 0x%p\n", Driver));
//
// Initialize all the properties specific to the device.
// Framework has default values for the one that are not
// set explicitly here. So please read the doc and make sure
// you are okay with the defaults.
//
WdfDeviceInitSetDeviceType(DeviceInit, FILE_DEVICE_BUS_EXTENDER);
WdfDeviceInitSetExclusive(DeviceInit, TRUE);
//
// Since this is pure software bus enumerator, we don't have to register for
// any PNP/Power callbacks. Framework will take the default action for
// all the PNP and Power IRPs.
//
//
// WDF_ DEVICE_LIST_CONFIG describes how the framework should handle
// dynamic child enumeration on behalf of the driver writer.
// Since we are a bus driver, we need to specify identification description
// for our child devices. This description will serve as the identity of our
// child device. Since the description is opaque to the framework, we
// have to provide bunch of callbacks to compare, copy, or free
// any other resources associated with the description.
//
WDF_CHILD_LIST_CONFIG_INIT(&config,
sizeof(PDO_IDENTIFICATION_DESCRIPTION),
Bus_EvtDeviceListCreatePdo // callback to create a child device.
);
//
// This function pointer will be called when the framework needs to copy a
// identification description from one location to another. An implementation
// of this function is only necessary if the description contains description
// relative pointer values (like LIST_ENTRY for instance) .
// If set to NULL, the framework will use RtlCopyMemory to copy an identification .
// description. In this sample, it's not required to provide these callbacks.
// they are added just for illustration.
//
config.EvtChildListIdentificationDescriptionDuplicate =
Bus_EvtChildListIdentificationDescriptionDuplicate;
//
// This function pointer will be called when the framework needs to compare
// two identificaiton descriptions. If left NULL a call to RtlCompareMemory
// will be used to compare two identificaiton descriptions.
//
config.EvtChildListIdentificationDescriptionCompare =
Bus_EvtChildListIdentificationDescriptionCompare;
//
// This function pointer will be called when the framework needs to free a
// identification description. An implementation of this function is only
// necessary if the description contains dynamically allocated memory
// (by the driver writer) that needs to be freed. The actual identification
// description pointer itself will be freed by the framework.
//
config.EvtChildListIdentificationDescriptionCleanup =
Bus_EvtChildListIdentificationDescriptionCleanup;
//
// Tell the framework to use the built-in childlist to track the state
// of the device based on the configuration we just created.
//
WdfFdoInitSetDefaultChildListConfig(DeviceInit,
&config,
WDF_NO_OBJECT_ATTRIBUTES);
//
// Initialize attributes structure to specify size and accessor function
// for storing device context.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, FDO_DEVICE_DATA);
//
// Create a framework device object. In response to this call, framework
// creates a WDM deviceobject and attach to the PDO.
//
status = WdfDeviceCreate(&DeviceInit, &fdoAttributes, &device);
if (!NT_SUCCESS(status)) {
KdPrint(("Error creating device 0x%x\n", status));
return status;
}
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchParallel
);
queueConfig.EvtIoDeviceControl = Bus_EvtIoDeviceControl;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests or
// forward them to other drivers. This driver completes the requests
// directly in the queue's handlers. If the EvtIoStop callback is not
// implemented, the framework waits for all driver-owned requests to be
// done before moving in the Dx/sleep states or before removing the
// device, which is the correct behavior for this type of driver.
// If the requests were taking an indeterminate amount of time to complete,
// or if the driver forwarded the requests to a lower driver/another stack,
// the queue should have an EvtIoStop/EvtIoResume.
//
__analysis_assume(queueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate( device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue );
__analysis_assume(queueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
KdPrint(("WdfIoQueueCreate failed status 0x%x\n", status));
return status;
}
//
// Get the device context.
//
//deviceData = FdoGetData(device);
//
// Create device interface for this device. The interface will be
// enabled by the framework when we return from StartDevice successfully.
// Clients of this driver will open this interface and send ioctls.
//
status = WdfDeviceCreateDeviceInterface(
device,
&GUID_DEVINTERFACE_BUSENUM_TOASTER,
NULL // No Reference String. If you provide one it will appended to the
); // symbolic link. Some drivers register multiple interfaces for the same device
// and use the reference string to distinguish between them
if (!NT_SUCCESS(status)) {
return status;
}
//
// This value is used in responding to the IRP_MN_QUERY_BUS_INFORMATION
// for the child devices. This is an optional information provided to
// uniquely idenitfy the bus the device is connected.
//
busInfo.BusTypeGuid = GUID_DEVCLASS_TOASTER;
busInfo.LegacyBusType = PNPBus;
busInfo.BusNumber = 0;
WdfDeviceSetBusInformationForChildren(device, &busInfo);
status = Bus_WmiRegistration(device);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Check the registry to see if we need to enumerate child devices during
// start.
//
status = Bus_DoStaticEnumeration(device);
return status;
}
VOID
FxWakeInterruptMachine::ProcessEventInner(
__inout FxPostProcessInfo* Info
)
{
KIRQL irql;
FxWakeInterruptEvents event;
const FxWakeInterruptStateTable* entry;
FxWakeInterruptStates newState;
//
// Process as many events as we can
//
for ( ; ; ) {
//
// Acquire state machine *queue* lock
//
Lock(&irql);
if (IsEmpty()) {
//
// The queue is empty.
//
GetFinishedState(Info);
Unlock(irql);
return;
}
//
// Get the event from the queue
//
event = m_Queue[GetHead()];
IncrementHead();
//
// Drop the state machine *queue* lock
//
Unlock(irql);
//
// Get the state table entry for the current state
//
// NOTE: Prefast complains about buffer overflow if (m_CurrentState ==
// WakeInterruptMax), but that should never happen because WakeInterruptMax is not a real
// state. We just use it to represent the maximum value in the enum that
// defines the states.
//
__analysis_assume(m_CurrentState < WakeInterruptMax);
entry = &m_StateTable[m_CurrentState - WakeInterruptFailed];
//
// Based on the event received, figure out the next state
//
newState = WakeInterruptMax;
for (ULONG i = 0; i < entry->TargetStatesCount; i++) {
if (entry->TargetStates[i].WakeInterruptEvent == event) {
DO_EVENT_TRAP(&entry->TargetStates[i]);
newState = entry->TargetStates[i].WakeInterruptState;
break;
}
}
if (newState == WakeInterruptMax) {
//
// Unexpected event for this state
//
DoTraceLevelMessage(
m_PkgPnp->GetDriverGlobals(),
TRACE_LEVEL_INFORMATION,
TRACINGPNP,
"WDFDEVICE 0x%p !devobj 0x%p wake interrupt state "
"%!FxWakeInterruptStates! dropping event "
"%!FxWakeInterruptEvents!",
m_PkgPnp->GetDevice()->GetHandle(),
m_PkgPnp->GetDevice()->GetDeviceObject(),
m_CurrentState,
event
);
COVERAGE_TRAP();
}
while (newState != WakeInterruptMax) {
DoTraceLevelMessage(
m_PkgPnp->GetDriverGlobals(),
TRACE_LEVEL_INFORMATION,
TRACINGPNPPOWERSTATES,
"WDFDEVICE 0x%p !devobj 0x%p entering wake interrupt "
"state %!FxWakeInterruptStates! from "
"%!FxWakeInterruptStates!",
m_PkgPnp->GetDevice()->GetHandle(),
m_PkgPnp->GetDevice()->GetDeviceObject(),
newState,
m_CurrentState
);
//
// Update the state history array
//
m_States.History[IncrementHistoryIndex()] = (UCHAR) newState;
//
// Move to the new state
//
m_CurrentState = (BYTE) newState;
entry = &m_StateTable[m_CurrentState-WakeInterruptFailed];
//
// Invoke the state entry function (if present) for the new state
//
if (entry->StateFunc != NULL) {
newState = entry->StateFunc(this);
}
else {
newState = WakeInterruptMax;
}
}
}
return;
}
HRESULT
ServerRemoteCodeGen(
/* [in] */ handle_t binding,
/* [in] */ intptr_t scriptContextInfoAddress,
/* [in] */ __RPC__in CodeGenWorkItemIDL *workItemData,
/* [out] */ __RPC__out JITOutputIDL *jitData)
{
AUTO_NESTED_HANDLED_EXCEPTION_TYPE(static_cast<ExceptionType>(ExceptionType_OutOfMemory | ExceptionType_StackOverflow));
LARGE_INTEGER start_time = { 0 };
if (PHASE_TRACE1(Js::BackEndPhase))
{
QueryPerformanceCounter(&start_time);
}
memset(jitData, 0, sizeof(JITOutputIDL));
ServerScriptContext * scriptContextInfo = (ServerScriptContext*)DecodePointer((void*)scriptContextInfoAddress);
if (scriptContextInfo == nullptr)
{
Assert(false);
return RPC_S_INVALID_ARG;
}
if (!ServerContextManager::IsScriptContextAlive(scriptContextInfo))
{
Assert(false);
return E_ACCESSDENIED;
}
AutoReleaseContext<ServerScriptContext> autoScriptContext(scriptContextInfo);
return ServerCallWrapper(scriptContextInfo, [&]() ->HRESULT
{
scriptContextInfo->UpdateGlobalObjectThisAddr(workItemData->globalThisAddr);
ServerThreadContext * threadContextInfo = scriptContextInfo->GetThreadContext();
NoRecoverMemoryJitArenaAllocator jitArena(L"JITArena", threadContextInfo->GetPageAllocator(), Js::Throw::OutOfMemory);
JITTimeWorkItem * jitWorkItem = Anew(&jitArena, JITTimeWorkItem, workItemData);
if (PHASE_VERBOSE_TRACE_RAW(Js::BackEndPhase, jitWorkItem->GetJITTimeInfo()->GetSourceContextId(), jitWorkItem->GetJITTimeInfo()->GetLocalFunctionId()))
{
LARGE_INTEGER freq;
LARGE_INTEGER end_time;
QueryPerformanceCounter(&end_time);
QueryPerformanceFrequency(&freq);
Output::Print(
L"BackendMarshalIn - function: %s time:%8.6f mSec\r\n",
jitWorkItem->GetJITFunctionBody()->GetDisplayName(),
(((double)((end_time.QuadPart - workItemData->startTime)* (double)1000.0 / (double)freq.QuadPart))) / (1));
Output::Flush();
}
auto profiler = scriptContextInfo->GetCodeGenProfiler();
#ifdef PROFILE_EXEC
if (profiler && !profiler->IsInitialized())
{
profiler->Initialize(threadContextInfo->GetPageAllocator(), nullptr);
}
#endif
if (jitWorkItem->GetWorkItemData()->xProcNumberPageSegment)
{
jitData->numberPageSegments = (XProcNumberPageSegment*)midl_user_allocate(sizeof(XProcNumberPageSegment));
if (!jitData->numberPageSegments)
{
return E_OUTOFMEMORY;
}
__analysis_assume(jitData->numberPageSegments);
memcpy_s(jitData->numberPageSegments, sizeof(XProcNumberPageSegment), jitWorkItem->GetWorkItemData()->xProcNumberPageSegment, sizeof(XProcNumberPageSegment));
}
Func::Codegen(
&jitArena,
jitWorkItem,
threadContextInfo,
scriptContextInfo,
jitData,
nullptr,
nullptr,
jitWorkItem->GetPolymorphicInlineCacheInfo(),
threadContextInfo->GetCodeGenAllocators(),
#if !FLOATVAR
nullptr, // number allocator
#endif
profiler,
true);
#ifdef PROFILE_EXEC
if (profiler && profiler->IsInitialized())
{
profiler->ProfilePrint(Js::Configuration::Global.flags.Profile.GetFirstPhase());
}
#endif
if (PHASE_VERBOSE_TRACE_RAW(Js::BackEndPhase, jitWorkItem->GetJITTimeInfo()->GetSourceContextId(), jitWorkItem->GetJITTimeInfo()->GetLocalFunctionId()))
{
LARGE_INTEGER freq;
LARGE_INTEGER end_time;
QueryPerformanceCounter(&end_time);
QueryPerformanceFrequency(&freq);
Output::Print(
L"EndBackEndInner - function: %s time:%8.6f mSec\r\n",
jitWorkItem->GetJITFunctionBody()->GetDisplayName(),
(((double)((end_time.QuadPart - start_time.QuadPart)* (double)1000.0 / (double)freq.QuadPart))) / (1));
Output::Flush();
}
LARGE_INTEGER out_time = { 0 };
if (PHASE_TRACE1(Js::BackEndPhase))
{
QueryPerformanceCounter(&out_time);
jitData->startTime = out_time.QuadPart;
}
return S_OK;
});
}
NTSTATUS
ImDiskReadWriteLowerDeviceCompletion(PDEVICE_OBJECT DeviceObject,
PIRP Irp, PVOID Context)
{
PLOWER_DEVICE_WORK_ITEM item = (PLOWER_DEVICE_WORK_ITEM)Context;
ASSERT(item != NULL);
__analysis_assume(item != NULL);
UNREFERENCED_PARAMETER(DeviceObject);
item->OriginalIrp->IoStatus = Irp->IoStatus;
if (!NT_SUCCESS(Irp->IoStatus.Status))
{
KdPrint(("ImDiskReadWriteLowerDeviceCompletion: Parallel I/O failed with status %#x\n",
Irp->IoStatus.Status));
}
else
{
if (item->CopyBack)
{
RtlCopyMemory(item->SystemBuffer, item->AllocatedBuffer,
Irp->IoStatus.Information);
}
if (item->AllocatedBuffer != NULL)
{
KLOCK_QUEUE_HANDLE lock_handle;
ImDiskAcquireLock(&item->DeviceExtension->last_io_lock, &lock_handle);
if (item->DeviceExtension->last_io_data != NULL)
{
ExFreePoolWithTag(item->DeviceExtension->last_io_data,
POOL_TAG);
}
item->DeviceExtension->last_io_data = item->AllocatedBuffer;
item->DeviceExtension->last_io_offset = item->OriginalOffset;
item->DeviceExtension->last_io_length =
(ULONG)Irp->IoStatus.Information;
ImDiskReleaseLock(&lock_handle);
}
}
if (Irp->MdlAddress != item->OriginalIrp->MdlAddress)
{
ImDiskFreeIrpWithMdls(Irp);
}
else
{
IoFreeIrp(Irp);
}
IoCompleteRequest(item->OriginalIrp, IO_DISK_INCREMENT);
ExFreePoolWithTag(item, POOL_TAG);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
OsrFxEvtDeviceAdd(
WDFDRIVER Driver,
PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. We create and initialize a device object to
represent a new instance of the device. All the software resources
should be allocated in this callback.
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES attributes;
NTSTATUS status;
WDFDEVICE device;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PDEVICE_CONTEXT pDevContext;
WDFQUEUE queue;
GUID activity;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"--> OsrFxEvtDeviceAdd routine\n");
//
// Initialize the pnpPowerCallbacks structure. Callback events for PNP
// and Power are specified here. If you don't supply any callbacks,
// the Framework will take appropriate default actions based on whether
// DeviceInit is initialized to be an FDO, a PDO or a filter device
// object.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// For usb devices, PrepareHardware callback is the to place select the
// interface and configure the device.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = OsrFxEvtDevicePrepareHardware;
//
// These two callbacks start and stop the wdfusb pipe continuous reader
// as we go in and out of the D0-working state.
//
pnpPowerCallbacks.EvtDeviceD0Entry = OsrFxEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = OsrFxEvtDeviceD0Exit;
pnpPowerCallbacks.EvtDeviceSelfManagedIoFlush = OsrFxEvtDeviceSelfManagedIoFlush;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoBuffered);
//
// Now specify the size of device extension where we track per device
// context.DeviceInit is completely initialized. So call the framework
// to create the device and attach it to the lower stack.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed with Status code %!STATUS!\n", status);
return status;
}
//
// Setup the activity ID so that we can log events using it.
//
activity = DeviceToActivityId(device);
//
// Get the DeviceObject context by using accessor function specified in
// the WDF_DECLARE_CONTEXT_TYPE_WITH_NAME macro for DEVICE_CONTEXT.
//
pDevContext = GetDeviceContext(device);
//
// Get the device's friendly name and location so that we can use it in
// error logging. If this fails then it will setup dummy strings.
//
GetDeviceEventLoggingNames(device);
//
// Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
// that you don't get the popup in usermodewhen you surprise remove the device.
//
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.SurpriseRemovalOK = WdfTrue;
WdfDeviceSetPnpCapabilities(device, &pnpCaps);
//
// Create a parallel default queue and register an event callback to
// receive ioctl requests. We will create separate queues for
// handling read and write requests. All other requests will be
// completed with error status automatically by the framework.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoDeviceControl = OsrFxEvtIoDeviceControl;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests for
// long time or forward them to other drivers.
// If the EvtIoStop callback is not implemented, the framework waits for
// all driver-owned requests to be done before moving in the Dx/sleep
// states or before removing the device, which is the correct behavior
// for this type of driver. If the requests were taking an indeterminate
// amount of time to complete, or if the driver forwarded the requests
// to a lower driver/another stack, the queue should have an
// EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue);// pointer to default queue
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed %!STATUS!\n", status);
goto Error;
}
//
// We will create a separate sequential queue and configure it
// to receive read requests. We also need to register a EvtIoStop
// handler so that we can acknowledge requests that are pending
// at the target driver.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoRead = OsrFxEvtIoRead;
ioQueueConfig.EvtIoStop = OsrFxEvtIoStop;
status = WdfIoQueueCreate(
device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // queue handle
);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
status = WdfDeviceConfigureRequestDispatching(
device,
queue,
WdfRequestTypeRead);
if(!NT_SUCCESS (status)){
assert(NT_SUCCESS(status));
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceConfigureRequestDispatching failed 0x%x\n", status);
goto Error;
}
//
// We will create another sequential queue and configure it
// to receive write requests.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoWrite = OsrFxEvtIoWrite;
ioQueueConfig.EvtIoStop = OsrFxEvtIoStop;
status = WdfIoQueueCreate(
device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // queue handle
);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
status = WdfDeviceConfigureRequestDispatching(
device,
queue,
WdfRequestTypeWrite);
if(!NT_SUCCESS (status)){
assert(NT_SUCCESS(status));
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceConfigureRequestDispatching failed 0x%x\n", status);
goto Error;
}
//
// Register a manual I/O queue for handling Interrupt Message Read Requests.
// This queue will be used for storing Requests that need to wait for an
// interrupt to occur before they can be completed.
//
WDF_IO_QUEUE_CONFIG_INIT(&ioQueueConfig, WdfIoQueueDispatchManual);
//
// This queue is used for requests that dont directly access the device. The
// requests in this queue are serviced only when the device is in a fully
// powered state and sends an interrupt. So we can use a non-power managed
// queue to park the requests since we dont care whether the device is idle
// or fully powered up.
//
ioQueueConfig.PowerManaged = WdfFalse;
status = WdfIoQueueCreate(device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pDevContext->InterruptMsgQueue
);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed 0x%x\n", status);
goto Error;
}
//
// Register a device interface so that app can find our device and talk to it.
//
status = WdfDeviceCreateDeviceInterface(device,
(LPGUID) &GUID_DEVINTERFACE_OSRUSBFX2,
NULL); // Reference String
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreateDeviceInterface failed %!STATUS!\n", status);
goto Error;
}
//
// Create the lock that we use to serialize calls to ResetDevice(). As an
// alternative to using a WDFWAITLOCK to serialize the calls, a sequential
// WDFQUEUE can be created and reset IOCTLs would be forwarded to it.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfWaitLockCreate(&attributes, &pDevContext->ResetDeviceWaitLock);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfWaitLockCreate failed %!STATUS!\n", status);
goto Error;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- OsrFxEvtDeviceAdd\n");
return status;
Error:
//
// Log fail to add device to the event log
//
EventWriteFailAddDevice(pDevContext->DeviceName,
pDevContext->Location,
status);
return status;
}
NTSTATUS
AmccPciAddDevice(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. It is responsible for initializing and
creating a WDFDEVICE object.
Any work that should be done after the object is created should be
deferred until EvtDeviceSoftwareInit, as that callback will be made
with the device lock held (if there is one.)
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
WDF_INTERRUPT_CONFIG interruptConfig;
WDF_OBJECT_ATTRIBUTES interruptAttributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PAMCC_DEVICE_EXTENSION devExt;
WDFQUEUE hQueue;
WDFDEVICE device;
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"AmccPciAddDevice: 0x%p", Driver);
//
// Zero out the PnpPowerCallbacks structure.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// Set Callbacks for any of the functions we are interested in.
// If no callback is set, Framework will take the default action
// by itself.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = AmccPciEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = AmccPciEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = AmccPciEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = AmccPciEvtDeviceD0Exit;
//
// Register the PnP Callbacks..
//
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
//
// Set various attributes for this device
//
WdfDeviceInitSetIoType( DeviceInit, WdfDeviceIoDirect );
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, AMCC_DEVICE_EXTENSION);
fdoAttributes.EvtCleanupCallback = AmccPciContextCleanup;
//
// We want all the queue callbacks, cancel routine, and DpcForIsr to be serialized
// at the device level, so we don't have worry about any synchronization issues.
//
fdoAttributes.SynchronizationScope = WdfSynchronizationScopeDevice;
status = WdfDeviceCreate( &DeviceInit, &fdoAttributes, &device );
if ( !NT_SUCCESS(status) ) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfDeviceInitialize failed 0x%X", status);
return status;
}
//
// Device Initialization is complete.
// Get the Device Extension and initialize it.
//
devExt = AmccPciGetDevExt(device);
devExt->Device = device;
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"PDO 0x%p, FDO 0x%p, DevExt 0x%p",
WdfDeviceWdmGetPhysicalDevice(device),
WdfDeviceWdmGetDeviceObject( device ), devExt);
//
// This device generates an interrupt. So create an interrupt object which
// will later be associated with the devices resources and connected
// by the Framework.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&interruptAttributes, INTERRUPT_DATA);
//
// Configure the Interrupt object
//
WDF_INTERRUPT_CONFIG_INIT(&interruptConfig,
AmccPciEvtInterruptIsr,
AmccPciEvtInterruptDpc);
status = WdfInterruptCreate(device,
&interruptConfig,
&interruptAttributes,
&devExt->WdfInterrupt);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfInterruptCreate failed: %!STATUS!\n", status);
return status;
}
//
// The S5933 requires DMA buffers be aligned on a 32-bit boundary
//
// NOTE: Read the existing alignment value. If it is greater than
// or equal then keep it. If it is less then update the
// alignment requirement field with this device's required
// value.
//
// NOTE: See the MSDN section titled "Initializing a Device Object"
// for details on how to specify this alignment value.
//
// NOTE: AMCC5933_ALIGNMENT__32BITS is equated to (4-1) for 32-bit
// alignment.
//
{
ULONG alignReq;
alignReq = WdfDeviceGetAlignmentRequirement( device );
if (alignReq < AMCC5933_ALIGNMENT__32BITS) {
//
// Set the S5933 alignment requirement as new value.
//
WdfDeviceSetAlignmentRequirement( device,
AMCC5933_ALIGNMENT__32BITS);
}
}
//
// Register I/O callbacks.
//
// Create a sequential IO Queue for serial operation. That means all the requests (Read/Write
// & IOCTL) are serialized to the device. Until the driver completes the request presented to it,
// the framework will not schedule another one. The requests held in the framework will be
// cancelled automatically if the source of request (application) terminate or cancels it.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE( &ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoDefault = AmccPciEvtIoDefault;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests for
// long time or forward them to other drivers.
// If the EvtIoStop callback is not implemented, the framework waits for
// all driver-owned requests to be done before moving in the Dx/sleep
// states or before removing the device, which is the correct behavior
// for this type of driver. If the requests were taking an indeterminate
// amount of time to complete, or if the driver forwarded the requests
// to a lower driver/another stack, the queue should have an
// EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate( device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&hQueue );
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS (status)) {
//
// We don't have worry about deleting the device here because framework will automatically
// cleanup that when the driver unloads.
//
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfIoQueueCreate failed %!STATUS!", status);
return status;
}
//
// Register an interface so that application can find and talk to us.
// NOTE: See the note in Public.h concerning this GUID value.
//
status = WdfDeviceCreateDeviceInterface( device,
(LPGUID) &GUID_DEVINTERFACE_AMCC_PCI,
NULL );
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"<-- AMCCAddDevice: WdfDeviceCreateDeviceInterface failed %!STATUS!", status);
return status;
}
devExt->MaximumTransferLength = MAXIMUM_REQUEST_CONTEXT_LENGTH;
//
// Set the maximum physical pages for now, but this value may change if
// there aren't enough map registers
//
devExt->MaximumPhysicalPages = MAXIMUM_PHYSICAL_PAGES;
return status;
}
DWORD Sm::LoadInstapiIfNeeded()
{
DWORD dwError = ERROR_SUCCESS;
INSTAPILIBSTRUCT* pInstapiStruct = NULL;
BidxScopeAutoSNI0( SNIAPI_TAG _T("\n") );
// Check to see if instapdll is already loaded
//
if (InterlockedCompareExchangePointer (
reinterpret_cast<volatile PVOID*>(&gpInstapiStruct),
NULL, NULL))
{
goto ErrorExit;
}
pInstapiStruct = NewNoX(gpmo) INSTAPILIBSTRUCT;
if ( NULL == pInstapiStruct )
{
dwError = ERROR_OUTOFMEMORY;
goto ErrorExit;
}
pInstapiStruct -> hInstapidll = NULL;
// Temparorily load the DLL.
//1. Read registry value SharedCode under HKLM\Software\Microsoft\Microsoft SQL Server\90\Shared,
const char szSharedPathLocation[]="Software\\Microsoft\\Microsoft SQL Server\\90";
HKEY hKey;
dwError = static_cast<DWORD> (RegOpenKeyEx( HKEY_LOCAL_MACHINE,// handle to open key
szSharedPathLocation, // subkey name
0, // reserved
KEY_QUERY_VALUE, // security access mask
&hKey )); // handle to open key
if( ERROR_SUCCESS != dwError )
{
BidTrace1(ERROR_TAG _T("Cannot retrieve the shared path. %d{WINERR}\n"), dwError);
goto ErrorExit;
}
char szSharedPath[MAX_PATH+1];
DWORD cszSharedPath = MAX_PATH;
DWORD dwSharedPathRegType;
dwError = static_cast<DWORD> ( RegQueryValueEx( hKey, // handle to key
"SharedCode", // value name
0, // reserved
&dwSharedPathRegType, // value type
(LPBYTE)szSharedPath, // value data
&cszSharedPath )); // size of value data
RegCloseKey( hKey );
if( ERROR_SUCCESS != dwError )
{
BidTrace1(ERROR_TAG _T("Cannot retrieve the shared path. %d{WINERR}\n"), dwError);
goto ErrorExit;
}
if(REG_SZ != dwSharedPathRegType)
{
// RegValue is corrupted. In this case, we error out.
dwError = ERROR_INVALID_DATA;
goto ErrorExit;
}
__analysis_assume(cszSharedPath<=MAX_PATH); //The current header we use does not annotate RegQueryValueEx correctly, adding this to suppress Prefast 26015, we could remove it when the tools set is updated to Vista SDK.
// Ensure NULL-termination.
szSharedPath[cszSharedPath] = '\0';
//2. Load instapi.dll from the location where SharedCode points to
const char szInstapidllname[] ="instapi.dll";
char szInstapipath[MAX_PATH+sizeof(szInstapidllname)+1];
if(FAILED(StringCchPrintf_lA( szInstapipath,
CCH_ANSI_STRING(szInstapipath),
"%s%s", GetDefaultLocale(),szSharedPath,szInstapidllname)))
{
dwError = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
szInstapipath[sizeof(szInstapipath)-1] = '\0';
if( NULL == (pInstapiStruct->hInstapidll = LoadLibrary( szInstapipath)) )
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load instapi.dll. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
const char * szGetSvcInstanceIDFromName = "GetSvcInstanceIDFromName";
if( !(pInstapiStruct->pfnGetSvcInstanceIDFromName
= (PFNGetSvcInstanceIDFromName)GetProcAddress( pInstapiStruct->hInstapidll,
szGetSvcInstanceIDFromName))
)
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load function GetSvcInstanceIDFromName. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
const char * szGetSQLInstanceRegStringByID = "GetSQLInstanceRegStringByID";
if( !(pInstapiStruct->pfnGetSQLInstanceRegStringByID
= (PFNGetSQLInstanceRegStringByID)GetProcAddress( pInstapiStruct->hInstapidll,
szGetSQLInstanceRegStringByID))
)
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load function GetSQLInstanceRegStringByID. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
Assert (ERROR_SUCCESS == dwError );
// Now try to set global gpInstapiStruct
if ( InterlockedCompareExchangePointer (
reinterpret_cast<volatile PVOID*>(&gpInstapiStruct),
reinterpret_cast<PVOID>(pInstapiStruct) ,NULL))
{
goto ErrorExit;
}
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("Loaded instapi.dll. %d{WINERR}\n"), dwError );
return dwError;
ErrorExit:
if ( pInstapiStruct )
{
if ( pInstapiStruct -> hInstapidll )
FreeLibrary( pInstapiStruct -> hInstapidll );
delete pInstapiStruct;
}
if ( ERROR_SUCCESS != dwError )
SNI_SET_LAST_ERROR( SM_PROV, SNIE_36, dwError );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError );
return dwError;
}
HRESULT Helpers::LoadScriptFromFile(LPCSTR filenameToLoad, LPCSTR& contents, UINT* lengthBytesOut /*= nullptr*/, std::string* fullPath /*= nullptr*/, bool shouldMute /*=false */)
{
static char sHostApplicationPathBuffer[MAX_URI_LENGTH];
static uint sHostApplicationPathBufferLength = (uint) -1;
char combinedPathBuffer[MAX_URI_LENGTH];
HRESULT hr = S_OK;
BYTE * pRawBytes = nullptr;
BYTE * pRawBytesFromMap = nullptr;
UINT lengthBytes = 0;
contents = nullptr;
FILE * file = NULL;
size_t bufferLength = 0;
LPCSTR filename = fullPath == nullptr ? filenameToLoad : LPCSTR(fullPath->c_str());
if (sHostApplicationPathBufferLength == (uint)-1)
{
// consider incoming filename as the host app and base its' path for others
sHostApplicationPathBufferLength = GetPathNameLocation(filename);
if (sHostApplicationPathBufferLength == -1)
{
// host app has no path info. (it must be located on current folder!)
sHostApplicationPathBufferLength = 0;
}
else
{
sHostApplicationPathBufferLength += 1;
Assert(sHostApplicationPathBufferLength < MAX_URI_LENGTH);
// save host app's path and fix the path separator for platform
pathcpy(sHostApplicationPathBuffer, filename, sHostApplicationPathBufferLength);
}
sHostApplicationPathBuffer[sHostApplicationPathBufferLength] = char(0);
}
else if (filename[0] != '/' && filename[0] != '\\' && fullPath == nullptr) // make sure it's not a full path
{
// concat host path and filename
uint len = ConcatPath(sHostApplicationPathBuffer, sHostApplicationPathBufferLength,
filename, combinedPathBuffer, MAX_URI_LENGTH);
if (len == (uint)-1)
{
hr = E_FAIL;
goto Error;
}
filename = combinedPathBuffer;
}
// check if have it registered
AutoString *data;
if (SourceMap::Find(filenameToLoad, strlen(filenameToLoad), &data) ||
SourceMap::Find(filename, strlen(filename), &data))
{
pRawBytesFromMap = (BYTE*) data->GetString();
lengthBytes = (UINT) data->GetLength();
}
else
{
// Open the file as a binary file to prevent CRT from handling encoding, line-break conversions,
// etc.
if (fopen_s(&file, filename, "rb") != 0)
{
if (!HostConfigFlags::flags.MuteHostErrorMsgIsEnabled && !shouldMute)
{
#ifdef _WIN32
DWORD lastError = GetLastError();
char16 wszBuff[MAX_URI_LENGTH];
fprintf(stderr, "Error in opening file '%s' ", filename);
wszBuff[0] = 0;
if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
lastError,
0,
wszBuff,
_countof(wszBuff),
nullptr))
{
fwprintf(stderr, _u(": %s"), wszBuff);
}
fwprintf(stderr, _u("\n"));
#elif defined(_POSIX_VERSION)
fprintf(stderr, "Error in opening file: ");
perror(filename);
#endif
}
IfFailGo(E_FAIL);
}
}
if (file != NULL)
{
// Determine the file length, in bytes.
fseek(file, 0, SEEK_END);
lengthBytes = ftell(file);
fseek(file, 0, SEEK_SET);
}
if (lengthBytes != 0)
{
bufferLength = lengthBytes + sizeof(BYTE);
pRawBytes = (LPBYTE)malloc(bufferLength);
}
else
{
bufferLength = 1;
pRawBytes = (LPBYTE)malloc(bufferLength);
}
if (nullptr == pRawBytes)
{
fwprintf(stderr, _u("out of memory"));
IfFailGo(E_OUTOFMEMORY);
}
if (lengthBytes != 0)
{
if (file != NULL)
{
//
// Read the entire content as a binary block.
//
size_t readBytes = fread(pRawBytes, sizeof(BYTE), lengthBytes, file);
if (readBytes < lengthBytes * sizeof(BYTE))
{
IfFailGo(E_FAIL);
}
}
else // from module source register
{
// Q: module source is on persistent memory. Why do we use the copy instead?
// A: if we use the same memory twice, ch doesn't know that during FinalizeCallback free.
// the copy memory will be freed by the finalizer
Assert(pRawBytesFromMap);
memcpy_s(pRawBytes, bufferLength, pRawBytesFromMap, lengthBytes);
}
}
if (pRawBytes)
{
pRawBytes[lengthBytes] = 0; // Null terminate it. Could be UTF16
}
if (file != NULL)
{
//
// Read encoding to make sure it's supported
//
// Warning: The UNICODE buffer for parsing is supposed to be provided by the host.
// This is not a complete read of the encoding. Some encodings like UTF7, UTF1, EBCDIC, SCSU, BOCU could be
// wrongly classified as ANSI
//
#pragma warning(push)
// suppressing prefast warning that "readable size is bufferLength
// bytes but 2 may be read" as bufferLength is clearly > 2 in the code that follows
#pragma warning(disable:6385)
C_ASSERT(sizeof(WCHAR) == 2);
if (bufferLength > 2)
{
__analysis_assume(bufferLength > 2);
#pragma prefast(push)
#pragma prefast(disable:6385, "PREfast incorrectly reports this as an out-of-bound access.");
if ((pRawBytes[0] == 0xFE && pRawBytes[1] == 0xFF) ||
(pRawBytes[0] == 0xFF && pRawBytes[1] == 0xFE) ||
(bufferLength > 4 && pRawBytes[0] == 0x00 && pRawBytes[1] == 0x00 &&
((pRawBytes[2] == 0xFE && pRawBytes[3] == 0xFF) ||
(pRawBytes[2] == 0xFF && pRawBytes[3] == 0xFE))))
{
// unicode unsupported
fwprintf(stderr, _u("unsupported file encoding. Only ANSI and UTF8 supported"));
IfFailGo(E_UNEXPECTED);
}
#pragma prefast(pop)
}
#pragma warning(pop)
}
contents = reinterpret_cast<LPCSTR>(pRawBytes);
Error:
if (SUCCEEDED(hr))
{
if (lengthBytesOut)
{
*lengthBytesOut = lengthBytes;
}
}
if (file != NULL)
{
fclose(file);
}
if (pRawBytes && reinterpret_cast<LPCSTR>(pRawBytes) != contents)
{
free(pRawBytes);
}
return hr;
}
