ioerr.c File Reference

#include "pch.h"

Go to the source code of this file.

Functions
HANDLE	IoepInitErrLog (IN ULONG KeyType, IN PVOID Key, IN ULONG ulFlags)
PERRTHREAD	IoepFindErrThread (IN ULONG KeyType, IN PVOID Key)
PERRTHREAD	IoepNewErrThread (IN ULONG KeyType, IN PVOID Key)
VOID	IoepLogErr (IN ULONG KeyType, IN PVOID Key, IN CONST GUID *ComponentGuid, IN ULONG ErrCode, IN PWSTR TextData OPTIONAL, IN ULONG DataBlkType, IN ULONG DataBlkLen OPTIONAL, IN PVOID DataBlock OPTIONAL, IN CONST GUID *MofGuid OPTIONAL)
VOID	IoepFreeErrStack (IN PERRENTRY ErrStack)
PERRMODULE	IoepFindErrModule (IN CONST GUID *ComponentGuid)
NTSTATUS	IoepExtractErrData (IN PERRENTRY ErrStack, OUT PVOID Buffer, IN ULONG BuffSize, OUT PULONG DataSize OPTIONAL)
NTSTATUS	IoepFireWMIEvent (IN PERRINFO ErrInfo, IN PWSTR InstanceName)
NTSTATUS	IoepHandleErrCase (IN PERRINFO ErrInfo, IN PERRCASE ErrCase, IN ULONG Method, OUT PUNICODE_STRING unicodeMsg OPTIONAL)
PERRHANDLER	IoepFindErrHandler (IN CONST GUID *ComponentGuid, IN ULONG HandlerIndex)
BOOLEAN	IoepMatchErrIDPath (IN PERRINFO ErrInfo, IN PERRID ErrIDPath, IN ULONG NumErrIDs)
NTSTATUS	IoepGetErrMessage (IN PMSGDATA MsgData, IN PERRINFO ErrInfo, OUT PUNICODE_STRING unicodeMsg)
NTSTATUS	IoepCatMsgArg (IN OUT PUNICODE_STRING unicodeMsg, IN PMSGARG MsgArg, IN PERRINFO ErrInfo)
NTSTATUS	IoepUnicodeStringCatN (IN OUT PUNICODE_STRING unicodeStr, IN PWSTR pwstr, IN ULONG len)
PERRCASEDB	IoepGetErrCaseDB (VOID)

---

Function Documentation

NTSTATUS IoepCatMsgArg (  IN OUT PUNICODE_STRING  unicodeMsg, IN PMSGARG  MsgArg, IN PERRINFO  ErrInfo )

Definition at line 1052 of file ioerr.c. References _handlerdata::ComponentGuid, _errcasedb::DataBlkOffset, _errdata::DataBlkOffset, DBGPRINT, ENTER, EXIT, _handlerdata::HandlerIndex, IOEDATA_PRIVATE, IOEDATA_TEXT, IOEDATA_WSTRING, IoepFindErrHandler(), IoepGetErrCaseDB(), NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _handlerdata::Param, PERRHANDLER, PROCNAME, RtlAppendUnicodeToString(), STATUS_IOE_DATABASE_NOT_READY, and _errdata::TextDataOffset. Referenced by IoepGetErrMessage(). : This routine appends the substituted message argument to the unicode string if there is enough space. Otherwise, STATUS_BUFFER_TOO_SMALL is returned. Arguments: unicodeMsg - points to the target unicode message MsgArg - points to the message argument structure ErrInfo - points to the error info. Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code --*/ { PROCNAME("IoepCatMsgArg"); NTSTATUS status = STATUS_SUCCESS; PERRCASEDB ErrCaseDB; PAGED_CODE(); ENTER(2, ("(Msg=%S,pMsgArg=%p,ErrInfo=%p)\n", unicodeMsg->Buffer, MsgArg, ErrInfo)); ErrCaseDB = IoepGetErrCaseDB(); if (ErrCaseDB != NULL) { if (MsgArg->ErrIDIndex < ErrInfo->NumErrEntries) { PERRDATA ErrData; ANSI_STRING ansiStr; UNICODE_STRING unicodeStr; PHANDLERDATA HandlerData; PERRHANDLER ErrHandler; ErrData = &ErrInfo->ErrEntries[MsgArg->ErrIDIndex]; switch (MsgArg->ArgType) { case IOEDATA_TEXT: status = RtlAppendUnicodeToString( unicodeMsg, (PWSTR)((PUCHAR)ErrInfo + ErrData->TextDataOffset)); if (!NT_SUCCESS(status)) { DBGPRINT(("failed to append unicode string (rc=%x)\n", status)); } break; case IOEDATA_WSTRING: status = RtlAppendUnicodeToString( unicodeMsg, (PWSTR)((PUCHAR)ErrInfo + ErrData->DataBlkOffset)); if (!NT_SUCCESS(status)) { DBGPRINT(("failed to append unicode string argument (rc=%x)\n", status)); } break; case IOEDATA_PRIVATE: HandlerData = (PHANDLERDATA)((ULONG_PTR)ErrCaseDB + ErrCaseDB->DataBlkOffset + MsgArg->ArgDataOffset); ErrHandler = IoepFindErrHandler(&HandlerData->ComponentGuid, HandlerData->HandlerIndex); if (ErrHandler != NULL) { status = ErrHandler(ErrData, HandlerData->Param); } break; default: DBGPRINT(("invalid message argument type %d\n", MsgArg->ArgType)); } } else { status = STATUS_UNSUCCESSFUL; DBGPRINT(("failed to find error entry\n")); } } else { status = STATUS_IOE_DATABASE_NOT_READY; DBGPRINT(("error case database not ready\n")); } EXIT(2, ("=%x(Msg=%S)\n", status, unicodeMsg->Buffer)); return status; } //IoepCatMsgArg

NTSTATUS IoepExtractErrData (  IN PERRENTRY  ErrStack, OUT PVOID  Buffer, IN ULONG  BuffSize, OUT PULONG DataSize  OPTIONAL )

Definition at line 501 of file ioerr.c. References ASSERT, Buffer, _errentry::DataBlk, _errdata::DataBlkLen, _errentry::DataBlkLen, _errdata::DataBlkOffset, _errentry::DataBlkType, _errdata::DataBlkType, _errinfo::DataTag, DBGPRINT, ENTER, _errinfo::ErrEntries, _errentry::ErrID, _errdata::ErrID, EXIT, IOE_ERRINFO_VERSION, IoepGetNextErrEntry, _errentry::MofGuid, _errdata::MofGuid, NTSTATUS(), NULL, _errinfo::NumErrEntries, PROCNAME, SIG_ERRINFO, _errinfo::Signature, _errinfo::Size, _errinfo::TagFlags, _errdata::TextDataOffset, _errentry::unicodeStr, and _errinfo::Version. Referenced by IoErrGetErrData(). : This routine stores the error stack data into a flat buffer. Arguments: ErrStack - points to the error stack Buffer - points to the buffer for the data BuffSize - specifies the buffer size DataSize - points to the variable to receive the actual data size Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code --*/ { PROCNAME("IoepExtractErrData"); NTSTATUS status; PERRENTRY Err; ULONG len, i; ASSERT(ErrStack != NULL); ASSERT((Buffer != NULL) && (BuffSize > 0) || (DataSize != NULL)); ENTER(2, ("(ErrStack=%p,Buff=%p,BuffSize=%d,pDataSize=%p)\n", ErrStack, Buffer, BuffSize, DataSize)); for (Err = ErrStack, len = sizeof(ERRINFO) - sizeof(ERRDATA), i = 0; Err != NULL; Err = IoepGetNextErrEntry(Err), i++) { len += sizeof(ERRDATA) + Err->DataBlkLen + Err->unicodeStr.MaximumLength; } if (len <= BuffSize) { if ((Buffer != NULL) && (len > 0)) { PERRINFO ErrInfo = (PERRINFO)Buffer; PUCHAR pBuff; ErrInfo->Signature = SIG_ERRINFO; ErrInfo->Version = IOE_ERRINFO_VERSION; ErrInfo->Size = len; ErrInfo->DataTag = NULL; ErrInfo->TagFlags = 0; ErrInfo->NumErrEntries = i; pBuff = (PUCHAR)ErrInfo + sizeof(ERRINFO) + sizeof(ERRDATA)*(i - 1); for (Err = ErrStack, i = 0; Err != NULL; Err = IoepGetNextErrEntry(Err), i++) { ErrInfo->ErrEntries[i].ErrID = Err->ErrID; ErrInfo->ErrEntries[i].DataBlkType = Err->DataBlkType; ErrInfo->ErrEntries[i].DataBlkLen = Err->DataBlkLen; ErrInfo->ErrEntries[i].MofGuid = Err->MofGuid; if (Err->unicodeStr.MaximumLength > 0) { ErrInfo->ErrEntries[i].TextDataOffset = pBuff - (PUCHAR)ErrInfo; RtlCopyMemory(pBuff, Err->unicodeStr.Buffer, Err->unicodeStr.MaximumLength); pBuff += Err->unicodeStr.MaximumLength; } else { ErrInfo->ErrEntries[i].TextDataOffset = 0; } if (Err->DataBlk != NULL) { ErrInfo->ErrEntries[i].DataBlkOffset = pBuff - (PUCHAR)ErrInfo; RtlCopyMemory(pBuff, Err->DataBlk, Err->DataBlkLen); pBuff += Err->DataBlkLen; } else { ErrInfo->ErrEntries[i].DataBlkOffset = 0; } } } status = STATUS_SUCCESS; } else { status = STATUS_BUFFER_TOO_SMALL; DBGPRINT(("buffer too small (size=%d,need=%d)\n", BuffSize, len)); } if (DataSize != NULL) { *DataSize = len; } EXIT(2, ("=%x(len=%d)\n", status, len)); return status; } //IoepExtractErrData

PERRHANDLER IoepFindErrHandler (  IN CONST GUID *  ComponentGuid, IN ULONG  HandlerIndex )

Definition at line 824 of file ioerr.c. References ENTER, EXIT, _errmodule::HandlerTable, IoepFindErrModule(), NULL, _errmodule::NumErrHandlers, PERRHANDLER, and PROCNAME. Referenced by IoepCatMsgArg(), and IoepHandleErrCase(). : This routine find the error handler with the given module GUID and handler index. Arguments: ComponentGuid - points to the GUID of the handler module HandlerIndex - index into handler table Return Value: Success - returns pointer to error handler found Failure - returns NULL --*/ { PROCNAME("IoepFindErrHandler"); PERRHANDLER ErrHandler = NULL; PERRMODULE ErrModule; ENTER(2, ("(pGuid=%p,Index=%x)\n", ComponentGuid, HandlerIndex)); ErrModule = IoepFindErrModule(ComponentGuid); if ((ErrModule != NULL) && (HandlerIndex < ErrModule->NumErrHandlers)) { ErrHandler = ErrModule->HandlerTable[HandlerIndex]; } EXIT(2, ("=%p\n", ErrHandler)); return ErrHandler; } //IoepFindErrHandler

PERRMODULE IoepFindErrModule (  IN CONST GUID *  ComponentGuid  )

Definition at line 456 of file ioerr.c. References _errmodule::ComponentGuid, ENTER, EXIT, IoepErrListLock, IoepErrModuleListHead, NULL, and PROCNAME. Referenced by IoepFindErrHandler(), and IoErrRegisterErrHandlers(). : This routine finds a registered error module with a given module GUID. Arguments: ComponentGuid - points to the GUID of the error module Return Value: Success - returns pointer to error module found Failure - returns NULL --*/ { PROCNAME("IoepFindErrModule"); PERRMODULE ErrModule = NULL; PLIST_ENTRY list; KIRQL Irql; ENTER(2, ("(pGuid=%p)\n", ComponentGuid)); ExAcquireSpinLock(&IoepErrListLock, &Irql); for (list = IoepErrModuleListHead.Flink; list != &IoepErrModuleListHead; list = list->Flink) { ErrModule = CONTAINING_RECORD(list, ERRMODULE, list); if (RtlEqualMemory(&ErrModule->ComponentGuid, ComponentGuid, sizeof(GUID))) { break; } ErrModule = NULL; } ExReleaseSpinLock(&IoepErrListLock, Irql); EXIT(2, ("=%p\n", ErrModule)); return ErrModule; } //IoepFindErrModule

PERRTHREAD IoepFindErrThread (  IN ULONG  KeyType, IN PVOID  Key )

Definition at line 108 of file ioerr.c. References _IO_STACK_LOCATION::DeviceObject, ENTER, EXIT, IoepErrListLock, IoepErrThreadListHead, IoGetCurrentIrpStackLocation, Key, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NULL, _IO_STACK_LOCATION::Parameters, PROCNAME, _errthread::ThreadKey, THREADKEY_IRP, THREADKEY_THREADID, and _errthread::ThreadKeyType. Referenced by IoepInitErrLog(), and IoepLogErr(). : This routine finds the error thread keyed by the given Key. Arguments: KeyType - specifies the type of key. Key - points to the key that is used to locate the logging session. Return Value: Success - returns the error thread handle found. Failure - returns NULL. --*/ { PROCNAME("IoepFindErrThread"); PERRTHREAD ErrThread = NULL; PLIST_ENTRY list; KIRQL Irql; ENTER(2, ("(KeyType=%x,Key=%p)\n", KeyType, Key)); ExAcquireSpinLock(&IoepErrListLock, &Irql); for (list = IoepErrThreadListHead.Flink; list != &IoepErrThreadListHead; list = list->Flink) { ErrThread = CONTAINING_RECORD(list, ERRTHREAD, list); if (ErrThread->ThreadKeyType == KeyType) { switch (KeyType) { case THREADKEY_IRP: if ((PIRP)Key == ErrThread->ThreadKey.IrpKey.Irp) { break; } else { PIO_STACK_LOCATION IrpSp; IrpSp = IoGetCurrentIrpStackLocation((PIRP)Key); if ((IrpSp->MajorFunction == ErrThread->ThreadKey.IrpKey.MajorFunction) && (IrpSp->MinorFunction == ErrThread->ThreadKey.IrpKey.MinorFunction) && RtlEqualMemory(&IrpSp->Parameters.Others, ErrThread->ThreadKey.IrpKey.Arguments, sizeof(PVOID)*4) && (IopDbgGetLowestDevice(IrpSp->DeviceObject) == ErrThread->ThreadKey.IrpKey.TargetDevice)) { break; } } break; case THREADKEY_THREADID: if ((PKTHREAD)Key == ErrThread->ThreadKey.ThIDKey.ThreadID) { break; } break; } } ErrThread = NULL; } ExReleaseSpinLock(&IoepErrListLock, Irql); EXIT(2, ("=%p\n", ErrThread)); return ErrThread; } //IoepFindErrThread

NTSTATUS IoepFireWMIEvent (  IN PERRINFO  ErrInfo, IN PWSTR  InstanceName )

Definition at line 612 of file ioerr.c. References DBGPRINT, ENTER, ExAllocatePoolWithTag, EXIT, IoepGuid, IOETAG_WMIEVENT, IoWMIWriteEvent(), KeQuerySystemTime(), NonPagedPool, NTSTATUS(), NULL, and PROCNAME. Referenced by IoErrTerminateErrLog(). : This routine fires a WMI event notifying the availability of an error info. Arguments: ErrInfo - points to the error info. InstanceName - points to the instance name string Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code --*/ { PROCNAME("IoepFireWMIEvent"); NTSTATUS status; ENTER(2, ("(ErrInfo=%p,InstanceName=%S)\n", ErrInfo, InstanceName)); if (ErrInfo != NULL) { ULONG NameLen, EventSize; PWNODE_SINGLE_INSTANCE event; NameLen = wcslen(InstanceName)*sizeof(WCHAR) + sizeof(UNICODE_NULL); EventSize = sizeof(WNODE_SINGLE_INSTANCE) + NameLen + ErrInfo->Size; event = ExAllocatePoolWithTag(NonPagedPool, EventSize, IOETAG_WMIEVENT); if (event != NULL) { event->WnodeHeader.BufferSize = EventSize; event->WnodeHeader.ProviderId = 0; event->WnodeHeader.Guid = IoepGuid; event->WnodeHeader.Flags = WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_EVENT_ITEM; KeQuerySystemTime(&event->WnodeHeader.TimeStamp); event->OffsetInstanceName = sizeof(WNODE_SINGLE_INSTANCE); event->DataBlockOffset = sizeof(WNODE_SINGLE_INSTANCE) + NameLen; event->SizeDataBlock = ErrInfo->Size; RtlCopyMemory(&event->VariableData, InstanceName, NameLen); RtlCopyMemory(event->VariableData + NameLen, ErrInfo, ErrInfo->Size); status = IoWMIWriteEvent(event); } else { status = STATUS_INSUFFICIENT_RESOURCES; DBGPRINT(("failed to allocate WMI event node (len=%d)\n", EventSize)); } } else { status = STATUS_SUCCESS; } EXIT(2, ("=%x\n", status)); return status; } //IoepFireWMIEvent

VOID IoepFreeErrStack (  IN PERRENTRY  ErrStack  )

Definition at line 414 of file ioerr.c. References ASSERT, _errentry::DataBlk, ENTER, ExFreePool(), EXIT, IoepErrListLock, IoepGetNextErrEntry, NULL, PROCNAME, RtlFreeUnicodeString(), _errentry::slist, and _errentry::unicodeStr. Referenced by IoErrTerminateErrLog(). : This routine frees an error stack and the associated data blocks. Arguments: ErrStack - points to the error stack to be freed Return Value: None --*/ { PROCNAME("IoepFreeErrStack"); PERRENTRY Err, ErrNext; KIRQL Irql; ASSERT(ErrStack != NULL); ENTER(2, ("(ErrStack=%p)\n", ErrStack)); ExAcquireSpinLock(&IoepErrListLock, &Irql); for (Err = ErrStack; Err != NULL; Err = ErrNext) { if (Err->DataBlk != NULL) { ExFreePool(Err->DataBlk); Err->DataBlk = NULL; } RtlFreeUnicodeString(&Err->unicodeStr); ErrNext = IoepGetNextErrEntry(Err); Err->slist.Next = NULL; ExFreePool(Err); } ExReleaseSpinLock(&IoepErrListLock, Irql); EXIT(2, ("!\n")); } //IoepFreeErrStack

PERRCASEDB IoepGetErrCaseDB (  VOID   )

Definition at line 1200 of file ioerr.c. References DBGPRINT, ENTER, ExAllocatePoolWithTag, ExFreePool(), EXIT, IoepErrCaseDB, IoepRegKeyStrIoErr, IOETAG_ERRCASEDB, IopGetRegistryValue(), L, _errcasedb::Length, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, PROCNAME, RtlInitUnicodeString(), and ZwCreateFile(). Referenced by IoepCatMsgArg(), IoepGetErrMessage(), IoepHandleErrCase(), IoErrFindErrCaseByID(), and IoErrMatchErrCase(). 01205 : 01206 This routine checks if the ErrCase database has been read into memory. 01207 If it has, it returns the pointer to the error case database. Otherwise, 01208 it tries to read the database in. 01209 01210 Arguments: 01211 None 01212 01213 Return Value: 01214 Success - returns pointer to the error case database 01215 Failure - returns NULL 01216 01217 --*/ 01218 { 01219 PROCNAME("IoepGetErrCaseDB"); 01220 01221 PAGED_CODE(); 01222 ENTER(2, ("()\n")); 01223 01224 if (IoepErrCaseDB == NULL) 01225 { 01226 OBJECT_ATTRIBUTES ObjAttr; 01227 NTSTATUS status; 01228 HANDLE hReg, hFile; 01229 01230 InitializeObjectAttributes(&ObjAttr, 01231 &IoepRegKeyStrIoErr, 01232 OBJ_CASE_INSENSITIVE, 01233 NULL, 01234 NULL); 01235 status = ZwOpenKey(&hReg, KEY_READ, &ObjAttr); 01236 if (NT_SUCCESS(status)) 01237 { 01238 PKEY_VALUE_FULL_INFORMATION KeyValue; 01239 01240 status = IopGetRegistryValue(hReg, L"ErrCaseDB", &KeyValue); 01241 if (NT_SUCCESS(status)) 01242 { 01243 UNICODE_STRING unicodeStr; 01244 IO_STATUS_BLOCK IoStatusBlk; 01245 01246 RtlInitUnicodeString(&unicodeStr, 01247 (PWSTR)((PUCHAR)KeyValue + 01248 KeyValue->DataOffset)); 01249 InitializeObjectAttributes(&ObjAttr, 01250 &unicodeStr, 01251 OBJ_CASE_INSENSITIVE, 01252 NULL, 01253 NULL); 01254 status = ZwCreateFile(&hFile, 01255 FILE_READ_DATA, 01256 &ObjAttr, 01257 &IoStatusBlk, 01258 NULL, 01259 FILE_ATTRIBUTE_NORMAL, 01260 FILE_SHARE_READ, 01261 FILE_OPEN, 01262 FILE_NON_DIRECTORY_FILE | 01263 FILE_SEQUENTIAL_ONLY | 01264 FILE_SYNCHRONOUS_IO_NONALERT, 01265 NULL, 01266 0); 01267 01268 if (NT_SUCCESS(status) && 01269 (IoStatusBlk.Information == FILE_OPENED)) 01270 { 01271 ERRCASEDB DBHeader; 01272 01273 status = ZwReadFile(hFile, 01274 NULL, 01275 NULL, 01276 NULL, 01277 &IoStatusBlk, 01278 &DBHeader, 01279 sizeof(DBHeader), 01280 NULL, 01281 NULL); 01282 01283 if (NT_SUCCESS(status)) 01284 { 01285 IoepErrCaseDB = ExAllocatePoolWithTag(PagedPool, 01286 DBHeader.Length, 01287 IOETAG_ERRCASEDB); 01288 if (IoepErrCaseDB != NULL) 01289 { 01290 RtlCopyMemory(IoepErrCaseDB, 01291 &DBHeader, 01292 sizeof(DBHeader)); 01293 status = ZwReadFile(hFile, 01294 NULL, 01295 NULL, 01296 NULL, 01297 &IoStatusBlk, 01298 (PUCHAR)IoepErrCaseDB + 01299 sizeof(DBHeader), 01300 DBHeader.Length - 01301 sizeof(DBHeader), 01302 NULL, 01303 NULL); 01304 01305 if (!NT_SUCCESS(status)) 01306 { 01307 ExFreePool(IoepErrCaseDB); 01308 IoepErrCaseDB = NULL; 01309 DBGPRINT(("failed to read error case database (rc=%x)\n", 01310 status)); 01311 } 01312 } 01313 else 01314 { 01315 DBGPRINT(("failed to allocate storage for error case database (len=%d)\n", 01316 DBHeader.Length)); 01317 } 01318 } 01319 else 01320 { 01321 DBGPRINT(("failed to read database header (rc=%x)\n", 01322 status)); 01323 } 01324 ZwClose(hFile); 01325 } 01326 else 01327 { 01328 DBGPRINT(("failed to open error case database (rc=%x)\n", 01329 status)); 01330 } 01331 ExFreePool(KeyValue); 01332 } 01333 else 01334 { 01335 DBGPRINT(("failed to read registry value (rc=%x)\n", status)); 01336 } 01337 ZwClose(hReg); 01338 } 01339 else 01340 { 01341 DBGPRINT(("failed to open registry key (rc=%x)\n", status)); 01342 } 01343 } 01344 01345 EXIT(2, ("=%p\n", IoepErrCaseDB)); 01346 return IoepErrCaseDB; 01347 } //IoepGetErrCaseDB } //IoepGetErrCaseDB

NTSTATUS IoepGetErrMessage (  IN PMSGDATA  MsgData, IN PERRINFO  ErrInfo, OUT PUNICODE_STRING  unicodeMsg )

Definition at line 936 of file ioerr.c. References _errcasedb::DataBlkOffset, DBGPRINT, ENTER, ExAllocatePoolWithTag, EXIT, IoepCatMsgArg(), IoepGetErrCaseDB(), IoepUnicodeStringCatN(), IOETAG_MSGBUFF, L, MAX_MSG_LEN, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, PROCNAME, RtlAppendUnicodeToString(), RtlInitUnicodeString(), and STATUS_IOE_DATABASE_NOT_READY. Referenced by IoepHandleErrCase(). : This routine constructs the error message from the message method data. Arguments: MsgData - points to the message method data ErrInfo - points to the error info unicodeMsg - points to the uninitialized unicode string message buffer Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code Note: This routine will allocate the actual string buffer of the unicode message. Therefore, it is the caller's responsibility to free the message buffer via RtlFreeUnicodeString. --*/ { PROCNAME("IoepGetErrMessage"); NTSTATUS status = STATUS_SUCCESS; PERRCASEDB ErrCaseDB; PAGED_CODE(); ENTER(2, ("(pMsgData=%p,ErrInfo=%p,pMsg=%p)\n", MsgData, ErrInfo, unicodeMsg)); ErrCaseDB = IoepGetErrCaseDB(); if (ErrCaseDB != NULL) { PWSTR MsgTemplate, MsgBuff, pwstr; MsgTemplate = (PWSTR)((ULONG_PTR)ErrCaseDB + ErrCaseDB->DataBlkOffset + MsgData->MsgTemplateOffset); MsgBuff = ExAllocatePoolWithTag(PagedPool, sizeof(WCHAR)*MAX_MSG_LEN + sizeof(UNICODE_NULL), IOETAG_MSGBUFF); if (MsgBuff != NULL) { MsgBuff[0] = L'\0'; RtlInitUnicodeString(unicodeMsg, MsgBuff); unicodeMsg->MaximumLength = sizeof(WCHAR)*MAX_MSG_LEN + sizeof(UNICODE_NULL); while (NT_SUCCESS(status)) { pwstr = wcschr(MsgTemplate, L'%'); if (pwstr == NULL) { status = RtlAppendUnicodeToString(unicodeMsg, MsgTemplate); if (!NT_SUCCESS(status)) { DBGPRINT(("failed to append unicode string (rc=%x)\n", status)); } break; } else if ((pwstr[1] >= L'0') && (pwstr[1] <= L'9')) { ULONG ArgIndex; PWSTR pwstr2; ArgIndex = wcstoul(&pwstr[1], &pwstr2, 10); status = IoepUnicodeStringCatN(unicodeMsg, MsgTemplate, pwstr - MsgTemplate); if (NT_SUCCESS(status)) { MsgTemplate = pwstr2; status = IoepCatMsgArg(unicodeMsg, &MsgData->Args[ArgIndex], ErrInfo); } } else { pwstr++; status = IoepUnicodeStringCatN(unicodeMsg, MsgTemplate, pwstr - MsgTemplate); if (NT_SUCCESS(status)) { MsgTemplate = pwstr; } } } } else { status = STATUS_INSUFFICIENT_RESOURCES; DBGPRINT(("failed to allocate message buffer\n")); } } else { status = STATUS_IOE_DATABASE_NOT_READY; DBGPRINT(("error case database not ready\n")); } EXIT(2, ("=%x(Msg=%S)\n", status, unicodeMsg->Buffer? unicodeMsg->Buffer: L"")); return status; } //IoepGetErrMessage

NTSTATUS IoepHandleErrCase (  IN PERRINFO  ErrInfo, IN PERRCASE  ErrCase, IN ULONG  Method, OUT PUNICODE_STRING unicodeMsg  OPTIONAL )

Definition at line 680 of file ioerr.c. References _errcasedb::DataBlkOffset, DBGPRINT, ENTER, ExAllocatePoolWithTag, EXIT, IOEMETHOD_ANY, IOEMETHOD_HANDLER, IOEMETHOD_LONGMSG, IOEMETHOD_SHORTMSG, IoepFindErrHandler(), IoepGetErrCaseDB(), IoepGetErrMessage(), IOETAG_DATAWSTR, IoRaiseInformationalHardError(), _method::MethodDataOffset, _method::MethodType, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, PERRHANDLER, PROCNAME, RtlFreeUnicodeString(), RtlInitUnicodeString(), STATUS_IOE_DATABASE_NOT_READY, and STATUS_IOE_MESSAGE. Referenced by IoErrGetLongErrMessage(), IoErrGetShortErrMessage(), and IoErrHandleErrCase(). : This routine handles an error case by executing the resolution method. Arguments: ErrInfo - points to the error info ErrCase - points to the error case Method - specifying what method to use to handle the error case unicodeMsg - point to unicodeStr to receive the error message Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code --*/ { PROCNAME("IoepHandleErrCase"); NTSTATUS status; PERRCASEDB ErrCaseDB; PAGED_CODE(); ENTER(2, ("(ErrInfo=%p,ErrCase=%p,Method=%x,unicodeMsg=%p)\n", ErrInfo, ErrCase, Method, unicodeMsg)); ErrCaseDB = IoepGetErrCaseDB(); if (ErrCaseDB != NULL) { PMETHOD MethodTable; ULONG i; PVOID MethodData; UNICODE_STRING unicodeStr; PERRHANDLER ErrHandler; PWSTR MsgTemplate; MethodTable = (PMETHOD)((ULONG_PTR)ErrCaseDB + ErrCaseDB->DataBlkOffset + ErrCase->MethodOffset); for (i = 0, status = STATUS_NOT_FOUND; (status == STATUS_NOT_FOUND) && (i < ErrCase->NumMethods); ++i) { if ((Method != IOEMETHOD_ANY) && (Method != MethodTable[i].MethodType)) { continue; } MethodData = (PVOID)((ULONG_PTR)ErrCaseDB + ErrCaseDB->DataBlkOffset + MethodTable[i].MethodDataOffset); switch (MethodTable[i].MethodType) { case IOEMETHOD_LONGMSG: status = IoepGetErrMessage((PMSGDATA)MethodData, ErrInfo, unicodeMsg? unicodeMsg: &unicodeStr); if (NT_SUCCESS(status) && (unicodeMsg == NULL)) { IoRaiseInformationalHardError(STATUS_IOE_MESSAGE, &unicodeStr, NULL); RtlFreeUnicodeString(&unicodeStr); } break; case IOEMETHOD_SHORTMSG: MsgTemplate = (PWSTR)((ULONG_PTR)ErrCaseDB + ErrCaseDB->DataBlkOffset + ((PMSGDATA)MethodData)->MsgTemplateOffset); if (unicodeMsg == NULL) { RtlInitUnicodeString(&unicodeStr, MsgTemplate); IoRaiseInformationalHardError(STATUS_IOE_MESSAGE, &unicodeStr, NULL); status = STATUS_SUCCESS; } else { ULONG len; PWSTR pwstr; len = wcslen(MsgTemplate)*sizeof(WCHAR) + sizeof(UNICODE_NULL); pwstr = ExAllocatePoolWithTag(PagedPool, len, IOETAG_DATAWSTR); if (pwstr != NULL) { RtlCopyMemory(pwstr, MsgTemplate, len); RtlInitUnicodeString(unicodeMsg, pwstr); status = STATUS_SUCCESS; } else { status = STATUS_INSUFFICIENT_RESOURCES; DBGPRINT(("failed to allocate short message buffer (len=%d)\n", len)); } } break; case IOEMETHOD_HANDLER: ErrHandler = IoepFindErrHandler( &((PHANDLERDATA)MethodData)->ComponentGuid, ((PHANDLERDATA)MethodData)->HandlerIndex); if (ErrHandler != NULL) { status = ErrHandler(ErrInfo, ((PHANDLERDATA)MethodData)->Param); } break; default: DBGPRINT(("invalid method type %d\n", MethodTable[i].MethodType)); } } } else { status = STATUS_IOE_DATABASE_NOT_READY; DBGPRINT(("error case database not ready\n")); } EXIT(2, ("=%x\n", status)); return status; } //IoepHandleErrCase

HANDLE IoepInitErrLog (  IN ULONG  KeyType, IN PVOID  Key, IN ULONG  ulFlags )

Definition at line 39 of file ioerr.c. References ASSERT, DBGPRINT, ENTER, _errlog::ErrInfo, _errthread::ErrLogListHead, _errlog::ErrStack, _errlog::ErrThread, ExAllocatePoolWithTag, ExFreePool(), ExInterlockedInsertHeadList(), EXIT, IoepErrListLock, IoepFindErrThread(), IoepNewErrThread(), IOETAG_ERRLOG, Key, _errlog::list, LOGF_INITMASK, NonPagedPool, NULL, PROCNAME, SIG_ERRLOG, _errlog::Signature, and _errlog::ulFlags. Referenced by IoErrInitErrLogByIrp(), and IoErrInitErrLogByThreadID(). : This routine initializes an error logging session with the specified key. Arguments: KeyType - specifies the key type Key - points to the key ulFlags - log session flags Return Value: Success - returns the newly created error log handle. Failure - returns NULL. --*/ { PROCNAME("IoepInitErrLog"); PERRLOG ErrLog; ASSERT(Key != NULL); ASSERT(ulFlags & ~LOGF_INITMASK == 0); ENTER(2, ("(KeyType=%x,Key=%p,ulFlags=%x)\n", KeyType, Key, ulFlags)); ErrLog = ExAllocatePoolWithTag(NonPagedPool, sizeof(ERRLOG), IOETAG_ERRLOG); if (ErrLog != NULL) { PERRTHREAD ErrThread; ErrThread = IoepFindErrThread(KeyType, Key); if (ErrThread == NULL) { ErrThread = IoepNewErrThread(KeyType, Key); } if (ErrThread != NULL) { ErrLog->Signature = SIG_ERRLOG; ErrLog->ulFlags = ulFlags & LOGF_INITMASK; ErrLog->ErrThread = ErrThread; ErrLog->ErrStack.Next = NULL; ErrLog->ErrInfo = NULL; ExInterlockedInsertHeadList(&ErrThread->ErrLogListHead, &ErrLog->list, &IoepErrListLock); } else { ExFreePool(ErrLog); ErrLog = NULL; } } else { DBGPRINT(("failed to allocate new error log\n")); } EXIT(2, ("=%p\n", ErrLog)); return ErrLog; } //IoepInitErrLog

