📄 utils.cod
字号:
; 909 :
; 910 : //
; 911 : // There is a current error in the driver. No requests should
; 912 : // come through except for the GET_COMMSTATUS.
; 913 : //
; 914 :
; 915 : if ((irpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL) ||
; 916 : (irpSp->Parameters.DeviceIoControl.IoControlCode !=
; 917 : IOCTL_SERIAL_GET_COMMSTATUS)) {
000e3 80 38 0e cmp BYTE PTR [eax], 14 ; 0000000eH
000e6 75 09 jne SHORT $L15153
000e8 81 78 0c 6c 00
1b 00 cmp DWORD PTR [eax+12], 1769580 ; 001b006cH
000ef 74 35 je SHORT $L15152
$L15153:
; 918 :
; 919 : status = STATUS_CANCELLED;
; 920 : Irp->IoStatus.Status = STATUS_CANCELLED;
; 921 : Irp->IoStatus.Information = 0;
000f1 83 66 1c 00 and DWORD PTR [esi+28], 0
000f5 b8 20 01 00 c0 mov eax, -1073741536 ; c0000120H
000fa 89 46 18 mov DWORD PTR [esi+24], eax
000fd 89 45 08 mov DWORD PTR _status$[ebp], eax
; 922 :
; 923 : SerialDump(
; 924 : SERIRPPATH,
; 925 : ("SERIAL: Complete Irp: %x\n",Irp)
; 926 : );
00100 f6 05 00 00 00
00 20 test BYTE PTR _SerialDebugLevel, 32 ; 00000020H
00107 74 0d je SHORT $L15157
00109 56 push esi
0010a 68 00 00 00 00 push OFFSET FLAT:$SG15162
0010f e8 00 00 00 00 call _DbgPrint
00114 59 pop ecx
00115 59 pop ecx
$L15157:
; 927 : SerialCompleteRequest(extension, Irp, 0);
00116 32 d2 xor dl, dl
00118 8b ce mov ecx, esi
0011a ff 15 00 00 00
00 call DWORD PTR __imp_@IofCompleteRequest@8
00120 57 push edi
00121 e8 00 00 00 00 call _SerialIRPEpilogue@4
$L15152:
; 928 : }
; 929 :
; 930 : }
; 931 :
; 932 : return status;
00126 8b 45 08 mov eax, DWORD PTR _status$[ebp]
00129 5f pop edi
0012a 5e pop esi
; 933 :
; 934 : }
0012b 5d pop ebp
0012c c2 08 00 ret 8
_SerialCompleteIfError@8 ENDP
PAGESER ENDS
PUBLIC _SerialFilterCancelQueued@8
; Function compile flags: /Ogs
; COMDAT _SerialFilterCancelQueued@8
_TEXT SEGMENT
_PIrp$ = 12
_SerialFilterCancelQueued@8 PROC NEAR ; COMDAT
; 955 : {
00000 55 push ebp
00001 8b ec mov ebp, esp
; 956 : PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
; 957 : PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(PIrp);
; 958 :
; 959 : PIrp->IoStatus.Status = STATUS_CANCELLED;
00003 8b 45 0c mov eax, DWORD PTR _PIrp$[ebp]
; 960 : PIrp->IoStatus.Information = 0;
; 961 :
; 962 : RemoveEntryList(&PIrp->Tail.Overlay.ListEntry);
00006 8b 50 5c mov edx, DWORD PTR [eax+92]
00009 8b 48 58 mov ecx, DWORD PTR [eax+88]
0000c 83 60 1c 00 and DWORD PTR [eax+28], 0
00010 c7 40 18 20 01
00 c0 mov DWORD PTR [eax+24], -1073741536 ; c0000120H
00017 89 0a mov DWORD PTR [edx], ecx
00019 89 51 04 mov DWORD PTR [ecx+4], edx
; 963 :
; 964 : IoReleaseCancelSpinLock(PIrp->CancelIrql);
0001c 8a 40 25 mov al, BYTE PTR [eax+37]
0001f 50 push eax
00020 ff 15 00 00 00
00 call DWORD PTR __imp__IoReleaseCancelSpinLock@4
; 965 : }
00026 5d pop ebp
00027 c2 08 00 ret 8
_SerialFilterCancelQueued@8 ENDP
_TEXT ENDS
PUBLIC _SerialKillAllStalled@4
; Function compile flags: /Ogs
; COMDAT _SerialKillAllStalled@4
_TEXT SEGMENT
_PDevObj$ = 8
_cancelIrql$ = -4
_SerialKillAllStalled@4 PROC NEAR ; COMDAT
; 969 : {
00000 55 push ebp
00001 8b ec mov ebp, esp
00003 51 push ecx
; 970 : KIRQL cancelIrql;
; 971 : PDRIVER_CANCEL cancelRoutine;
; 972 : PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
00004 8b 45 08 mov eax, DWORD PTR _PDevObj$[ebp]
00007 53 push ebx
00008 56 push esi
00009 57 push edi
0000a 8b 58 28 mov ebx, DWORD PTR [eax+40]
; 973 :
; 974 : IoAcquireCancelSpinLock(&cancelIrql);
0000d 8b 3d 00 00 00
00 mov edi, DWORD PTR __imp__IoAcquireCancelSpinLock@4
00013 8d 45 fc lea eax, DWORD PTR _cancelIrql$[ebp]
00016 50 push eax
00017 ff d7 call edi
; 975 :
; 976 : while (!IsListEmpty(&pDevExt->StalledIrpQueue)) {
00019 8d b3 2c 05 00
00 lea esi, DWORD PTR [ebx+1324]
0001f eb 30 jmp SHORT $L15598
$L15187:
; 977 :
; 978 : PIRP currentLastIrp = CONTAINING_RECORD(pDevExt->StalledIrpQueue.Blink,
; 979 : IRP, Tail.Overlay.ListEntry);
00021 8b 8b 30 05 00
00 mov ecx, DWORD PTR [ebx+1328]
; 980 :
; 981 : RemoveEntryList(pDevExt->StalledIrpQueue.Blink);
00027 8b 11 mov edx, DWORD PTR [ecx]
00029 8d 41 a8 lea eax, DWORD PTR [ecx-88]
0002c 8b 49 04 mov ecx, DWORD PTR [ecx+4]
; 982 :
; 983 : cancelRoutine = currentLastIrp->CancelRoutine;
; 984 : currentLastIrp->CancelIrql = cancelIrql;
; 985 : currentLastIrp->CancelRoutine = NULL;
; 986 : currentLastIrp->Cancel = TRUE;
; 987 :
; 988 : cancelRoutine(PDevObj, currentLastIrp);
0002f 50 push eax
00030 ff 75 08 push DWORD PTR _PDevObj$[ebp]
00033 89 11 mov DWORD PTR [ecx], edx
00035 89 4a 04 mov DWORD PTR [edx+4], ecx
00038 8a 55 fc mov dl, BYTE PTR _cancelIrql$[ebp]
0003b 8b 48 38 mov ecx, DWORD PTR [eax+56]
0003e 83 60 38 00 and DWORD PTR [eax+56], 0
00042 88 50 25 mov BYTE PTR [eax+37], dl
00045 c6 40 24 01 mov BYTE PTR [eax+36], 1
00049 ff d1 call ecx
; 989 :
; 990 : IoAcquireCancelSpinLock(&cancelIrql);
0004b 8d 45 fc lea eax, DWORD PTR _cancelIrql$[ebp]
0004e 50 push eax
0004f ff d7 call edi
$L15598:
; 975 :
; 976 : while (!IsListEmpty(&pDevExt->StalledIrpQueue)) {
00051 39 36 cmp DWORD PTR [esi], esi
00053 75 cc jne SHORT $L15187
; 991 : }
; 992 :
; 993 : IoReleaseCancelSpinLock(cancelIrql);
00055 ff 75 fc push DWORD PTR _cancelIrql$[ebp]
00058 ff 15 00 00 00
00 call DWORD PTR __imp__IoReleaseCancelSpinLock@4
0005e 5f pop edi
0005f 5e pop esi
00060 5b pop ebx
; 994 : }
00061 c9 leave
00062 c2 04 00 ret 4
_SerialKillAllStalled@4 ENDP
_TEXT ENDS
PUBLIC _SerialFilterIrps@8
EXTRN __imp_@KfAcquireSpinLock@4:NEAR
EXTRN __imp_@KfReleaseSpinLock@8:NEAR
; Function compile flags: /Ogs
; COMDAT _SerialFilterIrps@8
_TEXT SEGMENT
_PIrp$ = 8
_PDevExt$ = 12
_pIrpStack$ = -4
_oldIrql$15213 = 8
_SerialFilterIrps@8 PROC NEAR ; COMDAT
; 1018 : {
00000 55 push ebp
00001 8b ec mov ebp, esp
00003 51 push ecx
00004 56 push esi
; 1019 : PIO_STACK_LOCATION pIrpStack;
; 1020 : KIRQL oldIrqlFlags;
; 1021 :
; 1022 : pIrpStack = IoGetCurrentIrpStackLocation(PIrp);
00005 8b 75 08 mov esi, DWORD PTR _PIrp$[ebp]
00008 57 push edi
; 1023 :
; 1024 : KeAcquireSpinLock(&PDevExt->FlagsLock, &oldIrqlFlags);
00009 8b 7d 0c mov edi, DWORD PTR _PDevExt$[ebp]
0000c 8b 46 60 mov eax, DWORD PTR [esi+96]
0000f 8d 8f e8 01 00
00 lea ecx, DWORD PTR [edi+488]
00015 89 45 fc mov DWORD PTR _pIrpStack$[ebp], eax
00018 89 4d 08 mov DWORD PTR 8+[ebp], ecx
0001b ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
; 1025 :
; 1026 : if ((PDevExt->DevicePNPAccept == SERIAL_PNPACCEPT_OK)
; 1027 : && ((PDevExt->Flags & SERIAL_FLAGS_BROKENHW) == 0)) {
00021 8b 8f cc 04 00
00 mov ecx, DWORD PTR [edi+1228]
00027 8a d0 mov dl, al
00029 85 c9 test ecx, ecx
0002b 75 19 jne SHORT $L15204
0002d f6 87 e4 04 00
00 04 test BYTE PTR [edi+1252], 4
00034 75 10 jne SHORT $L15204
; 1028 : KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
00036 8b 4d 08 mov ecx, DWORD PTR 8+[ebp]
$L15219:
; 1088 : }
; 1089 : }
; 1090 :
; 1091 : KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
00039 ff 15 00 00 00
00 call DWORD PTR __imp_@KfReleaseSpinLock@8
$L15603:
; 1092 :
; 1093 : return STATUS_SUCCESS;
0003f 33 c0 xor eax, eax
00041 e9 a7 00 00 00 jmp $L15201
$L15204:
; 1029 : return STATUS_SUCCESS;
; 1030 : }
; 1031 :
; 1032 : if ((PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_REMOVING)
; 1033 : || (PDevExt->Flags & SERIAL_FLAGS_BROKENHW)
; 1034 : || (PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_SURPRISE_REMOVING)) {
00046 f6 c1 09 test cl, 9
00049 0f 85 81 00 00
00 jne $L15207
0004f f6 87 e4 04 00
00 04 test BYTE PTR [edi+1252], 4
00056 75 78 jne SHORT $L15207
; 1047 : return STATUS_DELETE_PENDING;
; 1048 : }
; 1049 :
; 1050 : if (PDevExt->DevicePNPAccept & SERIAL_PNPACCEPT_STOPPING) {
00058 f6 c1 02 test cl, 2
; 1051 : KIRQL oldIrql;
; 1052 :
; 1053 : KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
0005b 8b 4d 08 mov ecx, DWORD PTR 8+[ebp]
0005e 74 d9 je SHORT $L15219
00060 ff 15 00 00 00
00 call DWORD PTR __imp_@KfReleaseSpinLock@8
; 1054 :
; 1055 :
; 1056 : //
; 1057 : // Accept all PNP IRP's -- we assume PNP can synchronize itself
; 1058 : //
; 1059 :
; 1060 : if (pIrpStack->MajorFunction == IRP_MJ_PNP) {
00066 8b 45 fc mov eax, DWORD PTR _pIrpStack$[ebp]
00069 80 38 1b cmp BYTE PTR [eax], 27 ; 0000001bH
; 1061 : return STATUS_SUCCESS;
0006c 74 d1 je SHORT $L15603
; 1062 : }
; 1063 :
; 1064 : IoAcquireCancelSpinLock(&oldIrql);
0006e 8d 45 08 lea eax, DWORD PTR _oldIrql$15213[ebp]
00071 50 push eax
00072 ff 15 00 00 00
00 call DWORD PTR __imp__IoAcquireCancelSpinLock@4
; 1065 :
; 1066 : if (PIrp->Cancel) {
00078 80 7e 24 00 cmp BYTE PTR [esi+36], 0
0007c 74 10 je SHORT $L15216
; 1067 : IoReleaseCancelSpinLock(oldIrql);
0007e ff 75 08 push DWORD PTR _oldIrql$15213[ebp]
00081 ff 15 00 00 00
00 call DWORD PTR __imp__IoReleaseCancelSpinLock@4
; 1068 : PIrp->IoStatus.Status = STATUS_CANCELLED;
00087 b8 20 01 00 c0 mov eax, -1073741536 ; c0000120H
; 1069 : return STATUS_CANCELLED;
0008c eb 5c jmp SHORT $L15602
$L15216:
; 1070 : } else {
; 1071 : //
; 1072 : // Mark the Irp as pending
; 1073 : //
; 1074 :
; 1075 : PIrp->IoStatus.Status = STATUS_PENDING;
; 1076 : IoMarkIrpPending(PIrp);
0008e 8b 46 60 mov eax, DWORD PTR [esi+96]
00091 c7 46 18 03 01
00 00 mov DWORD PTR [esi+24], 259 ; 00000103H
; 1077 :
; 1078 : //
; 1079 : // Queue up the IRP
; 1080 : //
; 1081 :
; 1082 : InsertTailList(&PDevExt->StalledIrpQueue,
; 1083 : &PIrp->Tail.Overlay.ListEntry);
00098 8d 4e 58 lea ecx, DWORD PTR [esi+88]
0009b 80 48 03 01 or BYTE PTR [eax+3], 1
0009f 8d 87 2c 05 00
00 lea eax, DWORD PTR [edi+1324]
000a5 8b 50 04 mov edx, DWORD PTR [eax+4]
000a8 89 01 mov DWORD PTR [ecx], eax
000aa 89 56 5c mov DWORD PTR [esi+92], edx
000ad 89 0a mov DWORD PTR [edx], ecx
000af 89 48 04 mov DWORD PTR [eax+4], ecx
; 1084 :
; 1085 : IoSetCancelRoutine(PIrp, SerialFilterCancelQueued);
000b2 8d 4e 38 lea ecx, DWORD PTR [esi+56]
000b5 ba 00 00 00 00 mov edx, OFFSET FLAT:_SerialFilterCancelQueued@8
000ba ff 15 00 00 00
00 call DWORD PTR __imp_@InterlockedExchange@8
; 1086 : IoReleaseCancelSpinLock(oldIrql);
000c0 ff 75 08 push DWORD PTR _oldIrql$15213[ebp]
000c3 ff 15 00 00 00
00 call DWORD PTR __imp__IoReleaseCancelSpinLock@4
; 1087 : return STATUS_PENDING;
000c9 b8 03 01 00 00 mov eax, 259 ; 00000103H
000ce eb 1d jmp SHORT $L15201
$L15207:
; 1035 :
; 1036 : KeReleaseSpinLock(&PDevExt->FlagsLock, oldIrqlFlags);
000d0 8b 4d 08 mov ecx, DWORD PTR 8+[ebp]
000d3 ff 15 00 00 00
00 call DWORD PTR __imp_@KfReleaseSpinLock@8
; 1037 :
; 1038 : //
; 1039 : // Accept all PNP IRP's -- we assume PNP can synchronize itself
; 1040 : //
; 1041 :
; 1042 : if (pIrpStack->MajorFunction == IRP_MJ_PNP) {
000d9 8b 45 fc mov eax, DWORD PTR _pIrpStack$[ebp]
000dc 80 38 1b cmp BYTE PTR [eax], 27 ; 0000001bH
; 1043 : return STATUS_SUCCESS;
000df 0f 84 5a ff ff
ff je $L15603
; 1044 : }
; 1045 :
; 1046 : PIrp->IoStatus.Status = STATUS_DELETE_PENDING;
000e5 b8 56 00 00 c0 mov eax, -1073741738 ; c0000056H
$L15602:
000ea 89 46 18 mov DWORD P⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -