/* Copyright (c) Citrix Systems Inc.
* All rights reserved.
- *
- * Redistribution and use in source and binary forms,
- * with or without modification, are permitted provided
+ *
+ * Redistribution and use in source and binary forms,
+ * with or without modification, are permitted provided
* that the following conditions are met:
- *
- * * Redistributions of source code must retain the above
- * copyright notice, this list of conditions and the
+ *
+ * * Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the
* following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the
- * following disclaimer in the documentation and/or other
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the
+ * following disclaimer in the documentation and/or other
* materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
ANSI_STRING AnsiValue;
char *value;
NTSTATUS status;
- NT_ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
+ NT_ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
status = XENBUS_STORE(Read,
&Fdo->StoreInterface,
NULL,
}
ZwClose(RegHandle);
-
+
RtlFreeUnicodeString(&UnicodeValue);
XENBUS_STORE(Free, &Fdo->StoreInterface, value);
#define REGISTRY_THREAD_END_EVENT 1
#define REGISTRY_EVENTS 2
-static NTSTATUS FdoRegistryThreadHandler(IN PXENIFACE_THREAD Self,
- IN PVOID StartContext) {
- KEVENT* threadevents[REGISTRY_EVENTS];
- PXENIFACE_FDO Fdo = (PXENIFACE_FDO)StartContext;
- NTSTATUS status;
+static NTSTATUS FdoRegistryThreadHandler(IN PXENIFACE_THREAD Self,
+ IN PVOID StartContext) {
+ KEVENT* threadevents[REGISTRY_EVENTS];
+ PXENIFACE_FDO Fdo = (PXENIFACE_FDO)StartContext;
+ NTSTATUS status;
- PKEVENT Event;
+ PKEVENT Event;
Event = ThreadGetEvent(Self);
- threadevents[REGISTRY_WRITE_EVENT] = &Fdo->registryWriteEvent;
- threadevents[REGISTRY_THREAD_END_EVENT] = Event;
+ threadevents[REGISTRY_WRITE_EVENT] = &Fdo->registryWriteEvent;
+ threadevents[REGISTRY_THREAD_END_EVENT] = Event;
- for(;;) {
-
- status = KeWaitForMultipleObjects(REGISTRY_EVENTS, (PVOID *)threadevents, WaitAny, Executive, KernelMode, TRUE, NULL, NULL);
- if ((status>=STATUS_WAIT_0) && (status < STATUS_WAIT_0+REGISTRY_EVENTS)) {
- if (status == STATUS_WAIT_0+REGISTRY_WRITE_EVENT) {
+ for(;;) {
+
+ status = KeWaitForMultipleObjects(REGISTRY_EVENTS, (PVOID *)threadevents, WaitAny, Executive, KernelMode, TRUE, NULL, NULL);
+ if ((status>=STATUS_WAIT_0) && (status < STATUS_WAIT_0+REGISTRY_EVENTS)) {
+ if (status == STATUS_WAIT_0+REGISTRY_WRITE_EVENT) {
XenIfaceDebugPrint(ERROR,"WriteRegistry\n");
FdoInitialiseXSRegistryEntries(Fdo);
KeClearEvent(threadevents[REGISTRY_WRITE_EVENT]);
- }
- if (status == STATUS_WAIT_0+REGISTRY_THREAD_END_EVENT) {
- if (ThreadIsAlerted(Self))
- return STATUS_SUCCESS;
- KeClearEvent(threadevents[REGISTRY_THREAD_END_EVENT]);
- }
-
- }
- else if (!NT_SUCCESS(status)) {
- XenIfaceDebugPrint(ERROR, "Registry handler thread failed %x\n", status);
- return status;
- }
- }
+ }
+ if (status == STATUS_WAIT_0+REGISTRY_THREAD_END_EVENT) {
+ if (ThreadIsAlerted(Self))
+ return STATUS_SUCCESS;
+ KeClearEvent(threadevents[REGISTRY_THREAD_END_EVENT]);
+ }
+
+ }
+ else if (!NT_SUCCESS(status)) {
+ XenIfaceDebugPrint(ERROR, "Registry handler thread failed %x\n", status);
+ return status;
+ }
+ }
}
status = RtlUnicodeStringToAnsiString(&Ansi, &Unicode, FALSE);
if (!NT_SUCCESS(status))
goto fail1;
-
+
for (Index = 0; Dx->Name[Index] != '\0'; Index++) {
if (!isalnum((UCHAR)Dx->Name[Index]))
Dx->Name[Index] = '_';
IN PVOID Context
)
{
- PKEVENT Event = (PKEVENT)Context;
+ PKEVENT Event = (PKEVENT)Context;
UNREFERENCED_PARAMETER(DeviceObject);
UNREFERENCED_PARAMETER(Irp);
for (Index = 0; Ansi[Index].Buffer != NULL; Index++)
__FdoFree(Ansi[Index].Buffer);
-
+
__FdoFree(Ansi);
}
if (!NT_SUCCESS(status))
goto fail4;
- Fdo->InterfacesAcquired = TRUE;
+ Fdo->InterfacesAcquired = TRUE;
KeLowerIrql(Irql);
return STATUS_SUCCESS;
fail4:
Error("fail4\n");
- XENBUS_SHARED_INFO(Release, &Fdo->SharedInfoInterface);
+ XENBUS_SHARED_INFO(Release, &Fdo->SharedInfoInterface);
fail3:
Error("fail3\n");
KIRQL Irql;
ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
- Fdo->InterfacesAcquired = FALSE;
+ Fdo->InterfacesAcquired = FALSE;
KeRaiseIrql(DISPATCH_LEVEL, &Irql);
XENBUS_SUSPEND(Deregister,
Fdo->SuspendCallbackLate);
Fdo->SuspendCallbackLate = NULL;
- XENBUS_SHARED_INFO(Release, &Fdo->SharedInfoInterface);
+ XENBUS_SHARED_INFO(Release, &Fdo->SharedInfoInterface);
XENBUS_SUSPEND(Release, &Fdo->SuspendInterface);
__FdoD0ToD3(Fdo);
-
+
KeLowerIrql(Irql);
}
if (!NT_SUCCESS(status))
goto fail3;
- status = IoSetDeviceInterfaceState(&Fdo->InterfaceName, TRUE);
- if (!NT_SUCCESS(status))
- goto fail4;
+ status = IoSetDeviceInterfaceState(&Fdo->InterfaceName, TRUE);
+ if (!NT_SUCCESS(status))
+ goto fail4;
- if (__FdoGetDevicePnpState(Fdo) != Stopped) {
- status = WmiInit(Fdo);
- if (!NT_SUCCESS(status))
- goto fail5;
- }
+ if (__FdoGetDevicePnpState(Fdo) != Stopped) {
+ status = WmiInit(Fdo);
+ if (!NT_SUCCESS(status))
+ goto fail5;
+ }
__FdoSetDevicePnpState(Fdo, Started);
return status;
fail5:
- Error("fail5\n");
+ Error("fail5\n");
#pragma warning(suppress : 6031)
- IoSetDeviceInterfaceState(&Fdo->InterfaceName, FALSE);
+ IoSetDeviceInterfaceState(&Fdo->InterfaceName, FALSE);
fail4:
- Error("fail4\n");
- FdoD0ToD3(Fdo);
+ Error("fail4\n");
+ FdoD0ToD3(Fdo);
fail3:
Error("fail3\n");
__FdoSetDevicePnpState(Fdo, SurpriseRemovePending);
Irp->IoStatus.Status = STATUS_SUCCESS;
-#pragma warning(suppress : 6031)
+#pragma warning(suppress : 6031)
IoSetDeviceInterfaceState(&Fdo->InterfaceName, FALSE);
WmiFinalise(Fdo);
if (__FdoGetDevicePowerState(Fdo) != PowerDeviceD0)
goto done;
- FdoD0ToD3(Fdo);
+ FdoD0ToD3(Fdo);
__FdoSetSystemPowerState(Fdo, PowerSystemSleeping3);
FdoS3ToS4(Fdo);
__FdoSetDevicePnpState(Fdo, Deleted);
Irp->IoStatus.Status = STATUS_SUCCESS;
-#pragma warning(suppress : 6031)
+#pragma warning(suppress : 6031)
IoSetDeviceInterfaceState(&Fdo->InterfaceName, FALSE);
WmiFinalise(Fdo);
if (!NT_SUCCESS(status))
goto fail1;
- NotDisableable = FALSE;
+ NotDisableable = FALSE;
for (Type = (DEVICE_USAGE_NOTIFICATION_TYPE)0; Type <= DeviceUsageTypeDumpFile; Type++) {
if (Fdo->Usage[Type] != 0) {
NotDisableable = TRUE;
if (Fdo->NotDisableable != NotDisableable) {
Fdo->NotDisableable = NotDisableable;
-
+
IoInvalidateDeviceState(__FdoGetPhysicalDeviceObject(Fdo));
}
MinorFunction = StackLocation->MinorFunction;
Trace("====> (%02x:%s)\n",
- MinorFunction,
- PnpMinorFunctionName(MinorFunction));
+ MinorFunction,
+ PnpMinorFunctionName(MinorFunction));
switch (StackLocation->MinorFunction) {
case IRP_MN_START_DEVICE:
}
Trace("<==== (%02x:%s)(%08x)\n",
- MinorFunction,
+ MinorFunction,
PnpMinorFunctionName(MinorFunction),
- status);
+ status);
return status;
}
ASSERT3U(DeviceState, ==, PowerDeviceD0);
status = FdoD3ToD0(Fdo);
- SessionsResumeAll(Fdo);
+ SessionsResumeAll(Fdo);
ASSERT(NT_SUCCESS(status));
done:
ASSERT3U(DeviceState, ==, PowerDeviceD3);
if (__FdoGetDevicePowerState(Fdo) == PowerDeviceD0){
- SessionsSuspendAll(Fdo);
+ SessionsSuspendAll(Fdo);
FdoD0ToD3(Fdo);
- }
+ }
IoSkipCurrentIrpStackLocation(Irp);
status = IoCallDriver(Fdo->LowerDeviceObject, Irp);
PowerAction = StackLocation->Parameters.Power.ShutdownType;
Trace("====> (%s:%s)\n",
- PowerDeviceStateName(DeviceState),
+ PowerDeviceStateName(DeviceState),
PowerActionName(PowerAction));
ASSERT3U(PowerAction, <, PowerActionShutdown);
done:
Trace("<==== (%s:%s)(%08x)\n",
- PowerDeviceStateName(DeviceState),
+ PowerDeviceStateName(DeviceState),
PowerActionName(PowerAction),
status);
return status;
PowerAction = StackLocation->Parameters.Power.ShutdownType;
Trace("====> (%s:%s)\n",
- PowerSystemStateName(SystemState),
+ PowerSystemStateName(SystemState),
PowerActionName(PowerAction));
ASSERT3U(PowerAction, <, PowerActionShutdown);
done:
Trace("<==== (%s:%s)(%08x)\n",
- PowerSystemStateName(SystemState),
+ PowerSystemStateName(SystemState),
PowerActionName(PowerAction),
status);
return status;
PowerAction = StackLocation->Parameters.Power.ShutdownType;
Trace("====> (%s:%s)\n",
- PowerDeviceStateName(DeviceState),
+ PowerDeviceStateName(DeviceState),
PowerActionName(PowerAction));
ASSERT3U(PowerAction, <, PowerActionShutdown);
done:
Trace("<==== (%s:%s)(%08x)\n",
- PowerDeviceStateName(DeviceState),
+ PowerDeviceStateName(DeviceState),
PowerActionName(PowerAction),
status);
return status;
PowerAction = StackLocation->Parameters.Power.ShutdownType;
Trace("====> (%s:%s)\n",
- PowerSystemStateName(SystemState),
+ PowerSystemStateName(SystemState),
PowerActionName(PowerAction));
ASSERT3U(PowerAction, <, PowerActionShutdown);
done:
Trace("<==== (%s:%s)(%08x)\n",
- PowerSystemStateName(SystemState),
+ PowerSystemStateName(SystemState),
PowerActionName(PowerAction),
status);
status = FdoDispatchPower(Fdo, Irp);
break;
- case IRP_MJ_DEVICE_CONTROL:
- status = XenIFaceIoctl(Fdo, Irp);
- break;
+ case IRP_MJ_DEVICE_CONTROL:
+ status = XenIFaceIoctl(Fdo, Irp);
+ break;
- case IRP_MJ_SYSTEM_CONTROL:
- status = XenIfaceSystemControl(Fdo, Irp);
- break;
+ case IRP_MJ_SYSTEM_CONTROL:
+ status = XenIfaceSystemControl(Fdo, Irp);
+ break;
- case IRP_MJ_READ:
- case IRP_MJ_WRITE:
- status = FdoReadWrite(Fdo, Irp);
- break;
+ case IRP_MJ_READ:
+ case IRP_MJ_WRITE:
+ status = FdoReadWrite(Fdo, Irp);
+ break;
- case IRP_MJ_CREATE:
- status = FdoCreateFile(Fdo, Irp);
- break;
+ case IRP_MJ_CREATE:
+ status = FdoCreateFile(Fdo, Irp);
+ break;
- case IRP_MJ_CLOSE:
- status = FdoClose(Fdo, Irp);
- break;
+ case IRP_MJ_CLOSE:
+ status = FdoClose(Fdo, Irp);
+ break;
default:
status = FdoDispatchDefault(Fdo, Irp);
StackLocation->Parameters.QueryInterface.Size = (USHORT)Size;
StackLocation->Parameters.QueryInterface.Version = (USHORT)Version;
StackLocation->Parameters.QueryInterface.Interface = Interface;
-
+
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
status = IoCallDriver(Fdo->LowerDeviceObject, Irp);
Dx->SystemPowerState = PowerSystemShutdown;
Dx->DevicePowerState = PowerDeviceD3;
- FunctionDeviceObject->Flags |= DO_POWER_PAGABLE;
+ FunctionDeviceObject->Flags |= DO_POWER_PAGABLE;
FunctionDeviceObject->Flags |= DO_BUFFERED_IO;
Fdo = (PXENIFACE_FDO)__FdoAllocate(sizeof (XENIFACE_FDO));
goto fail5;
#pragma prefast(suppress:6014) // Possibly leaking Fdo->InterfaceName
- status = IoRegisterDeviceInterface(PhysicalDeviceObject,
- (LPGUID)&GUID_INTERFACE_XENIFACE,
- NULL,
- &Fdo->InterfaceName);
- if (!NT_SUCCESS(status))
- goto fail6;
+ status = IoRegisterDeviceInterface(PhysicalDeviceObject,
+ (LPGUID)&GUID_INTERFACE_XENIFACE,
+ NULL,
+ &Fdo->InterfaceName);
+ if (!NT_SUCCESS(status))
+ goto fail6;
status = __FdoSetName(Fdo, Name);
if (!NT_SUCCESS(status))
InitializeListHead(&Dx->ListEntry);
Fdo->References = 1;
- FdoInitialiseXSRegistryEntries(Fdo);
+ FdoInitialiseXSRegistryEntries(Fdo);
- KeInitializeEvent(&Fdo->registryWriteEvent, NotificationEvent, FALSE);
+ KeInitializeEvent(&Fdo->registryWriteEvent, NotificationEvent, FALSE);
- status = ThreadCreate(FdoRegistryThreadHandler, Fdo, &Fdo->registryThread);
- if (!NT_SUCCESS(status))
- goto fail11;
+ status = ThreadCreate(FdoRegistryThreadHandler, Fdo, &Fdo->registryThread);
+ if (!NT_SUCCESS(status))
+ goto fail11;
Info("%p (%s)\n",
FunctionDeviceObject,
return STATUS_SUCCESS;
-
+
fail11:
- Error("fail11\n");
+ Error("fail11\n");
RtlZeroMemory(&Fdo->StoreInterface,
sizeof (XENBUS_STORE_INTERFACE));
fail10:
- Error("fail10\n");
+ Error("fail10\n");
RtlZeroMemory(&Fdo->SharedInfoInterface,
sizeof (XENBUS_SHARED_INFO_INTERFACE));
fail7:
Error("fail7\n");
- RtlFreeUnicodeString(&Fdo->InterfaceName);
- RtlZeroMemory(&Fdo->InterfaceName,sizeof(UNICODE_STRING));
+ RtlFreeUnicodeString(&Fdo->InterfaceName);
+ RtlZeroMemory(&Fdo->InterfaceName,sizeof(UNICODE_STRING));
fail6:
Error("fail6\n");
ThreadAlert(Fdo->DevicePowerThread);
ThreadJoin(Fdo->DevicePowerThread);
Fdo->DevicePowerThread = NULL;
-
+
fail4:
Error("fail4\n");
ThreadAlert(Fdo->SystemPowerThread);
ThreadJoin(Fdo->SystemPowerThread);
Fdo->SystemPowerThread = NULL;
-
+
fail3:
Error("fail3\n");
RtlZeroMemory(&Fdo->Mutex, sizeof (XENIFACE_MUTEX));
- Fdo->InterfacesAcquired = FALSE;
+ Fdo->InterfacesAcquired = FALSE;
RtlZeroMemory(&Fdo->StoreInterface,
sizeof (XENBUS_STORE_INTERFACE));
RtlZeroMemory(&Fdo->SuspendInterface,
sizeof (XENBUS_SUSPEND_INTERFACE));
- ThreadAlert(Fdo->registryThread);
+ ThreadAlert(Fdo->registryThread);
ThreadJoin(Fdo->registryThread);
Fdo->registryThread = NULL;
Fdo->PhysicalDeviceObject = NULL;
Fdo->Dx = NULL;
- RtlZeroMemory(&Fdo->SessionLock, sizeof(FAST_MUTEX));
- RtlZeroMemory(&Fdo->SessionHead, sizeof(LIST_ENTRY));
- RtlZeroMemory(&Fdo->registryWriteEvent, sizeof(KEVENT));
+ RtlZeroMemory(&Fdo->SessionLock, sizeof(FAST_MUTEX));
+ RtlZeroMemory(&Fdo->SessionHead, sizeof(LIST_ENTRY));
+ RtlZeroMemory(&Fdo->registryWriteEvent, sizeof(KEVENT));
- RtlFreeUnicodeString(&Fdo->InterfaceName);
- RtlZeroMemory(&Fdo->InterfaceName,sizeof(UNICODE_STRING));
+ RtlFreeUnicodeString(&Fdo->InterfaceName);
+ RtlZeroMemory(&Fdo->InterfaceName,sizeof(UNICODE_STRING));
ASSERT(IsZeroMemory(Fdo, sizeof (XENIFACE_FDO)));
__FdoFree(Fdo);
/* Copyright (c) Citrix Systems Inc.
* All rights reserved.
*
- * Redistribution and use in source and binary forms,
- * with or without modification, are permitted provided
+ * Redistribution and use in source and binary forms,
+ * with or without modification, are permitted provided
* that the following conditions are met:
*
- * * Redistributions of source code must retain the above
- * copyright notice, this list of conditions and the
+ * * Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the
* following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the
- * following disclaimer in the documentation and/or other
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the
+ * following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <version.h>
__drv_raisesIRQL(APC_LEVEL)
-__drv_savesIRQLGlobal(OldIrql, fdoData->SessionLock)
+__drv_savesIRQLGlobal(OldIrql, fdoData->SessionLock)
void LockSessions(
XENIFACE_FDO* fdoData)
{
// Rather inconveniently, xenstore needs UTF8 data, WMI works in UTF16
// and windows doesn't provide conversion functions in any version
-// prior to Windows 7.
+// prior to Windows 7.
USHORT Utf32FromUtf16(ULONG *utf32, const WCHAR* utf16) {
ULONG w;
else if ((utf8[0] & 0xE0) == 0xC0) {
y = utf8[0] & 0x1F;
x = utf8[1] & 0x3F;
- *utf32 = (y<<6) | x;
+ *utf32 = (y<<6) | x;
return 2;
}
else if ((utf8[0] & 0xF0) == 0xE0) {
z = utf8[0] & 0x0F;
y = utf8[1] & 0x3F;
x = utf8[2] & 0x3F;
- *utf32 = (z <<12) | (y<<6) | x;
+ *utf32 = (z <<12) | (y<<6) | x;
return 3;
- }
+ }
else {
ua = utf8[0] & 0x7;
ub = (utf8[1] & 0x30) >> 4;
u = (ua << 2) | ub;
z = utf8[1] & 0x0f;
- y = utf8[2] & 0x3f;
+ y = utf8[2] & 0x3f;
x = utf8[3] & 0x3f;
*utf32 = (u<<16) | (z <<12) | (y <<6) | x;
return 4;
(*utf8)->Length = bytecount;
(*utf8)->Buffer[bytecount]=0;
-
+
bytecount = 0;
i=0;
while (i < bufsize/sizeof(WCHAR)) {
USHORT bufsize = *(USHORT*)location;
LPWSTR ustring = (LPWSTR)(location+sizeof(USHORT));
GetUnicodeString(unicode, bufsize, ustring);
-}
+}
NTSTATUS GetCountedAnsiString(ANSI_STRING *ansi, UCHAR *location)
{
WMI_STRINGOFFSET
} WMI_TYPE;
-int AccessWmiBuffer(PUCHAR Buffer, int readbuffer, ULONG * RequiredSize,
+int AccessWmiBuffer(PUCHAR Buffer, int readbuffer, ULONG * RequiredSize,
size_t BufferSize, ...) {
va_list vl;
ULONG_PTR offset;
UCHAR *bufferpos = Buffer + inpos;
ULONG insize = va_arg(vl, ULONG);
UCHAR **writebuf = va_arg(vl, UCHAR**);
- *writebuf = NULL;
+ *writebuf = NULL;
if (bufferpos+ insize > endbuffer) {;
overflow = TRUE;
}
LPWSTR *val;
offset = (2-((ULONG_PTR)position%2))%2;
position += offset;
- if (position + sizeof(WCHAR)*25 > endbuffer)
+ if (position + sizeof(WCHAR)*25 > endbuffer)
overflow = TRUE;
- val = va_arg(vl, LPWSTR*);
- *val = NULL;
- if (!overflow)
- *val = (LPWSTR )position;
+ val = va_arg(vl, LPWSTR*);
+ *val = NULL;
+ if (!overflow)
+ *val = (LPWSTR )position;
position += sizeof(WCHAR)*25;
}
break;
break;
}
}
- *RequiredSize = (ULONG)(position - Buffer);
+ *RequiredSize = (ULONG)(position - Buffer);
va_end(vl);
if (overflow)
return FALSE;
}
-NTSTATUS
+NTSTATUS
WriteCountedUnicodeString(
- const UNICODE_STRING *ustr,
+ const UNICODE_STRING *ustr,
UCHAR *location
)
{
}
buffer[bytesize/sizeof(WCHAR)] = 0;
- i=0;
+ i=0;
b=0;
while (string[i] != 0) {
i += Utf32FromUtf8(&utf32, &string[i]);
WriteCountedString(
const char * string,
UCHAR * location
- )
+ )
{
ANSI_STRING ansi;
UNICODE_STRING unicode;
RtlInitAnsiString(&ansi, string);
status = RtlAnsiStringToUnicodeString(&unicode, &ansi, TRUE);
- if (NT_SUCCESS(status)) {
+ if (NT_SUCCESS(status)) {
status = WriteCountedUnicodeString(&unicode, location);
RtlFreeUnicodeString(&unicode);
return status;
}
-NTSTATUS
+NTSTATUS
StringToUnicode(UNICODE_STRING *ustr, const char * str) {
ANSI_STRING ansi;
RtlInitAnsiString(&ansi, str);
return status;
}
destsz = FdoData->SuggestedInstanceName.Length +
- sizeof(WCHAR) +
+ sizeof(WCHAR) +
unicode.Length;
AllocUnicodeStringBuffer(dest, (USHORT)destsz);
RtlFreeUnicodeString(&unicode);
return STATUS_INSUFFICIENT_RESOURCES;
}
- status = RtlUnicodeStringPrintf(dest, L"%s\\%s",
- FdoData->SuggestedInstanceName.Buffer,
+ status = RtlUnicodeStringPrintf(dest, L"%s\\%s",
+ FdoData->SuggestedInstanceName.Buffer,
unicode.Buffer);
if (!NT_SUCCESS(status)) {
RtlFreeUnicodeString(&unicode);
dest->Buffer = src->Buffer;
dest->Length = src->Length;
dest->MaximumLength = src->MaximumLength;
-}
+}
XenStoreSession*
-FindSessionLocked(XENIFACE_FDO *fdoData,
+FindSessionLocked(XENIFACE_FDO *fdoData,
LONG id) {
XenStoreSession *session;
-
+
session = (XenStoreSession *)fdoData->SessionHead.Flink;
while (session != (XenStoreSession *)&fdoData->SessionHead){
if (session->id == id) {
SessionFindWatchLocked(XenStoreSession *session,
UNICODE_STRING *path) {
XenStoreWatch * watch;
-
+
XenIfaceDebugPrint(TRACE,"Wait for session watch lock\n");
ExAcquireFastMutex(&session->WatchMapLock);
XenIfaceDebugPrint(TRACE,"got session watch lock\n");
XenIfaceDebugPrint(WARNING,"couldn't find watch\n");
return NULL;
-}
+}
void FireSuspendEvent(PXENIFACE_FDO fdoData) {
- XenIfaceDebugPrint(ERROR,"Ready to unsuspend Event\n");
- KeSetEvent(&fdoData->registryWriteEvent, IO_NO_INCREMENT, FALSE);
+ XenIfaceDebugPrint(ERROR,"Ready to unsuspend Event\n");
+ KeSetEvent(&fdoData->registryWriteEvent, IO_NO_INCREMENT, FALSE);
if (fdoData->WmiReady) {
XenIfaceDebugPrint(TRACE,"Fire Suspend Event\n");
WmiFireEvent(fdoData->Dx->DeviceObject,
0,
NULL);
}
-}
+}
void FireWatch(XenStoreWatch* watch) {
UCHAR * eventdata;
ULONG RequiredSize;
WMI_STRING, GetCountedUnicodeStringSize(&watch->path),
&sesbuf,
WMI_DONE);
-
+
eventdata = ExAllocatePoolWithTag(NonPagedPool, RequiredSize,'XIEV');
if (eventdata!=NULL) {
AccessWmiBuffer(eventdata, FALSE, &RequiredSize, RequiredSize,
&sesbuf,
WMI_DONE);
- WriteCountedUnicodeString(&watch->path, sesbuf);
+ WriteCountedUnicodeString(&watch->path, sesbuf);
}
if (eventdata !=NULL) {
XenIfaceDebugPrint(TRACE,"Fire Watch Event\n");
- WmiFireEvent(watch->fdoData->Dx->DeviceObject,
+ WmiFireEvent(watch->fdoData->Dx->DeviceObject,
(LPGUID)&OBJECT_GUID(XenStoreWatchEvent),
0,
- RequiredSize,
+ RequiredSize,
eventdata);
- }
+ }
}
NTSTATUS
StartWatch(XENIFACE_FDO *fdoData, XenStoreWatch *watch)
{
- char *tmppath;
+ char *tmppath;
ANSI_STRING ansipath;
NTSTATUS status;
status = RtlUnicodeStringToAnsiString(&ansipath, &watch->path, TRUE);
}
RtlZeroMemory(tmppath, ansipath.Length+1);
RtlCopyBytes(tmppath,ansipath.Buffer, ansipath.Length);
-
+
status = XENBUS_STORE(WatchAdd, &fdoData->StoreInterface, NULL, tmppath, &watch->watchevent, &watch->watchhandle );
if (!NT_SUCCESS(status)) {
ExFreePool(tmppath);
watch = (XenStoreWatch *)watch->listentry.Flink;
}
session->mapchanged = FALSE;
- session->watchevents[i] = &session->SessionChangedEvent;
+ session->watchevents[i] = &session->SessionChangedEvent;
}
ExReleaseFastMutex(&session->WatchMapLock);
XenIfaceDebugPrint(TRACE,"Wait for new event\n");
if (watch->suspendcount !=XENBUS_SUSPEND(GetCount, &watch->fdoData->SuspendInterface)) {
watch->suspendcount = XENBUS_SUSPEND(GetCount, &watch->fdoData->SuspendInterface);
XenIfaceDebugPrint(WARNING,"SessionSuspendResumeUnwatch %p\n", watch->watchhandle);
-
+
XENBUS_STORE(WatchRemove, &watch->fdoData->StoreInterface, watch->watchhandle);
StartWatch(watch->fdoData, watch);
}
}
else if ( status == STATUS_WAIT_0 + i) {
ExAcquireFastMutex(&session->WatchMapLock);
- KeClearEvent(&session->SessionChangedEvent);
+ KeClearEvent(&session->SessionChangedEvent);
if (session->closing==TRUE) {
XenIfaceDebugPrint(TRACE,"Trying to end session thread\n");
if (session->watchcount != 0) {
XenStoreWatch *watch;
- for (watch = (XenStoreWatch *)session->watches.Flink;
- watch!=(XenStoreWatch *)&session->watches;
+ for (watch = (XenStoreWatch *)session->watches.Flink;
+ watch!=(XenStoreWatch *)&session->watches;
watch=(XenStoreWatch *)session->watches.Flink) {
FreeUnicodeStringBuffer(&watch->path);
RemoveEntryList((LIST_ENTRY*)watch);
//ExReleaseFastMutex(&session->WatchMapLock);
}
else {
-
+
ExReleaseFastMutex(&session->WatchMapLock);
}
}
}
NTSTATUS
-SessionAddWatchLocked(XenStoreSession *session,
- XENIFACE_FDO* fdoData,
+SessionAddWatchLocked(XenStoreSession *session,
+ XENIFACE_FDO* fdoData,
UNICODE_STRING *path,
XenStoreWatch **watch) {
-
+
NTSTATUS status;
XenStoreWatch *pwatch;
return STATUS_INSUFFICIENT_RESOURCES;
}
- (*watch)->finished = FALSE;
+ (*watch)->finished = FALSE;
(*watch)->fdoData = fdoData;
UnicodeShallowCopy(&(*watch)->path, path);
-
+
(*watch)->suspendcount = XENBUS_SUSPEND(GetCount, &fdoData->SuspendInterface);
-
+
KeInitializeEvent(&(*watch)->watchevent, NotificationEvent, FALSE);
-
+
status = StartWatch(fdoData, *watch);
if ((!NT_SUCCESS(status)) || ((*watch)->watchhandle == NULL)) {
ExFreePool(*watch);
XenIfaceDebugPrint(TRACE, "wait remove mutex\n");
ExAcquireFastMutex(&session->WatchMapLock);
- for (watch = (XenStoreWatch *)session->watches.Flink;
- watch!=(XenStoreWatch *)&session->watches;
+ for (watch = (XenStoreWatch *)session->watches.Flink;
+ watch!=(XenStoreWatch *)&session->watches;
watch=(XenStoreWatch *)watch->listentry.Flink) {
XenIfaceDebugPrint(TRACE, "try remove %p\n",session->watches.Flink );
FindSessionByInstanceLocked(XENIFACE_FDO *fdoData,
UNICODE_STRING *instance) {
XenStoreSession *session;
-
+
session = (XenStoreSession *)fdoData->SessionHead.Flink;
while (session != (XenStoreSession *)&fdoData->SessionHead) {
if (CompareUnicodeStrings(instance, &session->instancename)==0) {
out = ExAllocatePoolWithTag(NonPagedPool, basesize, 'XenP');
if (out == NULL)
return NULL;
-
+
status = RtlStringCbVPrintfExA(out, basesize, NULL, &unused,0, fmt, argv);
ExFreePool(out);
return out;
}
-NTSTATUS
-CreateNewSession(XENIFACE_FDO *fdoData,
- UNICODE_STRING *stringid,
+NTSTATUS
+CreateNewSession(XENIFACE_FDO *fdoData,
+ UNICODE_STRING *stringid,
ULONG *sessionid) {
XenStoreSession *session;
PSTR iname;
if (session == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
RtlZeroMemory(session, sizeof(XenStoreSession));
-
+
ExInitializeFastMutex(&session->WatchMapLock);
session->mapchanged = TRUE;
status = RtlUnicodeStringToAnsiString(&ansi, stringid, TRUE);
status = STATUS_NO_MEMORY;
if (iname == NULL) {
UnlockSessions(fdoData);
- RtlFreeAnsiString(&ansi);
+ RtlFreeAnsiString(&ansi);
ExFreePool(session);
return status;
}
ExFreePool(iname);
if (!NT_SUCCESS(status)) {
UnlockSessions(fdoData);
- RtlFreeAnsiString(&ansi);
+ RtlFreeAnsiString(&ansi);
ExFreePool(session);
return status;
}
count++;
-
+
} while (FindSessionByInstanceLocked(fdoData, &session->instancename) != NULL);
-
-
-
-
+
+
+
+
if (fdoData->SessionHead.Flink==&fdoData->SessionHead) {
session->id=0;
}
InsertHeadList((PLIST_ENTRY)&fdoData->SessionHead, (PLIST_ENTRY)session);
*sessionid = session->id;
UnicodeShallowCopy(&session->stringid, stringid);
-
+
InitializeListHead((PLIST_ENTRY)&session->watches);
-
+
KeInitializeEvent(&session->SessionChangedEvent, NotificationEvent, FALSE);
session->closing = FALSE;
- if (fdoData->InterfacesAcquired){
+ if (fdoData->InterfacesAcquired){
XenIfaceDebugPrint(TRACE,"Add session unsuspended\n");
session->suspended=FALSE;
}
status = PsCreateSystemThread(&hthread, THREAD_ALL_ACCESS, &oa, NULL, NULL, WatchCallbackThread, session);
if (!NT_SUCCESS(status)) {
- RtlFreeAnsiString(&ansi);
+ RtlFreeAnsiString(&ansi);
ExFreePool(session);
return status;
}
return STATUS_SUCCESS;
}
-void
-RemoveSessionLocked(XENIFACE_FDO *fdoData,
+void
+RemoveSessionLocked(XENIFACE_FDO *fdoData,
XenStoreSession *session) {
-
+
XenIfaceDebugPrint(TRACE,"RemoveSessionLocked\n");
RemoveEntryList((LIST_ENTRY*)session);
fdoData->Sessions--;
SessionRemoveWatchesLocked(session);
if (session->transaction != NULL) {
- XENBUS_STORE(TransactionEnd, &fdoData->StoreInterface, session->transaction, FALSE);
- }
+ XENBUS_STORE(TransactionEnd, &fdoData->StoreInterface, session->transaction, FALSE);
+ }
session->closing = TRUE;
KeSetEvent(&session->SessionChangedEvent, IO_NO_INCREMENT, FALSE);
KeWaitForSingleObject(session->WatchThread, Executive, KernelMode, FALSE, NULL);
}
void
-RemoveSession(XENIFACE_FDO *fdoData,
+RemoveSession(XENIFACE_FDO *fdoData,
XenStoreSession *session) {
XenIfaceDebugPrint(TRACE,"RemoveSession\n");
LockSessions(fdoData);
}
void SessionsRemoveAll(XENIFACE_FDO *fdoData) {
- XenIfaceDebugPrint(TRACE,"lock");
+ XenIfaceDebugPrint(TRACE,"lock");
LockSessions(fdoData);
- XenIfaceDebugPrint(TRACE,"in lock");
+ XenIfaceDebugPrint(TRACE,"in lock");
while (fdoData->SessionHead.Flink != &fdoData->SessionHead) {
RemoveSessionLocked(fdoData, (XenStoreSession *)fdoData->SessionHead.Flink);
}
- XenIfaceDebugPrint(TRACE,"unlock");
+ XenIfaceDebugPrint(TRACE,"unlock");
UnlockSessions(fdoData);
- XenIfaceDebugPrint(TRACE,"unlocked");
+ XenIfaceDebugPrint(TRACE,"unlocked");
}
ExReleaseFastMutex(&session->WatchMapLock);
}
-void SuspendSessionLocked(XENIFACE_FDO *fdoData,
+void SuspendSessionLocked(XENIFACE_FDO *fdoData,
XenStoreSession *session) {
SessionUnwatchWatchesLocked(session);
if (session->transaction != NULL) {
XenIfaceDebugPrint(TRACE, "End transaction %p\n",session->transaction);
-
- XENBUS_STORE(TransactionEnd, &fdoData->StoreInterface, session->transaction, FALSE);
+
+ XENBUS_STORE(TransactionEnd, &fdoData->StoreInterface, session->transaction, FALSE);
session->transaction = NULL;
- }
+ }
}
ExReleaseFastMutex(&session->WatchMapLock);
}
-void ResumeSessionLocked(XENIFACE_FDO *fdoData,
+void ResumeSessionLocked(XENIFACE_FDO *fdoData,
XenStoreSession *session) {
SessionRenewWatchesLocked(session);
}
NTSTATUS
WmiInit(
PXENIFACE_FDO FdoData
- )
+ )
{
NTSTATUS status = STATUS_SUCCESS;
XenIfaceDebugPrint(TRACE,"%s\n",__FUNCTION__);
XenIfaceDebugPrint(INFO,"DRV: XenIface WMI Initialisation\n");
-
-
- IoWMISuggestInstanceName(FdoData->PhysicalDeviceObject, NULL, FALSE,
- &FdoData->SuggestedInstanceName);
+
+
+ IoWMISuggestInstanceName(FdoData->PhysicalDeviceObject, NULL, FALSE,
+ &FdoData->SuggestedInstanceName);
InitializeListHead(&FdoData->SessionHead);
FdoData->Sessions = 0;
ExInitializeFastMutex(&FdoData->SessionLock);
-
+
status = IoWMIRegistrationControl(FdoData->Dx->DeviceObject, WMIREG_ACTION_REGISTER);
FdoData->WmiReady = 1;
return status;
}
NTSTATUS
-WmiFinalise(
+WmiFinalise(
PXENIFACE_FDO FdoData
- )
+ )
{
NTSTATUS status = STATUS_SUCCESS;
- if (FdoData->WmiReady) {
+ if (FdoData->WmiReady) {
XenIfaceDebugPrint(INFO,"DRV: XenIface WMI Finalisation\n");
XenIfaceDebugPrint(TRACE,"%s\n",__FUNCTION__);
SessionsRemoveAll(FdoData);
status =IoWMIRegistrationControl(FdoData->Dx->DeviceObject, WMIREG_ACTION_DEREGISTER);
- RtlFreeUnicodeString(&FdoData->SuggestedInstanceName);
- RtlZeroBytes(&FdoData->SuggestedInstanceName, sizeof(UNICODE_STRING));
+ RtlFreeUnicodeString(&FdoData->SuggestedInstanceName);
+ RtlZeroBytes(&FdoData->SuggestedInstanceName, sizeof(UNICODE_STRING));
FdoData->WmiReady = 0;
}
}
status = GetCountedUTF8String(&pathname, upathname);
- if (!NT_SUCCESS(status))
+ if (!NT_SUCCESS(status))
return status;
status = STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(tmpbuffer, pathname->Length+1);
RtlCopyBytes(tmpbuffer,pathname->Buffer, pathname->Length);
-
+
status = STATUS_WMI_INSTANCE_NOT_FOUND;
if ((session = FindSessionByInstanceAndLock(fdoData, instance)) ==
NULL){
}
- XenIfaceDebugPrint(TRACE, "Find Watch\n");
+ XenIfaceDebugPrint(TRACE, "Find Watch\n");
watch = SessionFindWatchLocked(session, &unicpath_notbacked);
SessionRemoveWatchLocked(session, watch);
}
else {
- XenIfaceDebugPrint(WARNING, "No Watch\n");
+ XenIfaceDebugPrint(WARNING, "No Watch\n");
}
#pragma prefast (suppress:26110)
ExReleaseFastMutex(&session->WatchMapLock);
*byteswritten=0;
-
+
return STATUS_SUCCESS;
FreeUnicodeStringBuffer(&unicpath_backed);
return status;
}
-
+
*byteswritten=0;
-
+
return STATUS_SUCCESS;
UNICODE_STRING *instance,
OUT ULONG_PTR *byteswritten) {
XenStoreSession *session;
- XenIfaceDebugPrint(TRACE, "ExecuteEndSession\n");
+ XenIfaceDebugPrint(TRACE, "ExecuteEndSession\n");
*byteswritten = 0;
if ((session = FindSessionByInstanceAndLock(fdoData, instance)) ==
NULL){
char *tmppath;
char* tmpvalue;
- XenIfaceDebugPrint(TRACE, " Try to write\n");
+ XenIfaceDebugPrint(TRACE, " Try to write\n");
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
WMI_STRING, &upathname,
WMI_STRING, &uvalue,
return STATUS_INSUFFICIENT_RESOURCES;
}
status = GetCountedUTF8String(&pathname, upathname);
- if (!NT_SUCCESS(status))
+ if (!NT_SUCCESS(status))
return status;
- status = STATUS_INSUFFICIENT_RESOURCES;
+ status = STATUS_INSUFFICIENT_RESOURCES;
tmppath = ExAllocatePoolWithTag(NonPagedPool, pathname->Length+1, 'XenP');
if (!tmppath) {
goto fail1;
RtlZeroMemory(tmppath, pathname->Length+1);
RtlCopyBytes(tmppath,pathname->Buffer, pathname->Length);
status = GetCountedUTF8String(&value, uvalue);
- if (!NT_SUCCESS(status)){
+ if (!NT_SUCCESS(status)){
goto fail2;
}
status = STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(tmpvalue, value->Length+1);
RtlCopyBytes(tmpvalue,value->Buffer, value->Length);
-
+
status = STATUS_WMI_INSTANCE_NOT_FOUND;
if ((session = FindSessionByInstanceAndLock(fdoData, instance)) ==
NULL){
goto fail4;
}
status = XENBUS_STORE(Printf, &fdoData->StoreInterface, session->transaction, NULL, tmppath, tmpvalue);
- XenIfaceDebugPrint(TRACE, " Write %s to %s (%p)\n", tmpvalue, tmppath, status);
+ XenIfaceDebugPrint(TRACE, " Write %s to %s (%p)\n", tmpvalue, tmppath, status);
UnlockSessions(fdoData);
fail4:
fail1:
FreeUTF8String(pathname);
-
+
*byteswritten = 0;
return status;
-
+
}
NTSTATUS
SessionExecuteGetFirstChild(UCHAR *InBuffer,
XenStoreSession *session;
char *tmppath;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &uloc,
+ WMI_STRING, &uloc,
WMI_DONE)){
return STATUS_INVALID_DEVICE_REQUEST;
}
if (!fdoData->InterfacesAcquired) {
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
status = GetCountedUTF8String(&path, uloc);
-
+
if (!NT_SUCCESS(status)) {
return status;
}
}
status = XENBUS_STORE(Directory,&fdoData->StoreInterface, session->transaction, NULL, tmppath, &listresults);
UnlockSessions(fdoData);
-
+
if (!NT_SUCCESS(status)) {
goto fail2;
}
else {
stringarraysize+=GetCountedUtf8Size("");
}
-
+
status = STATUS_BUFFER_TOO_SMALL;
if (!AccessWmiBuffer(InBuffer, FALSE, &RequiredSize, OutBufferSize,
WMI_STRING, stringarraysize, &valuepos,
WMI_DONE)){
goto fail3;
}
-
+
status = STATUS_SUCCESS;
if ((listresults != NULL) && (listresults[0] != 0)) {
PSTR fullpath;
fullpath = Xmasprintf("/%s", listresults);
}
else {
- fullpath = Xmasprintf("%s/%s",
- path->Buffer, listresults);
+ fullpath = Xmasprintf("%s/%s",
+ path->Buffer, listresults);
}
if (fullpath == NULL) {
int leafoffset;
char *attemptstring;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &uloc,
+ WMI_STRING, &uloc,
WMI_DONE)){
return STATUS_INVALID_DEVICE_REQUEST;
}
if (!fdoData->InterfacesAcquired) {
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
status = GetCountedUTF8String(&path, uloc);
-
+
if (!NT_SUCCESS(status)) {
return status;
}
NULL){
goto fail3;
}
-
+
leafoffset = 0;
if (path->Length>1) {
leafoffset = path->Length;
status = XENBUS_STORE(Directory,&fdoData->StoreInterface, session->transaction, NULL, tmppath, &listresults);
UnlockSessions(fdoData);
-
+
if (!NT_SUCCESS(status)) {
goto fail3;
}
stringarraysize = 0;
RtlInitAnsiString(&checkleaf, tmpleaf);
-
+
nextresult = listresults;
while (*nextresult != 0) {
else {
stringarraysize+=GetCountedUtf8Size("");
}
-
+
status = STATUS_BUFFER_TOO_SMALL;
if (!AccessWmiBuffer(InBuffer, FALSE, &RequiredSize, OutBufferSize,
WMI_STRING, stringarraysize, &valuepos,
WMI_DONE)){
goto fail4;
}
-
+
status = STATUS_SUCCESS;
if (attemptstring != NULL) {
PSTR fullpath;
fullpath = Xmasprintf("/%s", attemptstring);
}
else {
- fullpath = Xmasprintf("%s/%s",
- tmppath, attemptstring);
+ fullpath = Xmasprintf("%s/%s",
+ tmppath, attemptstring);
}
if (fullpath == NULL) {
ExFreePool(tmpleaf);
fail2:
- ExFreePool(tmppath);
+ ExFreePool(tmppath);
fail1:
FreeUTF8String(path);
XenStoreSession *session;
char *tmppath;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &uloc,
+ WMI_STRING, &uloc,
WMI_DONE)){
return STATUS_INVALID_DEVICE_REQUEST;
}
if (!fdoData->InterfacesAcquired) {
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
status = GetCountedUTF8String(&path, uloc);
-
+
if (!NT_SUCCESS(status)) {
return status;
}
}
status = XENBUS_STORE(Directory,&fdoData->StoreInterface,session->transaction,NULL, tmppath, &listresults);
UnlockSessions(fdoData);
-
+
if (!NT_SUCCESS(status)) {
goto fail2;
}
stringarraysize+=GetCountedUtf8Size(nextresults);
for (;*nextresults!=0;nextresults++);
nextresults++;
- }
-
+ }
+
status = STATUS_BUFFER_TOO_SMALL;
if (!AccessWmiBuffer(InBuffer, FALSE, &RequiredSize, OutBufferSize,
WMI_UINT32, &noofnodes,
fullpath = Xmasprintf("/%s", nextresults);
}
else {
- fullpath = Xmasprintf("%s/%s",
- path->Buffer, nextresults);
+ fullpath = Xmasprintf("%s/%s",
+ path->Buffer, nextresults);
}
if (fullpath == NULL) {
NTSTATUS status;
ANSI_STRING message;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &uloc,
+ WMI_STRING, &uloc,
WMI_DONE))
return STATUS_INVALID_DEVICE_REQUEST;
status = GetCountedAnsiString(&message, uloc);
- if (!NT_SUCCESS(status))
+ if (!NT_SUCCESS(status))
return status;
XenIfaceDebugPrint(INFO,"USER: %s\n", message.Buffer);
NTSTATUS status = STATUS_SUCCESS;
XenStoreSession *session;
-
+
if (!fdoData->InterfacesAcquired) {
status= STATUS_INSUFFICIENT_RESOURCES;
goto failnotinitialised;
}
XENBUS_STORE(TransactionStart, &fdoData->StoreInterface, &session->transaction);
-
+
failtransactionactive:
UnlockSessions(fdoData);
NTSTATUS status = STATUS_SUCCESS;
XenStoreSession *session;
-
+
if (!fdoData->InterfacesAcquired) {
status= STATUS_INSUFFICIENT_RESOURCES;
goto failnotinitialised;
}
status = XENBUS_STORE(TransactionEnd,&fdoData->StoreInterface, session->transaction, TRUE);
-
+
session->transaction = NULL;
failtransactionnotactive:
NTSTATUS status = STATUS_SUCCESS;
XenStoreSession *session;
-
+
if (!fdoData->InterfacesAcquired) {
status= STATUS_INSUFFICIENT_RESOURCES;
goto failnotinitialised;
}
status = XENBUS_STORE(TransactionEnd, &fdoData->StoreInterface, session->transaction, FALSE);
-
+
session->transaction = NULL;
failtransactionnotactive:
*byteswritten = 0;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &uloc,
+ WMI_STRING, &uloc,
WMI_DONE))
return STATUS_INVALID_DEVICE_REQUEST;
if (!fdoData->InterfacesAcquired) {
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
status = GetCountedUTF8String(&path, uloc);
-
- if (!NT_SUCCESS(status))
+
+ if (!NT_SUCCESS(status))
return status;;
-
+
status = STATUS_INSUFFICIENT_RESOURCES;
tmppath = ExAllocatePoolWithTag(NonPagedPool,path->Length+1,'XenP');
if (!tmppath) {
}
RtlZeroMemory(tmppath, path->Length+1);
RtlCopyBytes(tmppath,path->Buffer, path->Length);
-
+
status = STATUS_WMI_INSTANCE_NOT_FOUND;
if ((session = FindSessionByInstanceAndLock(fdoData, instance)) ==
}
status = XENBUS_STORE(Read, &fdoData->StoreInterface, session->transaction, NULL, tmppath, &value);
UnlockSessions(fdoData);
-
- if (!NT_SUCCESS(status))
+
+ if (!NT_SUCCESS(status))
goto fail2;
-
+
status = STATUS_BUFFER_TOO_SMALL;
if (!AccessWmiBuffer(OutBuffer, FALSE, &RequiredSize, OutBufferSize,
WMI_STRING, GetCountedUtf8Size(value), &valuepos,
NTSTATUS status;
*byteswritten = 0;
if (!AccessWmiBuffer(InBuffer, TRUE, &RequiredSize, InBufferSize,
- WMI_STRING, &stringid,
+ WMI_STRING, &stringid,
WMI_DONE)){
return STATUS_INVALID_DEVICE_REQUEST;
}
*byteswritten = RequiredSize;
return STATUS_BUFFER_TOO_SMALL;
}
-
+
AllocUnicodeStringBuffer(&ustring, *(USHORT*)(stringid));
if (ustring.Buffer == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
status = RtlUnicodeStringCbCopyStringN(&ustring,
- (LPCWSTR)(stringid+sizeof(USHORT)),
+ (LPCWSTR)(stringid+sizeof(USHORT)),
*(USHORT*)(stringid));
if (!NT_SUCCESS(status)) {
FreeUnicodeStringBuffer(&ustring);
}
-NTSTATUS
+NTSTATUS
SessionExecuteMethod(UCHAR *Buffer,
ULONG BufferSize,
XENIFACE_FDO* fdoData,
return STATUS_INVALID_DEVICE_REQUEST;
}
- InBuffer = Buffer + Method->DataBlockOffset;
+ InBuffer = Buffer + Method->DataBlockOffset;
GetCountedUnicodeString(&instance, InstStr);
-
+
XenIfaceDebugPrint(TRACE,"Method Id %d\n", Method->MethodId);
switch (Method->MethodId) {
- case GetValue:
- status = SessionExecuteGetValue(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case GetValue:
+ status = SessionExecuteGetValue(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case SetValue:
- status = SessionExecuteSetValue(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case SetValue:
+ status = SessionExecuteSetValue(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case GetChildren:
- status = SessionExecuteGetChildren(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case GetChildren:
+ status = SessionExecuteGetChildren(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case SetWatch:
- status = SessionExecuteSetWatch(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case SetWatch:
+ status = SessionExecuteSetWatch(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case EndSession:
- status = SessionExecuteEndSession(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteEndSession(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case RemoveWatch:
- status = SessionExecuteRemoveWatch(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case RemoveWatch:
+ status = SessionExecuteRemoveWatch(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case RemoveValue:
- status = SessionExecuteRemoveValue(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case RemoveValue:
+ status = SessionExecuteRemoveValue(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case Log:
- status = SessionExecuteLog(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteLog(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
- case StartTransaction:
- status = SessionExecuteStartTransaction(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ case StartTransaction:
+ status = SessionExecuteStartTransaction(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case CommitTransaction:
- status = SessionExecuteCommitTransaction(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteCommitTransaction(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case AbortTransaction:
- status = SessionExecuteAbortTransaction(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteAbortTransaction(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case GetFirstChild:
- status = SessionExecuteGetFirstChild(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteGetFirstChild(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
case GetNextSibling:
- status = SessionExecuteGetNextSibling(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
+ status = SessionExecuteGetNextSibling(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
fdoData,
- &instance,
+ &instance,
byteswritten);
break;
if (status == STATUS_BUFFER_TOO_SMALL) {
return NodeTooSmall(Buffer, BufferSize, (ULONG)*byteswritten, byteswritten);
}
-
+
Method->WnodeHeader.BufferSize = (ULONG)*byteswritten;
return status;
}
-NTSTATUS
+NTSTATUS
BaseExecuteMethod(UCHAR *Buffer,
ULONG BufferSize,
XENIFACE_FDO* fdoData,
return STATUS_INVALID_DEVICE_REQUEST;
}
- InBuffer = Buffer + Method->DataBlockOffset;
+ InBuffer = Buffer + Method->DataBlockOffset;
switch (Method->MethodId) {
- case AddSession:
- status = BaseExecuteAddSession(InBuffer, Method->SizeDataBlock,
- Buffer+Method->DataBlockOffset,
- BufferSize-Method->DataBlockOffset,
- fdoData,
+ case AddSession:
+ status = BaseExecuteAddSession(InBuffer, Method->SizeDataBlock,
+ Buffer+Method->DataBlockOffset,
+ BufferSize-Method->DataBlockOffset,
+ fdoData,
byteswritten);
Method->SizeDataBlock = (ULONG)*byteswritten;
*byteswritten+=Method->DataBlockOffset;
if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreBase))) {
return BaseExecuteMethod(stack->Parameters.WMI.Buffer,
- stack->Parameters.WMI.BufferSize,
+ stack->Parameters.WMI.BufferSize,
fdoData, byteswritten);
}
else if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreSession))) {
return SessionExecuteMethod(stack->Parameters.WMI.Buffer,
- stack->Parameters.WMI.BufferSize,
+ stack->Parameters.WMI.BufferSize,
fdoData, byteswritten);
}
-
+
else
return STATUS_NOT_SUPPORTED;
}
ULONG* nameoffsets;
UCHAR *data;
UCHAR *names;
-
+
LockSessions(fdoData);
AccessWmiBuffer((PUCHAR)nodesizerequired, FALSE, &RequiredSize, 0,
WMI_UINT32, &id,
- WMI_STRING,
- GetCountedUnicodeStringSize(&session->stringid),
+ WMI_STRING,
+ GetCountedUnicodeStringSize(&session->stringid),
&sesbuf,
WMI_DONE);
nodesizerequired += RequiredSize;
-
+
AccessWmiBuffer((PUCHAR)namesizerequired, FALSE, &RequiredSize, 0,
- WMI_STRING,
+ WMI_STRING,
GetCountedUnicodeStringSize(&session->instancename),
&inamebuf,
WMI_DONE);
entries++;
session = (XenStoreSession *)session->listentry.Flink;
}
-
+
//perform the access check
if (!AccessWmiBuffer(Buffer, FALSE, &RequiredSize, BufferSize,
WMI_BUFFER, sizeof(WNODE_ALL_DATA), &node,
AccessWmiBuffer(datapos, FALSE, &RequiredSize, BufferSize+Buffer-datapos,
WMI_UINT32, &id,
- WMI_STRING,
- GetCountedUnicodeStringSize(&session->stringid),
+ WMI_STRING,
+ GetCountedUnicodeStringSize(&session->stringid),
&sesbuf,
WMI_DONE);
- node->OffsetInstanceDataAndLength[entrynum].OffsetInstanceData =
+ node->OffsetInstanceDataAndLength[entrynum].OffsetInstanceData =
(ULONG)((UCHAR *)id - Buffer);
- node->OffsetInstanceDataAndLength[entrynum].LengthInstanceData =
+ node->OffsetInstanceDataAndLength[entrynum].LengthInstanceData =
RequiredSize;
*id = session->id;
WriteCountedUnicodeString(&session->stringid, sesbuf);
datapos+=RequiredSize;
AccessWmiBuffer(namepos, FALSE, &RequiredSize, BufferSize+Buffer-namepos,
- WMI_STRING,
+ WMI_STRING,
GetCountedUnicodeStringSize(&session->instancename),
&inamebuf,
WMI_DONE);
else {
*time = 0;
}
-
-
+
+
node->WnodeHeader.BufferSize = node->DataBlockOffset+RequiredSize;
node->SizeDataBlock = RequiredSize;
ULONG* id;
XenStoreSession *session;
UCHAR *sesbuf;
-
+
if (!AccessWmiBuffer(Buffer, TRUE, &RequiredSize, BufferSize,
WMI_BUFFER, sizeof(WNODE_SINGLE_INSTANCE), &node,
WMI_DONE))
}
if (!AccessWmiBuffer(Buffer, TRUE, &RequiredSize, BufferSize,
WMI_BUFFER, sizeof(WNODE_SINGLE_INSTANCE), &node,
- WMI_STRINGOFFSET, node->OffsetInstanceName, &InstStr,
+ WMI_STRINGOFFSET, node->OffsetInstanceName, &InstStr,
WMI_OFFSET, node->DataBlockOffset, 0, &dbo,
WMI_DONE))
{
UnlockSessions(fdoData);
return STATUS_WMI_INSTANCE_NOT_FOUND;
}
-
+
if (!AccessWmiBuffer(dbo, FALSE, &RequiredSize, BufferSize-node->DataBlockOffset,
WMI_UINT32, &id,
- WMI_STRING,
+ WMI_STRING,
GetCountedUnicodeStringSize(&session->stringid),
&sesbuf,
WMI_DONE)) {
node->WnodeHeader.BufferSize = node->DataBlockOffset + RequiredSize;
*byteswritten = node->DataBlockOffset + RequiredSize;
-
+
return STATUS_SUCCESS;
OUT ULONG_PTR *byteswritten
)
{
-
- if (IsEqualGUID(stack->Parameters.WMI.DataPath,
+
+ if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreBase))) {
return GenerateBaseBlock( fdoData,
- stack->Parameters.WMI.Buffer,
+ stack->Parameters.WMI.Buffer,
stack->Parameters.WMI.BufferSize,
byteswritten);
}
- else if (IsEqualGUID(stack->Parameters.WMI.DataPath,
+ else if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreSession))) {
- return GenerateSessionBlock(stack->Parameters.WMI.Buffer,
+ return GenerateSessionBlock(stack->Parameters.WMI.Buffer,
stack->Parameters.WMI.BufferSize,
fdoData,
byteswritten);
if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreBase))) {
return GenerateBaseInstance(fdoData,
- stack->Parameters.WMI.Buffer,
+ stack->Parameters.WMI.Buffer,
stack->Parameters.WMI.BufferSize,
byteswritten);
}
else if (IsEqualGUID(stack->Parameters.WMI.DataPath,
&OBJECT_GUID(XenStoreSession))) {
- return GenerateSessionInstance(stack->Parameters.WMI.Buffer,
+ return GenerateSessionInstance(stack->Parameters.WMI.Buffer,
stack->Parameters.WMI.BufferSize,
fdoData,
byteswritten);
ULONG RequiredSize;
int entries = 4;
const static UNICODE_STRING mofname = RTL_CONSTANT_STRING(L"XENIFACEMOF");
-
+
size_t mofnamesz;
mofnamesz = 0;
}
if(!AccessWmiBuffer(stack->Parameters.WMI.Buffer, FALSE,
- &RequiredSize,
+ &RequiredSize,
stack->Parameters.WMI.BufferSize,
WMI_BUFFER, sizeof(WMIREGINFO), (UCHAR **)®info,
WMI_BUFFER, entries * sizeof(WMIREGGUID), (UCHAR **)&guiddata,
WMI_STRING, mofnamesz, &mofnameptr,
- WMI_STRING, DriverParameters.RegistryPath.Length+sizeof(USHORT),
+ WMI_STRING, DriverParameters.RegistryPath.Length+sizeof(USHORT),
®path,
WMI_DONE)){
reginfo->BufferSize = RequiredSize;
return STATUS_BUFFER_TOO_SMALL;
}
- if (stack->Parameters.WMI.DataPath == WMIREGISTER) {
+ if (stack->Parameters.WMI.DataPath == WMIREGISTER) {
reginfo->MofResourceName = (ULONG)((ULONG_PTR)mofnameptr - (ULONG_PTR)reginfo);
WriteCountedUnicodeString(&mofname, mofnameptr);
reginfo->RegistryPath = (ULONG)((ULONG_PTR)regpath - (ULONG_PTR)reginfo);
guid->InstanceCount = 1;
guid->Guid = OBJECT_GUID(XenStoreBase);
guid->Flags = WMIREG_FLAG_INSTANCE_PDO;
- guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
- ObReferenceObject(fdoData->PhysicalDeviceObject);
-
+ guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
+ ObReferenceObject(fdoData->PhysicalDeviceObject);
+
guid = ®info->WmiRegGuid[1];
guid->Guid = OBJECT_GUID(XenStoreSession);
guid->Flags =0;
-
+
guid = ®info->WmiRegGuid[2];
guid->InstanceCount = 1;
guid->Guid = OBJECT_GUID(XenStoreWatchEvent);
guid->Flags = WMIREG_FLAG_INSTANCE_PDO |
WMIREG_FLAG_EVENT_ONLY_GUID ;
- guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
- ObReferenceObject(fdoData->PhysicalDeviceObject);
+ guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
+ ObReferenceObject(fdoData->PhysicalDeviceObject);
guid = ®info->WmiRegGuid[3];
guid->InstanceCount = 1;
guid->Guid = OBJECT_GUID(XenStoreUnsuspendedEvent);
guid->Flags = WMIREG_FLAG_INSTANCE_PDO |
WMIREG_FLAG_EVENT_ONLY_GUID ;
- guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
- ObReferenceObject(fdoData->PhysicalDeviceObject);
+ guid->Pdo = (ULONG_PTR)fdoData->PhysicalDeviceObject;
+ ObReferenceObject(fdoData->PhysicalDeviceObject);
*byteswritten = RequiredSize;
OUT ULONG_PTR *byteswritten
)
{
-
+
XenIfaceDebugPrint(TRACE,"%s\n",__FUNCTION__);
return WmiRegInfo(fdoData, stack, byteswritten);
}
PIO_STACK_LOCATION stack;
UCHAR MinorFunction;
-
+
stack = IoGetCurrentIrpStackLocation(Irp);
- if (stack->Parameters.WMI.ProviderId != (ULONG_PTR)fdoData->Dx->DeviceObject) {
- XenIfaceDebugPrint(TRACE,"ProviderID %p %p", stack->Parameters.WMI.ProviderId, fdoData->PhysicalDeviceObject);
- return STATUS_NOT_SUPPORTED;
- }
- else {
- XenIfaceDebugPrint(TRACE,"ProviderID Match %p %p", stack->Parameters.WMI.ProviderId, fdoData->PhysicalDeviceObject);
- }
+ if (stack->Parameters.WMI.ProviderId != (ULONG_PTR)fdoData->Dx->DeviceObject) {
+ XenIfaceDebugPrint(TRACE,"ProviderID %p %p", stack->Parameters.WMI.ProviderId, fdoData->PhysicalDeviceObject);
+ return STATUS_NOT_SUPPORTED;
+ }
+ else {
+ XenIfaceDebugPrint(TRACE,"ProviderID Match %p %p", stack->Parameters.WMI.ProviderId, fdoData->PhysicalDeviceObject);
+ }
MinorFunction = stack->MinorFunction;
switch (MinorFunction)
status = WmiProcessMinorFunction(fdoData, Irp);
if (status != STATUS_NOT_SUPPORTED) {
- Irp->IoStatus.Status = status;
+ Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
+
}
else {
IoSkipCurrentIrpStackLocation(Irp);
projects / people / pauldu / xeniface.git / commitdiff