ntoskrnl/io/iomgr/error.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/io/iomgr/error.c
   5  * PURPOSE:         I/O Error Functions and Error Log Support
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  *                  Eric Kohl
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #include <subsys/iolog/iolog.h>
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* TYPES *********************************************************************/
  19
  20 typedef struct _IOP_ERROR_LOG_WORKER_DPC
  21 {
  22     KDPC Dpc;
  23     KTIMER Timer;
  24 } IOP_ERROR_LOG_WORKER_DPC, *PIOP_ERROR_LOG_WORKER_DPC;
  25
  26 /* GLOBALS *******************************************************************/
  27
  28 #define IOP_MAXIMUM_LOG_SIZE    (100 * PAGE_SIZE)
  29 LONG IopTotalLogSize;
  30 LIST_ENTRY IopErrorLogListHead;
  31 KSPIN_LOCK IopLogListLock;
  32
  33 BOOLEAN IopLogWorkerRunning;
  34 BOOLEAN IopLogPortConnected;
  35 HANDLE IopLogPort;
  36 WORK_QUEUE_ITEM IopErrorLogWorkItem;
  37
  38 PDEVICE_OBJECT IopErrorLogObject;
  39
  40 /* PRIVATE FUNCTIONS *********************************************************/
  41
  42 VOID
  43 NTAPI
  44 IopLogDpcRoutine(IN PKDPC Dpc,
  45                  IN PVOID DeferredContext,
  46                  IN PVOID SystemArgument1,
  47                  IN PVOID SystemArgument2)
  48 {
  49     /* If we have a DPC, free it */
  50     if (Dpc) ExFreePool(Dpc);
  51
  52     /* Initialize and queue the work item */
  53     ExInitializeWorkItem(&IopErrorLogWorkItem, IopLogWorker, NULL);
  54     ExQueueWorkItem(&IopErrorLogWorkItem, DelayedWorkQueue);
  55 }
  56
  57 PLIST_ENTRY
  58 NTAPI
  59 IopGetErrorLogEntry(VOID)
  60 {
  61     KIRQL OldIrql;
  62     PLIST_ENTRY ListEntry;
  63
  64     /* Acquire the lock and check if the list is empty */
  65     KeAcquireSpinLock(&IopLogListLock, &OldIrql);
  66     if (IsListEmpty(&IopErrorLogListHead))
  67     {
  68         /* List is empty, disable the worker and return NULL */
  69         IopLogWorkerRunning = FALSE;
  70         ListEntry = NULL;
  71     }
  72     else
  73     {
  74         /* Otherwise, remove an entry */
  75         ListEntry = RemoveHeadList(&IopErrorLogListHead);
  76     }
  77
  78     /* Release the lock and return the entry */
  79     KeReleaseSpinLock(&IopLogListLock, OldIrql);
  80     return ListEntry;
  81 }
  82
  83 VOID
  84 NTAPI
  85 IopRestartLogWorker(VOID)
  86 {
  87     PIOP_ERROR_LOG_WORKER_DPC WorkerDpc;
  88     LARGE_INTEGER Timeout;
  89
  90     /* Allocate a DPC Context */
  91     WorkerDpc = ExAllocatePool(NonPagedPool, sizeof(IOP_ERROR_LOG_WORKER_DPC));
  92     if (!WorkerDpc)
  93     {
  94         /* Fail */
  95         IopLogWorkerRunning = FALSE;
  96         return;
  97     }
  98
  99     /* Initialize DPC and Timer */
 100     KeInitializeDpc(&WorkerDpc->Dpc, IopLogDpcRoutine, WorkerDpc);
 101     KeInitializeTimer(&WorkerDpc->Timer);
 102
 103     /* Restart after 30 seconds */
 104     Timeout.QuadPart = (LONGLONG)-300000000;
 105     KeSetTimer(&WorkerDpc->Timer, Timeout, &WorkerDpc->Dpc);
 106 }
 107
 108 BOOLEAN
 109 NTAPI
 110 IopConnectLogPort(VOID)
 111 {
 112     NTSTATUS Status;
 113     UNICODE_STRING PortName = RTL_CONSTANT_STRING(ELF_PORT_NAME);
 114     SECURITY_QUALITY_OF_SERVICE SecurityQos;
 115
 116     /* Make sure we're not already connected */
 117     if (IopLogPortConnected) return TRUE;
 118
 119     /* Setup the QoS structure */
 120     SecurityQos.Length = sizeof(SecurityQos);
 121     SecurityQos.ImpersonationLevel = SecurityIdentification;
 122     SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
 123     SecurityQos.EffectiveOnly = TRUE;
 124
 125     /* Connect the port */
 126     Status = ZwConnectPort(&IopLogPort,
 127                            &PortName,
 128                            &SecurityQos,
 129                            NULL,
 130                            NULL,
 131                            NULL,
 132                            NULL,
 133                            NULL);
 134     if (NT_SUCCESS(Status))
 135     {
 136         /* Remember we're connected */
 137         IopLogPortConnected = TRUE;
 138         return TRUE;
 139     }
 140
 141     /* We failed, try again */
 142     IopRestartLogWorker();
 143     return FALSE;
 144 }
 145
 146 VOID
 147 NTAPI
 148 IopLogWorker(IN PVOID Parameter)
 149 {
 150 #define IO_ERROR_OBJECT_NAMES_LENGTH    100
 151
 152     NTSTATUS Status;
 153     PELF_API_MSG Message;
 154     PIO_ERROR_LOG_MESSAGE ErrorMessage;
 155     PLIST_ENTRY ListEntry;
 156     PERROR_LOG_ENTRY LogEntry;
 157     PIO_ERROR_LOG_PACKET Packet;
 158     PCHAR StringBuffer;
 159     ULONG RemainingLength;
 160     PDRIVER_OBJECT DriverObject;
 161     PWCHAR NameString;
 162     ULONG DriverNameLength, DeviceNameLength;
 163     UCHAR Buffer[sizeof(OBJECT_NAME_INFORMATION) + IO_ERROR_OBJECT_NAMES_LENGTH];
 164     POBJECT_NAME_INFORMATION ObjectNameInfo = (POBJECT_NAME_INFORMATION)&Buffer;
 165     POBJECT_NAME_INFORMATION PoolObjectNameInfo;
 166     ULONG ReturnedLength, MessageLength;
 167     ULONG ExtraStringLength;
 168     PWCHAR p;
 169
 170     PAGED_CODE();
 171
 172     UNREFERENCED_PARAMETER(Parameter);
 173
 174     /* Connect to the port */
 175     if (!IopConnectLogPort()) return;
 176
 177     /* Allocate the message */
 178     Message = ExAllocatePoolWithTag(PagedPool, IO_ERROR_LOG_MESSAGE_LENGTH, TAG_IO);
 179     if (!Message)
 180     {
 181         /* Couldn't allocate, try again */
 182         IopRestartLogWorker();
 183         return;
 184     }
 185
 186     /* Zero out the message and get the actual I/O structure */
 187     RtlZeroMemory(Message, sizeof(*Message));
 188     ErrorMessage = &Message->IoErrorMessage;
 189
 190     /* Start loop */
 191     while (TRUE)
 192     {
 193         /* Get an entry */
 194         ListEntry = IopGetErrorLogEntry();
 195         if (!ListEntry) break;
 196         LogEntry = CONTAINING_RECORD(ListEntry, ERROR_LOG_ENTRY, ListEntry);
 197
 198         /* Get pointer to the log packet */
 199         Packet = (PIO_ERROR_LOG_PACKET)((ULONG_PTR)LogEntry +
 200                                         sizeof(ERROR_LOG_ENTRY));
 201
 202         /* Calculate the total length of the message only */
 203         MessageLength = sizeof(IO_ERROR_LOG_MESSAGE) -
 204                         sizeof(ERROR_LOG_ENTRY) -
 205                         sizeof(IO_ERROR_LOG_PACKET) +
 206                         LogEntry->Size;
 207
 208         /* Copy the packet */
 209         RtlCopyMemory(&ErrorMessage->EntryData,
 210                       Packet,
 211                       LogEntry->Size - sizeof(ERROR_LOG_ENTRY));
 212
 213         /* Set the timestamp and time */
 214         ErrorMessage->TimeStamp = LogEntry->TimeStamp;
 215         ErrorMessage->Type = IO_TYPE_ERROR_MESSAGE;
 216
 217         /* Check if this message has any strings */
 218         if (Packet->NumberOfStrings)
 219         {
 220             /* String buffer is after the current strings */
 221             StringBuffer = (PCHAR)&ErrorMessage->EntryData +
 222                             Packet->StringOffset;
 223         }
 224         else
 225         {
 226             /* Otherwise, string buffer is at the end */
 227             StringBuffer = (PCHAR)ErrorMessage + MessageLength;
 228         }
 229
 230         /* Align the buffer */
 231         StringBuffer = ALIGN_UP_POINTER(StringBuffer, WCHAR);
 232
 233         /* Set the offset for the driver's name to the current buffer */
 234         ErrorMessage->DriverNameOffset = (ULONG)(StringBuffer -
 235                                                 (PCHAR)ErrorMessage);
 236
 237         /* Check how much space we have left for the device string */
 238         RemainingLength = (ULONG)((ULONG_PTR)Message +
 239                                   IO_ERROR_LOG_MESSAGE_LENGTH -
 240                                   (ULONG_PTR)StringBuffer);
 241
 242         NameString = NULL;
 243         DriverNameLength = 0; DeviceNameLength = 0;
 244         PoolObjectNameInfo = NULL;
 245         ObjectNameInfo = (POBJECT_NAME_INFORMATION)&Buffer;
 246
 247         /* Now check if there is a driver object */
 248         DriverObject = LogEntry->DriverObject;
 249         if (DriverObject)
 250         {
 251             /* Check if the driver has a name, and use it if so */
 252             if (DriverObject->DriverName.Buffer)
 253             {
 254                 NameString = DriverObject->DriverName.Buffer;
 255                 DriverNameLength = DriverObject->DriverName.Length;
 256             }
 257             else
 258             {
 259                 NameString = NULL;
 260                 DriverNameLength = 0;
 261             }
 262
 263             /* Check if there isn't a valid name */
 264             if (!DriverNameLength)
 265             {
 266                 /* Query the name directly */
 267                 Status = ObQueryNameString(DriverObject,
 268                                            ObjectNameInfo,
 269                                            sizeof(Buffer),
 270                                            &ReturnedLength);
 271                 if (!NT_SUCCESS(Status) || (ObjectNameInfo->Name.Length == 0))
 272                 {
 273                     /* We don't have a name */
 274                     DriverNameLength = 0;
 275                 }
 276                 else
 277                 {
 278                     NameString = ObjectNameInfo->Name.Buffer;
 279                     DriverNameLength = ObjectNameInfo->Name.Length;
 280                 }
 281             }
 282         }
 283         else
 284         {
 285             /* Use default name */
 286             NameString = L"Application Popup";
 287             DriverNameLength = (ULONG)wcslen(NameString) * sizeof(WCHAR);
 288         }
 289
 290         /* Check if we have a driver name */
 291         if (DriverNameLength)
 292         {
 293             /* Skip to the end of the driver's name */
 294             p = &NameString[DriverNameLength / sizeof(WCHAR)];
 295
 296             /* Now we'll walk backwards and assume the minimum size */
 297             DriverNameLength = sizeof(WCHAR);
 298             p--;
 299             while ((*p != L'\\') && (p != NameString))
 300             {
 301                 /* No backslash found, keep going */
 302                 p--;
 303                 DriverNameLength += sizeof(WCHAR);
 304             }
 305
 306             /* Now we probably hit the backslash itself, skip past it */
 307             if (*p == L'\\')
 308             {
 309                 p++;
 310                 DriverNameLength -= sizeof(WCHAR);
 311             }
 312
 313             /*
 314              * Now make sure that the driver name fits in the buffer, minus
 315              * 3 NULL chars (driver name, device name, and remaining strings),
 316              * and copy the driver name in the string buffer.
 317              */
 318             DriverNameLength = min(DriverNameLength,
 319                                    RemainingLength - 3 * sizeof(UNICODE_NULL));
 320             RtlCopyMemory(StringBuffer, p, DriverNameLength);
 321         }
 322
 323         /* Null-terminate the driver name */
 324         *((PWSTR)(StringBuffer + DriverNameLength)) = UNICODE_NULL;
 325         DriverNameLength += sizeof(WCHAR);
 326
 327         /* Go to the next string buffer position */
 328         StringBuffer += DriverNameLength;
 329         RemainingLength -= DriverNameLength;
 330
 331         /* Update the string offset */
 332         ErrorMessage->EntryData.StringOffset =
 333             (USHORT)((ULONG_PTR)StringBuffer - (ULONG_PTR)ErrorMessage);
 334
 335         /* Check if we have a device object */
 336         if (LogEntry->DeviceObject)
 337         {
 338             /* We do, query its name */
 339             Status = ObQueryNameString(LogEntry->DeviceObject,
 340                                        ObjectNameInfo,
 341                                        sizeof(Buffer) - DriverNameLength,
 342                                        &ReturnedLength);
 343             if (!NT_SUCCESS(Status) || (ObjectNameInfo->Name.Length == 0))
 344             {
 345                 /* Setup an empty name */
 346                 RtlInitEmptyUnicodeString(&ObjectNameInfo->Name, L"", 0);
 347
 348                 /* Check if we failed because our buffer wasn't large enough */
 349                 if (Status == STATUS_INFO_LENGTH_MISMATCH)
 350                 {
 351                     /* Then we'll allocate one... we really want this name! */
 352                     PoolObjectNameInfo = ExAllocatePoolWithTag(PagedPool,
 353                                                                ReturnedLength,
 354                                                                TAG_IO);
 355                     if (PoolObjectNameInfo)
 356                     {
 357                         /* Query it again */
 358                         ObjectNameInfo = PoolObjectNameInfo;
 359                         Status = ObQueryNameString(LogEntry->DeviceObject,
 360                                                    ObjectNameInfo,
 361                                                    ReturnedLength,
 362                                                    &ReturnedLength);
 363                         if (NT_SUCCESS(Status))
 364                         {
 365                             /* Success, update the information */
 366                             ObjectNameInfo->Name.Length =
 367                                 IO_ERROR_OBJECT_NAMES_LENGTH - (USHORT)DriverNameLength;
 368                         }
 369                     }
 370                 }
 371             }
 372
 373             NameString = ObjectNameInfo->Name.Buffer;
 374             DeviceNameLength = ObjectNameInfo->Name.Length;
 375         }
 376         else
 377         {
 378             /* No device object, setup an empty name */
 379             NameString = L"";
 380             DeviceNameLength = 0;
 381         }
 382
 383         /*
 384          * Now make sure that the device name fits in the buffer, minus
 385          * 2 NULL chars (device name, and remaining strings), and copy
 386          * the device name in the string buffer.
 387          */
 388         DeviceNameLength = min(DeviceNameLength,
 389                                RemainingLength - 2 * sizeof(UNICODE_NULL));
 390         RtlCopyMemory(StringBuffer, NameString, DeviceNameLength);
 391
 392         /* Null-terminate the device name */
 393         *((PWSTR)(StringBuffer + DeviceNameLength)) = UNICODE_NULL;
 394         DeviceNameLength += sizeof(WCHAR);
 395
 396         /* Free the buffer if we had one */
 397         if (PoolObjectNameInfo)
 398         {
 399             ExFreePoolWithTag(PoolObjectNameInfo, TAG_IO);
 400             PoolObjectNameInfo = NULL;
 401         }
 402
 403         /* Go to the next string buffer position */
 404         ErrorMessage->EntryData.NumberOfStrings++;
 405         StringBuffer += DeviceNameLength;
 406         RemainingLength -= DeviceNameLength;
 407
 408         /* Check if we have any extra strings */
 409         if (Packet->NumberOfStrings)
 410         {
 411             /* Find out the size of the extra strings */
 412             ExtraStringLength = LogEntry->Size -
 413                                 sizeof(ERROR_LOG_ENTRY) -
 414                                 Packet->StringOffset;
 415
 416             /* Round up the length */
 417             ExtraStringLength = ROUND_UP(ExtraStringLength, sizeof(WCHAR));
 418
 419             /* Make sure that the extra strings fit in our buffer */
 420             if (ExtraStringLength > (RemainingLength - sizeof(UNICODE_NULL)))
 421             {
 422                 /* They wouldn't, so set normalize the length */
 423                 MessageLength -= ExtraStringLength - RemainingLength;
 424                 ExtraStringLength = RemainingLength - sizeof(UNICODE_NULL);
 425             }
 426
 427             /* Now copy the extra strings */
 428             RtlCopyMemory(StringBuffer,
 429                           (PCHAR)Packet + Packet->StringOffset,
 430                           ExtraStringLength);
 431
 432             /* Null-terminate them */
 433             *((PWSTR)(StringBuffer + ExtraStringLength)) = UNICODE_NULL;
 434         }
 435
 436         /* Set the driver name length */
 437         ErrorMessage->DriverNameLength = (USHORT)DriverNameLength;
 438
 439         /* Update the message length to include the driver and device names */
 440         MessageLength += DriverNameLength + DeviceNameLength;
 441         ErrorMessage->Size = (USHORT)MessageLength;
 442
 443         /* Now update it again for the size of the actual LPC */
 444         MessageLength += (FIELD_OFFSET(ELF_API_MSG, IoErrorMessage) -
 445                           FIELD_OFFSET(ELF_API_MSG, Unknown[0]));
 446
 447         /* Set the total and data lengths */
 448         Message->Header.u1.s1.TotalLength =
 449             (USHORT)(sizeof(PORT_MESSAGE) + MessageLength);
 450         Message->Header.u1.s1.DataLength = (USHORT)MessageLength;
 451
 452         /* Send the message */
 453         Status = ZwRequestPort(IopLogPort, &Message->Header);
 454         if (!NT_SUCCESS(Status))
 455         {
 456             /*
 457              * An error happened while sending the message on the port.
 458              * Close the port, requeue the log message on top of the list
 459              * and restart the worker.
 460              */
 461             ZwClose(IopLogPort);
 462             IopLogPortConnected = FALSE;
 463
 464             ExInterlockedInsertHeadList(&IopErrorLogListHead,
 465                                         &LogEntry->ListEntry,
 466                                         &IopLogListLock);
 467
 468             IopRestartLogWorker();
 469             break;
 470         }
 471
 472         /* NOTE: The following is basically 'IoFreeErrorLogEntry(Packet)' */
 473
 474         /* Dereference both objects */
 475         if (LogEntry->DeviceObject) ObDereferenceObject(LogEntry->DeviceObject);
 476         if (LogEntry->DriverObject) ObDereferenceObject(LogEntry->DriverObject);
 477
 478         /* Decrease the total allocation size and free the entry */
 479         InterlockedExchangeAdd(&IopTotalLogSize, -(LONG)LogEntry->Size);
 480         ExFreePoolWithTag(LogEntry, TAG_ERROR_LOG);
 481     }
 482
 483     /* Free the LPC Message */
 484     ExFreePoolWithTag(Message, TAG_IO);
 485 }
 486
 487 VOID
 488 NTAPI
 489 IopFreeApc(IN PKAPC Apc)
 490 {
 491     /* Free the APC */
 492     ExFreePool(Apc);
 493 }
 494
 495 VOID
 496 NTAPI
 497 IopRaiseHardError(IN PVOID NormalContext,
 498                   IN PVOID SystemArgument1,
 499                   IN PVOID SystemArgument2)
 500 {
 501     PIRP Irp = NormalContext;
 502     //PVPB Vpb = SystemArgument1;
 503     //PDEVICE_OBJECT DeviceObject = SystemArgument2;
 504
 505     UNIMPLEMENTED;
 506
 507     /* FIXME: UNIMPLEMENTED */
 508     Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
 509     Irp->IoStatus.Information = 0;
 510     IoCompleteRequest(Irp, IO_DISK_INCREMENT);
 511 }
 512
 513 /* PUBLIC FUNCTIONS **********************************************************/
 514
 515 /*
 516  * @implemented
 517  */
 518 PVOID
 519 NTAPI
 520 IoAllocateErrorLogEntry(IN PVOID IoObject,
 521                         IN UCHAR EntrySize)
 522 {
 523     PERROR_LOG_ENTRY LogEntry;
 524     ULONG LogEntrySize;
 525     PDEVICE_OBJECT DeviceObject;
 526     PDRIVER_OBJECT DriverObject;
 527
 528     /* Make sure we have an object */
 529     if (!IoObject) return NULL;
 530
 531     /* Check if this is a device object or driver object */
 532     DeviceObject = (PDEVICE_OBJECT)IoObject;
 533     if (DeviceObject->Type == IO_TYPE_DEVICE)
 534     {
 535         /* It's a device, get the driver */
 536         // DeviceObject = (PDEVICE_OBJECT)IoObject;
 537         DriverObject = DeviceObject->DriverObject;
 538     }
 539     else if (DeviceObject->Type == IO_TYPE_DRIVER)
 540     {
 541         /* It's a driver, so we don't have a device */
 542         DeviceObject = NULL;
 543         DriverObject = (PDRIVER_OBJECT)IoObject;
 544     }
 545     else
 546     {
 547         /* Fail */
 548         return NULL;
 549     }
 550
 551     /* Check whether the size is too small or too large */
 552     if ((EntrySize < sizeof(IO_ERROR_LOG_PACKET)) ||
 553         (EntrySize > ERROR_LOG_MAXIMUM_SIZE))
 554     {
 555         /* Fail */
 556         return NULL;
 557     }
 558
 559     /* Round up the size and calculate the total size */
 560     EntrySize = ROUND_UP(EntrySize, sizeof(PVOID));
 561     LogEntrySize = sizeof(ERROR_LOG_ENTRY) + EntrySize;
 562
 563     /* Check if we're past our buffer */
 564     // TODO: Improve (what happens in case of concurrent calls?)
 565     if (IopTotalLogSize + LogEntrySize > IOP_MAXIMUM_LOG_SIZE) return NULL;
 566
 567     /* Allocate the entry */
 568     LogEntry = ExAllocatePoolWithTag(NonPagedPool,
 569                                      LogEntrySize,
 570                                      TAG_ERROR_LOG);
 571     if (!LogEntry) return NULL;
 572
 573     /* Reference the Objects */
 574     if (DeviceObject) ObReferenceObject(DeviceObject);
 575     if (DriverObject) ObReferenceObject(DriverObject);
 576
 577     /* Update log size */
 578     InterlockedExchangeAdd(&IopTotalLogSize, LogEntrySize);
 579
 580     /* Clear the entry and set it up */
 581     RtlZeroMemory(LogEntry, LogEntrySize);
 582     LogEntry->Type = IO_TYPE_ERROR_LOG;
 583     LogEntry->Size = LogEntrySize;
 584     LogEntry->DeviceObject = DeviceObject;
 585     LogEntry->DriverObject = DriverObject;
 586
 587     /* Return the entry data */
 588     return (PVOID)((ULONG_PTR)LogEntry + sizeof(ERROR_LOG_ENTRY));
 589 }
 590
 591 /*
 592  * @implemented
 593  */
 594 VOID
 595 NTAPI
 596 IoFreeErrorLogEntry(IN PVOID ElEntry)
 597 {
 598     PERROR_LOG_ENTRY LogEntry;
 599
 600     /* Make sure there is an entry */
 601     if (!ElEntry) return;
 602
 603     /* Get the actual header */
 604     LogEntry = (PERROR_LOG_ENTRY)((ULONG_PTR)ElEntry - sizeof(ERROR_LOG_ENTRY));
 605
 606     /* Dereference both objects */
 607     if (LogEntry->DeviceObject) ObDereferenceObject(LogEntry->DeviceObject);
 608     if (LogEntry->DriverObject) ObDereferenceObject(LogEntry->DriverObject);
 609
 610     /* Decrease the total allocation size and free the entry */
 611     InterlockedExchangeAdd(&IopTotalLogSize, -(LONG)LogEntry->Size);
 612     ExFreePoolWithTag(LogEntry, TAG_ERROR_LOG);
 613 }
 614
 615 /*
 616  * @implemented
 617  */
 618 VOID
 619 NTAPI
 620 IoWriteErrorLogEntry(IN PVOID ElEntry)
 621 {
 622     PERROR_LOG_ENTRY LogEntry;
 623     KIRQL Irql;
 624
 625     /* Make sure there is an entry */
 626     if (!ElEntry) return;
 627
 628     /* Get the actual header */
 629     LogEntry = (PERROR_LOG_ENTRY)((ULONG_PTR)ElEntry - sizeof(ERROR_LOG_ENTRY));
 630
 631     /* Get time stamp */
 632     KeQuerySystemTime(&LogEntry->TimeStamp);
 633
 634     /* Acquire the lock and insert this write in the list */
 635     KeAcquireSpinLock(&IopLogListLock, &Irql);
 636     InsertHeadList(&IopErrorLogListHead, &LogEntry->ListEntry);
 637
 638     /* Check if the worker is running */
 639     if (!IopLogWorkerRunning)
 640     {
 641         /* It's not, initialize it and queue it */
 642         IopLogWorkerRunning = TRUE;
 643         ExInitializeWorkItem(&IopErrorLogWorkItem, IopLogWorker, NULL);
 644         ExQueueWorkItem(&IopErrorLogWorkItem, DelayedWorkQueue);
 645     }
 646
 647     /* Release the lock and return */
 648     KeReleaseSpinLock(&IopLogListLock, Irql);
 649 }
 650
 651 /*
 652  * @implemented
 653  */
 654 VOID
 655 NTAPI
 656 IoRaiseHardError(IN PIRP Irp,
 657                  IN PVPB Vpb,
 658                  IN PDEVICE_OBJECT RealDeviceObject)
 659 {
 660     PETHREAD Thread = (PETHREAD)&Irp->Tail.Overlay.Thread;
 661     PKAPC ErrorApc;
 662
 663     /* Don't do anything if hard errors are disabled on the thread */
 664     if (Thread->HardErrorsAreDisabled)
 665     {
 666         /* Complete the request */
 667         Irp->IoStatus.Information = 0;
 668         IoCompleteRequest(Irp, IO_DISK_INCREMENT);
 669         return;
 670     }
 671
 672     /* Setup an APC */
 673     ErrorApc = ExAllocatePoolWithTag(NonPagedPool,
 674                                      sizeof(KAPC),
 675                                      TAG_APC);
 676     KeInitializeApc(ErrorApc,
 677                     &Thread->Tcb,
 678                     Irp->ApcEnvironment,
 679                     NULL,
 680                     IopFreeApc,
 681                     IopRaiseHardError,
 682                     KernelMode,
 683                     Irp);
 684
 685     /* Queue an APC to deal with the error (see osr documentation) */
 686     KeInsertQueueApc(ErrorApc, Vpb, RealDeviceObject, 0);
 687 }
 688
 689 /*
 690  * @unimplemented
 691  */
 692 BOOLEAN
 693 NTAPI
 694 IoRaiseInformationalHardError(IN NTSTATUS ErrorStatus,
 695                               IN PUNICODE_STRING String,
 696                               IN PKTHREAD Thread)
 697 {
 698     DPRINT1("IoRaiseInformationalHardError: %lx, %wZ\n", ErrorStatus, String);
 699     return FALSE;
 700 }
 701
 702 /*
 703  * @implemented
 704  */
 705 BOOLEAN
 706 NTAPI
 707 IoSetThreadHardErrorMode(IN BOOLEAN HardErrorEnabled)
 708 {
 709     PETHREAD Thread = PsGetCurrentThread();
 710     BOOLEAN OldMode;
 711
 712     /* Get the current value */
 713     OldMode = !Thread->HardErrorsAreDisabled;
 714
 715     /* Set the new one and return the old */
 716     Thread->HardErrorsAreDisabled = !HardErrorEnabled;
 717     return OldMode;
 718 }