VOID IoepLogErr (  IN ULONG  KeyType, IN PVOID  Key, IN CONST GUID *  ComponentGuid, IN ULONG  ErrCode, IN PWSTR TextData  OPTIONAL, IN ULONG  DataBlkType, IN ULONG DataBlkLen  OPTIONAL, IN PVOID DataBlock  OPTIONAL, IN CONST GUID *MofGuid  OPTIONAL )

Definition at line 255 of file ioerr.c. References ASSERT, _errid::ComponentGuid, _errentry::DataBlk, _errentry::DataBlkLen, _errentry::DataBlkType, DBGPRINT, ENTER, _errid::ErrCode, ERRENTRY, _errentry::ErrID, _errthread::ErrLogListHead, _errlog::ErrStack, ExAllocatePoolWithTag, ExFreePool(), EXIT, FALSE, IOEDATA_MAX, IOEDATA_NONE, IoepErrListLock, IoepFindErrThread(), IOETAG_DATABLOCK, IOETAG_DATATEXT, IOETAG_ERRENTRY, Key, L, _errentry::MofGuid, NonPagedPool, NULL, PROCNAME, RtlInitUnicodeString(), _errentry::slist, TRUE, and _errentry::unicodeStr. Referenced by IoErrLogErrByIrp(), and IoErrLogErrByThreadID(). : This routine logs the error data to the error log session identified by the given key. Arguments: KeyType - specifies the type of key. Key - points to the key that is used to locate the logging session. ComponentGuid - points to the component GUID of the caller ErrCode - unique error code TextData - points to an optional WSTR of text data DataBlkType - data type of the data block DataBlkLen - length of the data block DataBlock - points to the data block MofGuid - points to the MOF GUID of the data block if applicable Return Value: None --*/ { PROCNAME("IoepLogErr"); PERRTHREAD ErrThread; ASSERT(Key != NULL); ASSERT(ComponentGuid != NULL); ASSERT((DataBlkType == IOEDATA_NONE) || (DataBlkLen > 0) && (DataBlock != NULL)); ASSERT(DataBlkType <= IOEDATA_MAX); ENTER(2, ("(KeyType=%x,Key=%p,pGuid=%p,ErrCode=%x,Text=%S,Type=%x,Len=%d,DataBlk=%p,MofGuid=%p)\n", KeyType, Key, ComponentGuid, ErrCode, TextData? TextData: L"", DataBlkType, DataBlkLen, DataBlock, MofGuid)); ErrThread = IoepFindErrThread(KeyType, Key); if (ErrThread != NULL) { PERRENTRY Err; ASSERT(!IsListEmpty(&ErrThread->ErrLogListHead)); Err = ExAllocatePoolWithTag(NonPagedPool, sizeof(ERRENTRY), IOETAG_ERRENTRY); if (Err != NULL) { BOOLEAN fOK = TRUE; PVOID Data = NULL; PWSTR pwstr = NULL; RtlZeroMemory(Err, sizeof(ERRENTRY)); if (DataBlkType != IOEDATA_NONE) { Data = ExAllocatePoolWithTag(NonPagedPool, DataBlkLen, IOETAG_DATABLOCK); if (Data != NULL) { RtlCopyMemory(Data, DataBlock, DataBlkLen); } else { fOK = FALSE; DBGPRINT(("failed to allocate data block (len=%d)\n", DataBlkLen)); } } else { // // Make sure DataLen does not have garbage. // DataBlkLen = 0; } if (TextData != NULL) { ULONG len; len = wcslen(TextData)*sizeof(WCHAR) + sizeof(UNICODE_NULL); pwstr = ExAllocatePoolWithTag(NonPagedPool, len, IOETAG_DATATEXT); if (pwstr != NULL) { RtlCopyMemory(pwstr, TextData, len); RtlInitUnicodeString(&Err->unicodeStr, pwstr); } else { fOK = FALSE; DBGPRINT(("failed to allocate text data (len=%d)\n", len)); } } if (fOK) { PERRLOG ErrLog; KIRQL Irql; Err->ErrID.ComponentGuid = *ComponentGuid; Err->ErrID.ErrCode = ErrCode; Err->DataBlkType = DataBlkType; Err->DataBlkLen = DataBlkLen; Err->DataBlk = Data; if (MofGuid != NULL) { Err->MofGuid = *MofGuid; } ExAcquireSpinLock(&IoepErrListLock, &Irql); ErrLog = CONTAINING_RECORD(ErrThread->ErrLogListHead.Flink, ERRLOG, list); PushEntryList(&ErrLog->ErrStack, &Err->slist); ExReleaseSpinLock(&IoepErrListLock, Irql); } else { if (Data != NULL) { ExFreePool(Data); } if (pwstr != NULL) { ExFreePool(pwstr); } ExFreePool(Err); } } else { DBGPRINT(("failed to allocate error entry\n")); } } else { DBGPRINT(("failed to find associated error thread (Type=%x,Key=%p)\n", KeyType, Key)); } EXIT(2, ("!\n")); } //IoepLogErr

BOOLEAN IoepMatchErrIDPath (  IN PERRINFO  ErrInfo, IN PERRID  ErrIDPath, IN ULONG  NumErrIDs )

Definition at line 862 of file ioerr.c. References ENTER, EXIT, FALSE, PAGED_CODE, PROCNAME, and TRUE. Referenced by IoErrMatchErrCase(). : This routine compares the error ID paths for a match. Arguments: ErrInfo - points to the error info buffer ErrIDPath - points to the error ID path of the error case NumErrIDs - number of error IDs in the path Return Value: Success - returns TRUE: matched Failure - returns FALSE: no match --*/ { PROCNAME("IoepMatchErrIDPath"); BOOLEAN rc = TRUE; BOOLEAN fWildCard = FALSE; ULONG i, j; PAGED_CODE(); ENTER(2, ("(ErrInfo=%p,pErrID=%p,NumIDs=%d)\n", ErrInfo, ErrIDPath, NumErrIDs)); for (i = j = 0; (i < NumErrIDs) && (j < ErrInfo->NumErrEntries);) { if (ErrIDPath[i].ErrCode == 0) { fWildCard = TRUE; i++; } else if (RtlEqualMemory(&ErrIDPath[i].ComponentGuid, &ErrInfo->ErrEntries[j].ErrID.ComponentGuid, sizeof(GUID)) && (ErrIDPath[i].ErrCode == ErrInfo->ErrEntries[j].ErrID.ErrCode)) { i++; j++; fWildCard = FALSE; } else if (fWildCard) { j++; } else { rc = FALSE; break; } } if ((rc == TRUE) && (i < NumErrIDs)) { // // The database ID path is longer than the error stack ID path. // This is not a good match, so let's move on to find another match. // However, the reverse is OK though (i.e. error stack ID path is // longer than the database ID path). In this case, the database // ID path has an implicit wild card at the end. // rc = FALSE; } EXIT(2, ("=%x\n", rc)); return rc; } //IoepMatchErrIDPath

PERRTHREAD IoepNewErrThread (  IN ULONG  KeyType, IN PVOID  Key )

Definition at line 186 of file ioerr.c. References DBGPRINT, _IO_STACK_LOCATION::DeviceObject, ENTER, _errthread::ErrLogListHead, ExAllocatePoolWithTag, ExInterlockedInsertHeadList(), EXIT, IoepErrListLock, IoepErrThreadListHead, IOETAG_ERRTHREAD, IoGetCurrentIrpStackLocation, Key, _errthread::list, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NonPagedPool, NULL, _IO_STACK_LOCATION::Parameters, PROCNAME, _errthread::ThreadKey, THREADKEY_IRP, THREADKEY_THREADID, and _errthread::ThreadKeyType. Referenced by IoepInitErrLog(). : This routine creates a new error thread with a given key. Arguments: KeyType - specifies the type of key. Key - points to the key that is used to create the new logging session. Return Value: Success - returns the error thread handle created. Failure - returns NULL. --*/ { PROCNAME("IoepNewErrThread"); PERRTHREAD ErrThread; ENTER(2, ("(KeyType=%x,Key=%p)\n", KeyType, Key)); ErrThread = ExAllocatePoolWithTag(NonPagedPool, sizeof(ERRTHREAD), IOETAG_ERRTHREAD); if (ErrThread != NULL) { PIO_STACK_LOCATION IrpSp; InitializeListHead(&ErrThread->ErrLogListHead); ErrThread->ThreadKeyType = KeyType; switch (KeyType) { case THREADKEY_IRP: IrpSp = IoGetCurrentIrpStackLocation((PIRP)Key); ErrThread->ThreadKey.IrpKey.Irp = (PIRP)Key; ErrThread->ThreadKey.IrpKey.MajorFunction = IrpSp->MajorFunction; ErrThread->ThreadKey.IrpKey.MinorFunction = IrpSp->MinorFunction; RtlCopyMemory(ErrThread->ThreadKey.IrpKey.Arguments, &IrpSp->Parameters.Others, sizeof(PVOID)*4); ErrThread->ThreadKey.IrpKey.TargetDevice = IopDbgGetLowestDevice(IrpSp->DeviceObject); break; case THREADKEY_THREADID: ErrThread->ThreadKey.ThIDKey.ThreadID = (PKTHREAD)Key; break; } ExInterlockedInsertHeadList(&IoepErrThreadListHead, &ErrThread->list, &IoepErrListLock); } else { DBGPRINT(("failed to allocate error thread\n")); } EXIT(2, ("=%p\n", ErrThread)); return ErrThread; } //IoepNewErrThread

NTSTATUS IoepUnicodeStringCatN (  IN OUT PUNICODE_STRING  unicodeStr, IN PWSTR  pwstr, IN ULONG  len )

Definition at line 1155 of file ioerr.c. References DBGPRINT, ENTER, EXIT, L, NTSTATUS(), PAGED_CODE, PROCNAME, and USHORT. Referenced by IoepGetErrMessage(). : This routine appends the wchar string to the unicode string if there is enough space. Otherwise, STATUS_BUFFER_TOO_SMALL is returned. Arguments: unicodeStr - points to the target unicode string pwstr - points to the wchar string len - length of wstr in bytes to append Return Value: Success - returns STATUS_SUCCESS Failure - returns NT status code --*/ { PROCNAME("IoepUnicodeStringCatN"); NTSTATUS status = STATUS_SUCCESS; PAGED_CODE(); ENTER(2, ("(Msg=%S,Str=%S,Len=%d)\n", unicodeStr->Buffer, pwstr, len)); if (len < (ULONG)(unicodeStr->MaximumLength - unicodeStr->Length)) { wcsncpy(unicodeStr->Buffer, pwstr, len/sizeof(WCHAR)); unicodeStr->Length += (USHORT)len; unicodeStr->Buffer[len/sizeof(WCHAR)] = L'\0'; } else { status = STATUS_BUFFER_TOO_SMALL; DBGPRINT(("unicode string too small\n")); } EXIT(2, ("=%x(Msg=%S)\n", status, unicodeStr->Buffer)); return status; } //IoepUnicodeStringCatN

---