📄 ioctl.cod
字号:
00273 8b c6 mov eax, esi
00275 e9 de 07 00 00 jmp $L15022
$L15039:
; 620 : }
; 621 :
; 622 : SerialDump(
; 623 : SERIRPPATH,
; 624 : ("SERIAL: Dispatch entry for: %x\n",Irp)
; 625 : );
0027a f6 05 00 00 00
00 20 test BYTE PTR _SerialDebugLevel, 32 ; 00000020H
00281 74 0d je SHORT $L15044
00283 57 push edi
00284 68 00 00 00 00 push OFFSET FLAT:$SG15045
00289 e8 00 00 00 00 call _DbgPrint
0028e 59 pop ecx
0028f 59 pop ecx
$L15044:
; 626 : if (SerialCompleteIfError(
; 627 : DeviceObject,
; 628 : Irp
; 629 : ) != STATUS_SUCCESS) {
00290 57 push edi
00291 ff 75 08 push DWORD PTR _DeviceObject$[ebp]
00294 e8 00 00 00 00 call _SerialCompleteIfError@8
00299 85 c0 test eax, eax
0029b 74 0a je SHORT $L15053
; 630 :
; 631 : return STATUS_CANCELLED;
0029d b8 20 01 00 c0 mov eax, -1073741536 ; c0000120H
002a2 e9 b1 07 00 00 jmp $L15022
$L15053:
; 632 :
; 633 : }
; 634 : IrpSp = IoGetCurrentIrpStackLocation(Irp);
002a7 8b 77 60 mov esi, DWORD PTR [edi+96]
002aa 89 75 e0 mov DWORD PTR _IrpSp$[ebp], esi
; 635 : Irp->IoStatus.Information = 0L;
002ad 33 d2 xor edx, edx
002af 89 57 1c mov DWORD PTR [edi+28], edx
; 636 : Status = STATUS_SUCCESS;
002b2 89 55 dc mov DWORD PTR _Status$[ebp], edx
; 637 : switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
002b5 8b 46 0c mov eax, DWORD PTR [esi+12]
002b8 05 fc ff e4 ff add eax, -1769476 ; ffe4fffcH
002bd 3d 98 00 00 00 cmp eax, 152 ; 00000098H
002c2 0f 87 5a 07 00
00 ja $L15519
002c8 0f b6 80 00 00
00 00 movzx eax, BYTE PTR $L15781[eax]
002cf ff 24 85 00 00
00 00 jmp DWORD PTR $L15800[eax*4]
$L15060:
; 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)) {
002d6 83 7e 08 04 cmp DWORD PTR [esi+8], 4
002da 73 0c jae SHORT $L15064
$L15793:
; 663 :
; 664 : Status = STATUS_BUFFER_TOO_SMALL;
002dc c7 45 dc 23 00
00 c0 mov DWORD PTR _Status$[ebp], -1073741789 ; c0000023H
; 665 : break;
002e3 e9 41 07 00 00 jmp $DoneWithIoctl$15133
$L15064:
; 666 :
; 667 : } else {
; 668 :
; 669 : BaudRate = ((PSERIAL_BAUD_RATE)(Irp->AssociatedIrp.SystemBuffer))->BaudRate;
002e8 8b 47 0c mov eax, DWORD PTR [edi+12]
002eb 8b 00 mov eax, DWORD PTR [eax]
002ed 89 45 d8 mov DWORD PTR _BaudRate$15061[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 : );
002f0 8d 4d d6 lea ecx, DWORD PTR _AppropriateDivisor$15062[ebp]
002f3 51 push ecx
002f4 50 push eax
002f5 ff b3 4c 01 00
00 push DWORD PTR [ebx+332]
002fb e8 00 00 00 00 call _SerialGetDivisorFromBaud@12
00300 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)) {
00303 85 c0 test eax, eax
00305 7c 22 jl SHORT $L15072
; 689 : if (Extension->PowerState != PowerDeviceD0) {
00307 83 bb a4 04 00
00 01 cmp DWORD PTR [ebx+1188], 1
0030e 74 19 je SHORT $L15072
; 690 : Status = SerialGotoPowerState(Extension->Pdo, Extension,
; 691 : PowerDeviceD0);
00310 6a 01 push 1
00312 53 push ebx
00313 ff b3 80 05 00
00 push DWORD PTR [ebx+1408]
00319 e8 00 00 00 00 call _SerialGotoPowerState@12
0031e 89 45 dc mov DWORD PTR _Status$[ebp], eax
; 692 : if (!NT_SUCCESS(Status)) {
00321 85 c0 test eax, eax
00323 0f 8c 00 07 00
00 jl $DoneWithIoctl$15133
$L15072:
; 693 : break;
; 694 : }
; 695 : }
; 696 : }
; 697 :
; 698 : KeAcquireSpinLock(
; 699 : &Extension->ControlLock,
; 700 : &OldIrql
; 701 : );
00329 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
0032f ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
00335 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 702 :
; 703 : if (NT_SUCCESS(Status)) {
00338 83 7d dc 00 cmp DWORD PTR _Status$[ebp], 0
0033c 0f 8c 28 09 00
00 jl $L15074
; 704 :
; 705 : SERIAL_IOCTL_SYNC S;
; 706 :
; 707 :
; 708 : Extension->CurrentBaud = BaudRate;
00342 8b 45 d8 mov eax, DWORD PTR _BaudRate$15061[ebp]
00345 89 83 34 01 00
00 mov DWORD PTR [ebx+308], eax
; 709 : Extension->WmiCommData.BaudRate = BaudRate;
0034b 89 83 b4 05 00
00 mov DWORD PTR [ebx+1460], eax
; 710 :
; 711 : S.Extension = Extension;
00351 89 5d c8 mov DWORD PTR _S$15075[ebp], ebx
; 712 : S.Data = (PVOID)AppropriateDivisor;
00354 0f bf 45 d6 movsx eax, WORD PTR _AppropriateDivisor$15062[ebp]
00358 89 45 cc mov DWORD PTR _S$15075[ebp+4], eax
; 713 : KeSynchronizeExecution(
; 714 : Extension->Interrupt,
; 715 : SerialSetBaud,
; 716 : &S
; 717 : );
0035b 8d 45 c8 lea eax, DWORD PTR _S$15075[ebp]
0035e 50 push eax
0035f 68 00 00 00 00 push OFFSET FLAT:_SerialSetBaud@4
; 718 :
; 719 : }
; 720 :
; 721 : KeReleaseSpinLock(
; 722 : &Extension->ControlLock,
; 723 : OldIrql
; 724 : );
; 725 :
; 726 : break;
00364 e9 f5 08 00 00 jmp $L15790
$L15077:
; 727 : }
; 728 : case IOCTL_SERIAL_GET_BAUD_RATE: {
; 729 :
; 730 : PSERIAL_BAUD_RATE Br = (PSERIAL_BAUD_RATE)Irp->AssociatedIrp.SystemBuffer;
00369 8b 47 0c mov eax, DWORD PTR [edi+12]
0036c 89 45 c4 mov DWORD PTR _Br$15078[ebp], eax
; 731 : if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength <
; 732 : sizeof(SERIAL_BAUD_RATE)) {
0036f 83 7e 04 04 cmp DWORD PTR [esi+4], 4
; 733 :
; 734 : Status = STATUS_BUFFER_TOO_SMALL;
; 735 : break;
00373 0f 82 63 ff ff
ff jb $L15793
; 736 :
; 737 : }
; 738 :
; 739 : KeAcquireSpinLock(
; 740 : &Extension->ControlLock,
; 741 : &OldIrql
; 742 : );
00379 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
0037f ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
00385 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 743 :
; 744 : Br->BaudRate = Extension->CurrentBaud;
00388 8b 83 34 01 00
00 mov eax, DWORD PTR [ebx+308]
0038e 8b 4d c4 mov ecx, DWORD PTR _Br$15078[ebp]
00391 89 01 mov DWORD PTR [ecx], eax
; 745 :
; 746 : KeReleaseSpinLock(
; 747 : &Extension->ControlLock,
; 748 : OldIrql
; 749 : );
00393 8a 55 d2 mov dl, BYTE PTR _OldIrql$[ebp]
00396 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
0039c ff 15 00 00 00
00 call DWORD PTR __imp_@KfReleaseSpinLock@8
; 750 :
; 751 : Irp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
003a2 c7 47 1c 04 00
00 00 mov DWORD PTR [edi+28], 4
; 752 :
; 753 : break;
003a9 e9 7b 06 00 00 jmp $DoneWithIoctl$15133
$L15084:
; 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)) {
003ae 6a 04 push 4
003b0 58 pop eax
003b1 39 46 04 cmp DWORD PTR [esi+4], eax
; 762 :
; 763 : Status = STATUS_BUFFER_TOO_SMALL;
; 764 : break;
003b4 0f 82 22 ff ff
ff jb $L15793
; 765 :
; 766 : }
; 767 :
; 768 : Irp->IoStatus.Information = sizeof(ULONG);
003ba 89 47 1c mov DWORD PTR [edi+28], eax
; 769 :
; 770 : S.Extension = Extension;
003bd 89 5d bc mov DWORD PTR _S$15085[ebp], ebx
; 771 : S.Data = Irp->AssociatedIrp.SystemBuffer;
003c0 8b 47 0c mov eax, DWORD PTR [edi+12]
003c3 89 45 c0 mov DWORD PTR _S$15085[ebp+4], eax
; 772 :
; 773 : KeAcquireSpinLock(
; 774 : &Extension->ControlLock,
; 775 : &OldIrql
; 776 : );
003c6 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
003cc ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
003d2 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 777 :
; 778 : KeSynchronizeExecution(
; 779 : Extension->Interrupt,
; 780 : SerialGetMCRContents,
; 781 : &S
; 782 : );
003d5 8d 45 bc lea eax, DWORD PTR _S$15085[ebp]
003d8 50 push eax
003d9 68 00 00 00 00 push OFFSET FLAT:_SerialGetMCRContents@4
; 783 :
; 784 : KeReleaseSpinLock(
; 785 : &Extension->ControlLock,
; 786 : OldIrql
; 787 : );
; 788 :
; 789 : break;
003de e9 7b 08 00 00 jmp $L15790
$L15090:
; 790 : }
; 791 : case IOCTL_SERIAL_SET_MODEM_CONTROL: {
; 792 : SERIAL_IOCTL_SYNC S;
; 793 :
; 794 : if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
; 795 : sizeof(ULONG)) {
003e3 83 7e 08 04 cmp DWORD PTR [esi+8], 4
; 796 :
; 797 : Status = STATUS_BUFFER_TOO_SMALL;
; 798 : break;
003e7 0f 82 ef fe ff
ff jb $L15793
; 799 :
; 800 : }
; 801 :
; 802 : S.Extension = Extension;
003ed 89 5d b4 mov DWORD PTR _S$15091[ebp], ebx
; 803 : S.Data = Irp->AssociatedIrp.SystemBuffer;
003f0 8b 47 0c mov eax, DWORD PTR [edi+12]
003f3 89 45 b8 mov DWORD PTR _S$15091[ebp+4], eax
; 804 :
; 805 : //
; 806 : // Make sure we are at power D0
; 807 : //
; 808 :
; 809 : if (Extension->PowerState != PowerDeviceD0) {
003f6 83 bb a4 04 00
00 01 cmp DWORD PTR [ebx+1188], 1
003fd 74 19 je SHORT $L15097
; 810 : Status = SerialGotoPowerState(Extension->Pdo, Extension,
; 811 : PowerDeviceD0);
003ff 6a 01 push 1
00401 53 push ebx
00402 ff b3 80 05 00
00 push DWORD PTR [ebx+1408]
00408 e8 00 00 00 00 call _SerialGotoPowerState@12
0040d 89 45 dc mov DWORD PTR _Status$[ebp], eax
; 812 : if (!NT_SUCCESS(Status)) {
00410 85 c0 test eax, eax
00412 0f 8c 11 06 00
00 jl $DoneWithIoctl$15133
$L15097:
; 813 : break;
; 814 : }
; 815 : }
; 816 :
; 817 : KeAcquireSpinLock(
; 818 : &Extension->ControlLock,
; 819 : &OldIrql
; 820 : );
00418 8d 8b e4 01 00
00 lea ecx, DWORD PTR [ebx+484]
0041e ff 15 00 00 00
00 call DWORD PTR __imp_@KfAcquireSpinLock@4
00424 88 45 d2 mov BYTE PTR _OldIrql$[ebp], al
; 821 :
; 822 : KeSynchronizeExecution(
; 823 : Extension->Interrupt,
; 824 : SerialSetMCRContents,
; 825 : &S
; 826 : );
00427 8d 45 b4 lea eax, DWORD PTR _S$15091[ebp]
0042a 50 push eax
0042b 68 00 00 00 00 push OFFSET FLAT:_SerialSetMCRContents@4
; 827 :
; 828 : KeReleaseSpinLock(
; 829 : &Extension->ControlLock,
; 830 : OldIrql
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -