📄 ioctl.cod
字号:
0007e 8b 77 60 mov esi, DWORD PTR [edi+96]
00081 89 75 e0 mov DWORD PTR _IrpSp$[ebp], esi
; 635 : Irp->IoStatus.Information = 0L;
00084 83 67 1c 00 and DWORD PTR [edi+28], 0
; 636 : Status = STATUS_SUCCESS;
00088 83 65 dc 00 and DWORD PTR _Status$[ebp], 0
; 637 : switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
0008c 8b 46 0c mov eax, DWORD PTR [esi+12]
0008f 05 fc ff e4 ff add eax, -1769476 ; ffe4fffcH
00094 3d 98 00 00 00 cmp eax, 152 ; 00000098H
00099 0f 87 9b 0a 00
00 ja $L15323
0009f 0f b6 80 00 00
00 00 movzx eax, BYTE PTR $L15541[eax]
000a6 ff 24 85 00 00
00 00 jmp DWORD PTR $L15559[eax*4]
$L14938:
; 638 :
; 639 : case IOCTL_SERIAL_SET_BAUD_RATE : {
; 640 :
; 641 : ULONG BaudRate;
; 642 : //
; 643 : // Will hold the value of the appropriate divisor for
; 644 : // the requested baud rate. If the baudrate is invalid
; 645 : // (because the device won't support that baud rate) then
; 646 : // this value is undefined.
; 647 : //
; 648 : // Note: in one sense the concept of a valid baud rate
; 649 : // is cloudy. We could allow the user to request any
; 650 : // baud rate. We could then calculate the divisor needed
; 651 : // for that baud rate. As long as the divisor wasn't less
; 652 : // than one we would be "ok". (The percentage difference
; 653 : // between the "true" divisor and the "rounded" value given
; 654 : // to the hardware might make it unusable, but... ) It would
; 655 : // really be up to the user to "Know" whether the baud rate
; 656 : // is suitable. So much for theory, *We* only support a given
; 657 : // set of baud rates.
; 658 : //
; 659 : SHORT AppropriateDivisor;
; 660 :
; 661 : if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
; 662 : sizeof(SERIAL_BAUD_RATE)) {
000ad 83 7e 08 04 cmp DWORD PTR [esi+8], 4
000b1 73 0c jae SHORT $L14942
$L15554:
; 663 :
; 664 : Status = STATUS_BUFFER_TOO_SMALL;
000b3 c7 45 dc 23 00
00 c0 mov DWORD PTR _Status$[ebp], -1073741789 ; c0000023H
; 665 : break;
000ba e9 82 0a 00 00 jmp $DoneWithIoctl$15011
$L14942:
; 666 :
; 667 : } else {
; 668 :
; 669 : BaudRate = ((PSERIAL_BAUD_RATE)(Irp->AssociatedIrp.SystemBuffer))->BaudRate;
000bf 8b 47 0c mov eax, DWORD PTR [edi+12]
000c2 8b 00 mov eax, DWORD PTR [eax]
000c4 89 45 d8 mov DWORD PTR _BaudRate$14939[ebp], eax
; 670 :
; 671 : }
; 672 :
; 673 : //
; 674 : // Get the baud rate from the irp. We pass it
; 675 : // to a routine which will set the correct divisor.
; 676 : //
; 677 :
; 678 : Status = SerialGetDivisorFromBaud(
; 679 : Extension->ClockRate,
; 680 : BaudRate,
; 681 : &AppropriateDivisor
; 682 : );
000c7 8d 4d d6 lea ecx, DWORD PTR _AppropriateDivisor$14940[ebp]
000ca 51 push ecx
000cb 50 push eax
000cc ff b3 4c 01 00
00 push DWORD PTR [ebx+332]
000d2 e8 00 00 00 00 call _SerialGetDivisorFromBaud@12
000d7 89 45 dc mov DWORD PTR _Status$[ebp], eax
; 683 :
; 684 : //
; 685 : // Make sure we are at power D0
; 686 : //
; 687 :
; 688 : if (NT_SUCCESS(Status)) {
000da 85 c0 test eax, eax
000dc 7c 22 jl SHORT $L14950
; 689 : if (Extension->PowerState != PowerDeviceD0) {
000de 83 bb a4 04 00
00 01 cmp DWORD PTR [ebx+1188], 1
000e5 74 19 je SHORT $L14950
; 690 : Status = SerialGotoPowerState(Extension->Pdo, Extension,
; 691 : PowerDeviceD0);
000e7 6a 01 push 1
000e9 53 push ebx
000ea ff b3 80 05 00
00 push DWORD PTR [ebx+1408]
000f0 e8 00 00 00 00 call _SerialGotoPowerState@12
000f5 89 45 dc mov DWORD PTR _Status$[ebp], eax
; 692 : if (!NT_SUCCESS(Status)) {
000f8 85 c0 test eax, eax
000fa 0f 8c 41 0a 00
00 jl $DoneWithIoctl$15011
$L14950:
; 693 : break;
; 694 : }
; 695 : }
; 696 : }
; 697 :
; 698 : KeAcquireSpinLock(
; 699 : &Extension->ControlLock,
; 700 : &OldIrql
; 701 : );
00100 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
00106 ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
0010c 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 702 :
; 703 : if (NT_SUCCESS(Status)) {
0010f 83 7d dc 00 cmp DWORD PTR _Status$[ebp], 0
00113 0f 8c 5a 08 00
00 jl $L14952
; 704 :
; 705 : SERIAL_IOCTL_SYNC S;
; 706 :
; 707 :
; 708 : Extension->CurrentBaud = BaudRate;
00119 8b 45 d8 mov eax, DWORD PTR _BaudRate$14939[ebp]
0011c 89 83 34 01 00
00 mov DWORD PTR [ebx+308], eax
; 709 : Extension->WmiCommData.BaudRate = BaudRate;
00122 89 83 b4 05 00
00 mov DWORD PTR [ebx+1460], eax
; 710 :
; 711 : S.Extension = Extension;
00128 89 5d c8 mov DWORD PTR _S$14953[ebp], ebx
; 712 : S.Data = (PVOID)AppropriateDivisor;
0012b 0f bf 45 d6 movsx eax, WORD PTR _AppropriateDivisor$14940[ebp]
0012f 89 45 cc mov DWORD PTR _S$14953[ebp+4], eax
; 713 : KeSynchronizeExecution(
; 714 : Extension->Interrupt,
; 715 : SerialSetBaud,
; 716 : &S
; 717 : );
00132 8d 45 c8 lea eax, DWORD PTR _S$14953[ebp]
00135 50 push eax
00136 68 00 00 00 00 push OFFSET FLAT:_SerialSetBaud@4
; 718 :
; 719 : }
; 720 :
; 721 : KeReleaseSpinLock(
; 722 : &Extension->ControlLock,
; 723 : OldIrql
; 724 : );
; 725 :
; 726 : break;
0013b e9 27 08 00 00 jmp $L15551
$L14955:
; 727 : }
; 728 : case IOCTL_SERIAL_GET_BAUD_RATE: {
; 729 :
; 730 : PSERIAL_BAUD_RATE Br = (PSERIAL_BAUD_RATE)Irp->AssociatedIrp.SystemBuffer;
00140 8b 47 0c mov eax, DWORD PTR [edi+12]
00143 89 45 c4 mov DWORD PTR _Br$14956[ebp], eax
; 731 : if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength <
; 732 : sizeof(SERIAL_BAUD_RATE)) {
00146 83 7e 04 04 cmp DWORD PTR [esi+4], 4
; 733 :
; 734 : Status = STATUS_BUFFER_TOO_SMALL;
; 735 : break;
0014a 0f 82 63 ff ff
ff jb $L15554
; 736 :
; 737 : }
; 738 :
; 739 : KeAcquireSpinLock(
; 740 : &Extension->ControlLock,
; 741 : &OldIrql
; 742 : );
00150 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
00156 ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
0015c 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 743 :
; 744 : Br->BaudRate = Extension->CurrentBaud;
0015f 8b 83 34 01 00
00 mov eax, DWORD PTR [ebx+308]
00165 8b 4d c4 mov ecx, DWORD PTR _Br$14956[ebp]
00168 89 01 mov DWORD PTR [ecx], eax
; 745 :
; 746 : KeReleaseSpinLock(
; 747 : &Extension->ControlLock,
; 748 : OldIrql
; 749 : );
0016a 8a 55 d2 mov dl, BYTE PTR _OldIrql$[ebp]
0016d 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
00173 ff 15 00 00 00
00 call DWORD PTR __imp_@KfReleaseSpinLock@8
; 750 :
; 751 : Irp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
00179 c7 47 1c 04 00
00 00 mov DWORD PTR [edi+28], 4
; 752 :
; 753 : break;
00180 e9 bc 09 00 00 jmp $DoneWithIoctl$15011
$L14962:
; 754 :
; 755 : }
; 756 :
; 757 : case IOCTL_SERIAL_GET_MODEM_CONTROL: {
; 758 : SERIAL_IOCTL_SYNC S;
; 759 :
; 760 : if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength <
; 761 : sizeof(ULONG)) {
00185 6a 04 push 4
00187 58 pop eax
00188 39 46 04 cmp DWORD PTR [esi+4], eax
; 762 :
; 763 : Status = STATUS_BUFFER_TOO_SMALL;
; 764 : break;
0018b 0f 82 22 ff ff
ff jb $L15554
; 765 :
; 766 : }
; 767 :
; 768 : Irp->IoStatus.Information = sizeof(ULONG);
00191 89 47 1c mov DWORD PTR [edi+28], eax
; 769 :
; 770 : S.Extension = Extension;
00194 89 5d bc mov DWORD PTR _S$14963[ebp], ebx
; 771 : S.Data = Irp->AssociatedIrp.SystemBuffer;
00197 8b 47 0c mov eax, DWORD PTR [edi+12]
0019a 89 45 c0 mov DWORD PTR _S$14963[ebp+4], eax
; 772 :
; 773 : KeAcquireSpinLock(
; 774 : &Extension->ControlLock,
; 775 : &OldIrql
; 776 : );
0019d 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
001a3 ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
001a9 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 777 :
; 778 : KeSynchronizeExecution(
; 779 : Extension->Interrupt,
; 780 : SerialGetMCRContents,
; 781 : &S
; 782 : );
001ac 8d 45 bc lea eax, DWORD PTR _S$14963[ebp]
001af 50 push eax
001b0 68 00 00 00 00 push OFFSET FLAT:_SerialGetMCRContents@4
; 783 :
; 784 : KeReleaseSpinLock(
; 785 : &Extension->ControlLock,
; 786 : OldIrql
; 787 : );
; 788 :
; 789 : break;
001b5 e9 ad 07 00 00 jmp $L15551
$L14968:
; 790 : }
; 791 : case IOCTL_SERIAL_SET_MODEM_CONTROL: {
; 792 : SERIAL_IOCTL_SYNC S;
; 793 :
; 794 : if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
; 795 : sizeof(ULONG)) {
001ba 83 7e 08 04 cmp DWORD PTR [esi+8], 4
; 796 :
; 797 : Status = STATUS_BUFFER_TOO_SMALL;
; 798 : break;
001be 0f 82 ef fe ff
ff jb $L15554
; 799 :
; 800 : }
; 801 :
; 802 : S.Extension = Extension;
001c4 89 5d b4 mov DWORD PTR _S$14969[ebp], ebx
; 803 : S.Data = Irp->AssociatedIrp.SystemBuffer;
001c7 8b 47 0c mov eax, DWORD PTR [edi+12]
001ca 89 45 b8 mov DWORD PTR _S$14969[ebp+4], eax
; 804 :
; 805 : //
; 806 : // Make sure we are at power D0
; 807 : //
; 808 :
; 809 : if (Extension->PowerState != PowerDeviceD0) {
001cd 83 bb a4 04 00
00 01 cmp DWORD PTR [ebx+1188], 1
001d4 74 19 je SHORT $L14975
; 810 : Status = SerialGotoPowerState(Extension->Pdo, Extension,
; 811 : PowerDeviceD0);
001d6 6a 01 push 1
001d8 53 push ebx
001d9 ff b3 80 05 00
00 push DWORD PTR [ebx+1408]
001df e8 00 00 00 00 call _SerialGotoPowerState@12
001e4 89 45 dc mov DWORD PTR _Status$[ebp], eax
; 812 : if (!NT_SUCCESS(Status)) {
001e7 85 c0 test eax, eax
001e9 0f 8c 52 09 00
00 jl $DoneWithIoctl$15011
$L14975:
; 813 : break;
; 814 : }
; 815 : }
; 816 :
; 817 : KeAcquireSpinLock(
; 818 : &Extension->ControlLock,
; 819 : &OldIrql
; 820 : );
001ef 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
001f5 ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
001fb 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 821 :
; 822 : KeSynchronizeExecution(
; 823 : Extension->Interrupt,
; 824 : SerialSetMCRContents,
; 825 : &S
; 826 : );
001fe 8d 45 b4 lea eax, DWORD PTR _S$14969[ebp]
00201 50 push eax
00202 68 00 00 00 00 push OFFSET FLAT:_SerialSetMCRContents@4
; 827 :
; 828 : KeReleaseSpinLock(
; 829 : &Extension->ControlLock,
; 830 : OldIrql
; 831 : );
; 832 :
; 833 : break;
00207 e9 5b 07 00 00 jmp $L15551
$L14976:
; 834 : }
; 835 : case IOCTL_SERIAL_SET_FIFO_CONTROL: {
; 836 : SERIAL_IOCTL_SYNC S;
; 837 :
; 838 : if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
; 839 : sizeof(ULONG)) {
0020c 83 7e 08 04 cmp DWORD PTR [esi+8], 4
; 840 :
; 841 : Status = STATUS_BUFFER_TOO_SMALL;
; 842 : break;
00210 0f 82 9d fe ff
ff jb $L15554
; 843 :
; 844 : }
; 845 :
; 846 : S.Extension = Extension;
00216 89 5d ac mov DWORD PTR _S$14977[ebp], ebx
; 847 : S.Data = Irp->AssociatedIrp.SystemBuffer;
00219 8b 47 0c mov eax, DWORD PTR [edi+12]
0021c 89 45 b0 mov DWORD PTR _S$14977[ebp+4], eax
; 848 :
; 849 : //
; 850 : // Make sure we are at power D0
; 851 : //
; 852 :
; 853 : if (Extension->PowerState != PowerDeviceD0) {
0021f 83 bb a4 04 00
00 01 cmp DWORD PTR [ebx+1188], 1
00226 74 19 je SHORT $L14983
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -