Implement IoRaiseHardError, combine error stuff, fix hideously wrong
implementatin of Controller Objects.
Modified: trunk/reactos/include/ddk/iotypes.h
Modified: trunk/reactos/include/ddk/ketypes.h
Modified: trunk/reactos/ntoskrnl/Makefile
Deleted: trunk/reactos/ntoskrnl/io/cntrller.c
Added: trunk/reactos/ntoskrnl/io/controller.c
Deleted: trunk/reactos/ntoskrnl/io/errlog.c
Modified: trunk/reactos/ntoskrnl/io/error.c
_____
Modified: trunk/reactos/include/ddk/iotypes.h
--- trunk/reactos/include/ddk/iotypes.h 2005-04-26 13:17:44 UTC (rev
14815)
+++ trunk/reactos/include/ddk/iotypes.h 2005-04-26 14:51:18 UTC (rev
14816)
@@ -684,7 +684,35 @@
PIO_COMPLETION_CONTEXT CompletionContext;
} FILE_OBJECT, *PFILE_OBJECT;
+typedef IO_ALLOCATION_ACTION STDCALL_FUNC
+(*PDRIVER_CONTROL)(struct _DEVICE_OBJECT *DeviceObject,
+ struct _IRP *Irp,
+ PVOID MapRegisterBase,
+ PVOID Context);
+#if (_WIN32_WINNT >= 0x0400)
+typedef VOID STDCALL_FUNC
+(*PFSDNOTIFICATIONPROC)(IN struct _DEVICE_OBJECT
*PtrTargetFileSystemDeviceObject,
+ IN BOOLEAN DriverActive);
+#endif // (_WIN32_WINNT >= 0x0400)
+typedef struct _KDEVICE_QUEUE_ENTRY
+{
+ LIST_ENTRY DeviceListEntry;
+ ULONG SortKey;
+ BOOLEAN Inserted;
+} KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY;
+
+typedef struct _WAIT_CONTEXT_BLOCK
+{
+ KDEVICE_QUEUE_ENTRY WaitQueueEntry;
+ PDRIVER_CONTROL DeviceRoutine;
+ PVOID DeviceContext;
+ ULONG NumberOfMapRegisters;
+ PVOID DeviceObject;
+ PVOID CurrentIrp;
+ PKDPC BufferChainingDpc;
+} WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
+
typedef struct _IRP
{
CSHORT Type;
@@ -757,7 +785,6 @@
WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH];
} VPB, *PVPB;
-
typedef struct _DEVICE_OBJECT
{
CSHORT Type;
@@ -1133,18 +1160,6 @@
} DRIVER_LAYOUT_INFORMATION, *PDRIVER_LAYOUT_INFORMATION;
-typedef IO_ALLOCATION_ACTION STDCALL_FUNC
-(*PDRIVER_CONTROL)(PDEVICE_OBJECT DeviceObject,
- PIRP Irp,
- PVOID MapRegisterBase,
- PVOID Context);
-#if (_WIN32_WINNT >= 0x0400)
-typedef VOID STDCALL_FUNC
-(*PFSDNOTIFICATIONPROC)(IN PDEVICE_OBJECT
PtrTargetFileSystemDeviceObject,
- IN BOOLEAN DriverActive);
-#endif // (_WIN32_WINNT >= 0x0400)
-
-
typedef struct _NAMED_PIPE_CREATE_PARAMETERS
{
ULONG NamedPipeType;
_____
Modified: trunk/reactos/include/ddk/ketypes.h
--- trunk/reactos/include/ddk/ketypes.h 2005-04-26 13:17:44 UTC (rev
14815)
+++ trunk/reactos/include/ddk/ketypes.h 2005-04-26 14:51:18 UTC (rev
14816)
@@ -285,37 +285,6 @@
ULONG DpcCount;
} KDPC_DATA, *PKDPC_DATA;
-typedef struct _KDEVICE_QUEUE_ENTRY
-{
- LIST_ENTRY DeviceListEntry;
- ULONG SortKey;
- BOOLEAN Inserted;
-} KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY;
-
-typedef struct _WAIT_CONTEXT_BLOCK
-{
- KDEVICE_QUEUE_ENTRY WaitQueueEntry;
- /*
- * XXX THIS IS WRONG XXX
- *
- * Our headers have enough circular dependancies that
- * I can't figure out, given 5 minutes of testing, what
- * order to include them in to get PDRIVER_CONTROL to be
- * defined here. The proper definition of the next item
- * is:
- *
- * PDRIVER_CONTROL DeviceRoutine;
- *
- * but instead we use PVOID until headers are fixed.
- */
- PVOID DeviceRoutine;
- PVOID DeviceContext;
- ULONG NumberOfMapRegisters;
- PVOID DeviceObject;
- PVOID CurrentIrp;
- PKDPC BufferChainingDpc;
-} WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
-
typedef enum _KBUGCHECK_CALLBACK_REASON {
KbCallbackInvalid,
KbCallbackReserved1,
_____
Modified: trunk/reactos/ntoskrnl/Makefile
--- trunk/reactos/ntoskrnl/Makefile 2005-04-26 13:17:44 UTC (rev
14815)
+++ trunk/reactos/ntoskrnl/Makefile 2005-04-26 14:51:18 UTC (rev
14816)
@@ -149,14 +149,13 @@
io/buildirp.o \
io/cancel.o \
io/cleanup.o \
- io/cntrller.o \
+ io/controller.o \
io/create.o \
io/device.o \
io/deviface.o \
io/dir.o \
io/driver.o \
io/efi.o \
- io/errlog.o \
io/error.o \
io/event.o \
io/file.o \
_____
Deleted: trunk/reactos/ntoskrnl/io/cntrller.c
--- trunk/reactos/ntoskrnl/io/cntrller.c 2005-04-26 13:17:44 UTC
(rev 14815)
+++ trunk/reactos/ntoskrnl/io/cntrller.c 2005-04-26 14:51:18 UTC
(rev 14816)
@@ -1,175 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: ntoskrnl/io/cntrller.c
- * PURPOSE: Implements the controller object
- *
- * PROGRAMMERS: David Welch (welch(a)mcmail.com)
- */
-
-/* INCLUDES
*****************************************************************/
-
-#include <ntoskrnl.h>
-#include <internal/debug.h>
-
-/* GLOBALS
*******************************************************************/
-
-#define TAG_CQE TAG('C', 'Q', 'E', ' ')
-#define TAG_CONTROLLER TAG('C', 'N', 'T', 'R')
-#define TAG_CONTROLLER_EXTENSION TAG('C', 'E', 'X', 'T')
-
-/* TYPES
********************************************************************/
-
-typedef struct
-/*
- * PURPOSE: A entry in the queue waiting for a controller object
- */
-{
- KDEVICE_QUEUE_ENTRY Entry;
- PDEVICE_OBJECT DeviceObject;
- PDRIVER_CONTROL ExecutionRoutine;
- PVOID Context;
-} CONTROLLER_QUEUE_ENTRY, *PCONTROLLER_QUEUE_ENTRY;
-
-/* FUNCTIONS
*****************************************************************/
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-IoAllocateController(PCONTROLLER_OBJECT ControllerObject,
- PDEVICE_OBJECT DeviceObject,
- PDRIVER_CONTROL ExecutionRoutine,
- PVOID Context)
-/*
- * FUNCTION: Sets up a call to a driver-supplied ControllerControl
routine
- * as soon as the device controller, represented by the given
controller
- * object, is available to carry out an I/O operation for the target
device,
- * represented by the given device object.
- * ARGUMENTS:
- * ControllerObject = Driver created controller object
- * DeviceObject = Target device for the current irp
- * ExecutionRoutine = Routine to be called when the device is
available
- * Context = Driver supplied context to be passed on to the above
routine
- * NOTE: Is the below implementation correct.
- */
-{
- PCONTROLLER_QUEUE_ENTRY entry;
- IO_ALLOCATION_ACTION Result;
-
- ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
-
- entry =
- ExAllocatePoolWithTag(NonPagedPool,
sizeof(CONTROLLER_QUEUE_ENTRY),
- TAG_CQE);
- ASSERT(entry!=NULL);
-
- entry->DeviceObject = DeviceObject;
- entry->ExecutionRoutine = ExecutionRoutine;
- entry->Context = Context;
-
- if
(KeInsertDeviceQueue(&ControllerObject->DeviceWaitQueue,&entry->Entry))
- {
- return;
- }
- Result = ExecutionRoutine(DeviceObject,DeviceObject->CurrentIrp,
- NULL,Context);
- if (Result == DeallocateObject)
- {
- IoFreeController(ControllerObject);
- }
- ExFreePool(entry);
-}
-
-/*
- * @implemented
- */
-PCONTROLLER_OBJECT
-STDCALL
-IoCreateController(ULONG Size)
-/*
- * FUNCTION: Allocates memory and initializes a controller object
- * ARGUMENTS:
- * Size = Size (in bytes) to be allocated for the controller
extension
- * RETURNS: A pointer to the created object
- */
-{
- PCONTROLLER_OBJECT controller;
-
- ASSERT_IRQL(PASSIVE_LEVEL);
-
- controller =
- ExAllocatePoolWithTag(NonPagedPool, sizeof(CONTROLLER_OBJECT),
- TAG_CONTROLLER);
- if (controller==NULL)
- {
- return(NULL);
- }
-
- controller->ControllerExtension =
- ExAllocatePoolWithTag(NonPagedPool, Size,
TAG_CONTROLLER_EXTENSION);
- if (controller->ControllerExtension==NULL)
- {
- ExFreePool(controller);
- return(NULL);
- }
-
- KeInitializeDeviceQueue(&controller->DeviceWaitQueue);
- return(controller);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-IoDeleteController(PCONTROLLER_OBJECT ControllerObject)
-/*
- * FUNCTION: Removes a given controller object from the system
- * ARGUMENTS:
- * ControllerObject = Controller object to be released
- */
-{
- ASSERT_IRQL(PASSIVE_LEVEL);
-
- ExFreePool(ControllerObject->ControllerExtension);
- ExFreePool(ControllerObject);
-}
-
-/*
- * @implemented
- */
-VOID
-STDCALL
-IoFreeController(PCONTROLLER_OBJECT ControllerObject)
-/*
- * FUNCTION: Releases a previously allocated controller object when a
- * device has finished an I/O request
- * ARGUMENTS:
- * ControllerObject = Controller object to be released
- */
-{
- PKDEVICE_QUEUE_ENTRY QEntry;
- CONTROLLER_QUEUE_ENTRY* Entry;
- IO_ALLOCATION_ACTION Result;
-
- do
- {
- QEntry =
KeRemoveDeviceQueue(&ControllerObject->DeviceWaitQueue);
- Entry = CONTAINING_RECORD(QEntry,CONTROLLER_QUEUE_ENTRY,Entry);
- if (QEntry==NULL)
- {
- return;
- }
- Result = Entry->ExecutionRoutine(Entry->DeviceObject,
-
Entry->DeviceObject->CurrentIrp,
- NULL,
- Entry->Context);
- ExFreePool(Entry);
- } while (Result == DeallocateObject);
-}
-
-
-/* EOF */
_____
Copied: trunk/reactos/ntoskrnl/io/controller.c (from rev 14808,
trunk/reactos/ntoskrnl/io/cntrller.c)
--- trunk/reactos/ntoskrnl/io/cntrller.c 2005-04-25 20:35:37 UTC
(rev 14808)
+++ trunk/reactos/ntoskrnl/io/controller.c 2005-04-26 14:51:18 UTC
(rev 14816)
@@ -0,0 +1,178 @@
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/io/contrller.c
+ * PURPOSE: Implements the controller object
+ *
+ * PROGRAMMERS: Alex Ionescu (alex(a)relsoft.net)
+ */
+
+/* INCLUDES
*****************************************************************/
+
+#include <ntoskrnl.h>
+#include <internal/debug.h>
+
+/* GLOBALS
*******************************************************************/
+
+POBJECT_TYPE IoControllerObjectType;
+
+/* FUNCTIONS
*****************************************************************/
+
+/*
+ * @implemented
+ *
+ * FUNCTION: Sets up a call to a driver-supplied ControllerControl
routine
+ * as soon as the device controller, represented by the given
controller
+ * object, is available to carry out an I/O operation for the target
device,
+ * represented by the given device object.
+ * ARGUMENTS:
+ * ControllerObject = Driver created controller object
+ * DeviceObject = Target device for the current irp
+ * ExecutionRoutine = Routine to be called when the device is
available
+ * Context = Driver supplied context to be passed on to the above
routine
+ */
+VOID
+STDCALL
+IoAllocateController(PCONTROLLER_OBJECT ControllerObject,
+ PDEVICE_OBJECT DeviceObject,
+ PDRIVER_CONTROL ExecutionRoutine,
+ PVOID Context)
+{
+ IO_ALLOCATION_ACTION Result;
+
+ ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+
+ /* Initialize the Wait Context Block */
+ DeviceObject->Queue.Wcb.DeviceContext = Context;
+ DeviceObject->Queue.Wcb.DeviceRoutine = ExecutionRoutine;
+
+ /* Insert the Device Queue */
+ if (!KeInsertDeviceQueue(&ControllerObject->DeviceWaitQueue,
+ &DeviceObject->Queue.Wcb.WaitQueueEntry));
+ {
+ Result = ExecutionRoutine(DeviceObject,
+ DeviceObject->CurrentIrp,
+ NULL,
+ Context);
+ }
+
+ if (Result == DeallocateObject)
+ {
+ IoFreeController(ControllerObject);
+ }
+}
+
+/*
+ * @implemented
+ *
+ * FUNCTION: Allocates memory and initializes a controller object
+ * ARGUMENTS:
+ * Size = Size (in bytes) to be allocated for the controller
extension
+ * RETURNS: A pointer to the created object
+ */
+PCONTROLLER_OBJECT
+STDCALL
+IoCreateController(ULONG Size)
+
+{
+ PCONTROLLER_OBJECT Controller;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ HANDLE Handle;
+ NTSTATUS Status;
+ ASSERT_IRQL(PASSIVE_LEVEL);
+
+ /* Initialize an empty OBA */
+ InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
+
+ /* Create the Object */
+ Status = ObCreateObject(KernelMode,
+ IoControllerObjectType,
+ &ObjectAttributes,
+ KernelMode,
+ NULL,
+ sizeof(CONTROLLER_OBJECT) + Size,
+ 0,
+ 0,
+ (PVOID*)&Controller);
+ if (!NT_SUCCESS(Status)) return NULL;
+
+ /* Insert it */
+ Status = ObInsertObject(Controller,
+ NULL,
+ FILE_READ_DATA | FILE_WRITE_DATA,
+ 0,
+ NULL,
+ &Handle);
+ if (!NT_SUCCESS(Status)) return NULL;
+
+ /* Close the dummy handle */
+ NtClose(Handle);
+
+ /* Zero the Object and set its data */
+ RtlZeroMemory(Controller, sizeof(CONTROLLER_OBJECT) + Size);
+ Controller->Type = IO_TYPE_CONTROLLER;
+ Controller->Size = sizeof(CONTROLLER_OBJECT) + Size;
+ Controller->ControllerExtension = (Controller + 1);
+
+ /* Initialize its Queue */
+ KeInitializeDeviceQueue(&Controller->DeviceWaitQueue);
+
+ /* Return Controller */
+ return Controller;
+}
+
+/*
+ * @implemented
+ *
+ * FUNCTION: Removes a given controller object from the system
+ * ARGUMENTS:
+ * ControllerObject = Controller object to be released
+ */
+VOID
+STDCALL
+IoDeleteController(PCONTROLLER_OBJECT ControllerObject)
+
+{
+ /* Just Dereference it */
+ ObDereferenceObject(ControllerObject);
+}
+
+/*
+ * @implemented
+ *
+ * FUNCTION: Releases a previously allocated controller object when a
+ * device has finished an I/O request
+ * ARGUMENTS:
+ * ControllerObject = Controller object to be released
+ */
+VOID
+STDCALL
+IoFreeController(PCONTROLLER_OBJECT ControllerObject)
+{
+ PKDEVICE_QUEUE_ENTRY QueueEntry;
+ PDEVICE_OBJECT DeviceObject;
+ IO_ALLOCATION_ACTION Result;
+
+ /* Remove the Queue */
+ if ((QueueEntry =
KeRemoveDeviceQueue(&ControllerObject->DeviceWaitQueue)))
+ {
+ /* Get the Device Object */
+ DeviceObject = CONTAINING_RECORD(QueueEntry,
+ DEVICE_OBJECT,
+ Queue.Wcb.WaitQueueEntry);
+ /* Call the routine */
+ Result = DeviceObject->Queue.Wcb.DeviceRoutine(DeviceObject,
+
DeviceObject->CurrentIrp,
+ NULL,
+
DeviceObject->Queue.Wcb.DeviceContext);
+ /* Check the result */
+ if (Result == DeallocateObject)
+ {
+ /* Free it again */
+ IoFreeController(ControllerObject);
+ }
+ }
+}
+
+
+/* EOF */
_____
Deleted: trunk/reactos/ntoskrnl/io/errlog.c
--- trunk/reactos/ntoskrnl/io/errlog.c 2005-04-26 13:17:44 UTC (rev
14815)
+++ trunk/reactos/ntoskrnl/io/errlog.c 2005-04-26 14:51:18 UTC (rev
14816)
@@ -1,450 +0,0 @@
-/* $Id$
- *
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: ntoskrnl/io/errlog.c
- * PURPOSE: Error logging
- *
- * PROGRAMMERS: David Welch (welch(a)cwcom.net)
- */
-
-/* INCLUDES
*****************************************************************/
-
-#include <ntoskrnl.h>
-#define NDEBUG
-#include <internal/debug.h>
-
-/* TYPES
*********************************************************************/
-
-typedef struct _ERROR_LOG_ENTRY
-{
- LIST_ENTRY Entry;
- LARGE_INTEGER TimeStamp;
- PVOID IoObject;
- ULONG PacketSize;
-} ERROR_LOG_ENTRY, *PERROR_LOG_ENTRY;
-
-typedef struct _LOG_WORKER_DPC
-{
- KDPC Dpc;
- KTIMER Timer;
-} LOG_WORKER_DPC, *PLOG_WORKER_DPC;
-
-
-static VOID STDCALL
-IopLogWorker (PVOID Parameter);
-
-
-/* GLOBALS
*******************************************************************/
-
-static KSPIN_LOCK IopAllocationLock;
-static ULONG IopTotalLogSize;
-
-static KSPIN_LOCK IopLogListLock;
-static LIST_ENTRY IopLogListHead;
-
-static BOOLEAN IopLogWorkerRunning = FALSE;
-static BOOLEAN IopLogPortConnected = FALSE;
-static HANDLE IopLogPort;
-
-
-/* FUNCTIONS
*****************************************************************/
-
-NTSTATUS
-IopInitErrorLog (VOID)
-{
- IopTotalLogSize = 0;
- KeInitializeSpinLock (&IopAllocationLock);
-
- KeInitializeSpinLock (&IopLogListLock);
- InitializeListHead (&IopLogListHead);
-
- return STATUS_SUCCESS;
-}
-
-
-static VOID STDCALL
-IopLogDpcRoutine (PKDPC Dpc,
- PVOID DeferredContext,
- PVOID SystemArgument1,
- PVOID SystemArgument2)
-{
- PWORK_QUEUE_ITEM LogWorkItem;
-
- DPRINT ("\nIopLogDpcRoutine() called\n");
-
- /* Release the WorkerDpc struct */
- ExFreePool (DeferredContext);
-
- /* Allocate, initialize and restart a work item */
- LogWorkItem = ExAllocatePool (NonPagedPool,
- sizeof(WORK_QUEUE_ITEM));
- if (LogWorkItem == NULL)
- {
- IopLogWorkerRunning = FALSE;
- return;
- }
-
- ExInitializeWorkItem (LogWorkItem,
- IopLogWorker,
- LogWorkItem);
-
- ExQueueWorkItem (LogWorkItem,
- DelayedWorkQueue);
-}
-
-
-static VOID
-IopRestartLogWorker (VOID)
-{
- PLOG_WORKER_DPC WorkerDpc;
- LARGE_INTEGER Timeout;
-
- DPRINT ("IopRestartWorker() called\n");
-
- WorkerDpc = ExAllocatePool (NonPagedPool,
- sizeof(LOG_WORKER_DPC));
- if (WorkerDpc == NULL)
- {
- IopLogWorkerRunning = FALSE;
- return;
- }
-
- /* Initialize DPC and Timer */
- KeInitializeDpc (&WorkerDpc->Dpc,
- IopLogDpcRoutine,
- WorkerDpc);
- KeInitializeTimer (&WorkerDpc->Timer);
-
- /* Restart after 30 seconds */
- Timeout.QuadPart = (LONGLONG)-300000000;
- KeSetTimer (&WorkerDpc->Timer,
- Timeout,
- &WorkerDpc->Dpc);
-}
-
-
-static BOOLEAN
-IopConnectLogPort (VOID)
-{
- UNICODE_STRING PortName;
- NTSTATUS Status;
-
- DPRINT ("IopConnectLogPort() called\n");
-
- RtlInitUnicodeString (&PortName,
- L"\\ErrorLogPort");
-
- Status = ZwConnectPort (&IopLogPort,
- &PortName,
- NULL,
- NULL,
- NULL,
- NULL,
- NULL,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- DPRINT ("ZwConnectPort() failed (Status %lx)\n", Status);
- return FALSE;
- }
-
- DPRINT ("IopConnectLogPort() done\n");
-
- return TRUE;
-}
-
-
-static VOID STDCALL
-IopLogWorker (PVOID Parameter)
-{
- PERROR_LOG_ENTRY LogEntry;
- PLPC_MAX_MESSAGE Request;
- PIO_ERROR_LOG_MESSAGE Message;
- PIO_ERROR_LOG_PACKET Packet;
- KIRQL Irql;
- NTSTATUS Status;
-
- UCHAR Buffer[256];
- POBJECT_NAME_INFORMATION ObjectNameInfo;
- ULONG ReturnedLength;
- PWCHAR DriverName;
- ULONG DriverNameLength;
-
- DPRINT ("IopLogWorker() called\n");
-
- /* Release the work item */
- ExFreePool (Parameter);
-
- /* Connect to the error log port */
- if (IopLogPortConnected == FALSE)
- {
- if (IopConnectLogPort () == FALSE)
- {
- IopRestartLogWorker ();
- return;
- }
-
- IopLogPortConnected = TRUE;
- }
-
- while (TRUE)
- {
- /* Remove last entry from the list */
- KeAcquireSpinLock (&IopLogListLock,
- &Irql);
-
- if (!IsListEmpty (&IopLogListHead))
- {
- LogEntry = CONTAINING_RECORD (IopLogListHead.Blink,
- ERROR_LOG_ENTRY,
- Entry);
- RemoveEntryList (&LogEntry->Entry);
- }
- else
- {
- LogEntry = NULL;
- }
-
- KeReleaseSpinLock (&IopLogListLock,
- Irql);
-
- if (LogEntry == NULL)
- {
- DPRINT ("No message in log list\n");
- break;
- }
-
- /* Get pointer to the log packet */
- Packet = (PIO_ERROR_LOG_PACKET)((ULONG_PTR)LogEntry +
sizeof(ERROR_LOG_ENTRY));
-
-
- /* Get driver or device name */
- ObjectNameInfo = (POBJECT_NAME_INFORMATION)Buffer;
- Status = ObQueryNameString (LogEntry->IoObject,
- ObjectNameInfo,
- 256,
- &ReturnedLength);
- if (NT_SUCCESS(Status))
- {
- DPRINT ("ReturnedLength: %lu\n", ReturnedLength);
- DPRINT ("Length: %hu\n", ObjectNameInfo->Name.Length);
- DPRINT ("MaximumLength: %hu\n",
ObjectNameInfo->Name.MaximumLength);
- DPRINT ("Object: %wZ\n", &ObjectNameInfo->Name);
-
- DriverName = wcsrchr(ObjectNameInfo->Name.Buffer, L'\\');
- if (DriverName != NULL)
- DriverName++;
- else
- DriverName = ObjectNameInfo->Name.Buffer;
-
- DriverNameLength = wcslen (DriverName) * sizeof(WCHAR);
- DPRINT ("Driver name '%S'\n", DriverName);
- }
- else
- {
- DriverName = NULL;
- DriverNameLength = 0;
- }
-
- /* Allocate request buffer */
- Request = ExAllocatePool (NonPagedPool,
- sizeof(LPC_MAX_MESSAGE));
- if (Request == NULL)
- {
- DPRINT ("Failed to allocate request buffer!\n");
-
- /* Requeue log message and restart the worker */
- ExInterlockedInsertTailList (&IopLogListHead,
- &LogEntry->Entry,
- &IopLogListLock);
- IopRestartLogWorker ();
-
- return;
- }
-
- /* Initialize the log message */
- Message = (PIO_ERROR_LOG_MESSAGE)Request->Data;
- Message->Type = 0xC; //IO_TYPE_ERROR_MESSAGE;
- Message->Size =
- sizeof(IO_ERROR_LOG_MESSAGE) - sizeof(IO_ERROR_LOG_PACKET) +
- LogEntry->PacketSize + DriverNameLength;
- Message->DriverNameLength = (USHORT)DriverNameLength;
- Message->TimeStamp.QuadPart = LogEntry->TimeStamp.QuadPart;
- Message->DriverNameOffset = (DriverName != NULL) ?
LogEntry->PacketSize : 0;
-
- /* Copy error log packet */
- RtlCopyMemory (&Message->EntryData,
- Packet,
- LogEntry->PacketSize);
-
- /* Copy driver or device name */
- RtlCopyMemory ((PVOID)((ULONG_PTR)Message +
Message->DriverNameOffset),
- DriverName,
- DriverNameLength);
-
- DPRINT ("SequenceNumber %lx\n", Packet->SequenceNumber);
-
- Request->Header.DataSize = Message->Size;
- Request->Header.MessageSize =
- Request->Header.DataSize + sizeof(LPC_MESSAGE);
-
- /* Send the error message to the log port */
- Status = ZwRequestPort (IopLogPort,
- &Request->Header);
-
- /* Release request buffer */
- ExFreePool (Request);
-
- if (!NT_SUCCESS(Status))
- {
- DPRINT ("ZwRequestPort() failed (Status %lx)\n", Status);
-
- /* Requeue log message and restart the worker */
- ExInterlockedInsertTailList (&IopLogListHead,
- &LogEntry->Entry,
- &IopLogListLock);
- IopRestartLogWorker ();
-
- return;
- }
-
- /* Release error log entry */
- KeAcquireSpinLock (&IopAllocationLock,
- &Irql);
-
- IopTotalLogSize -= (LogEntry->PacketSize -
sizeof(ERROR_LOG_ENTRY));
- ExFreePool (LogEntry);
-
- KeReleaseSpinLock (&IopAllocationLock,
- Irql);
- }
-
- IopLogWorkerRunning = FALSE;
-
- DPRINT ("IopLogWorker() done\n");
-}
-
-
-/*
- * @implemented
- */
-PVOID STDCALL
-IoAllocateErrorLogEntry (IN PVOID IoObject,
- IN UCHAR EntrySize)
-{
- PERROR_LOG_ENTRY LogEntry;
- ULONG LogEntrySize;
- KIRQL Irql;
-
- DPRINT("IoAllocateErrorLogEntry() called\n");
-
- if (IoObject == NULL)
- return NULL;
-
- KeAcquireSpinLock (&IopAllocationLock,
- &Irql);
-
- if (IopTotalLogSize > PAGE_SIZE)
- {
- KeReleaseSpinLock (&IopAllocationLock,
- Irql);
- return NULL;
- }
-
- LogEntrySize = sizeof(ERROR_LOG_ENTRY) + EntrySize;
- LogEntry = ExAllocatePool (NonPagedPool,
- LogEntrySize);
- if (LogEntry == NULL)
- {
- KeReleaseSpinLock (&IopAllocationLock,
- Irql);
- return NULL;
- }
-
- IopTotalLogSize += EntrySize;
-
- LogEntry->IoObject = IoObject;
- LogEntry->PacketSize = LogEntrySize;
-
- KeReleaseSpinLock (&IopAllocationLock,
- Irql);
-
- return (PVOID)((ULONG_PTR)LogEntry + sizeof(ERROR_LOG_ENTRY));
-}
-
-
-/*
- * @implemented
- */
-VOID STDCALL
-IoFreeErrorLogEntry(IN PVOID ElEntry)
-{
- PERROR_LOG_ENTRY LogEntry;
- KIRQL Irql;
-
- DPRINT("IoFreeErrorLogEntry() called\n");
-
- if (ElEntry == NULL)
- return;
-
- LogEntry = (PERROR_LOG_ENTRY)((ULONG_PTR)ElEntry -
sizeof(ERROR_LOG_ENTRY));
-
- KeAcquireSpinLock(&IopAllocationLock,
- &Irql);
-
- IopTotalLogSize -= (LogEntry->PacketSize - sizeof(ERROR_LOG_ENTRY));
- ExFreePool(LogEntry);
-
- KeReleaseSpinLock(&IopAllocationLock,
- Irql);
-}
-
-
-/*
- * @implemented
- */
-VOID STDCALL
-IoWriteErrorLogEntry (IN PVOID ElEntry)
-{
- PWORK_QUEUE_ITEM LogWorkItem;
- PERROR_LOG_ENTRY LogEntry;
- KIRQL Irql;
-
- DPRINT("IoWriteErrorLogEntry() called\n");
-
- LogEntry = (PERROR_LOG_ENTRY)((ULONG_PTR)ElEntry -
sizeof(ERROR_LOG_ENTRY));
-
- /* Get time stamp */
- KeQuerySystemTime (&LogEntry->TimeStamp);
-
- KeAcquireSpinLock (&IopLogListLock,
- &Irql);
-
- InsertHeadList (&IopLogListHead,
- &LogEntry->Entry);
-
- if (IopLogWorkerRunning == FALSE)
- {
- LogWorkItem = ExAllocatePool (NonPagedPool,
- sizeof(WORK_QUEUE_ITEM));
- if (LogWorkItem != NULL)
- {
- ExInitializeWorkItem (LogWorkItem,
- IopLogWorker,
- LogWorkItem);
-
- ExQueueWorkItem (LogWorkItem,
- DelayedWorkQueue);
-
- IopLogWorkerRunning = TRUE;
- }
- }
-
- KeReleaseSpinLock (&IopLogListLock,
- Irql);
-
- DPRINT("IoWriteErrorLogEntry() done\n");
-}
-
-/* EOF */
_____
Modified: trunk/reactos/ntoskrnl/io/error.c
--- trunk/reactos/ntoskrnl/io/error.c 2005-04-26 13:17:44 UTC (rev
14815)
+++ trunk/reactos/ntoskrnl/io/error.c 2005-04-26 14:51:18 UTC (rev
14816)
@@ -2,49 +2,530 @@
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: ntoskrnl/io/error.c
- * PURPOSE: Handle media errors
- *
- * PROGRAMMERS: David Welch (welch(a)mcmail.com)
+ * FILE: ntoskrnl/io/errlog.c
+ * PURPOSE: Error logging
+ *
+ * PROGRAMMERS: David Welch (welch(a)cwcom.net)
*/
/* INCLUDES
*****************************************************************/
#include <ntoskrnl.h>
+#define NDEBUG
#include <internal/debug.h>
+/* TYPES
*********************************************************************/
+
+typedef struct _ERROR_LOG_ENTRY
+{
+ LIST_ENTRY Entry;
+ LARGE_INTEGER TimeStamp;
+ PVOID IoObject;
+ ULONG PacketSize;
+} ERROR_LOG_ENTRY, *PERROR_LOG_ENTRY;
+
+typedef struct _LOG_WORKER_DPC
+{
+ KDPC Dpc;
+ KTIMER Timer;
+} LOG_WORKER_DPC, *PLOG_WORKER_DPC;
+
+
+static VOID STDCALL
+IopLogWorker (PVOID Parameter);
+
+
+/* GLOBALS
*******************************************************************/
+
+static KSPIN_LOCK IopAllocationLock;
+static ULONG IopTotalLogSize;
+
+static KSPIN_LOCK IopLogListLock;
+static LIST_ENTRY IopLogListHead;
+
[truncated at 1000 lines; 502 more skipped]
