diff options
| author | Felix Geyer <fgeyer@debian.org> | 2014-04-05 22:17:15 +0200 |
|---|---|---|
| committer | Felix Geyer <fgeyer@debian.org> | 2014-04-05 22:17:15 +0200 |
| commit | 1700c7d32f7d9d101cbba9f1fcb8bb57ed16a727 (patch) | |
| tree | 727251ad65172262944f82bb0f28601c3fb6f6b3 /src/VBox/Devices | |
| parent | 1e85aed889b772c2f2daa7a6d9e8bd967aa213d8 (diff) | |
| download | virtualbox-upstream.tar.gz | |
Imported Upstream version 4.3.10-dfsgupstream/4.3.10-dfsgupstream
Diffstat (limited to 'src/VBox/Devices')
47 files changed, 1852 insertions, 1139 deletions
diff --git a/src/VBox/Devices/EFI/DevEFI.cpp b/src/VBox/Devices/EFI/DevEFI.cpp index 1400a63b0..34b4b24f5 100644 --- a/src/VBox/Devices/EFI/DevEFI.cpp +++ b/src/VBox/Devices/EFI/DevEFI.cpp @@ -2241,7 +2241,7 @@ static DECLCALLBACK(int) efiConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMN */ pThis->u64TscFrequency = TMCpuTicksPerSecond(PDMDevHlpGetVM(pDevIns)); pThis->u64CpuFrequency = pThis->u64TscFrequency; - pThis->u64FsbFrequency = CPUMGetGuestBusFrequency(PDMDevHlpGetVM(pDevIns)); + pThis->u64FsbFrequency = CPUMGetGuestScalableBusFrequency(PDMDevHlpGetVM(pDevIns)); /* * GOP graphics. diff --git a/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI32.fd b/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI32.fd Binary files differindex 22c648a31..dd8f84641 100644 --- a/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI32.fd +++ b/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI32.fd diff --git a/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI64.fd b/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI64.fd Binary files differindex eab9b08ae..d64748c3b 100644 --- a/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI64.fd +++ b/src/VBox/Devices/EFI/FirmwareBin/VBoxEFI64.fd diff --git a/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.asm b/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.asm index 850c34f8d..183842bb8 100644 --- a/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.asm +++ b/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.asm @@ -1642,7 +1642,7 @@ vga_read_char_attr_: ; 0xc0acb LB 0xa8 call 02f93h ; e8 73 24 movzx bx, ch ; 0f b6 dd sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 jne short 00b5ah ; 75 2d mov dx, ax ; 89 c2 imul dx, di ; 0f af d7 @@ -1658,7 +1658,7 @@ vga_read_char_attr_: ; 0xc0acb LB 0xa8 add ax, ax ; 01 c0 mov dx, cx ; 89 ca add dx, ax ; 01 c2 - mov ax, word [bx+04832h] ; 8b 87 32 48 + mov ax, word [bx+04833h] ; 8b 87 33 48 call 02f93h ; e8 3c 24 mov word [ss:si], ax ; 36 89 04 lea sp, [bp-008h] ; 8d 66 f8 @@ -1724,18 +1724,18 @@ vga_get_font_info_: ; 0xc0b73 LB 0x82 retn 00002h ; c2 02 00 mov dx, 0010ch ; ba 0c 01 jmp short 00b91h ; eb bf - mov ax, 05daeh ; b8 ae 5d + mov ax, 05dafh ; b8 af 5d mov dx, 0c000h ; ba 00 c0 jmp short 00b96h ; eb bc - mov ax, 055aeh ; b8 ae 55 + mov ax, 055afh ; b8 af 55 jmp short 00bd5h ; eb f6 - mov ax, 059aeh ; b8 ae 59 + mov ax, 059afh ; b8 af 59 jmp short 00bd5h ; eb f1 - mov ax, 07baeh ; b8 ae 7b + mov ax, 07bafh ; b8 af 7b jmp short 00bd5h ; eb ec - mov ax, 06baeh ; b8 ae 6b + mov ax, 06bafh ; b8 af 6b jmp short 00bd5h ; eb e7 - mov ax, 07cdbh ; b8 db 7c + mov ax, 07cdch ; b8 dc 7c jmp short 00bd5h ; eb e2 jmp short 00bc4h ; eb cf vga_read_pixel_: ; 0xc0bf5 LB 0x139 @@ -1757,9 +1757,9 @@ vga_read_pixel_: ; 0xc0bf5 LB 0x139 je near 00d27h ; 0f 84 0d 01 movzx bx, al ; 0f b6 d8 sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 je near 00d27h ; 0f 84 fe 00 - mov bl, byte [bx+04830h] ; 8a 9f 30 48 + mov bl, byte [bx+04831h] ; 8a 9f 31 48 cmp bl, 003h ; 80 fb 03 jc short 00c43h ; 72 11 jbe short 00c4bh ; 76 17 @@ -1818,7 +1818,7 @@ vga_read_pixel_: ; 0xc0bf5 LB 0x139 call 02f77h ; e8 b4 22 movzx bx, cl ; 0f b6 d9 sal bx, 003h ; c1 e3 03 - cmp byte [bx+04831h], 002h ; 80 bf 31 48 02 + cmp byte [bx+04832h], 002h ; 80 bf 32 48 02 jne short 00cebh ; 75 1b mov cx, si ; 89 f1 xor ch, ch ; 30 ed @@ -2119,7 +2119,7 @@ biosfn_set_active_page_: ; 0xc0f00 LB 0xdc movzx bx, ch ; 0f b6 dd mov si, bx ; 89 de sal si, 003h ; c1 e6 03 - cmp byte [si+0482fh], 000h ; 80 bc 2f 48 00 + cmp byte [si+04830h], 000h ; 80 bc 30 48 00 jne short 00f83h ; 75 40 mov dx, strict word 0004ah ; ba 4a 00 mov ax, strict word 00040h ; b8 40 00 @@ -2146,10 +2146,10 @@ biosfn_set_active_page_: ; 0xc0f00 LB 0xdc lea bx, [si+001h] ; 8d 5c 01 imul bx, di ; 0f af df jmp short 00f95h ; eb 12 - movzx bx, byte [bx+048aeh] ; 0f b6 9f ae 48 + movzx bx, byte [bx+048afh] ; 0f b6 9f af 48 sal bx, 006h ; c1 e3 06 movzx ax, cl ; 0f b6 c1 - mov bx, word [bx+048c5h] ; 8b 9f c5 48 + mov bx, word [bx+048c6h] ; 8b 9f c6 48 imul bx, ax ; 0f af d8 mov dx, strict word 00063h ; ba 63 00 mov ax, strict word 00040h ; b8 40 00 @@ -2214,15 +2214,15 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 cmp AL, strict byte 0ffh ; 3c ff je near 01359h ; 0f 84 43 03 movzx si, al ; 0f b6 f0 - mov al, byte [si+048aeh] ; 8a 84 ae 48 + mov al, byte [si+048afh] ; 8a 84 af 48 mov byte [bp-00ch], al ; 88 46 f4 movzx bx, al ; 0f b6 d8 sal bx, 006h ; c1 e3 06 - movzx ax, byte [bx+048c2h] ; 0f b6 87 c2 48 - mov word [bp-018h], ax ; 89 46 e8 movzx ax, byte [bx+048c3h] ; 0f b6 87 c3 48 - mov word [bp-016h], ax ; 89 46 ea + mov word [bp-018h], ax ; 89 46 e8 movzx ax, byte [bx+048c4h] ; 0f b6 87 c4 48 + mov word [bp-016h], ax ; 89 46 ea + movzx ax, byte [bx+048c5h] ; 0f b6 87 c5 48 mov word [bp-014h], ax ; 89 46 ec mov dx, 00087h ; ba 87 00 mov ax, strict word 00040h ; b8 40 00 @@ -2238,13 +2238,13 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 jne near 010ebh ; 0f 85 8a 00 mov bx, si ; 89 f3 sal bx, 003h ; c1 e3 03 - mov al, byte [bx+04834h] ; 8a 87 34 48 + mov al, byte [bx+04835h] ; 8a 87 35 48 mov dx, 003c6h ; ba c6 03 out DX, AL ; ee xor al, al ; 30 c0 mov dx, 003c8h ; ba c8 03 out DX, AL ; ee - mov bl, byte [bx+04835h] ; 8a 9f 35 48 + mov bl, byte [bx+04836h] ; 8a 9f 36 48 cmp bl, 001h ; 80 fb 01 jc short 0108bh ; 72 0e jbe short 01094h ; 76 15 @@ -2255,13 +2255,13 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 jmp short 010a1h ; eb 16 test bl, bl ; 84 db jne short 010a1h ; 75 12 - mov di, 05042h ; bf 42 50 + mov di, 05043h ; bf 43 50 jmp short 010a1h ; eb 0d - mov di, 05102h ; bf 02 51 + mov di, 05103h ; bf 03 51 jmp short 010a1h ; eb 08 - mov di, 051c2h ; bf c2 51 + mov di, 051c3h ; bf c3 51 jmp short 010a1h ; eb 03 - mov di, 05282h ; bf 82 52 + mov di, 05283h ; bf 83 52 xor bx, bx ; 31 db jmp short 010b4h ; eb 0f xor al, al ; 30 c0 @@ -2274,8 +2274,8 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 jnc short 010deh ; 73 2a movzx si, byte [bp-012h] ; 0f b6 76 ee sal si, 003h ; c1 e6 03 - movzx si, byte [si+04835h] ; 0f b6 b4 35 48 - movzx dx, byte [si+048beh] ; 0f b6 94 be 48 + movzx si, byte [si+04836h] ; 0f b6 b4 36 48 + movzx dx, byte [si+048bfh] ; 0f b6 94 bf 48 cmp bx, dx ; 39 d3 jnbe short 010a5h ; 77 dc imul si, bx, strict byte 00003h ; 6b f3 03 @@ -2307,7 +2307,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 movzx si, byte [bp-00ch] ; 0f b6 76 f4 sal si, 006h ; c1 e6 06 add si, bx ; 01 de - mov al, byte [si+048e5h] ; 8a 84 e5 48 + mov al, byte [si+048e6h] ; 8a 84 e6 48 out DX, AL ; ee inc bx ; 43 jmp short 010f5h ; eb e4 @@ -2331,7 +2331,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 movzx si, byte [bp-00ch] ; 0f b6 76 f4 sal si, 006h ; c1 e6 06 add si, bx ; 01 de - mov al, byte [si+048c6h] ; 8a 84 c6 48 + mov al, byte [si+048c7h] ; 8a 84 c7 48 mov dx, 003c5h ; ba c5 03 out DX, AL ; ee inc bx ; 43 @@ -2346,14 +2346,14 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 movzx si, byte [bp-00ch] ; 0f b6 76 f4 sal si, 006h ; c1 e6 06 add si, bx ; 01 de - mov al, byte [si+048f9h] ; 8a 84 f9 48 + mov al, byte [si+048fah] ; 8a 84 fa 48 mov dx, 003cfh ; ba cf 03 out DX, AL ; ee inc bx ; 43 jmp short 0114ch ; eb e1 movzx bx, byte [bp-012h] ; 0f b6 5e ee sal bx, 003h ; c1 e3 03 - cmp byte [bx+04830h], 001h ; 80 bf 30 48 01 + cmp byte [bx+04831h], 001h ; 80 bf 31 48 01 jne short 0117eh ; 75 05 mov dx, 003b4h ; ba b4 03 jmp short 01181h ; eb 03 @@ -2373,12 +2373,12 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 mov di, cx ; 89 cf add di, bx ; 01 df lea dx, [si+001h] ; 8d 54 01 - mov al, byte [di+048cch] ; 8a 85 cc 48 + mov al, byte [di+048cdh] ; 8a 85 cd 48 out DX, AL ; ee inc bx ; 43 jmp short 0118bh ; eb e0 mov bx, cx ; 89 cb - mov al, byte [bx+048cbh] ; 8a 87 cb 48 + mov al, byte [bx+048cch] ; 8a 87 cc 48 mov dx, 003c2h ; ba c2 03 out DX, AL ; ee mov AL, strict byte 020h ; b0 20 @@ -2392,9 +2392,9 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 jne short 01226h ; 75 5f movzx bx, byte [bp-012h] ; 0f b6 5e ee sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 jne short 011e8h ; 75 13 - mov es, [bx+04832h] ; 8e 87 32 48 + mov es, [bx+04833h] ; 8e 87 33 48 mov cx, 04000h ; b9 00 40 mov ax, 00720h ; b8 20 07 xor di, di ; 31 ff @@ -2404,7 +2404,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 jmp short 01226h ; eb 3e cmp byte [bp-00eh], 00dh ; 80 7e f2 0d jnc short 01200h ; 73 12 - mov es, [bx+04832h] ; 8e 87 32 48 + mov es, [bx+04833h] ; 8e 87 33 48 mov cx, 04000h ; b9 00 40 xor ax, ax ; 31 c0 xor di, di ; 31 ff @@ -2422,7 +2422,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 mov word [bp-01ah], ax ; 89 46 e6 mov AL, strict byte 00fh ; b0 0f out DX, AL ; ee - mov es, [bx+04832h] ; 8e 87 32 48 + mov es, [bx+04833h] ; 8e 87 33 48 mov cx, 08000h ; b9 00 80 xor ax, ax ; 31 c0 xor di, di ; 31 ff @@ -2441,7 +2441,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 call 02fa1h ; e8 62 1d movzx bx, byte [bp-00ch] ; 0f b6 5e f4 sal bx, 006h ; c1 e3 06 - mov bx, word [bx+048c5h] ; 8b 9f c5 48 + mov bx, word [bx+048c6h] ; 8b 9f c6 48 mov dx, strict word 0004ch ; ba 4c 00 mov ax, strict word 00040h ; b8 40 00 call 02fa1h ; e8 4e 1d @@ -2480,7 +2480,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 mov ax, strict word 00040h ; b8 40 00 call 02f85h ; e8 ce 1c mov cx, ds ; 8c d9 - mov bx, 05592h ; bb 92 55 + mov bx, 05593h ; bb 93 55 mov dx, 000a8h ; ba a8 00 mov ax, strict word 00040h ; b8 40 00 call 02fc1h ; e8 fc 1c @@ -2494,7 +2494,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 call 02f85h ; e8 aa 1c movzx bx, byte [bp-012h] ; 0f b6 5e ee sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 jne short 012f2h ; 75 09 mov dx, strict word 00007h ; ba 07 00 mov ax, strict word 00006h ; b8 06 00 @@ -2512,7 +2512,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 call 00f00h ; e8 f5 fb movzx bx, byte [bp-012h] ; 0f b6 5e ee sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 jne short 01329h ; 75 10 xor bl, bl ; 30 db mov AL, strict byte 004h ; b0 04 @@ -2522,7 +2522,7 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 mov AL, strict byte 003h ; b0 03 mov AH, strict byte 011h ; b4 11 int 010h ; cd 10 - mov dx, 059aeh ; ba ae 59 + mov dx, 059afh ; ba af 59 mov ax, strict word 0001fh ; b8 1f 00 call 00a00h ; e8 ce f6 mov ax, word [bp-014h] ; 8b 46 ec @@ -2532,13 +2532,13 @@ biosfn_set_video_mode_: ; 0xc0fdc LB 0x387 je short 0134fh ; 74 10 cmp ax, strict word 00008h ; 3d 08 00 jne short 01359h ; 75 15 - mov dx, 055aeh ; ba ae 55 + mov dx, 055afh ; ba af 55 mov ax, strict word 00043h ; b8 43 00 call 00a00h ; e8 b3 f6 jmp short 01359h ; eb 0a - mov dx, 05daeh ; ba ae 5d + mov dx, 05dafh ; ba af 5d jmp short 01347h ; eb f3 - mov dx, 06baeh ; ba ae 6b + mov dx, 06bafh ; ba af 6b jmp short 01347h ; eb ee lea sp, [bp-00ah] ; 8d 66 f6 pop di ; 5f @@ -2848,7 +2848,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 mov word [bp-01ah], ax ; 89 46 e6 mov ax, word [bp-016h] ; 8b 46 ea imul ax, cx ; 0f af c1 - cmp byte [di+0482fh], 000h ; 80 bd 2f 48 00 + cmp byte [di+04830h], 000h ; 80 bd 30 48 00 jne near 017c7h ; 0f 85 9f 01 mov dx, ax ; 89 c2 add dx, ax ; 01 c2 @@ -2871,7 +2871,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 movzx dx, byte [bp-00ch] ; 0f b6 56 f4 sal dx, 008h ; c1 e2 08 add dx, strict byte 00020h ; 83 c2 20 - mov es, [di+04832h] ; 8e 85 32 48 + mov es, [di+04833h] ; 8e 85 33 48 mov cx, ax ; 89 c1 mov ax, dx ; 89 d0 mov di, bx ; 89 df @@ -2905,7 +2905,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 add di, dx ; 01 d7 movzx si, byte [bp-00eh] ; 0f b6 76 f2 sal si, 003h ; c1 e6 03 - mov es, [si+04832h] ; 8e 84 32 48 + mov es, [si+04833h] ; 8e 84 33 48 cld ; fc jcxz 016d3h ; e3 02 rep stosw ; f3 ab @@ -2919,7 +2919,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 add dx, dx ; 01 d2 movzx si, byte [bp-00eh] ; 0f b6 76 f2 sal si, 003h ; c1 e6 03 - mov ax, word [si+04832h] ; 8b 84 32 48 + mov ax, word [si+04833h] ; 8b 84 33 48 mov si, word [bp-014h] ; 8b 76 ec imul si, word [bp-016h] ; 0f af 76 ea add cx, si ; 01 f1 @@ -2963,7 +2963,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 add di, dx ; 01 d7 movzx si, byte [bp-00eh] ; 0f b6 76 f2 sal si, 003h ; c1 e6 03 - mov es, [si+04832h] ; 8e 84 32 48 + mov es, [si+04833h] ; 8e 84 33 48 cld ; fc jcxz 01774h ; e3 02 rep stosw ; f3 ab @@ -2978,7 +2978,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 add dx, dx ; 01 d2 movzx si, byte [bp-00eh] ; 0f b6 76 f2 sal si, 003h ; c1 e6 03 - mov ax, word [si+04832h] ; 8b 84 32 48 + mov ax, word [si+04833h] ; 8b 84 33 48 mov si, word [bp-014h] ; 8b 76 ec imul si, word [bp-016h] ; 0f af 76 ea add di, si ; 01 f7 @@ -2998,11 +2998,11 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 jc near 01a65h ; 0f 82 a4 02 dec word [bp-014h] ; ff 4e ec jmp near 01723h ; e9 5c ff - movzx bx, byte [si+048aeh] ; 0f b6 9c ae 48 + movzx bx, byte [si+048afh] ; 0f b6 9c af 48 sal bx, 006h ; c1 e3 06 - mov dl, byte [bx+048c4h] ; 8a 97 c4 48 + mov dl, byte [bx+048c5h] ; 8a 97 c5 48 mov byte [bp-00ah], dl ; 88 56 f6 - mov bl, byte [di+04830h] ; 8a 9d 30 48 + mov bl, byte [di+04831h] ; 8a 9d 31 48 cmp bl, 004h ; 80 fb 04 je short 017eeh ; 74 0f cmp bl, 003h ; 80 fb 03 @@ -3035,7 +3035,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 movzx ax, byte [bp-00ch] ; 0f b6 46 f4 movzx bx, byte [bp-00eh] ; 0f b6 5e f2 sal bx, 003h ; c1 e3 03 - mov es, [bx+04832h] ; 8e 87 32 48 + mov es, [bx+04833h] ; 8e 87 33 48 xor di, di ; 31 ff cld ; fc jcxz 0183fh ; e3 02 @@ -3117,7 +3117,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 jc near 01a65h ; 0f 82 3d 01 dec word [bp-014h] ; ff 4e ec jmp short 018bch ; eb 8f - mov dl, byte [di+04831h] ; 8a 95 31 48 + mov dl, byte [di+04832h] ; 8a 95 32 48 cmp byte [bp-010h], 000h ; 80 7e f0 00 jne short 01974h ; 75 3d cmp byte [bp-008h], 000h ; 80 7e f8 00 @@ -3135,7 +3135,7 @@ biosfn_scroll_: ; 0xc1568 LB 0x506 movzx cx, dl ; 0f b6 ca imul cx, ax ; 0f af c8 movzx ax, byte [bp-00ch] ; 0f b6 46 f4 - mov es, [di+04832h] ; 8e 85 32 48 + mov es, [di+04833h] ; 8e 85 33 48 xor di, di ; 31 ff cld ; fc jcxz 01971h ; e3 02 @@ -3237,11 +3237,11 @@ write_gfx_char_pl4_: ; 0xc1a6e LB 0xeb je short 01a8ch ; 74 0b cmp byte [bp+006h], 00eh ; 80 7e 06 0e jne short 01a91h ; 75 0a - mov di, 05daeh ; bf ae 5d + mov di, 05dafh ; bf af 5d jmp short 01a94h ; eb 08 - mov di, 06baeh ; bf ae 6b + mov di, 06bafh ; bf af 6b jmp short 01a94h ; eb 03 - mov di, 055aeh ; bf ae 55 + mov di, 055afh ; bf af 55 movzx si, cl ; 0f b6 f1 movzx bx, byte [bp+006h] ; 0f b6 5e 06 imul si, bx ; 0f af f3 @@ -3328,7 +3328,7 @@ write_gfx_char_cga_: ; 0xc1b59 LB 0x11e push di ; 57 sub sp, strict byte 00008h ; 83 ec 08 mov byte [bp-008h], dl ; 88 56 f8 - mov si, 055aeh ; be ae 55 + mov si, 055afh ; be af 55 xor bh, bh ; 30 ff movzx di, byte [bp+006h] ; 0f b6 7e 06 imul di, bx ; 0f af fb @@ -3442,7 +3442,7 @@ write_gfx_char_lin_: ; 0xc1c77 LB 0x91 push di ; 57 sub sp, strict byte 00008h ; 83 ec 08 mov byte [bp-006h], dl ; 88 56 fa - mov di, 055aeh ; bf ae 55 + mov di, 055afh ; bf af 55 movzx dx, cl ; 0f b6 d1 movzx cx, byte [bp+004h] ; 0f b6 4e 04 imul cx, dx ; 0f af ca @@ -3537,7 +3537,7 @@ biosfn_write_char_attr_: ; 0xc1d08 LB 0x168 movzx bx, cl ; 0f b6 d9 mov di, bx ; 89 df sal di, 003h ; c1 e7 03 - cmp byte [di+0482fh], 000h ; 80 bd 2f 48 00 + cmp byte [di+04830h], 000h ; 80 bd 30 48 00 jne short 01dc3h ; 75 47 mov bx, word [bp-018h] ; 8b 5e e8 imul bx, ax ; 0f af d8 @@ -3558,18 +3558,18 @@ biosfn_write_char_attr_: ; 0xc1d08 LB 0x168 add ax, bx ; 01 d8 mov word [bp-01ah], ax ; 89 46 e6 mov ax, word [bp-01ah] ; 8b 46 e6 - mov es, [di+04832h] ; 8e 85 32 48 + mov es, [di+04833h] ; 8e 85 33 48 mov cx, si ; 89 f1 mov di, dx ; 89 d7 cld ; fc jcxz 01dc0h ; e3 02 rep stosw ; f3 ab jmp near 01e69h ; e9 a6 00 - movzx bx, byte [bx+048aeh] ; 0f b6 9f ae 48 + movzx bx, byte [bx+048afh] ; 0f b6 9f af 48 sal bx, 006h ; c1 e3 06 - mov al, byte [bx+048c4h] ; 8a 87 c4 48 + mov al, byte [bx+048c5h] ; 8a 87 c5 48 mov byte [bp-008h], al ; 88 46 f8 - mov al, byte [di+04831h] ; 8a 85 31 48 + mov al, byte [di+04832h] ; 8a 85 32 48 mov byte [bp-014h], al ; 88 46 ec dec si ; 4e cmp si, strict byte 0ffffh ; 83 fe ff @@ -3579,7 +3579,7 @@ biosfn_write_char_attr_: ; 0xc1d08 LB 0x168 jnc near 01e69h ; 0f 83 7d 00 movzx bx, byte [bp-006h] ; 0f b6 5e fa sal bx, 003h ; c1 e3 03 - mov al, byte [bx+04830h] ; 8a 87 30 48 + mov al, byte [bx+04831h] ; 8a 87 31 48 cmp AL, strict byte 003h ; 3c 03 jc short 01e07h ; 72 0c jbe short 01e0dh ; 76 10 @@ -3667,7 +3667,7 @@ biosfn_write_char_only_: ; 0xc1e70 LB 0x16f movzx di, cl ; 0f b6 f9 mov bx, di ; 89 fb sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 jne short 01f2eh ; 75 4a mov dx, word [bp-018h] ; 8b 56 e8 imul dx, ax ; 0f af d0 @@ -3689,7 +3689,7 @@ biosfn_write_char_only_: ; 0xc1e70 LB 0x16f movzx ax, byte [bp-012h] ; 0f b6 46 ee movzx bx, byte [bp-00eh] ; 0f b6 5e f2 sal bx, 003h ; c1 e3 03 - mov di, word [bx+04832h] ; 8b bf 32 48 + mov di, word [bx+04833h] ; 8b bf 33 48 mov bx, ax ; 89 c3 mov dx, cx ; 89 ca mov ax, di ; 89 f8 @@ -3697,11 +3697,11 @@ biosfn_write_char_only_: ; 0xc1e70 LB 0x16f inc cx ; 41 inc cx ; 41 jmp short 01f0ah ; eb dc - movzx di, byte [di+048aeh] ; 0f b6 bd ae 48 + movzx di, byte [di+048afh] ; 0f b6 bd af 48 sal di, 006h ; c1 e7 06 - mov al, byte [di+048c4h] ; 8a 85 c4 48 + mov al, byte [di+048c5h] ; 8a 85 c5 48 mov byte [bp-00ah], al ; 88 46 f6 - mov al, byte [bx+04831h] ; 8a 87 31 48 + mov al, byte [bx+04832h] ; 8a 87 32 48 mov byte [bp-008h], al ; 88 46 f8 dec si ; 4e cmp si, strict byte 0ffffh ; 83 fe ff @@ -3711,7 +3711,7 @@ biosfn_write_char_only_: ; 0xc1e70 LB 0x16f jnc near 01fd8h ; 0f 83 81 00 movzx bx, byte [bp-00eh] ; 0f b6 5e f2 sal bx, 003h ; c1 e3 03 - mov bl, byte [bx+04830h] ; 8a 9f 30 48 + mov bl, byte [bx+04831h] ; 8a 9f 31 48 cmp bl, 003h ; 80 fb 03 jc short 01f75h ; 72 0e jbe short 01f7ch ; 76 13 @@ -3774,9 +3774,9 @@ biosfn_write_pixel_: ; 0xc1fdf LB 0x16a je near 02121h ; 0f 84 1e 01 movzx bx, al ; 0f b6 d8 sal bx, 003h ; c1 e3 03 - cmp byte [bx+0482fh], 000h ; 80 bf 2f 48 00 + cmp byte [bx+04830h], 000h ; 80 bf 30 48 00 je near 02121h ; 0f 84 0f 01 - mov al, byte [bx+04830h] ; 8a 87 30 48 + mov al, byte [bx+04831h] ; 8a 87 31 48 cmp AL, strict byte 003h ; 3c 03 jc short 02029h ; 72 0f jbe short 02030h ; 76 14 @@ -3830,7 +3830,7 @@ biosfn_write_pixel_: ; 0xc1fdf LB 0x16a mov ax, cx ; 89 c8 shr ax, 1 ; d1 e8 imul ax, ax, strict byte 00050h ; 6b c0 50 - cmp byte [bx+04831h], 002h ; 80 bf 31 48 02 + cmp byte [bx+04832h], 002h ; 80 bf 32 48 02 jne short 020abh ; 75 08 mov bx, word [bp-00ah] ; 8b 5e f6 shr bx, 002h ; c1 eb 02 @@ -3848,7 +3848,7 @@ biosfn_write_pixel_: ; 0xc1fdf LB 0x16a mov bl, al ; 88 c3 movzx si, byte [bp-004h] ; 0f b6 76 fc sal si, 003h ; c1 e6 03 - cmp byte [si+04831h], 002h ; 80 bc 31 48 02 + cmp byte [si+04832h], 002h ; 80 bc 32 48 02 jne short 020f1h ; 75 19 mov al, byte [bp-00ah] ; 8a 46 f6 and AL, strict byte 003h ; 24 03 @@ -3988,7 +3988,7 @@ biosfn_write_teletype_: ; 0xc2149 LB 0x284 movzx bx, byte [bp-00eh] ; 0f b6 5e f2 mov si, bx ; 89 de sal si, 003h ; c1 e6 03 - cmp byte [si+0482fh], 000h ; 80 bc 2f 48 00 + cmp byte [si+04830h], 000h ; 80 bc 30 48 00 jne short 02293h ; 75 4b mov ax, word [bp-012h] ; 8b 46 ee imul ax, word [bp-014h] ; 0f af 46 ec @@ -4004,7 +4004,7 @@ biosfn_write_teletype_: ; 0xc2149 LB 0x284 add cx, cx ; 01 c9 add cx, dx ; 01 d1 movzx bx, byte [bp-00ch] ; 0f b6 5e f4 - mov ax, word [si+04832h] ; 8b 84 32 48 + mov ax, word [si+04833h] ; 8b 84 33 48 mov dx, cx ; 89 ca call 02f85h ; e8 0b 0d cmp byte [bp-010h], 003h ; 80 7e f0 03 @@ -4012,14 +4012,14 @@ biosfn_write_teletype_: ; 0xc2149 LB 0x284 movzx bx, byte [bp-006h] ; 0f b6 5e fa mov dx, cx ; 89 ca inc dx ; 42 - mov ax, word [si+04832h] ; 8b 84 32 48 + mov ax, word [si+04833h] ; 8b 84 33 48 call 02f85h ; e8 f5 0c jmp near 02311h ; e9 7e 00 - movzx bx, byte [bx+048aeh] ; 0f b6 9f ae 48 + movzx bx, byte [bx+048afh] ; 0f b6 9f af 48 sal bx, 006h ; c1 e3 06 - mov ah, byte [bx+048c4h] ; 8a a7 c4 48 - mov dl, byte [si+04831h] ; 8a 94 31 48 - mov al, byte [si+04830h] ; 8a 84 30 48 + mov ah, byte [bx+048c5h] ; 8a a7 c5 48 + mov dl, byte [si+04832h] ; 8a 94 32 48 + mov al, byte [si+04831h] ; 8a 84 31 48 cmp AL, strict byte 003h ; 3c 03 jc short 022b7h ; 72 0c jbe short 022bdh ; 76 10 @@ -4075,7 +4075,7 @@ biosfn_write_teletype_: ; 0xc2149 LB 0x284 mov bh, byte [bp-012h] ; 8a 7e ee db 0feh, 0cfh ; dec bh ; fe cf - cmp byte [si+0482fh], 000h ; 80 bc 2f 48 00 + cmp byte [si+04830h], 000h ; 80 bc 30 48 00 jne short 0238dh ; 75 46 mov ax, word [bp-012h] ; 8b 46 ee imul ax, word [bp-014h] ; 0f af 46 ec @@ -4092,7 +4092,7 @@ biosfn_write_teletype_: ; 0xc2149 LB 0x284 add cx, cx ; 01 c9 add dx, cx ; 01 ca inc dx ; 42 - mov ax, word [si+04832h] ; 8b 84 32 48 + mov ax, word [si+04833h] ; 8b 84 33 48 call 02f77h ; e8 02 0c push strict byte 00001h ; 6a 01 movzx dx, byte [bp-004h] ; 0f b6 56 fc @@ -4367,7 +4367,7 @@ biosfn_load_text_8_14_pat_: ; 0xc2571 LB 0x70 mov di, bx ; 89 df sal di, 005h ; c1 e7 05 add di, word [bp-00ch] ; 03 7e f4 - add si, 05daeh ; 81 c6 ae 5d + add si, 05dafh ; 81 c6 af 5d mov cx, strict word 0000eh ; b9 0e 00 mov dx, 0c000h ; ba 00 c0 mov ax, 0a000h ; b8 00 a0 @@ -4423,7 +4423,7 @@ biosfn_load_text_8_8_pat_: ; 0xc25e1 LB 0x72 mov di, bx ; 89 df sal di, 005h ; c1 e7 05 add di, word [bp-00ch] ; 03 7e f4 - add si, 055aeh ; 81 c6 ae 55 + add si, 055afh ; 81 c6 af 55 mov cx, strict word 00008h ; b9 08 00 mov dx, 0c000h ; ba 00 c0 mov ax, 0a000h ; b8 00 a0 @@ -4479,7 +4479,7 @@ biosfn_load_text_8_16_pat_: ; 0xc2653 LB 0x72 mov di, bx ; 89 df sal di, 005h ; c1 e7 05 add di, word [bp-00ch] ; 03 7e f4 - add si, 06baeh ; 81 c6 ae 6b + add si, 06bafh ; 81 c6 af 6b mov cx, strict word 00010h ; b9 10 00 mov dx, 0c000h ; ba 00 c0 mov ax, 0a000h ; b8 00 a0 @@ -4613,7 +4613,7 @@ biosfn_read_state_info_: ; 0xc278b LB 0x101 push dx ; 52 push bx ; 53 mov cx, ds ; 8c d9 - mov bx, 05582h ; bb 82 55 + mov bx, 05583h ; bb 83 55 mov dx, word [bp-00ah] ; 8b 56 f6 mov ax, word [bp-008h] ; 8b 46 f8 call 02fc1h ; e8 20 08 @@ -5513,7 +5513,7 @@ find_vga_entry_: ; 0xc2f50 LB 0x27 jnbe short 02f71h ; 77 0e movzx bx, al ; 0f b6 d8 sal bx, 003h ; c1 e3 03 - cmp dl, byte [bx+0482eh] ; 3a 97 2e 48 + cmp dl, byte [bx+0482fh] ; 3a 97 2f 48 jne short 02f5dh ; 75 ee mov ah, al ; 88 c4 mov al, ah ; 88 e0 @@ -6779,10 +6779,10 @@ vesa_pm_end: ; 0xc4714 LB 0x1 ; Padding 0xeb bytes at 0xc4715 times 235 db 0 -section _DATA progbits vstart=0x4800 align=1 ; size=0x36e0 class=DATA group=DGROUP -_msg_vga_init: ; 0xc4800 LB 0x2e - db 'Oracle VM VirtualBox Version 4.3.8 VGA BIOS', 00dh, 00ah, 000h -_vga_modes: ; 0xc482e LB 0x80 +section _DATA progbits vstart=0x4800 align=1 ; size=0x36e1 class=DATA group=DGROUP +_msg_vga_init: ; 0xc4800 LB 0x2f + db 'Oracle VM VirtualBox Version 4.3.10 VGA BIOS', 00dh, 00ah, 000h +_vga_modes: ; 0xc482f LB 0x80 db 000h, 000h, 000h, 004h, 000h, 0b8h, 0ffh, 002h, 001h, 000h, 000h, 004h, 000h, 0b8h, 0ffh, 002h db 002h, 000h, 000h, 004h, 000h, 0b8h, 0ffh, 002h, 003h, 000h, 000h, 004h, 000h, 0b8h, 0ffh, 002h db 004h, 001h, 002h, 002h, 000h, 0b8h, 0ffh, 001h, 005h, 001h, 002h, 002h, 000h, 0b8h, 0ffh, 001h @@ -6791,11 +6791,11 @@ _vga_modes: ; 0xc482e LB 0x80 db 00fh, 001h, 003h, 001h, 000h, 0a0h, 0ffh, 000h, 010h, 001h, 004h, 004h, 000h, 0a0h, 0ffh, 002h db 011h, 001h, 003h, 001h, 000h, 0a0h, 0ffh, 002h, 012h, 001h, 004h, 004h, 000h, 0a0h, 0ffh, 002h db 013h, 001h, 005h, 008h, 000h, 0a0h, 0ffh, 003h, 06ah, 001h, 004h, 004h, 000h, 0a0h, 0ffh, 002h -_line_to_vpti: ; 0xc48ae LB 0x10 +_line_to_vpti: ; 0xc48af LB 0x10 db 017h, 017h, 018h, 018h, 004h, 005h, 006h, 007h, 00dh, 00eh, 011h, 012h, 01ah, 01bh, 01ch, 01dh -_dac_regs: ; 0xc48be LB 0x4 +_dac_regs: ; 0xc48bf LB 0x4 dd 0ff3f3f3fh -_video_param_table: ; 0xc48c2 LB 0x780 +_video_param_table: ; 0xc48c3 LB 0x780 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h @@ -6916,7 +6916,7 @@ _video_param_table: ; 0xc48c2 LB 0x780 db 072h, 0f0h, 000h, 060h, 000h, 000h, 000h, 000h, 000h, 000h, 059h, 08dh, 057h, 032h, 000h, 057h db 073h, 0e3h, 0ffh, 000h, 001h, 002h, 003h, 004h, 005h, 014h, 007h, 038h, 039h, 03ah, 03bh, 03ch db 03dh, 03eh, 03fh, 001h, 000h, 00fh, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 005h, 00fh, 0ffh -_palette0: ; 0xc5042 LB 0xc0 +_palette0: ; 0xc5043 LB 0xc0 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah db 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah @@ -6929,7 +6929,7 @@ _palette0: ; 0xc5042 LB 0xc0 db 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah db 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 02ah, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh db 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh, 03fh -_palette1: ; 0xc5102 LB 0xc0 +_palette1: ; 0xc5103 LB 0xc0 db 000h, 000h, 000h, 000h, 000h, 02ah, 000h, 02ah, 000h, 000h, 02ah, 02ah, 02ah, 000h, 000h, 02ah db 000h, 02ah, 02ah, 015h, 000h, 02ah, 02ah, 02ah, 000h, 000h, 000h, 000h, 000h, 02ah, 000h, 02ah db 000h, 000h, 02ah, 02ah, 02ah, 000h, 000h, 02ah, 000h, 02ah, 02ah, 015h, 000h, 02ah, 02ah, 02ah @@ -6942,7 +6942,7 @@ _palette1: ; 0xc5102 LB 0xc0 db 015h, 015h, 015h, 015h, 015h, 03fh, 015h, 03fh, 015h, 015h, 03fh, 03fh, 03fh, 015h, 015h, 03fh db 015h, 03fh, 03fh, 03fh, 015h, 03fh, 03fh, 03fh, 015h, 015h, 015h, 015h, 015h, 03fh, 015h, 03fh db 015h, 015h, 03fh, 03fh, 03fh, 015h, 015h, 03fh, 015h, 03fh, 03fh, 03fh, 015h, 03fh, 03fh, 03fh -_palette2: ; 0xc51c2 LB 0xc0 +_palette2: ; 0xc51c3 LB 0xc0 db 000h, 000h, 000h, 000h, 000h, 02ah, 000h, 02ah, 000h, 000h, 02ah, 02ah, 02ah, 000h, 000h, 02ah db 000h, 02ah, 02ah, 02ah, 000h, 02ah, 02ah, 02ah, 000h, 000h, 015h, 000h, 000h, 03fh, 000h, 02ah db 015h, 000h, 02ah, 03fh, 02ah, 000h, 015h, 02ah, 000h, 03fh, 02ah, 02ah, 015h, 02ah, 02ah, 03fh @@ -6955,7 +6955,7 @@ _palette2: ; 0xc51c2 LB 0xc0 db 015h, 015h, 000h, 015h, 015h, 02ah, 015h, 03fh, 000h, 015h, 03fh, 02ah, 03fh, 015h, 000h, 03fh db 015h, 02ah, 03fh, 03fh, 000h, 03fh, 03fh, 02ah, 015h, 015h, 015h, 015h, 015h, 03fh, 015h, 03fh db 015h, 015h, 03fh, 03fh, 03fh, 015h, 015h, 03fh, 015h, 03fh, 03fh, 03fh, 015h, 03fh, 03fh, 03fh -_palette3: ; 0xc5282 LB 0x300 +_palette3: ; 0xc5283 LB 0x300 db 000h, 000h, 000h, 000h, 000h, 02ah, 000h, 02ah, 000h, 000h, 02ah, 02ah, 02ah, 000h, 000h, 02ah db 000h, 02ah, 02ah, 015h, 000h, 02ah, 02ah, 02ah, 015h, 015h, 015h, 015h, 015h, 03fh, 015h, 03fh db 015h, 015h, 03fh, 03fh, 03fh, 015h, 015h, 03fh, 015h, 03fh, 03fh, 03fh, 015h, 03fh, 03fh, 03fh @@ -7004,12 +7004,12 @@ _palette3: ; 0xc5282 LB 0x300 db 00bh, 010h, 00bh, 00bh, 010h, 00ch, 00bh, 010h, 00dh, 00bh, 010h, 00fh, 00bh, 010h, 010h, 00bh db 00fh, 010h, 00bh, 00dh, 010h, 00bh, 00ch, 010h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_static_functionality: ; 0xc5582 LB 0x10 +_static_functionality: ; 0xc5583 LB 0x10 db 0ffh, 0e0h, 00fh, 000h, 000h, 000h, 000h, 007h, 002h, 008h, 0e7h, 00ch, 000h, 000h, 000h, 000h -_video_save_pointer_table: ; 0xc5592 LB 0x1c - db 0c2h, 048h, 000h, 0c0h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h +_video_save_pointer_table: ; 0xc5593 LB 0x1c + db 0c3h, 048h, 000h, 0c0h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_vgafont8: ; 0xc55ae LB 0x800 +_vgafont8: ; 0xc55af LB 0x800 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 07eh, 081h, 0a5h, 081h, 0bdh, 099h, 081h, 07eh db 07eh, 0ffh, 0dbh, 0ffh, 0c3h, 0e7h, 0ffh, 07eh, 06ch, 0feh, 0feh, 0feh, 07ch, 038h, 010h, 000h db 010h, 038h, 07ch, 0feh, 07ch, 038h, 010h, 000h, 038h, 07ch, 038h, 0feh, 0feh, 07ch, 038h, 07ch @@ -7138,7 +7138,7 @@ _vgafont8: ; 0xc55ae LB 0x800 db 000h, 000h, 000h, 000h, 018h, 000h, 000h, 000h, 00fh, 00ch, 00ch, 00ch, 0ech, 06ch, 03ch, 01ch db 078h, 06ch, 06ch, 06ch, 06ch, 000h, 000h, 000h, 070h, 018h, 030h, 060h, 078h, 000h, 000h, 000h db 000h, 000h, 03ch, 03ch, 03ch, 03ch, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_vgafont14: ; 0xc5dae LB 0xe00 +_vgafont14: ; 0xc5daf LB 0xe00 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 07eh, 081h, 0a5h, 081h, 081h, 0bdh, 099h, 081h, 07eh, 000h, 000h, 000h, 000h, 000h, 07eh, 0ffh db 0dbh, 0ffh, 0ffh, 0c3h, 0e7h, 0ffh, 07eh, 000h, 000h, 000h, 000h, 000h, 000h, 06ch, 0feh, 0feh @@ -7363,7 +7363,7 @@ _vgafont14: ; 0xc5dae LB 0xe00 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 070h, 0d8h, 030h, 060h, 0c8h, 0f8h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 07ch, 07ch, 07ch, 07ch, 07ch, 07ch, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_vgafont16: ; 0xc6bae LB 0x1000 +_vgafont16: ; 0xc6baf LB 0x1000 db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 07eh, 081h, 0a5h, 081h, 081h, 0bdh, 099h, 081h, 081h, 07eh, 000h, 000h, 000h, 000h db 000h, 000h, 07eh, 0ffh, 0dbh, 0ffh, 0ffh, 0c3h, 0e7h, 0ffh, 0ffh, 07eh, 000h, 000h, 000h, 000h @@ -7620,7 +7620,7 @@ _vgafont16: ; 0xc6bae LB 0x1000 db 000h, 070h, 0d8h, 030h, 060h, 0c8h, 0f8h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 07ch, 07ch, 07ch, 07ch, 07ch, 07ch, 07ch, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h -_vgafont14alt: ; 0xc7bae LB 0x12d +_vgafont14alt: ; 0xc7baf LB 0x12d db 01dh, 000h, 000h, 000h, 000h, 024h, 066h, 0ffh, 066h, 024h, 000h, 000h, 000h, 000h, 000h, 022h db 000h, 063h, 063h, 063h, 022h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 02bh, 000h db 000h, 000h, 018h, 018h, 018h, 0ffh, 018h, 018h, 018h, 000h, 000h, 000h, 000h, 02dh, 000h, 000h @@ -7640,7 +7640,7 @@ _vgafont14alt: ; 0xc7bae LB 0x12d db 000h, 0fch, 066h, 066h, 07ch, 062h, 066h, 06fh, 066h, 066h, 0f3h, 000h, 000h, 000h, 0f1h, 000h db 000h, 018h, 018h, 018h, 0ffh, 018h, 018h, 018h, 000h, 0ffh, 000h, 000h, 000h, 0f6h, 000h, 000h db 018h, 018h, 000h, 000h, 0ffh, 000h, 000h, 018h, 018h, 000h, 000h, 000h, 000h -_vgafont16alt: ; 0xc7cdb LB 0x145 +_vgafont16alt: ; 0xc7cdc LB 0x144 db 01dh, 000h, 000h, 000h, 000h, 000h, 024h, 066h, 0ffh, 066h, 024h, 000h, 000h, 000h, 000h, 000h db 000h, 030h, 000h, 000h, 03ch, 066h, 0c3h, 0c3h, 0dbh, 0dbh, 0c3h, 0c3h, 066h, 03ch, 000h, 000h db 000h, 000h, 04dh, 000h, 000h, 0c3h, 0e7h, 0ffh, 0ffh, 0dbh, 0c3h, 0c3h, 0c3h, 0c3h, 0c3h, 000h @@ -7661,31 +7661,34 @@ _vgafont16alt: ; 0xc7cdb LB 0x145 db 09eh, 000h, 0fch, 066h, 066h, 07ch, 062h, 066h, 06fh, 066h, 066h, 066h, 0f3h, 000h, 000h, 000h db 000h, 0abh, 000h, 0c0h, 0c0h, 0c2h, 0c6h, 0cch, 018h, 030h, 060h, 0ceh, 09bh, 006h, 00ch, 01fh db 000h, 000h, 0ach, 000h, 0c0h, 0c0h, 0c2h, 0c6h, 0cch, 018h, 030h, 066h, 0ceh, 096h, 03eh, 006h - db 006h, 000h, 000h, 000h, 000h + db 006h, 000h, 000h, 000h _vbebios_copyright: ; 0xc7e20 LB 0x15 db 'VirtualBox VESA BIOS', 000h _vbebios_vendor_name: ; 0xc7e35 LB 0x13 db 'Oracle Corporation', 000h _vbebios_product_name: ; 0xc7e48 LB 0x21 db 'Oracle VM VirtualBox VBE Adapter', 000h -_vbebios_product_revision: ; 0xc7e69 LB 0x23 - db 'Oracle VM VirtualBox Version 4.3.8', 000h -_vbebios_info_string: ; 0xc7e8c LB 0x2b +_vbebios_product_revision: ; 0xc7e69 LB 0x24 + db 'Oracle VM VirtualBox Version 4.3.10', 000h +_vbebios_info_string: ; 0xc7e8d LB 0x2b db 'VirtualBox VBE Display Adapter enabled', 00dh, 00ah, 00dh, 00ah, 000h -_no_vbebios_info_string: ; 0xc7eb7 LB 0x29 +_no_vbebios_info_string: ; 0xc7eb8 LB 0x29 db 'No VirtualBox VBE support available!', 00dh, 00ah, 00dh, 00ah, 000h -section CONST progbits vstart=0x7ee0 align=1 ; size=0x0 class=DATA group=DGROUP + ; Padding 0x1 bytes at 0xc7ee1 + db 001h + +section CONST progbits vstart=0x7ee2 align=1 ; size=0x0 class=DATA group=DGROUP -section CONST2 progbits vstart=0x7ee0 align=1 ; size=0x0 class=DATA group=DGROUP +section CONST2 progbits vstart=0x7ee2 align=1 ; size=0x0 class=DATA group=DGROUP - ; Padding 0x120 bytes at 0xc7ee0 - db 001h, 000h, 000h, 000h, 000h, 001h, 000h, 000h, 000h, 000h, 000h, 000h, 02fh, 068h, 06fh, 06dh - db 065h, 02fh, 066h, 06dh, 033h, 02fh, 073h, 072h, 063h, 02fh, 076h, 062h, 06fh, 078h, 02dh, 034h - db 02eh, 033h, 02fh, 06fh, 075h, 074h, 02fh, 06ch, 069h, 06eh, 075h, 078h, 02eh, 061h, 06dh, 064h - db 036h, 034h, 02fh, 072h, 065h, 06ch, 065h, 061h, 073h, 065h, 02fh, 06fh, 062h, 06ah, 02fh, 056h - db 042h, 06fh, 078h, 056h, 067h, 061h, 042h, 069h, 06fh, 073h, 02fh, 056h, 042h, 06fh, 078h, 056h - db 067h, 061h, 042h, 069h, 06fh, 073h, 02eh, 073h, 079h, 06dh, 000h, 000h, 000h, 000h, 000h, 000h + ; Padding 0x11e bytes at 0xc7ee2 + db 000h, 000h, 000h, 000h, 001h, 000h, 000h, 000h, 000h, 000h, 000h, 02fh, 068h, 06fh, 06dh, 065h + db 02fh, 066h, 06dh, 033h, 02fh, 073h, 072h, 063h, 02fh, 076h, 062h, 06fh, 078h, 02dh, 034h, 02eh + db 033h, 02fh, 06fh, 075h, 074h, 02fh, 06ch, 069h, 06eh, 075h, 078h, 02eh, 061h, 06dh, 064h, 036h + db 034h, 02fh, 072h, 065h, 06ch, 065h, 061h, 073h, 065h, 02fh, 06fh, 062h, 06ah, 02fh, 056h, 042h + db 06fh, 078h, 056h, 067h, 061h, 042h, 069h, 06fh, 073h, 02fh, 056h, 042h, 06fh, 078h, 056h, 067h + db 061h, 042h, 069h, 06fh, 073h, 02eh, 073h, 079h, 06dh, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h @@ -7697,4 +7700,4 @@ section CONST2 progbits vstart=0x7ee0 align=1 ; size=0x0 class=DATA group=DGROUP db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h - db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 016h + db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 068h diff --git a/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.md5sum b/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.md5sum index 4f54140b9..cb2d80157 100644 --- a/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.md5sum +++ b/src/VBox/Devices/Graphics/BIOS/VBoxVgaBiosAlternative.md5sum @@ -1 +1 @@ -86355c5abda5dd1b0bf3f2f65828c6a1 *VBoxVgaBios.rom +25d0dc05c628f90ff6b5aa5e3987ba1f *VBoxVgaBios.rom diff --git a/src/VBox/Devices/Graphics/DevVGA.cpp b/src/VBox/Devices/Graphics/DevVGA.cpp index e55a4eda5..da28d9be4 100644 --- a/src/VBox/Devices/Graphics/DevVGA.cpp +++ b/src/VBox/Devices/Graphics/DevVGA.cpp @@ -5455,6 +5455,8 @@ static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint static DECLCALLBACK(int) vgaR3LoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) { #ifdef VBOX_WITH_HGSMI + PVGASTATE pThis = PDMINS_2_DATA(pDevIns, PVGASTATE); + VBVAPause(pThis, (pThis->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0); return vboxVBVALoadStateDone(pDevIns, pSSM); #else return VINF_SUCCESS; @@ -5474,6 +5476,9 @@ static DECLCALLBACK(void) vgaR3Reset(PPDMDEVINS pDevIns) char *pchEnd; LogFlow(("vgaReset\n")); + if (pThis->pVdma) + vboxVDMAReset(pThis->pVdma); + #ifdef VBOX_WITH_HGSMI VBVAReset(pThis); #endif /* VBOX_WITH_HGSMI */ @@ -5924,6 +5929,7 @@ static DECLCALLBACK(int) vgaR3Construct(PPDMDEVINS pDevIns, int iInstance, PCF pThis->IVBVACallbacks.pfnCrHgsmiControlCompleteAsync = vboxVDMACrHgsmiControlCompleteAsync; # endif #endif + pThis->IVBVACallbacks.pfnCrCtlSubmit = vboxCmdVBVACmdHostCtl; /* * We use our own critical section to avoid unncessary pointer indirections diff --git a/src/VBox/Devices/Graphics/DevVGA.h b/src/VBox/Devices/Graphics/DevVGA.h index f3617bb6e..aad2b43cc 100644 --- a/src/VBox/Devices/Graphics/DevVGA.h +++ b/src/VBox/Devices/Graphics/DevVGA.h @@ -292,7 +292,8 @@ typedef struct VGAState { # if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI)) /** LUN\#0: VBVA callbacks interface */ PDMIDISPLAYVBVACALLBACKS IVBVACallbacks; -# elif HC_ARCH_BITS == 32 +# endif +# if HC_ARCH_BITS == 32 uint32_t Padding0; # endif /** Pointer to base interface of the driver. */ @@ -624,6 +625,10 @@ int vboxVBVASaveStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM); int vboxVDMACrHgsmiCommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc); int vboxVDMACrHgsmiControlCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, int rc); # endif +int vboxCmdVBVACmdHostCtl(PPDMIDISPLAYVBVACALLBACKS pInterface, + struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, + PFNCRCTLCOMPLETION pfnCompletion, + void *pvCompletion); int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM); int vboxVBVALoadStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version); @@ -633,17 +638,17 @@ int vboxVBVALoadStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM); typedef struct VBOXVDMAHOST *PVBOXVDMAHOST; int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements); int vboxVDMADestruct(PVBOXVDMAHOST pVdma); +int vboxVDMAReset(PVBOXVDMAHOST pVdma); void vboxVDMAControl(PVBOXVDMAHOST pVdma, PVBOXVDMA_CTL pCmd, uint32_t cbCmd); void vboxVDMACommand(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd); int vboxVDMASaveStateExecPrep(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM); int vboxVDMASaveStateExecDone(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM); # endif /* VBOX_WITH_VDMA */ -int vboxCmdVBVAEnable(PVGASTATE pVGAState, VBVABUFFER *pVBVA); -int vboxCmdVBVADisable(PVGASTATE pVGAState); int vboxCmdVBVACmdSubmit(PVGASTATE pVGAState); int vboxCmdVBVACmdFlush(PVGASTATE pVGAState); void vboxCmdVBVACmdTimer(PVGASTATE pVGAState); +int vboxCmdVBVACmdCtl(PVGASTATE pVGAState, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl); #endif /* VBOX_WITH_HGSMI */ diff --git a/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp b/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp index e7dccbb59..ed727b13e 100644 --- a/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp +++ b/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp @@ -1939,6 +1939,32 @@ static DECLCALLBACK(int) vbvaChannelHandler (void *pvHandler, uint16_t u16Channe switch (u16ChannelInfo) { + case VBVA_CMDVBVA_SUBMIT: + { + rc = vboxCmdVBVACmdSubmit(pVGAState); + break; + } + case VBVA_CMDVBVA_FLUSH: + { + rc =vboxCmdVBVACmdFlush(pVGAState); + break; + } + case VBVA_CMDVBVA_CTL: + { + if (cbBuffer < VBoxSHGSMIBufferHeaderSize() + sizeof (VBOXCMDVBVA_CTL)) + { + Log(("buffer too small\n")); +#ifdef DEBUG_misha + AssertMsgFailed(("buffer too small\n")); +#endif + rc = VERR_INVALID_PARAMETER; + break; + } + + VBOXCMDVBVA_CTL *pCtl = (VBOXCMDVBVA_CTL*)VBoxSHGSMIBufferData((PVBOXSHGSMIHEADER)pvBuffer); + rc = vboxCmdVBVACmdCtl(pVGAState, pCtl, cbBuffer - VBoxSHGSMIBufferHeaderSize()); + break; + } #ifdef VBOX_WITH_VDMA case VBVA_VDMA_CMD: { @@ -2252,54 +2278,6 @@ static DECLCALLBACK(int) vbvaChannelHandler (void *pvHandler, uint16_t u16Channe pCaps->rc = VINF_SUCCESS; } break; #endif - - case VBVA_CMDVBVA_ENABLE: - { - if (cbBuffer < sizeof (VBVAENABLE)) - { - rc = VERR_INVALID_PARAMETER; - break; - } - - VBVAENABLE *pEnable = (VBVAENABLE *)pvBuffer; - - if ((pEnable->u32Flags & (VBVA_F_ENABLE | VBVA_F_DISABLE)) == VBVA_F_ENABLE) - { - uint32_t u32Offset = pEnable->u32Offset; - VBVABUFFER *pVBVA = (VBVABUFFER *)HGSMIOffsetToPointerHost (pIns, u32Offset); - - if (pVBVA) - rc = vboxCmdVBVAEnable(pVGAState, pVBVA); - else - { - LogRel(("Invalid VBVABUFFER offset 0x%x!!!\n", - pEnable->u32Offset)); - rc = VERR_INVALID_PARAMETER; - } - } - else if ((pEnable->u32Flags & (VBVA_F_ENABLE | VBVA_F_DISABLE)) == VBVA_F_DISABLE) - { - rc = vboxCmdVBVADisable(pVGAState); - } - else - { - LogRel(("Invalid VBVA_ENABLE flags 0x%x!!!\n", pEnable->u32Flags)); - rc = VERR_INVALID_PARAMETER; - } - - pEnable->i32Result = rc; - break; - } - case VBVA_CMDVBVA_SUBMIT: - { - rc = vboxCmdVBVACmdSubmit(pVGAState); - break; - } - case VBVA_CMDVBVA_FLUSH: - { - rc =vboxCmdVBVACmdFlush(pVGAState); - break; - } case VBVA_SCANLINE_CFG: { if (cbBuffer < sizeof (VBVASCANLINECFG)) diff --git a/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp b/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp index bdec54a28..0e35fe5a3 100644 --- a/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp +++ b/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp @@ -20,12 +20,22 @@ #include <iprt/thread.h> #include <iprt/mem.h> #include <iprt/asm.h> +#include <iprt/list.h> #include "DevVGA.h" #include "HGSMI/SHGSMIHost.h" #include "HGSMI/HGSMIHostHlp.h" #include <VBox/VBoxVideo3D.h> +#include <VBox/VBoxVideoHost3D.h> + +#ifdef DEBUG_misha +# define VBOXVDBG_MEMCACHE_DISABLE +#endif + +#ifndef VBOXVDBG_MEMCACHE_DISABLE +# include <iprt/memcache.h> +#endif #ifdef DEBUG_misha #define WARN_BP() do { AssertFailed(); } while (0) @@ -37,127 +47,733 @@ WARN_BP(); \ } while (0) -#ifdef VBOX_VDMA_WITH_WORKERTHREAD -typedef enum -{ - VBOXVDMAPIPE_STATE_CLOSED = 0, - VBOXVDMAPIPE_STATE_CREATED = 1, - VBOXVDMAPIPE_STATE_OPENNED = 2, - VBOXVDMAPIPE_STATE_CLOSING = 3 -} VBOXVDMAPIPE_STATE; +#define VBOXVDMATHREAD_STATE_TERMINATED 0 +#define VBOXVDMATHREAD_STATE_CREATED 1 +#define VBOXVDMATHREAD_STATE_TERMINATING 2 -typedef struct VBOXVDMAPIPE +typedef struct VBOXVDMATHREAD { + RTTHREAD hWorkerThread; RTSEMEVENT hEvent; - /* critical section for accessing pipe properties */ - RTCRITSECT hCritSect; - VBOXVDMAPIPE_STATE enmState; - /* true iff the other end needs Event notification */ - bool bNeedNotify; -} VBOXVDMAPIPE, *PVBOXVDMAPIPE; - -typedef enum -{ - VBOXVDMAPIPE_CMD_TYPE_UNDEFINED = 0, - VBOXVDMAPIPE_CMD_TYPE_DMACMD = 1, - VBOXVDMAPIPE_CMD_TYPE_DMACTL = 2 -} VBOXVDMAPIPE_CMD_TYPE; - -typedef struct VBOXVDMAPIPE_CMD_BODY -{ - VBOXVDMAPIPE_CMD_TYPE enmType; - union - { - PVBOXVDMACBUF_DR pDr; - PVBOXVDMA_CTL pCtl; - void *pvCmd; - } u; -}VBOXVDMAPIPE_CMD_BODY, *PVBOXVDMAPIPE_CMD_BODY; - -typedef struct VBOXVDMAPIPE_CMD -{ - HGSMILISTENTRY Entry; - VBOXVDMAPIPE_CMD_BODY Cmd; -} VBOXVDMAPIPE_CMD, *PVBOXVDMAPIPE_CMD; - -#define VBOXVDMAPIPE_CMD_FROM_ENTRY(_pE) ( (PVBOXVDMAPIPE_CMD)((uint8_t *)(_pE) - RT_OFFSETOF(VBOXVDMAPIPE_CMD, Entry)) ) - -typedef struct VBOXVDMAPIPE_CMD_POOL -{ - HGSMILIST List; - uint32_t cCmds; - VBOXVDMAPIPE_CMD aCmds[1]; -} VBOXVDMAPIPE_CMD_POOL, *PVBOXVDMAPIPE_CMD_POOL; -#endif + RTSEMEVENT hClientEvent; + volatile uint32_t u32State; +} VBOXVDMATHREAD, *PVBOXVDMATHREAD; /* state transformations: * * submitter | processor - * STOPPED - * | - * | - * > + * * LISTENING ---> PROCESSING - * ^ _/ - * | _/ - * | _/ - * | _/ - * | _/ - * | _/ - * | / - * < > - * PAUSED * * */ -#define VBVAEXHOSTCONTEXT_STATE_STOPPED 0 -#define VBVAEXHOSTCONTEXT_STATE_LISTENING 1 -#define VBVAEXHOSTCONTEXT_STATE_PROCESSING 2 -#define VBVAEXHOSTCONTEXT_STATE_PAUSED 3 +#define VBVAEXHOSTCONTEXT_STATE_LISTENING 0 +#define VBVAEXHOSTCONTEXT_STATE_PROCESSING 1 + +#define VBVAEXHOSTCONTEXT_ESTATE_DISABLED -1 +#define VBVAEXHOSTCONTEXT_ESTATE_PAUSED 0 +#define VBVAEXHOSTCONTEXT_ESTATE_ENABLED 1 typedef struct VBVAEXHOSTCONTEXT { VBVABUFFER *pVBVA; - uint32_t cbCurData; - volatile uint32_t u32State; - volatile uint32_t u32Pause; - volatile uint32_t u32cOtherCommands; + volatile int32_t i32State; + volatile int32_t i32EnableState; + volatile uint32_t u32cCtls; + /* critical section for accessing ctl lists */ + RTCRITSECT CltCritSect; + RTLISTANCHOR GuestCtlList; + RTLISTANCHOR HostCtlList; +#ifndef VBOXVDBG_MEMCACHE_DISABLE + RTMEMCACHE CtlCache; +#endif } VBVAEXHOSTCONTEXT; +typedef enum +{ + VBVAEXHOSTCTL_TYPE_UNDEFINED = 0, + VBVAEXHOSTCTL_TYPE_HH_INTERNAL_PAUSE, + VBVAEXHOSTCTL_TYPE_HH_INTERNAL_RESUME, + VBVAEXHOSTCTL_TYPE_HH_ENABLE, + VBVAEXHOSTCTL_TYPE_HH_TERM, + VBVAEXHOSTCTL_TYPE_HH_RESET, + VBVAEXHOSTCTL_TYPE_HH_SAVESTATE, + VBVAEXHOSTCTL_TYPE_HH_LOADSTATE, + VBVAEXHOSTCTL_TYPE_HH_BE_OPAQUE, + VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE, + VBVAEXHOSTCTL_TYPE_GH_ENABLE_DISABLE +} VBVAEXHOSTCTL_TYPE; + +struct VBVAEXHOSTCTL; + +typedef DECLCALLBACKPTR(void, PFNVBVAEXHOSTCTL_COMPLETE)(VBVAEXHOSTCONTEXT *pVbva, struct VBVAEXHOSTCTL *pCtl, int rc, void *pvComplete); + +typedef struct VBVAEXHOSTCTL +{ + RTLISTNODE Node; + VBVAEXHOSTCTL_TYPE enmType; + union + { + struct + { + uint8_t * pu8Cmd; + uint32_t cbCmd; + } cmd; + + struct + { + PSSMHANDLE pSSM; + uint32_t u32Version; + } state; + } u; + PFNVBVAEXHOSTCTL_COMPLETE pfnComplete; + void *pvComplete; +} VBVAEXHOSTCTL; + /* VBoxVBVAExHP**, i.e. processor functions, can NOT be called concurrently with each other, * but can be called with other VBoxVBVAExS** (submitter) functions except Init/Start/Term aparently. * Can only be called be the processor, i.e. the entity that acquired the processor state by direct or indirect call to the VBoxVBVAExHSCheckCommands * see mor edetailed comments in headers for function definitions */ -static bool VBoxVBVAExHPCmdCheckRelease(struct VBVAEXHOSTCONTEXT *pCmdVbva); -static int VBoxVBVAExHPCmdGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd); +typedef enum +{ + VBVAEXHOST_DATA_TYPE_NO_DATA = 0, + VBVAEXHOST_DATA_TYPE_CMD, + VBVAEXHOST_DATA_TYPE_HOSTCTL, + VBVAEXHOST_DATA_TYPE_GUESTCTL +} VBVAEXHOST_DATA_TYPE; +static VBVAEXHOST_DATA_TYPE VBoxVBVAExHPDataGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd); + +static void VBoxVBVAExHPDataCompleteCmd(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint32_t cbCmd); +static void VBoxVBVAExHPDataCompleteCtl(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL *pCtl, int rc); /* VBoxVBVAExHP**, i.e. processor functions, can NOT be called concurrently with each other, * can be called concurrently with istelf as well as with other VBoxVBVAEx** functions except Init/Start/Term aparently */ static int VBoxVBVAExHSCheckCommands(struct VBVAEXHOSTCONTEXT *pCmdVbva); -static void VBoxVBVAExHSInit(struct VBVAEXHOSTCONTEXT *pCmdVbva); +static int VBoxVBVAExHSInit(struct VBVAEXHOSTCONTEXT *pCmdVbva); static int VBoxVBVAExHSEnable(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVABUFFER *pVBVA); static int VBoxVBVAExHSDisable(struct VBVAEXHOSTCONTEXT *pCmdVbva); static void VBoxVBVAExHSTerm(struct VBVAEXHOSTCONTEXT *pCmdVbva); static int VBoxVBVAExHSSaveState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM); static int VBoxVBVAExHSLoadState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM, uint32_t u32Version); +static VBVAEXHOSTCTL* VBoxVBVAExHCtlAlloc(VBVAEXHOSTCONTEXT *pCmdVbva) +{ +#ifndef VBOXVDBG_MEMCACHE_DISABLE + return (VBVAEXHOSTCTL*)RTMemCacheAlloc(pCmdVbva->CtlCache); +#else + return (VBVAEXHOSTCTL*)RTMemAlloc(sizeof (VBVAEXHOSTCTL)); +#endif +} + +static void VBoxVBVAExHCtlFree(VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL *pCtl) +{ +#ifndef VBOXVDBG_MEMCACHE_DISABLE + RTMemCacheFree(pCmdVbva->CtlCache, pCtl); +#else + RTMemFree(pCtl); +#endif +} + +static VBVAEXHOSTCTL* VBoxVBVAExHCtlCreate(VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL_TYPE enmType) +{ + VBVAEXHOSTCTL* pCtl = VBoxVBVAExHCtlAlloc(pCmdVbva); + if (!pCtl) + { + WARN(("VBoxVBVAExHCtlAlloc failed\n")); + return NULL; + } + + pCtl->enmType = enmType; + return pCtl; +} + +static int vboxVBVAExHSProcessorAcquire(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + Assert(pCmdVbva->i32State >= VBVAEXHOSTCONTEXT_STATE_LISTENING); + + if (ASMAtomicCmpXchgS32(&pCmdVbva->i32State, VBVAEXHOSTCONTEXT_STATE_PROCESSING, VBVAEXHOSTCONTEXT_STATE_LISTENING)) + return VINF_SUCCESS; + return VERR_SEM_BUSY; +} + +static VBVAEXHOSTCTL* vboxVBVAExHPCheckCtl(struct VBVAEXHOSTCONTEXT *pCmdVbva, bool *pfHostCtl, bool fHostOnlyMode) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + + if(!fHostOnlyMode && !ASMAtomicUoReadU32(&pCmdVbva->u32cCtls)) + return NULL; + + int rc = RTCritSectEnter(&pCmdVbva->CltCritSect); + if (RT_SUCCESS(rc)) + { + VBVAEXHOSTCTL* pCtl = RTListGetFirst(&pCmdVbva->HostCtlList, VBVAEXHOSTCTL, Node); + if (pCtl) + *pfHostCtl = true; + else if (!fHostOnlyMode) + { + if (ASMAtomicUoReadS32(&pCmdVbva->i32EnableState) > VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + { + pCtl = RTListGetFirst(&pCmdVbva->GuestCtlList, VBVAEXHOSTCTL, Node); + /* pCtl can not be null here since pCmdVbva->u32cCtls is not null, + * and there are no HostCtl commands*/ + Assert(pCtl); + *pfHostCtl = false; + } + } + + if (pCtl) + { + RTListNodeRemove(&pCtl->Node); + ASMAtomicDecU32(&pCmdVbva->u32cCtls); + } + + RTCritSectLeave(&pCmdVbva->CltCritSect); + + return pCtl; + } + else + WARN(("RTCritSectEnter failed %d\n", rc)); + + return NULL; +} + +static VBVAEXHOSTCTL* VBoxVBVAExHPCheckHostCtlOnDisable(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + bool fHostCtl; + return vboxVBVAExHPCheckCtl(pCmdVbva, &fHostCtl, true); +} + + +static bool vboxVBVAExHPCheckProcessCtlInternal(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL* pCtl) +{ + switch (pCtl->enmType) + { + case VBVAEXHOSTCTL_TYPE_HH_INTERNAL_PAUSE: + if (pCmdVbva->i32EnableState > VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + ASMAtomicWriteS32(&pCmdVbva->i32EnableState, VBVAEXHOSTCONTEXT_ESTATE_PAUSED); + return true; + case VBVAEXHOSTCTL_TYPE_HH_INTERNAL_RESUME: + if (pCmdVbva->i32EnableState == VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + ASMAtomicWriteS32(&pCmdVbva->i32EnableState, VBVAEXHOSTCONTEXT_ESTATE_ENABLED); + return true; + default: + return false; + } +} + +static void vboxVBVAExHPProcessorRelease(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + + ASMAtomicWriteS32(&pCmdVbva->i32State, VBVAEXHOSTCONTEXT_STATE_LISTENING); +} + +static void vboxVBVAExHPHgEventSet(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + if (pCmdVbva->pVBVA) + ASMAtomicOrU32(&pCmdVbva->pVBVA->hostFlags.u32HostEvents, VBVA_F_STATE_PROCESSING); +} + +static void vboxVBVAExHPHgEventClear(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + if (pCmdVbva->pVBVA) + ASMAtomicAndU32(&pCmdVbva->pVBVA->hostFlags.u32HostEvents, ~VBVA_F_STATE_PROCESSING); +} + +static int vboxVBVAExHPCmdGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + Assert(pCmdVbva->i32EnableState > VBVAEXHOSTCONTEXT_ESTATE_PAUSED); + + VBVABUFFER *pVBVA = pCmdVbva->pVBVA; + + uint32_t indexRecordFirst = pVBVA->indexRecordFirst; + uint32_t indexRecordFree = pVBVA->indexRecordFree; + + Log(("first = %d, free = %d\n", + indexRecordFirst, indexRecordFree)); + + if (indexRecordFirst == indexRecordFree) + { + /* No records to process. Return without assigning output variables. */ + return VINF_EOF; + } + + uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVBVA->aRecords[indexRecordFirst].cbRecord); + + /* A new record need to be processed. */ + if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL) + { + /* the record is being recorded, try again */ + return VINF_TRY_AGAIN; + } + + uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL; + + if (!cbRecord) + { + /* the record is being recorded, try again */ + return VINF_TRY_AGAIN; + } + + /* we should not get partial commands here actually */ + Assert(cbRecord); + + /* The size of largest contiguous chunk in the ring biffer. */ + uint32_t u32BytesTillBoundary = pVBVA->cbData - pVBVA->off32Data; + + /* The pointer to data in the ring buffer. */ + uint8_t *pSrc = &pVBVA->au8Data[pVBVA->off32Data]; + + /* Fetch or point the data. */ + if (u32BytesTillBoundary >= cbRecord) + { + /* The command does not cross buffer boundary. Return address in the buffer. */ + *ppCmd = pSrc; + *pcbCmd = cbRecord; + return VINF_SUCCESS; + } + + LogRel(("CmdVbva: cross-bound writes unsupported\n")); + return VERR_INVALID_STATE; +} + +static void VBoxVBVAExHPDataCompleteCmd(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint32_t cbCmd) +{ + VBVABUFFER *pVBVA = pCmdVbva->pVBVA; + pVBVA->off32Data = (pVBVA->off32Data + cbCmd) % pVBVA->cbData; + + pVBVA->indexRecordFirst = (pVBVA->indexRecordFirst + 1) % RT_ELEMENTS(pVBVA->aRecords); +} + +static void VBoxVBVAExHPDataCompleteCtl(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL *pCtl, int rc) +{ + if (pCtl->pfnComplete) + pCtl->pfnComplete(pCmdVbva, pCtl, rc, pCtl->pvComplete); + else + VBoxVBVAExHCtlFree(pCmdVbva, pCtl); +} + +static VBVAEXHOST_DATA_TYPE vboxVBVAExHPDataGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd) +{ + Assert(pCmdVbva->i32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); + VBVAEXHOSTCTL*pCtl; + bool fHostClt; + + for(;;) + { + pCtl = vboxVBVAExHPCheckCtl(pCmdVbva, &fHostClt, false); + if (pCtl) + { + if (fHostClt) + { + if (!vboxVBVAExHPCheckProcessCtlInternal(pCmdVbva, pCtl)) + { + *ppCmd = (uint8_t*)pCtl; + *pcbCmd = sizeof (*pCtl); + return VBVAEXHOST_DATA_TYPE_HOSTCTL; + } + } + else + { + *ppCmd = (uint8_t*)pCtl; + *pcbCmd = sizeof (*pCtl); + return VBVAEXHOST_DATA_TYPE_GUESTCTL; + } + } + + if (ASMAtomicUoReadS32(&pCmdVbva->i32EnableState) <= VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + return VBVAEXHOST_DATA_TYPE_NO_DATA; + + int rc = vboxVBVAExHPCmdGet(pCmdVbva, ppCmd, pcbCmd); + switch (rc) + { + case VINF_SUCCESS: + return VBVAEXHOST_DATA_TYPE_CMD; + case VINF_EOF: + return VBVAEXHOST_DATA_TYPE_NO_DATA; + case VINF_TRY_AGAIN: + RTThreadSleep(1); + continue; + default: + /* this is something really unexpected, i.e. most likely guest has written something incorrect to the VBVA buffer */ + WARN(("Warning: vboxVBVAExHCmdGet returned unexpected status %d\n", rc)); + return VBVAEXHOST_DATA_TYPE_NO_DATA; + } + } + + WARN(("Warning: VBoxVBVAExHCmdGet unexpected state\n")); + return VBVAEXHOST_DATA_TYPE_NO_DATA; +} + +static VBVAEXHOST_DATA_TYPE VBoxVBVAExHPDataGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd) +{ + VBVAEXHOST_DATA_TYPE enmType = vboxVBVAExHPDataGet(pCmdVbva, ppCmd, pcbCmd); + if (enmType == VBVAEXHOST_DATA_TYPE_NO_DATA) + { + vboxVBVAExHPHgEventClear(pCmdVbva); + vboxVBVAExHPProcessorRelease(pCmdVbva); + /* we need to prevent racing between us clearing the flag and command check/submission thread, i.e. + * 1. we check the queue -> and it is empty + * 2. submitter adds command to the queue + * 3. submitter checks the "processing" -> and it is true , thus it does not submit a notification + * 4. we clear the "processing" state + * 5. ->here we need to re-check the queue state to ensure we do not leak the notification of the above command + * 6. if the queue appears to be not-empty set the "processing" state back to "true" + **/ + int rc = vboxVBVAExHSProcessorAcquire(pCmdVbva); + if (RT_SUCCESS(rc)) + { + /* we are the processor now */ + enmType = vboxVBVAExHPDataGet(pCmdVbva, ppCmd, pcbCmd); + if (enmType == VBVAEXHOST_DATA_TYPE_NO_DATA) + { + vboxVBVAExHPProcessorRelease(pCmdVbva); + return VBVAEXHOST_DATA_TYPE_NO_DATA; + } + + vboxVBVAExHPHgEventSet(pCmdVbva); + } + } + + return enmType; +} + +DECLINLINE(bool) vboxVBVAExHSHasCommands(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + VBVABUFFER *pVBVA = pCmdVbva->pVBVA; + + if (pVBVA) + { + uint32_t indexRecordFirst = pVBVA->indexRecordFirst; + uint32_t indexRecordFree = pVBVA->indexRecordFree; + + if (indexRecordFirst != indexRecordFree) + return true; + } + + return !!ASMAtomicReadU32(&pCmdVbva->u32cCtls); +} + +/* Checks whether the new commands are ready for processing + * @returns + * VINF_SUCCESS - there are commands are in a queue, and the given thread is now the processor (i.e. typically it would delegate processing to a worker thread) + * VINF_EOF - no commands in a queue + * VINF_ALREADY_INITIALIZED - another thread already processing the commands + * VERR_INVALID_STATE - the VBVA is paused or pausing */ +static int VBoxVBVAExHSCheckCommands(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + int rc = vboxVBVAExHSProcessorAcquire(pCmdVbva); + if (RT_SUCCESS(rc)) + { + /* we are the processor now */ + if (vboxVBVAExHSHasCommands(pCmdVbva)) + { + vboxVBVAExHPHgEventSet(pCmdVbva); + return VINF_SUCCESS; + } + + vboxVBVAExHPProcessorRelease(pCmdVbva); + return VINF_EOF; + } + if (rc == VERR_SEM_BUSY) + return VINF_ALREADY_INITIALIZED; + return VERR_INVALID_STATE; +} + +static int VBoxVBVAExHSInit(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + memset(pCmdVbva, 0, sizeof (*pCmdVbva)); + int rc = RTCritSectInit(&pCmdVbva->CltCritSect); + if (RT_SUCCESS(rc)) + { +#ifndef VBOXVDBG_MEMCACHE_DISABLE + rc = RTMemCacheCreate(&pCmdVbva->CtlCache, sizeof (VBVAEXHOSTCTL), + 0, /* size_t cbAlignment */ + UINT32_MAX, /* uint32_t cMaxObjects */ + NULL, /* PFNMEMCACHECTOR pfnCtor*/ + NULL, /* PFNMEMCACHEDTOR pfnDtor*/ + NULL, /* void *pvUser*/ + 0 /* uint32_t fFlags*/ + ); + if (RT_SUCCESS(rc)) +#endif + { + RTListInit(&pCmdVbva->GuestCtlList); + RTListInit(&pCmdVbva->HostCtlList); + pCmdVbva->i32State = VBVAEXHOSTCONTEXT_STATE_PROCESSING; + pCmdVbva->i32EnableState = VBVAEXHOSTCONTEXT_ESTATE_DISABLED; + return VINF_SUCCESS; + } +#ifndef VBOXVDBG_MEMCACHE_DISABLE + else + WARN(("RTMemCacheCreate failed %d\n", rc)); +#endif + } + else + WARN(("RTCritSectInit failed %d\n", rc)); + + return rc; +} + +DECLINLINE(bool) VBoxVBVAExHSIsEnabled(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + return (ASMAtomicUoReadS32(&pCmdVbva->i32EnableState) >= VBVAEXHOSTCONTEXT_ESTATE_PAUSED); +} + +static int VBoxVBVAExHSEnable(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVABUFFER *pVBVA) +{ + if (VBoxVBVAExHSIsEnabled(pCmdVbva)) + return VINF_ALREADY_INITIALIZED; + + pCmdVbva->pVBVA = pVBVA; + pCmdVbva->pVBVA->hostFlags.u32HostEvents = 0; + ASMAtomicWriteS32(&pCmdVbva->i32EnableState, VBVAEXHOSTCONTEXT_ESTATE_ENABLED); + return VINF_SUCCESS; +} + +static int VBoxVBVAExHSDisable(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + if (!VBoxVBVAExHSIsEnabled(pCmdVbva)) + return VINF_SUCCESS; + + ASMAtomicWriteS32(&pCmdVbva->i32EnableState, VBVAEXHOSTCONTEXT_ESTATE_DISABLED); + return VINF_SUCCESS; +} + +static void VBoxVBVAExHSTerm(struct VBVAEXHOSTCONTEXT *pCmdVbva) +{ + /* ensure the processor is stopped */ + Assert(pCmdVbva->i32State >= VBVAEXHOSTCONTEXT_STATE_LISTENING); + + /* ensure no one tries to submit the command */ + if (pCmdVbva->pVBVA) + pCmdVbva->pVBVA->hostFlags.u32HostEvents = 0; + + Assert(RTListIsEmpty(&pCmdVbva->GuestCtlList)); + Assert(RTListIsEmpty(&pCmdVbva->HostCtlList)); + + RTCritSectDelete(&pCmdVbva->CltCritSect); + +#ifndef VBOXVDBG_MEMCACHE_DISABLE + RTMemCacheDestroy(pCmdVbva->CtlCache); +#endif + + memset(pCmdVbva, 0, sizeof (*pCmdVbva)); +} + +/* Saves state + * @returns - same as VBoxVBVAExHSCheckCommands, or failure on load state fail + */ +static int VBoxVBVAExHSSaveState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM) +{ + int rc; + + int32_t i32EnableState = ASMAtomicUoReadS32(&pCmdVbva->i32EnableState); + if (i32EnableState >= VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + { + if (i32EnableState != VBVAEXHOSTCONTEXT_ESTATE_PAUSED) + { + WARN(("vbva not paused\n")); + return VERR_INVALID_STATE; + } + + rc = SSMR3PutU32(pSSM, (uint32_t)(((uint8_t*)pCmdVbva->pVBVA) - pu8VramBase)); + AssertRCReturn(rc, rc); + return VINF_SUCCESS; + } + + rc = SSMR3PutU32(pSSM, 0xffffffff); + AssertRCReturn(rc, rc); + + return VINF_SUCCESS; +} + +typedef enum +{ + VBVAEXHOSTCTL_SOURCE_GUEST = 0, + VBVAEXHOSTCTL_SOURCE_HOST_ANY, + VBVAEXHOSTCTL_SOURCE_HOST_ENABLED +} VBVAEXHOSTCTL_SOURCE; + + +static int VBoxVBVAExHCtlSubmit(VBVAEXHOSTCONTEXT *pCmdVbva, VBVAEXHOSTCTL* pCtl, VBVAEXHOSTCTL_SOURCE enmSource, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete) +{ + if ((enmSource == VBVAEXHOSTCTL_SOURCE_HOST_ENABLED) && !VBoxVBVAExHSIsEnabled(pCmdVbva)) + { + WARN(("cmd vbva not enabled\n")); + return VERR_INVALID_STATE; + } + + pCtl->pfnComplete = pfnComplete; + pCtl->pvComplete = pvComplete; + + int rc = RTCritSectEnter(&pCmdVbva->CltCritSect); + if (RT_SUCCESS(rc)) + { + if (enmSource > VBVAEXHOSTCTL_SOURCE_GUEST) + { + if ((enmSource == VBVAEXHOSTCTL_SOURCE_HOST_ENABLED) && !VBoxVBVAExHSIsEnabled(pCmdVbva)) + { + WARN(("cmd vbva not enabled\n")); + RTCritSectLeave(&pCmdVbva->CltCritSect); + return VERR_INVALID_STATE; + } + RTListAppend(&pCmdVbva->HostCtlList, &pCtl->Node); + } + else + RTListAppend(&pCmdVbva->GuestCtlList, &pCtl->Node); + + ASMAtomicIncU32(&pCmdVbva->u32cCtls); + + RTCritSectLeave(&pCmdVbva->CltCritSect); + + rc = VBoxVBVAExHSCheckCommands(pCmdVbva); + } + else + WARN(("RTCritSectEnter failed %d\n", rc)); + + return rc; +} + + +/* Loads state + * @returns - same as VBoxVBVAExHSCheckCommands, or failure on load state fail + */ +static int VBoxVBVAExHSLoadState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM, uint32_t u32Version) +{ + AssertMsgFailed(("implement!\n")); + uint32_t u32; + int rc = SSMR3GetU32(pSSM, &u32); + AssertRCReturn(rc, rc); + if (u32 != 0xffffffff) + { + VBVABUFFER *pVBVA = (VBVABUFFER*)pu8VramBase + u32; + rc = VBoxVBVAExHSEnable(pCmdVbva, pVBVA); + AssertRCReturn(rc, rc); + return VBoxVBVAExHSCheckCommands(pCmdVbva); + } + + return VINF_SUCCESS; +} + typedef struct VBOXVDMAHOST { PHGSMIINSTANCE pHgsmi; PVGASTATE pVGAState; VBVAEXHOSTCONTEXT CmdVbva; + VBOXVDMATHREAD Thread; + VBOXCRCMD_SVRINFO CrSrvInfo; + VBVAEXHOSTCTL* pCurRemainingHostCtl; #ifdef VBOX_VDMA_WITH_WATCHDOG PTMTIMERR3 WatchDogTimer; #endif -#ifdef VBOX_VDMA_WITH_WORKERTHREAD - VBOXVDMAPIPE Pipe; - HGSMILIST PendingList; - RTTHREAD hWorkerThread; - VBOXVDMAPIPE_CMD_POOL CmdPool; -#endif } VBOXVDMAHOST, *PVBOXVDMAHOST; +int VBoxVDMAThreadNotifyConstructSucceeded(PVBOXVDMATHREAD pThread) +{ + Assert(pThread->u32State == VBOXVDMATHREAD_STATE_TERMINATED); + pThread->u32State = VBOXVDMATHREAD_STATE_CREATED; + int rc = RTSemEventSignal(pThread->hClientEvent); + AssertRC(rc); + return VINF_SUCCESS; +} + +int VBoxVDMAThreadNotifyConstructFailed(PVBOXVDMATHREAD pThread) +{ + Assert(pThread->u32State == VBOXVDMATHREAD_STATE_TERMINATED); + int rc = RTSemEventSignal(pThread->hClientEvent); + AssertRC(rc); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rc; +} + +DECLINLINE(bool) VBoxVDMAThreadIsTerminating(PVBOXVDMATHREAD pThread) +{ + return ASMAtomicUoReadU32(&pThread->u32State) == VBOXVDMATHREAD_STATE_TERMINATING; +} + +int VBoxVDMAThreadCreate(PVBOXVDMATHREAD pThread, PFNRTTHREAD pfnThread, void *pvThread) +{ + int rc = RTSemEventCreate(&pThread->hEvent); + if (RT_SUCCESS(rc)) + { + rc = RTSemEventCreate(&pThread->hClientEvent); + if (RT_SUCCESS(rc)) + { + pThread->u32State = VBOXVDMATHREAD_STATE_TERMINATED; + rc = RTThreadCreate(&pThread->hWorkerThread, pfnThread, pvThread, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "VDMA"); + if (RT_SUCCESS(rc)) + { + rc = RTSemEventWait(pThread->hClientEvent, RT_INDEFINITE_WAIT); + if (RT_SUCCESS(rc)) + { + if (pThread->u32State == VBOXVDMATHREAD_STATE_CREATED) + return VINF_SUCCESS; + WARN(("thread routine failed the initialization\n")); + rc = VERR_INVALID_STATE; + } + else + WARN(("RTSemEventWait failed %d\n", rc)); + + RTThreadWait(pThread->hWorkerThread, RT_INDEFINITE_WAIT, NULL); + } + else + WARN(("RTThreadCreate failed %d\n", rc)); + + RTSemEventDestroy(pThread->hClientEvent); + } + else + WARN(("RTSemEventCreate failed %d\n", rc)); + + RTSemEventDestroy(pThread->hEvent); + } + else + WARN(("RTSemEventCreate failed %d\n", rc)); + + return rc; +} + +DECLINLINE(int) VBoxVDMAThreadEventNotify(PVBOXVDMATHREAD pThread) +{ + int rc = RTSemEventSignal(pThread->hEvent); + AssertRC(rc); + return rc; +} + +DECLINLINE(int) VBoxVDMAThreadEventWait(PVBOXVDMATHREAD pThread, RTMSINTERVAL cMillies) +{ + int rc = RTSemEventWait(pThread->hEvent, cMillies); + AssertRC(rc); + return rc; +} + +void VBoxVDMAThreadMarkTerminating(PVBOXVDMATHREAD pThread) +{ + Assert(pThread->u32State == VBOXVDMATHREAD_STATE_CREATED); + ASMAtomicWriteU32(&pThread->u32State, VBOXVDMATHREAD_STATE_TERMINATING); +} + +void VBoxVDMAThreadTerm(PVBOXVDMATHREAD pThread) +{ + int rc; + if (ASMAtomicReadU32(&pThread->u32State) != VBOXVDMATHREAD_STATE_TERMINATING) + { + VBoxVDMAThreadMarkTerminating(pThread); + rc = VBoxVDMAThreadEventNotify(pThread); + AssertRC(rc); + } + rc = RTThreadWait(pThread->hWorkerThread, RT_INDEFINITE_WAIT, NULL); + AssertRC(rc); + RTSemEventDestroy(pThread->hClientEvent); + RTSemEventDestroy(pThread->hEvent); +} + +static int vdmaVBVACtlSubmitSync(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL* pCtl, VBVAEXHOSTCTL_SOURCE enmSource); #ifdef VBOX_WITH_CRHGSMI @@ -248,7 +864,7 @@ static int vboxVDMACrCtlPost(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd AssertRC(rc); if(RT_SUCCESS(rc)) { - rc = vboxVDMACrCtlPostAsync (pVGAState, pCmd, cbCmd, vboxVDMACrCtlCbSetEvent, (void*)hComplEvent); + rc = vboxVDMACrCtlPostAsync(pVGAState, pCmd, cbCmd, vboxVDMACrCtlCbSetEvent, (void*)hComplEvent); #ifdef DEBUG_misha AssertRC(rc); #endif @@ -270,17 +886,279 @@ static int vboxVDMACrCtlPost(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd return rc; } -static void vboxVDMACrCmdNotifyPerform(struct VBOXVDMAHOST *pVdma) +typedef struct VDMA_VBVA_CTL_CYNC_COMPLETION { + int rc; + RTSEMEVENT hEvent; +} VDMA_VBVA_CTL_CYNC_COMPLETION; + +static DECLCALLBACK(void) vboxVDMACrHgcmSubmitSyncCompletion(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion) +{ + VDMA_VBVA_CTL_CYNC_COMPLETION *pData = (VDMA_VBVA_CTL_CYNC_COMPLETION*)pvCompletion; + pData->rc = rc; + rc = RTSemEventSignal(pData->hEvent); + if (!RT_SUCCESS(rc)) + WARN(("RTSemEventSignal failed %d\n", rc)); +} + +static int vboxVDMACrHgcmSubmitSync(struct VBOXVDMAHOST *pVdma, VBOXCRCMDCTL* pCtl, uint32_t cbCtl) +{ + VDMA_VBVA_CTL_CYNC_COMPLETION Data; + Data.rc = VERR_NOT_IMPLEMENTED; + int rc = RTSemEventCreate(&Data.hEvent); + if (!RT_SUCCESS(rc)) + { + WARN(("RTSemEventCreate failed %d\n", rc)); + return rc; + } + PVGASTATE pVGAState = pVdma->pVGAState; - pVGAState->pDrv->pfnCrCmdNotifyCmds(pVGAState->pDrv); + rc = pVGAState->pDrv->pfnCrHgcmCtlSubmit(pVGAState->pDrv, pCtl, cbCtl, vboxVDMACrHgcmSubmitSyncCompletion, &Data); + if (RT_SUCCESS(rc)) + { + rc = RTSemEventWait(Data.hEvent, RT_INDEFINITE_WAIT); + if (RT_SUCCESS(rc)) + { + rc = Data.rc; + if (!RT_SUCCESS(rc)) + { + WARN(("pfnCrHgcmCtlSubmit command failed %d\n", rc)); + } + + } + else + WARN(("RTSemEventWait failed %d\n", rc)); + } + else + WARN(("pfnCrHgcmCtlSubmit failed %d\n", rc)); + + + RTSemEventDestroy(Data.hEvent); + + return rc; +} + +static DECLCALLBACK(uint8_t*) vboxVDMACrHgcmHandleEnableRemainingHostCommand(HVBOXCRCMDCTL_REMAINING_HOST_COMMAND hClient, uint32_t *pcbCtl, int prevCmdRc) +{ + struct VBOXVDMAHOST *pVdma = hClient; + if (!pVdma->pCurRemainingHostCtl) + { + /* disable VBVA, all subsequent host commands will go HGCM way */ + VBoxVBVAExHSDisable(&pVdma->CmdVbva); + } + else + { + VBoxVBVAExHPDataCompleteCtl(&pVdma->CmdVbva, pVdma->pCurRemainingHostCtl, prevCmdRc); + } + + pVdma->pCurRemainingHostCtl = VBoxVBVAExHPCheckHostCtlOnDisable(&pVdma->CmdVbva); + if (pVdma->pCurRemainingHostCtl) + { + *pcbCtl = pVdma->pCurRemainingHostCtl->u.cmd.cbCmd; + return pVdma->pCurRemainingHostCtl->u.cmd.pu8Cmd; + } + + *pcbCtl = 0; + return NULL; +} + +static int vboxVDMACrHgcmHandleEnable(struct VBOXVDMAHOST *pVdma) +{ + VBOXCRCMDCTL_ENABLE Enable; + Enable.Hdr.enmType = VBOXCRCMDCTL_TYPE_ENABLE; + Enable.hRHCmd = pVdma; + Enable.pfnRHCmd = vboxVDMACrHgcmHandleEnableRemainingHostCommand; + + int rc = vboxVDMACrHgcmSubmitSync(pVdma, &Enable.Hdr, sizeof (Enable)); + Assert(!pVdma->pCurRemainingHostCtl); + if (RT_SUCCESS(rc)) + { + Assert(!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)); + return VINF_SUCCESS; + } + + Assert(VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)); + WARN(("vboxVDMACrHgcmSubmitSync failed %d\n", rc)); + + return rc; } +static int vdmaVBVAEnableProcess(struct VBOXVDMAHOST *pVdma, uint32_t u32Offset) +{ + if (VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + WARN(("vdma VBVA is already enabled\n")); + return VERR_INVALID_STATE; + } + + VBVABUFFER *pVBVA = (VBVABUFFER *)HGSMIOffsetToPointerHost(pVdma->pHgsmi, u32Offset); + if (!pVBVA) + { + WARN(("invalid offset %d\n", u32Offset)); + return VERR_INVALID_PARAMETER; + } + + if (!pVdma->CrSrvInfo.pfnEnable) + { +#ifdef DEBUG_misha + WARN(("pfnEnable is NULL\n")); + return VERR_NOT_SUPPORTED; +#endif + } + + int rc = VBoxVBVAExHSEnable(&pVdma->CmdVbva, pVBVA); + if (RT_SUCCESS(rc)) + { + VBOXCRCMDCTL Ctl; + Ctl.enmType = VBOXCRCMDCTL_TYPE_DISABLE; + rc = vboxVDMACrHgcmSubmitSync(pVdma, &Ctl, sizeof (Ctl)); + if (RT_SUCCESS(rc)) + { + PVGASTATE pVGAState = pVdma->pVGAState; + VBOXCRCMD_SVRENABLE_INFO Info; + Info.hCltScr = pVGAState->pDrv; + Info.pfnCltScrUpdateBegin = pVGAState->pDrv->pfnVBVAUpdateBegin; + Info.pfnCltScrUpdateProcess = pVGAState->pDrv->pfnVBVAUpdateProcess; + Info.pfnCltScrUpdateEnd = pVGAState->pDrv->pfnVBVAUpdateEnd; + rc = pVdma->CrSrvInfo.pfnEnable(pVdma->CrSrvInfo.hSvr, &Info); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + else + WARN(("pfnEnable failed %d\n", rc)); + + vboxVDMACrHgcmHandleEnable(pVdma); + } + else + WARN(("vboxVDMACrHgcmSubmitSync failed %d\n", rc)); + + VBoxVBVAExHSDisable(&pVdma->CmdVbva); + } + else + WARN(("VBoxVBVAExHSEnable failed %d\n", rc)); + + return rc; +} + +static int vdmaVBVADisableProcess(struct VBOXVDMAHOST *pVdma) +{ + if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + Log(("vdma VBVA is already disabled\n")); + return VINF_SUCCESS; + } + + int rc = pVdma->CrSrvInfo.pfnDisable(pVdma->CrSrvInfo.hSvr); + if (RT_SUCCESS(rc)) + { + /* disable is a bit tricky + * we need to ensure the host ctl commands do not come out of order + * and do not come over HGCM channel until after it is enabled */ + rc = vboxVDMACrHgcmHandleEnable(pVdma); + if (RT_SUCCESS(rc)) + return rc; + + PVGASTATE pVGAState = pVdma->pVGAState; + VBOXCRCMD_SVRENABLE_INFO Info; + Info.hCltScr = pVGAState->pDrv; + Info.pfnCltScrUpdateBegin = pVGAState->pDrv->pfnVBVAUpdateBegin; + Info.pfnCltScrUpdateProcess = pVGAState->pDrv->pfnVBVAUpdateProcess; + Info.pfnCltScrUpdateEnd = pVGAState->pDrv->pfnVBVAUpdateEnd; + pVdma->CrSrvInfo.pfnEnable(pVdma->CrSrvInfo.hSvr, &Info); + } + else + WARN(("pfnDisable failed %d\n", rc)); + + return rc; +} + +static int vboxVDMACrHostCtlProcess(struct VBOXVDMAHOST *pVdma, VBVAEXHOSTCTL *pCmd) +{ + switch (pCmd->enmType) + { + case VBVAEXHOSTCTL_TYPE_HH_SAVESTATE: + if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + WARN(("VBVAEXHOSTCTL_TYPE_HH_SAVESTATE for disabled vdma VBVA\n")); + return VERR_INVALID_STATE; + } + return pVdma->CrSrvInfo.pfnSaveState(pVdma->CrSrvInfo.hSvr, pCmd->u.state.pSSM); + case VBVAEXHOSTCTL_TYPE_HH_LOADSTATE: + if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + WARN(("VBVAEXHOSTCTL_TYPE_HH_LOADSTATE for disabled vdma VBVA\n")); + return VERR_INVALID_STATE; + } + return pVdma->CrSrvInfo.pfnLoadState(pVdma->CrSrvInfo.hSvr, pCmd->u.state.pSSM, pCmd->u.state.u32Version); + case VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE: + if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + WARN(("VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE for disabled vdma VBVA\n")); + return VERR_INVALID_STATE; + } + return pVdma->CrSrvInfo.pfnHostCtl(pVdma->CrSrvInfo.hSvr, pCmd->u.cmd.pu8Cmd, pCmd->u.cmd.cbCmd); + case VBVAEXHOSTCTL_TYPE_HH_TERM: + { + int rc = vdmaVBVADisableProcess(pVdma); + if (!RT_SUCCESS(rc)) + { + WARN(("vdmaVBVADisableProcess failed %d\n", rc)); + return rc; + } + + VBoxVDMAThreadMarkTerminating(&pVdma->Thread); + return VINF_SUCCESS; + } + case VBVAEXHOSTCTL_TYPE_HH_RESET: + { + int rc = vdmaVBVADisableProcess(pVdma); + if (!RT_SUCCESS(rc)) + { + WARN(("vdmaVBVADisableProcess failed %d\n", rc)); + return rc; + } + return VINF_SUCCESS; + } + default: + WARN(("unexpected host ctl type %d\n", pCmd->enmType)); + return VERR_INVALID_PARAMETER; + } +} + +static int vboxVDMACrGuestCtlProcess(struct VBOXVDMAHOST *pVdma, VBVAEXHOSTCTL *pCmd) +{ + switch (pCmd->enmType) + { + case VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE: + if (!VBoxVBVAExHSIsEnabled(&pVdma->CmdVbva)) + { + WARN(("VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE for disabled vdma VBVA\n")); + return VERR_INVALID_STATE; + } + return pVdma->CrSrvInfo.pfnGuestCtl(pVdma->CrSrvInfo.hSvr, pCmd->u.cmd.pu8Cmd, pCmd->u.cmd.cbCmd); + case VBVAEXHOSTCTL_TYPE_GH_ENABLE_DISABLE: + { + VBVAENABLE *pEnable = (VBVAENABLE *)pCmd->u.cmd.pu8Cmd; + Assert(pCmd->u.cmd.cbCmd == sizeof (VBVAENABLE)); + if ((pEnable->u32Flags & (VBVA_F_ENABLE | VBVA_F_DISABLE)) == VBVA_F_ENABLE) + { + uint32_t u32Offset = pEnable->u32Offset; + return vdmaVBVAEnableProcess(pVdma, u32Offset); + } + + return vdmaVBVADisableProcess(pVdma); + } + default: + WARN(("unexpected ctl type %d\n", pCmd->enmType)); + return VERR_INVALID_PARAMETER; + } +} + + /* * @returns * */ -static int vboxVDMACrCmdPreprocess(struct VBOXVDMAHOST *pVdma, uint8_t* pu8Cmd, uint32_t cbCmd) +static int vboxVDMACrCmdProcess(struct VBOXVDMAHOST *pVdma, uint8_t* pu8Cmd, uint32_t cbCmd) { if (*pu8Cmd == VBOXCMDVBVA_OPTYPE_NOP) return VINF_EOF; @@ -298,96 +1176,74 @@ static int vboxVDMACrCmdPreprocess(struct VBOXVDMAHOST *pVdma, uint8_t* pu8Cmd, switch (pCmd->u8OpCode) { case VBOXCMDVBVA_OPTYPE_NOPCMD: - pCmd->i8Result = 0; + pCmd->u.i8Result = 0; return VINF_EOF; default: return VINF_SUCCESS; } } -static DECLCALLBACK(int) vboxVDMACrCmdCltCmdGet(HVBOXCRCMDCLT hClt, PVBOXCMDVBVA_HDR *ppNextCmd, uint32_t *pcbNextCmd) +static DECLCALLBACK(int) vboxVDMACrCmdEnable(HVBOXCRCMDSVR hSvr, VBOXCRCMD_SVRENABLE_INFO *pInfo) { - struct VBOXVDMAHOST *pVdma = hClt; + return VINF_SUCCESS; +} - VBoxVBVAExHPCmdCheckRelease(&pVdma->CmdVbva); +static DECLCALLBACK(void) vboxVDMACrCmdDisable(HVBOXCRCMDSVR hSvr) +{ +} - uint32_t cbCmd; - uint8_t *pu8Cmd; +static DECLCALLBACK(int) vboxVDMACrCmdCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd) +{ + return VERR_NOT_SUPPORTED; +} - for(;;) +static DECLCALLBACK(int) vboxVDMACrCmdCmd(HVBOXCRCMDSVR hSvr, PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd) +{ + switch (pCmd->u8OpCode) { - int rc = VBoxVBVAExHPCmdGet(&pVdma->CmdVbva, &pu8Cmd, &cbCmd); - switch (rc) +#if 0 + case VBOXCMDVBVA_OPTYPE_BLT_OFFPRIMSZFMT_OR_ID: { - case VINF_SUCCESS: - { - rc = vboxVDMACrCmdPreprocess(pVdma, pu8Cmd, cbCmd); - switch (rc) - { - case VINF_SUCCESS: - *ppNextCmd = (PVBOXCMDVBVA_HDR)pu8Cmd; - *pcbNextCmd = cbCmd; - return VINF_SUCCESS; - case VINF_EOF: - continue; - default: - Assert(!RT_FAILURE(rc)); - return RT_FAILURE(rc) ? rc : VERR_INTERNAL_ERROR; - } - break; - } - case VINF_EOF: - return VINF_EOF; - case VINF_PERMISSION_DENIED: - /* processing was paused, processing state was released, only VBoxVBVAExHS*** calls are now allowed */ - return VINF_EOF; - case VINF_INTERRUPTED: - /* command processing was interrupted, processor state remains set. client can process any commands */ - vboxVDMACrCmdNotifyPerform(pVdma); - return VINF_EOF; - default: - Assert(!RT_FAILURE(rc)); - return RT_FAILURE(rc) ? rc : VERR_INTERNAL_ERROR; + crVBoxServerCrCmdBltProcess(pCmd, cbCmd); + break; } +#endif + default: + WARN(("unsupported command\n")); + pCmd->u.i8Result = -1; } - - WARN(("Warning: vboxVDMACrCmdCltCmdGet unexpected state\n")); - return VERR_INTERNAL_ERROR; -} - -static DECLCALLBACK(int) vboxVDMACrCmdCltDmGet(HVBOXCRCMDCLT hClt, uint32_t idScreen, struct VBVAINFOSCREEN *pScreen, void **ppvVram) -{ - struct VBOXVDMAHOST *pVdma = hClt; - PVGASTATE pVGAState = pVdma->pVGAState; - - return VBVAGetScreenInfo(pVGAState, idScreen, pScreen, ppvVram); + return VINF_SUCCESS; } static int vboxVDMACrCtlHgsmiSetup(struct VBOXVDMAHOST *pVdma) { - PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pCmd; - pCmd = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP) vboxVDMACrCtlCreate (VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP, - sizeof (*pCmd)); + PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pCmd = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP) + vboxVDMACrCtlCreate (VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP, sizeof (*pCmd)); + int rc = VERR_NO_MEMORY; if (pCmd) { - VBOXCRCMD_CLTINFO CltInfo; - CltInfo.hClient = pVdma; - CltInfo.pfnCmdGet = vboxVDMACrCmdCltCmdGet; - CltInfo.pfnDmGet = vboxVDMACrCmdCltDmGet; PVGASTATE pVGAState = pVdma->pVGAState; pCmd->pvVRamBase = pVGAState->vram_ptrR3; pCmd->cbVRam = pVGAState->vram_size; - pCmd->pCrCmdClientInfo = &CltInfo; - int rc = vboxVDMACrCtlPost(pVGAState, &pCmd->Hdr, sizeof (*pCmd)); - Assert(RT_SUCCESS(rc) || rc == VERR_NOT_SUPPORTED); + rc = vboxVDMACrCtlPost(pVGAState, &pCmd->Hdr, sizeof (*pCmd)); if (RT_SUCCESS(rc)) { rc = vboxVDMACrCtlGetRc(&pCmd->Hdr); + if (RT_SUCCESS(rc)) + pVdma->CrSrvInfo = pCmd->CrCmdServerInfo; + else if (rc != VERR_NOT_SUPPORTED) + WARN(("vboxVDMACrCtlGetRc returned %d\n", rc)); } + else + WARN(("vboxVDMACrCtlPost failed %d\n", rc)); + vboxVDMACrCtlRelease(&pCmd->Hdr); - return rc; } - return VERR_NO_MEMORY; + + if (!RT_SUCCESS(rc)) + memset(&pVdma->CrSrvInfo, 0, sizeof (pVdma->CrSrvInfo)); + + return rc; } static int vboxVDMACmdExecBpbTransfer(PVBOXVDMAHOST pVdma, const PVBOXVDMACMD_DMA_BPB_TRANSFER pTransfer, uint32_t cbBuffer); @@ -883,236 +1739,52 @@ static int vboxVDMACmdExec(PVBOXVDMAHOST pVdma, const uint8_t *pvBuffer, uint32_ return VERR_INVALID_STATE; } -#ifdef VBOX_VDMA_WITH_WORKERTHREAD - -int vboxVDMAPipeConstruct(PVBOXVDMAPIPE pPipe) +static DECLCALLBACK(int) vboxVDMAWorkerThread(RTTHREAD ThreadSelf, void *pvUser) { - int rc = RTSemEventCreate(&pPipe->hEvent); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - rc = RTCritSectInit(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - pPipe->enmState = VBOXVDMAPIPE_STATE_CREATED; - pPipe->bNeedNotify = true; - return VINF_SUCCESS; -// RTCritSectDelete(pPipe->hCritSect); - } - RTSemEventDestroy(pPipe->hEvent); - } - return rc; -} + PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)pvUser; + PVGASTATE pVGAState = pVdma->pVGAState; + VBVAEXHOSTCONTEXT *pCmdVbva = &pVdma->CmdVbva; + PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi; + uint8_t *pCmd; + uint32_t cbCmd; -int vboxVDMAPipeOpenServer(PVBOXVDMAPIPE pPipe) -{ - int rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) + int rc = VBoxVDMAThreadNotifyConstructSucceeded(&pVdma->Thread); + if (!RT_SUCCESS(rc)) { - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED); - switch (pPipe->enmState) - { - case VBOXVDMAPIPE_STATE_CREATED: - pPipe->enmState = VBOXVDMAPIPE_STATE_OPENNED; - pPipe->bNeedNotify = false; - rc = VINF_SUCCESS; - break; - case VBOXVDMAPIPE_STATE_OPENNED: - pPipe->bNeedNotify = false; - rc = VINF_ALREADY_INITIALIZED; - break; - default: - AssertBreakpoint(); - rc = VERR_INVALID_STATE; - break; - } - - RTCritSectLeave(&pPipe->hCritSect); + WARN(("VBoxVDMAThreadNotifyConstructSucceeded failed %d\n", rc)); + return rc; } - return rc; -} -int vboxVDMAPipeCloseServer(PVBOXVDMAPIPE pPipe) -{ - int rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) + while (!VBoxVDMAThreadIsTerminating(&pVdma->Thread)) { - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED - || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING); - switch (pPipe->enmState) + VBVAEXHOST_DATA_TYPE enmType = VBoxVBVAExHPDataGet(pCmdVbva, &pCmd, &cbCmd); + switch (enmType) { - case VBOXVDMAPIPE_STATE_CLOSING: - pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED; - rc = VINF_SUCCESS; - break; - case VBOXVDMAPIPE_STATE_CLOSED: - rc = VINF_ALREADY_INITIALIZED; - break; - default: - AssertBreakpoint(); - rc = VERR_INVALID_STATE; + case VBVAEXHOST_DATA_TYPE_CMD: + vboxVDMACrCmdProcess(pVdma, pCmd, cbCmd); + VBoxVBVAExHPDataCompleteCmd(pCmdVbva, cbCmd); + VBVARaiseIrqNoWait(pVGAState, 0); break; - } - - RTCritSectLeave(&pPipe->hCritSect); - } - return rc; -} - -int vboxVDMAPipeCloseClient(PVBOXVDMAPIPE pPipe) -{ - int rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - bool bNeedNotify = false; - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED - || pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED - || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED); - switch (pPipe->enmState) - { - case VBOXVDMAPIPE_STATE_OPENNED: - pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSING; - bNeedNotify = pPipe->bNeedNotify; - pPipe->bNeedNotify = false; + case VBVAEXHOST_DATA_TYPE_HOSTCTL: + rc = vboxVDMACrHostCtlProcess(pVdma, (VBVAEXHOSTCTL*)pCmd); + VBoxVBVAExHPDataCompleteCtl(pCmdVbva, (VBVAEXHOSTCTL*)pCmd, rc); break; - case VBOXVDMAPIPE_STATE_CREATED: - pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED; - pPipe->bNeedNotify = false; + case VBVAEXHOST_DATA_TYPE_GUESTCTL: + rc = vboxVDMACrGuestCtlProcess(pVdma, (VBVAEXHOSTCTL*)pCmd); + VBoxVBVAExHPDataCompleteCtl(pCmdVbva, (VBVAEXHOSTCTL*)pCmd, rc); break; - case VBOXVDMAPIPE_STATE_CLOSED: - rc = VINF_ALREADY_INITIALIZED; + case VBVAEXHOST_DATA_TYPE_NO_DATA: + rc = VBoxVDMAThreadEventWait(&pVdma->Thread, RT_INDEFINITE_WAIT); + AssertRC(rc); break; default: - AssertBreakpoint(); - rc = VERR_INVALID_STATE; + WARN(("unexpected type %d\n", enmType)); break; } - - RTCritSectLeave(&pPipe->hCritSect); - - if (bNeedNotify) - { - rc = RTSemEventSignal(pPipe->hEvent); - AssertRC(rc); - } } - return rc; -} - - -typedef DECLCALLBACK(bool) FNHVBOXVDMARWCB(PVBOXVDMAPIPE pPipe, void *pvCallback); -typedef FNHVBOXVDMARWCB *PFNHVBOXVDMARWCB; - -int vboxVDMAPipeModifyServer(PVBOXVDMAPIPE pPipe, PFNHVBOXVDMARWCB pfnCallback, void * pvCallback) -{ - int rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - do - { - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED - || pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING); - - if (pPipe->enmState >= VBOXVDMAPIPE_STATE_OPENNED) - { - bool bProcessing = pfnCallback(pPipe, pvCallback); - pPipe->bNeedNotify = !bProcessing; - if (bProcessing) - { - RTCritSectLeave(&pPipe->hCritSect); - rc = VINF_SUCCESS; - break; - } - else if (pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSING) - { - pPipe->enmState = VBOXVDMAPIPE_STATE_CLOSED; - RTCritSectLeave(&pPipe->hCritSect); - rc = VINF_EOF; - break; - } - } - else - { - AssertBreakpoint(); - rc = VERR_INVALID_STATE; - RTCritSectLeave(&pPipe->hCritSect); - break; - } - - RTCritSectLeave(&pPipe->hCritSect); - - rc = RTSemEventWait(pPipe->hEvent, RT_INDEFINITE_WAIT); - AssertRC(rc); - if (!RT_SUCCESS(rc)) - break; - - rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (!RT_SUCCESS(rc)) - break; - } while (1); - } - - return rc; -} - -int vboxVDMAPipeModifyClient(PVBOXVDMAPIPE pPipe, PFNHVBOXVDMARWCB pfnCallback, void * pvCallback) -{ - int rc = RTCritSectEnter(&pPipe->hCritSect); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - bool bNeedNotify = false; - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED); - if (pPipe->enmState == VBOXVDMAPIPE_STATE_OPENNED) - { - bool bModified = pfnCallback(pPipe, pvCallback); - if (bModified) - { - bNeedNotify = pPipe->bNeedNotify; - pPipe->bNeedNotify = false; - } - } - else - rc = VERR_INVALID_STATE; - - RTCritSectLeave(&pPipe->hCritSect); - - if (bNeedNotify) - { - rc = RTSemEventSignal(pPipe->hEvent); - AssertRC(rc); - } - } - return rc; -} - -int vboxVDMAPipeDestruct(PVBOXVDMAPIPE pPipe) -{ - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED - || pPipe->enmState == VBOXVDMAPIPE_STATE_CREATED); - /* ensure the pipe is closed */ - vboxVDMAPipeCloseClient(pPipe); - - Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED); - - if (pPipe->enmState != VBOXVDMAPIPE_STATE_CLOSED) - return VERR_INVALID_STATE; - - int rc = RTCritSectDelete(&pPipe->hCritSect); - AssertRC(rc); - - rc = RTSemEventDestroy(pPipe->hEvent); - AssertRC(rc); return VINF_SUCCESS; } -#endif static void vboxVDMACommandProcess(PVBOXVDMAHOST pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t cbCmd) { @@ -1181,87 +1853,6 @@ static void vboxVDMAControlProcess(PVBOXVDMAHOST pVdma, PVBOXVDMA_CTL pCmd) AssertRC(rc); } -#ifdef VBOX_VDMA_WITH_WORKERTHREAD -typedef struct -{ - struct VBOXVDMAHOST *pVdma; - VBOXVDMAPIPE_CMD_BODY Cmd; - bool bHasCmd; -} VBOXVDMACMD_PROCESS_CONTEXT, *PVBOXVDMACMD_PROCESS_CONTEXT; - -static DECLCALLBACK(bool) vboxVDMACommandProcessCb(PVBOXVDMAPIPE pPipe, void *pvCallback) -{ - PVBOXVDMACMD_PROCESS_CONTEXT pContext = (PVBOXVDMACMD_PROCESS_CONTEXT)pvCallback; - struct VBOXVDMAHOST *pVdma = pContext->pVdma; - HGSMILISTENTRY *pEntry = hgsmiListRemoveHead(&pVdma->PendingList); - if (pEntry) - { - PVBOXVDMAPIPE_CMD pPipeCmd = VBOXVDMAPIPE_CMD_FROM_ENTRY(pEntry); - Assert(pPipeCmd); - pContext->Cmd = pPipeCmd->Cmd; - hgsmiListPrepend(&pVdma->CmdPool.List, pEntry); - pContext->bHasCmd = true; - return true; - } - - pContext->bHasCmd = false; - return false; -} - -static DECLCALLBACK(int) vboxVDMAWorkerThread(RTTHREAD ThreadSelf, void *pvUser) -{ - PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)pvUser; - PHGSMIINSTANCE pHgsmi = pVdma->pHgsmi; - VBOXVDMACMD_PROCESS_CONTEXT Context; - Context.pVdma = pVdma; - - int rc = vboxVDMAPipeOpenServer(&pVdma->Pipe); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - do - { - rc = vboxVDMAPipeModifyServer(&pVdma->Pipe, vboxVDMACommandProcessCb, &Context); - AssertRC(rc); - if (RT_SUCCESS(rc)) - { - switch (Context.Cmd.enmType) - { - case VBOXVDMAPIPE_CMD_TYPE_DMACMD: - { - PVBOXVDMACBUF_DR pDr = Context.Cmd.u.pDr; - vboxVDMACommandProcess(pVdma, pDr); - break; - } - case VBOXVDMAPIPE_CMD_TYPE_DMACTL: - { - PVBOXVDMA_CTL pCtl = Context.Cmd.u.pCtl; - vboxVDMAControlProcess(pVdma, pCtl); - break; - } - default: - AssertBreakpoint(); - break; - } - - if (rc == VINF_EOF) - { - rc = VINF_SUCCESS; - break; - } - } - else - break; - } while (1); - } - - /* always try to close the pipe to make sure the client side is notified */ - int tmpRc = vboxVDMAPipeCloseServer(&pVdma->Pipe); - AssertRC(tmpRc); - return rc; -} -#endif - #ifdef VBOX_VDMA_WITH_WATCHDOG static DECLCALLBACK(void) vboxVDMAWatchDogTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser) { @@ -1301,41 +1892,27 @@ int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements) "VDMA WatchDog Timer", &pVdma->WatchDogTimer); AssertRC(rc); #endif -#ifdef VBOX_VDMA_WITH_WORKERTHREAD - hgsmiListInit(&pVdma->PendingList); - rc = vboxVDMAPipeConstruct(&pVdma->Pipe); - AssertRC(rc); + rc = VBoxVBVAExHSInit(&pVdma->CmdVbva); if (RT_SUCCESS(rc)) { - rc = RTThreadCreate(&pVdma->hWorkerThread, vboxVDMAWorkerThread, pVdma, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "VDMA"); - AssertRC(rc); + rc = VBoxVDMAThreadCreate(&pVdma->Thread, vboxVDMAWorkerThread, pVdma); if (RT_SUCCESS(rc)) { - hgsmiListInit(&pVdma->CmdPool.List); - pVdma->CmdPool.cCmds = cPipeElements; - for (uint32_t i = 0; i < cPipeElements; ++i) - { - hgsmiListAppend(&pVdma->CmdPool.List, &pVdma->CmdPool.aCmds[i].Entry); - } -# if 0 //def VBOX_WITH_CRHGSMI - int tmpRc = vboxVDMACrCtlHgsmiSetup(pVdma); -# endif -#endif pVGAState->pVdma = pVdma; - VBoxVBVAExHSInit(&pVdma->CmdVbva); #ifdef VBOX_WITH_CRHGSMI int rcIgnored = vboxVDMACrCtlHgsmiSetup(pVdma); NOREF(rcIgnored); /** @todo is this ignoring intentional? */ #endif return VINF_SUCCESS; -#ifdef VBOX_VDMA_WITH_WORKERTHREAD } + else + WARN(("VBoxVDMAThreadCreate faile %d\n", rc)); - int tmpRc = vboxVDMAPipeDestruct(&pVdma->Pipe); - AssertRC(tmpRc); + VBoxVBVAExHSTerm(&pVdma->CmdVbva); } + else + WARN(("VBoxVBVAExHSInit faile %d\n", rc)); RTMemFree(pVdma); -#endif } else rc = VERR_OUT_OF_RESOURCES; @@ -1343,46 +1920,34 @@ int vboxVDMAConstruct(PVGASTATE pVGAState, uint32_t cPipeElements) return rc; } -int vboxVDMADestruct(struct VBOXVDMAHOST *pVdma) +int vboxVDMAReset(struct VBOXVDMAHOST *pVdma) { -#ifdef VBOX_VDMA_WITH_WORKERTHREAD - /* @todo: implement*/ - AssertBreakpoint(); -#endif - VBoxVBVAExHSTerm(&pVdma->CmdVbva); - RTMemFree(pVdma); + VBVAEXHOSTCTL Ctl; + Ctl.enmType = VBVAEXHOSTCTL_TYPE_HH_RESET; + int rc = vdmaVBVACtlSubmitSync(pVdma, &Ctl, VBVAEXHOSTCTL_SOURCE_HOST_ANY); + if (!RT_SUCCESS(rc)) + { + WARN(("vdmaVBVACtlSubmitSync failed %d\n", rc)); + return rc; + } return VINF_SUCCESS; } -#ifdef VBOX_VDMA_WITH_WORKERTHREAD -typedef struct -{ - struct VBOXVDMAHOST *pVdma; - VBOXVDMAPIPE_CMD_BODY Cmd; - bool bQueued; -} VBOXVDMACMD_SUBMIT_CONTEXT, *PVBOXVDMACMD_SUBMIT_CONTEXT; - -DECLCALLBACK(bool) vboxVDMACommandSubmitCb(PVBOXVDMAPIPE pPipe, void *pvCallback) +int vboxVDMADestruct(struct VBOXVDMAHOST *pVdma) { - PVBOXVDMACMD_SUBMIT_CONTEXT pContext = (PVBOXVDMACMD_SUBMIT_CONTEXT)pvCallback; - struct VBOXVDMAHOST *pVdma = pContext->pVdma; - HGSMILISTENTRY *pEntry = hgsmiListRemoveHead(&pVdma->CmdPool.List); - Assert(pEntry); - if (pEntry) + VBVAEXHOSTCTL Ctl; + Ctl.enmType = VBVAEXHOSTCTL_TYPE_HH_TERM; + int rc = vdmaVBVACtlSubmitSync(pVdma, &Ctl, VBVAEXHOSTCTL_SOURCE_HOST_ANY); + if (!RT_SUCCESS(rc)) { - PVBOXVDMAPIPE_CMD pPipeCmd = VBOXVDMAPIPE_CMD_FROM_ENTRY(pEntry); - pPipeCmd->Cmd = pContext->Cmd; - VBoxSHGSMICommandMarkAsynchCompletion(pContext->Cmd.u.pvCmd); - pContext->bQueued = true; - hgsmiListAppend(&pVdma->PendingList, pEntry); - return true; + WARN(("vdmaVBVACtlSubmitSync failed %d\n", rc)); + return rc; } - - /* @todo: should we try to flush some commands here? */ - pContext->bQueued = false; - return false; + VBoxVDMAThreadTerm(&pVdma->Thread); + VBoxVBVAExHSTerm(&pVdma->CmdVbva); + RTMemFree(pVdma); + return VINF_SUCCESS; } -#endif int vboxVDMASaveStateExecPrep(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM) { @@ -1545,377 +2110,201 @@ void vboxVDMACommand(struct VBOXVDMAHOST *pVdma, PVBOXVDMACBUF_DR pCmd, uint32_t } /**/ -static int vboxVBVAExHSProcessorAcquire(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State != VBVAEXHOSTCONTEXT_STATE_STOPPED); - uint32_t oldState; - if (!ASMAtomicReadU32(&pCmdVbva->u32Pause)) +static int vdmaVBVACtlSubmit(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL* pCtl, VBVAEXHOSTCTL_SOURCE enmSource, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete) +{ + int rc = VBoxVBVAExHCtlSubmit(&pVdma->CmdVbva, pCtl, enmSource, pfnComplete, pvComplete); + if (RT_SUCCESS(rc)) { - if (ASMAtomicCmpXchgExU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_PROCESSING, VBVAEXHOSTCONTEXT_STATE_LISTENING, &oldState)) - return VINF_SUCCESS; - return oldState == VBVAEXHOSTCONTEXT_STATE_PROCESSING ? VERR_SEM_BUSY : VERR_INVALID_STATE; + if (rc == VINF_SUCCESS) + return VBoxVDMAThreadEventNotify(&pVdma->Thread); + else + Assert(rc == VINF_ALREADY_INITIALIZED); } - return VERR_INVALID_STATE; -} - -static bool vboxVBVAExHPCheckPause(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - if (!ASMAtomicReadU32(&pCmdVbva->u32Pause)) - return false; - - ASMAtomicWriteU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_PAUSED); - return true; -} - -static bool vboxVBVAExHPCheckOtherCommands(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - return !!ASMAtomicUoReadU32(&pCmdVbva->u32cOtherCommands); -} - -static void vboxVBVAExHPProcessorRelease(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - if (!vboxVBVAExHPCheckPause(pCmdVbva)) - ASMAtomicWriteU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_LISTENING); else - ASMAtomicWriteU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_PAUSED); -} + WARN(("VBoxVBVAExHCtlSubmit failed %d\n", rc)); -static void vboxVBVAExHPHgEventSet(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - ASMAtomicOrU32(&pCmdVbva->pVBVA->hostFlags.u32HostEvents, VBVA_F_STATE_PROCESSING); -} - -static void vboxVBVAExHPHgEventClear(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - ASMAtomicAndU32(&pCmdVbva->pVBVA->hostFlags.u32HostEvents, ~VBVA_F_STATE_PROCESSING); + return rc; } -static bool vboxVBVAExHPCmdCheckRelease(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static DECLCALLBACK(void) vboxCmdVBVACmdCtlGuestCompletion(VBVAEXHOSTCONTEXT *pVbva, struct VBVAEXHOSTCTL *pCtl, int rc, void *pvContext) { - if (!pCmdVbva->cbCurData) - return false; - - VBVABUFFER *pVBVA = pCmdVbva->pVBVA; - pVBVA->off32Data = (pVBVA->off32Data + pCmdVbva->cbCurData) % pVBVA->cbData; - - pVBVA->indexRecordFirst = (pVBVA->indexRecordFirst + 1) % RT_ELEMENTS(pVBVA->aRecords); + PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)pvContext; + VBOXCMDVBVA_CTL *pGCtl = (VBOXCMDVBVA_CTL*)(pCtl->u.cmd.pu8Cmd - sizeof (VBOXCMDVBVA_CTL)); + AssertRC(rc); + pGCtl->i32Result = rc; - pCmdVbva->cbCurData = 0; + Assert(pVdma->pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD); + rc = VBoxSHGSMICommandComplete(pVdma->pHgsmi, pGCtl); + AssertRC(rc); - return true; + VBoxVBVAExHCtlFree(pVbva, pCtl); } -static int vboxVBVAExHPCmdGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd) +static int vdmaVBVACtlOpaqueSubmit(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL_SOURCE enmSource, uint8_t* pu8Cmd, uint32_t cbCmd, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete) { - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - VBVABUFFER *pVBVA = pCmdVbva->pVBVA; - - uint32_t indexRecordFirst = pVBVA->indexRecordFirst; - uint32_t indexRecordFree = pVBVA->indexRecordFree; - - Log(("first = %d, free = %d\n", - indexRecordFirst, indexRecordFree)); - - if (indexRecordFirst == indexRecordFree) - { - /* No records to process. Return without assigning output variables. */ - return VINF_EOF; - } - - uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVBVA->aRecords[indexRecordFirst].cbRecord); - - /* A new record need to be processed. */ - if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL) + VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, VBVAEXHOSTCTL_TYPE_GHH_BE_OPAQUE); + if (!pHCtl) { - /* the record is being recorded, try again */ - return VINF_TRY_AGAIN; + WARN(("VBoxVBVAExHCtlCreate failed\n")); + return VERR_NO_MEMORY; } - uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL; - - if (!cbRecord) - { - /* the record is being recorded, try again */ - return VINF_TRY_AGAIN; - } - - /* we should not get partial commands here actually */ - Assert(cbRecord); - - /* The size of largest contiguous chunk in the ring biffer. */ - uint32_t u32BytesTillBoundary = pVBVA->cbData - pVBVA->off32Data; - - /* The pointer to data in the ring buffer. */ - uint8_t *pSrc = &pVBVA->au8Data[pVBVA->off32Data]; - - /* Fetch or point the data. */ - if (u32BytesTillBoundary >= cbRecord) + pHCtl->u.cmd.pu8Cmd = pu8Cmd; + pHCtl->u.cmd.cbCmd = cbCmd; + int rc = vdmaVBVACtlSubmit(pVdma, pHCtl, enmSource, pfnComplete, pvComplete); + if (!RT_SUCCESS(rc)) { - /* The command does not cross buffer boundary. Return address in the buffer. */ - *ppCmd = pSrc; - *pcbCmd = cbRecord; - pCmdVbva->cbCurData = cbRecord; - return VINF_SUCCESS; + WARN(("vdmaVBVACtlSubmit failed rc %d\n", rc)); + return rc;; } - - LogRel(("CmdVbva: cross-bound writes unsupported\n")); - return VERR_INVALID_STATE; -} - -/* Resumes command processing - * @returns - same as VBoxVBVAExHSCheckCommands - */ -static int vboxVBVAExHSResume(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - Assert(pCmdVbva->u32State != VBVAEXHOSTCONTEXT_STATE_STOPPED); - - ASMAtomicWriteU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_LISTENING); - - return VBoxVBVAExHSCheckCommands(pCmdVbva); + return VINF_SUCCESS; } -/* pause the command processing. this will make the processor stop the command processing and release the processing state - * to resume the command processing the vboxVBVAExHSResume must be called */ -static void vboxVBVAExHSPause(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static int vdmaVBVACtlOpaqueGuestSubmit(PVBOXVDMAHOST pVdma, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl) { - Assert(pCmdVbva->u32State != VBVAEXHOSTCONTEXT_STATE_STOPPED); - - Assert(!pCmdVbva->u32Pause); - - ASMAtomicWriteU32(&pCmdVbva->u32Pause, 1); - - for(;;) - { - if (ASMAtomicCmpXchgU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_PAUSED, VBVAEXHOSTCONTEXT_STATE_LISTENING)) - break; - - if (ASMAtomicReadU32(&pCmdVbva->u32State) == VBVAEXHOSTCONTEXT_STATE_PAUSED) - break; - - RTThreadSleep(2); - } + Assert(cbCtl >= sizeof (VBOXCMDVBVA_CTL)); + VBoxSHGSMICommandMarkAsynchCompletion(pCtl); + int rc = vdmaVBVACtlOpaqueSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_GUEST, (uint8_t*)(pCtl+1), cbCtl - sizeof (VBOXCMDVBVA_CTL), vboxCmdVBVACmdCtlGuestCompletion, pVdma); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; - pCmdVbva->u32Pause = 0; + WARN(("vdmaVBVACtlOpaqueSubmit failed %d\n", rc)); + pCtl->i32Result = rc; + rc = VBoxSHGSMICommandComplete(pVdma->pHgsmi, pCtl); + AssertRC(rc); + return VINF_SUCCESS; } -/* releases (completed) the command previously acquired by VBoxVBVAExHCmdGet - * for convenience can be called if no command is currently acquired - * in that case it will do nothing and return false. - * if the completion notification is needed returns true. */ -static bool VBoxVBVAExHPCmdCheckRelease(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static DECLCALLBACK(void) vboxCmdVBVACmdCtlHostCompletion(VBVAEXHOSTCONTEXT *pVbva, struct VBVAEXHOSTCTL *pCtl, int rc, void *pvCompletion) { - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - return vboxVBVAExHPCmdCheckRelease(pCmdVbva); + VBOXCRCMDCTL* pVboxCtl = (VBOXCRCMDCTL*)pCtl->u.cmd.pu8Cmd; + if (pVboxCtl->pfnInternal) + ((PFNCRCTLCOMPLETION)pVboxCtl->pfnInternal)(pVboxCtl, pCtl->u.cmd.cbCmd, rc, pvCompletion); + VBoxVBVAExHCtlFree(pVbva, pCtl); } -/* - * @returns - * VINF_SUCCESS - new command is obtained - * VINF_EOF - processor has completed all commands and release the processing state, only VBoxVBVAExHS*** calls are now allowed - * VINF_PERMISSION_DENIED - processing was paused, processing state was released, only VBoxVBVAExHS*** calls are now allowed - * VINF_INTERRUPTED - command processing was interrupted, processor state remains set. client can process any commands, - * and call VBoxVBVAExHPCmdGet again for further processing - * VERR_** - error happened, most likely guest corrupted VBVA data - * - */ -static int VBoxVBVAExHPCmdGet(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t **ppCmd, uint32_t *pcbCmd) +static int vdmaVBVACtlOpaqueHostSubmit(PVBOXVDMAHOST pVdma, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, + PFNCRCTLCOMPLETION pfnCompletion, + void *pvCompletion) { - Assert(pCmdVbva->u32State == VBVAEXHOSTCONTEXT_STATE_PROCESSING); - - for(;;) + pCmd->pfnInternal = (void(*)())pfnCompletion; + int rc = vdmaVBVACtlOpaqueSubmit(pVdma, VBVAEXHOSTCTL_SOURCE_HOST_ENABLED, (uint8_t*)pCmd, cbCmd, vboxCmdVBVACmdCtlHostCompletion, pvCompletion); + if (!RT_SUCCESS(rc)) { - if (vboxVBVAExHPCheckPause(pCmdVbva)) - return VINF_PERMISSION_DENIED; - if (vboxVBVAExHPCheckOtherCommands(pCmdVbva)) - return VINF_INTERRUPTED; - - int rc = vboxVBVAExHPCmdGet(pCmdVbva, ppCmd, pcbCmd); - switch (rc) + if (rc == VERR_INVALID_STATE) { - case VINF_SUCCESS: - return VINF_SUCCESS; - case VINF_EOF: - vboxVBVAExHPHgEventClear(pCmdVbva); - vboxVBVAExHPProcessorRelease(pCmdVbva); - /* we need to prevent racing between us clearing the flag and command check/submission thread, i.e. - * 1. we check the queue -> and it is empty - * 2. submitter adds command to the queue - * 3. submitter checks the "processing" -> and it is true , thus it does not submit a notification - * 4. we clear the "processing" state - * 5. ->here we need to re-check the queue state to ensure we do not leak the notification of the above command - * 6. if the queue appears to be not-empty set the "processing" state back to "true" - **/ - if (VBoxVBVAExHSCheckCommands(pCmdVbva) == VINF_SUCCESS) - continue; - return VINF_EOF; - case VINF_TRY_AGAIN: - RTThreadSleep(1); - continue; - default: - /* this is something really unexpected, i.e. most likely guest has written something incorrect to the VBVA buffer */ - if (RT_FAILURE(rc)) - return rc; + pCmd->pfnInternal = NULL; + PVGASTATE pVGAState = pVdma->pVGAState; + rc = pVGAState->pDrv->pfnCrHgcmCtlSubmit(pVGAState->pDrv, pCmd, cbCmd, pfnCompletion, pvCompletion); + if (!RT_SUCCESS(rc)) + WARN(("pfnCrHgsmiControlProcess failed %d\n", rc)); - WARN(("Warning: vboxVBVAExHCmdGet returned unexpected success status %d\n", rc)); - return VERR_INTERNAL_ERROR; + return rc; } + WARN(("vdmaVBVACtlOpaqueSubmit failed %d\n", rc)); + return rc; } - WARN(("Warning: VBoxVBVAExHCmdGet unexpected state\n")); - return VERR_INTERNAL_ERROR; + return VINF_SUCCESS; } -/* Checks whether the new commands are ready for processing - * @returns - * VINF_SUCCESS - there are commands are in a queue, and the given thread is now the processor (i.e. typically it would delegate processing to a worker thread) - * VINF_EOF - no commands in a queue - * VINF_ALREADY_INITIALIZED - another thread already processing the commands - * VERR_INVALID_STATE - the VBVA is paused or pausing */ -static int VBoxVBVAExHSCheckCommands(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBVAENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete) { - if (ASMAtomicUoReadU32(&pCmdVbva->u32State) == VBVAEXHOSTCONTEXT_STATE_STOPPED) - return VINF_EOF; - - int rc = vboxVBVAExHSProcessorAcquire(pCmdVbva); - if (RT_SUCCESS(rc)) + VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, VBVAEXHOSTCTL_TYPE_GH_ENABLE_DISABLE); + if (!pHCtl) { - /* we are the processor now */ - VBVABUFFER *pVBVA = pCmdVbva->pVBVA; - - uint32_t indexRecordFirst = pVBVA->indexRecordFirst; - uint32_t indexRecordFree = pVBVA->indexRecordFree; - - if (indexRecordFirst != indexRecordFree) - { - vboxVBVAExHPHgEventSet(pCmdVbva); - return VINF_SUCCESS; - } - - vboxVBVAExHPProcessorRelease(pCmdVbva); - return VINF_EOF; + WARN(("VBoxVBVAExHCtlCreate failed\n")); + return VERR_NO_MEMORY; } - if (rc == VERR_SEM_BUSY) - return VINF_ALREADY_INITIALIZED; - Assert(rc == VERR_INVALID_STATE); - return VERR_INVALID_STATE; -} -static void VBoxVBVAExHSInit(struct VBVAEXHOSTCONTEXT *pCmdVbva) -{ - memset(pCmdVbva, 0, sizeof (*pCmdVbva)); -} - -static int VBoxVBVAExHSEnable(struct VBVAEXHOSTCONTEXT *pCmdVbva, VBVABUFFER *pVBVA) -{ - if (ASMAtomicUoReadU32(&pCmdVbva->u32State) != VBVAEXHOSTCONTEXT_STATE_STOPPED) - return VINF_ALREADY_INITIALIZED; - - pCmdVbva->pVBVA = pVBVA; - pCmdVbva->pVBVA->hostFlags.u32HostEvents = 0; - ASMAtomicWriteU32(&pCmdVbva->u32State, VBVAEXHOSTCONTEXT_STATE_LISTENING); + pHCtl->u.cmd.pu8Cmd = (uint8_t*)pEnable; + pHCtl->u.cmd.cbCmd = sizeof (*pEnable); + int rc = vdmaVBVACtlSubmit(pVdma, pHCtl, VBVAEXHOSTCTL_SOURCE_GUEST, pfnComplete, pvComplete); + if (!RT_SUCCESS(rc)) + { + WARN(("vdmaVBVACtlSubmit failed rc %d\n", rc)); + return rc;; + } return VINF_SUCCESS; } -static int VBoxVBVAExHSDisable(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static int vdmaVBVACtlEnableDisableSubmit(PVBOXVDMAHOST pVdma, VBOXCMDVBVA_CTL_ENABLE *pEnable) { - if (ASMAtomicUoReadU32(&pCmdVbva->u32State) == VBVAEXHOSTCONTEXT_STATE_STOPPED) - return VINF_SUCCESS; - - /* ensure no commands pending and one tries to submit them */ - int rc = vboxVBVAExHSProcessorAcquire(pCmdVbva); + VBoxSHGSMICommandMarkAsynchCompletion(&pEnable->Hdr); + int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, &pEnable->Enable, vboxCmdVBVACmdCtlGuestCompletion, pVdma); if (RT_SUCCESS(rc)) - { - pCmdVbva->pVBVA->hostFlags.u32HostEvents = 0; - memset(pCmdVbva, 0, sizeof (*pCmdVbva)); return VINF_SUCCESS; - } - return VERR_INVALID_STATE; + + WARN(("vdmaVBVACtlEnableDisableSubmitInternal failed %d\n", rc)); + pEnable->Hdr.i32Result = rc; + rc = VBoxSHGSMICommandComplete(pVdma->pHgsmi, &pEnable->Hdr); + AssertRC(rc); + return VINF_SUCCESS; } -static void VBoxVBVAExHSTerm(struct VBVAEXHOSTCONTEXT *pCmdVbva) +static DECLCALLBACK(void) vdmaVBVACtlSubmitSyncCompletion(VBVAEXHOSTCONTEXT *pVbva, struct VBVAEXHOSTCTL *pCtl, int rc, void *pvContext) { - /* ensure the processor is stopped */ - if (ASMAtomicUoReadU32(&pCmdVbva->u32State) == VBVAEXHOSTCONTEXT_STATE_STOPPED) - return; - - /* ensure no one tries to submit the command */ - vboxVBVAExHSPause(pCmdVbva); - pCmdVbva->pVBVA->hostFlags.u32HostEvents = 0; - memset(pCmdVbva, 0, sizeof (*pCmdVbva)); + VDMA_VBVA_CTL_CYNC_COMPLETION *pData = (VDMA_VBVA_CTL_CYNC_COMPLETION*)pvContext; + pData->rc = rc; + rc = RTSemEventSignal(pData->hEvent); + if (!RT_SUCCESS(rc)) + WARN(("RTSemEventSignal failed %d\n", rc)); } -/* Saves state - * @returns - same as VBoxVBVAExHSCheckCommands, or failure on load state fail - */ -static int VBoxVBVAExHSSaveState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM) +static int vdmaVBVACtlSubmitSync(PVBOXVDMAHOST pVdma, VBVAEXHOSTCTL* pCtl, VBVAEXHOSTCTL_SOURCE enmSource) { - int rc; - if (ASMAtomicUoReadU32(&pCmdVbva->u32State) != VBVAEXHOSTCONTEXT_STATE_STOPPED) + VDMA_VBVA_CTL_CYNC_COMPLETION Data; + Data.rc = VERR_NOT_IMPLEMENTED; + int rc = RTSemEventCreate(&Data.hEvent); + if (!RT_SUCCESS(rc)) { - vboxVBVAExHSPause(pCmdVbva); - rc = SSMR3PutU32(pSSM, (uint32_t)(((uint8_t*)pCmdVbva->pVBVA) - pu8VramBase)); - AssertRCReturn(rc, rc); - return vboxVBVAExHSResume(pCmdVbva); + WARN(("RTSemEventCreate failed %d\n", rc)); + return rc; } - rc = SSMR3PutU32(pSSM, 0xffffffff); - AssertRCReturn(rc, rc); - - return VINF_EOF; -} - -/* Loads state - * @returns - same as VBoxVBVAExHSCheckCommands, or failure on load state fail - */ -static int VBoxVBVAExHSLoadState(struct VBVAEXHOSTCONTEXT *pCmdVbva, uint8_t* pu8VramBase, PSSMHANDLE pSSM, uint32_t u32Version) -{ - uint32_t u32; - int rc = SSMR3GetU32(pSSM, &u32); - AssertRCReturn(rc, rc); - if (u32 != 0xffffffff) + rc = vdmaVBVACtlSubmit(pVdma, pCtl, enmSource, vdmaVBVACtlSubmitSyncCompletion, &Data); + if (RT_SUCCESS(rc)) { - VBVABUFFER *pVBVA = (VBVABUFFER*)pu8VramBase + u32; - rc = VBoxVBVAExHSEnable(pCmdVbva, pVBVA); - AssertRCReturn(rc, rc); - return VBoxVBVAExHSCheckCommands(pCmdVbva); + rc = RTSemEventWait(Data.hEvent, RT_INDEFINITE_WAIT); + if (RT_SUCCESS(rc)) + { + rc = Data.rc; + if (!RT_SUCCESS(rc)) + WARN(("vdmaVBVACtlSubmitSyncCompletion returned %d\n", rc)); + } + else + WARN(("RTSemEventWait failed %d\n", rc)); } + else + WARN(("vdmaVBVACtlSubmit failed %d\n", rc)); - return VINF_EOF; + RTSemEventDestroy(Data.hEvent); + + return rc; } -int vboxCmdVBVAEnable(PVGASTATE pVGAState, VBVABUFFER *pVBVA) +static int vdmaVBVAPause(PVBOXVDMAHOST pVdma) { - struct VBOXVDMAHOST *pVdma = pVGAState->pVdma; - return VBoxVBVAExHSEnable(&pVdma->CmdVbva, pVBVA); + VBVAEXHOSTCTL Ctl; + Ctl.enmType = VBVAEXHOSTCTL_TYPE_HH_INTERNAL_PAUSE; + return vdmaVBVACtlSubmitSync(pVdma, &Ctl, VBVAEXHOSTCTL_SOURCE_HOST_ANY); } -int vboxCmdVBVADisable(PVGASTATE pVGAState) +static int vdmaVBVAResume(PVBOXVDMAHOST pVdma) { - struct VBOXVDMAHOST *pVdma = pVGAState->pVdma; - return VBoxVBVAExHSDisable(&pVdma->CmdVbva); + VBVAEXHOSTCTL Ctl; + Ctl.enmType = VBVAEXHOSTCTL_TYPE_HH_INTERNAL_RESUME; + return vdmaVBVACtlSubmitSync(pVdma, &Ctl, VBVAEXHOSTCTL_SOURCE_HOST_ANY); } -static int vboxCmdVBVACmdSubmitPerform(PVGASTATE pVGAState) +static int vboxVDMACmdSubmitPerform(struct VBOXVDMAHOST *pVdma) { - struct VBOXVDMAHOST *pVdma = pVGAState->pVdma; int rc = VBoxVBVAExHSCheckCommands(&pVdma->CmdVbva); switch (rc) { case VINF_SUCCESS: - return pVGAState->pDrv->pfnCrCmdNotifyCmds(pVGAState->pDrv); + return VBoxVDMAThreadEventNotify(&pVdma->Thread); case VINF_ALREADY_INITIALIZED: case VINF_EOF: case VERR_INVALID_STATE: @@ -1926,17 +2315,70 @@ static int vboxCmdVBVACmdSubmitPerform(PVGASTATE pVGAState) } } + +int vboxCmdVBVACmdHostCtl(PPDMIDISPLAYVBVACALLBACKS pInterface, + struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, + PFNCRCTLCOMPLETION pfnCompletion, + void *pvCompletion) +{ + PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface); + struct VBOXVDMAHOST *pVdma = pVGAState->pVdma; + return vdmaVBVACtlOpaqueHostSubmit(pVdma, pCmd, cbCmd, pfnCompletion, pvCompletion); +} + +int vboxCmdVBVACmdCtl(PVGASTATE pVGAState, VBOXCMDVBVA_CTL *pCtl, uint32_t cbCtl) +{ + struct VBOXVDMAHOST *pVdma = pVGAState->pVdma; + int rc = VINF_SUCCESS; + switch (pCtl->u32Type) + { + case VBOXCMDVBVACTL_TYPE_3DCTL: + return vdmaVBVACtlOpaqueGuestSubmit(pVdma, pCtl, cbCtl); + case VBOXCMDVBVACTL_TYPE_ENABLE: + if (cbCtl != sizeof (VBOXCMDVBVA_CTL_ENABLE)) + { + WARN(("incorrect enable size\n")); + rc = VERR_INVALID_PARAMETER; + break; + } + return vdmaVBVACtlEnableDisableSubmit(pVdma, (VBOXCMDVBVA_CTL_ENABLE*)pCtl); + default: + WARN(("unsupported type\n")); + rc = VERR_INVALID_PARAMETER; + break; + } + + pCtl->i32Result = rc; + rc = VBoxSHGSMICommandComplete(pVdma->pHgsmi, pCtl); + AssertRC(rc); + return VINF_SUCCESS; +} + int vboxCmdVBVACmdSubmit(PVGASTATE pVGAState) { - return vboxCmdVBVACmdSubmitPerform(pVGAState); + if (!VBoxVBVAExHSIsEnabled(&pVGAState->pVdma->CmdVbva)) + { + WARN(("vdma VBVA is disabled\n")); + return VERR_INVALID_STATE; + } + + return vboxVDMACmdSubmitPerform(pVGAState->pVdma); } int vboxCmdVBVACmdFlush(PVGASTATE pVGAState) { - return vboxCmdVBVACmdSubmitPerform(pVGAState); + WARN(("flush\n")); + if (!VBoxVBVAExHSIsEnabled(&pVGAState->pVdma->CmdVbva)) + { + WARN(("vdma VBVA is disabled\n")); + return VERR_INVALID_STATE; + } + return vboxVDMACmdSubmitPerform(pVGAState->pVdma); } void vboxCmdVBVACmdTimer(PVGASTATE pVGAState) { - vboxCmdVBVACmdSubmitPerform(pVGAState); + if (!VBoxVBVAExHSIsEnabled(&pVGAState->pVdma->CmdVbva)) + return; + vboxVDMACmdSubmitPerform(pVGAState->pVdma); } diff --git a/src/VBox/Devices/Makefile.kmk b/src/VBox/Devices/Makefile.kmk index 8c723378f..179a99887 100644 --- a/src/VBox/Devices/Makefile.kmk +++ b/src/VBox/Devices/Makefile.kmk @@ -371,10 +371,11 @@ if !defined(VBOX_ONLY_EXTPACKS) # Goes on almost to the end of the file. include $(PATH_SUB_CURRENT)/Network/lwip-new/Makefile.kmk endif Network/DevINIP.cpp_DEFS += VBOX_WITH_NEW_LWIP + VBoxDD_LWIP_INCS += Network # for lwipopts.h $(eval $(call def_vbox_lwip_private, \ VBoxDD, Network/lwip-new)) $(eval $(call def_vbox_lwip_flags, \ - Network/DevINIP.cpp, Network/lwip-new)) + VBoxDD, Network/DevINIP.cpp, Network/lwip-new)) endif endif # VBOX_WITH_INIP @@ -449,7 +450,7 @@ if !defined(VBOX_ONLY_EXTPACKS) # Goes on almost to the end of the file. ifdef VBOX_WITH_NEW_LWIP Storage/DrvVD.cpp_DEFS += VBOX_WITH_NEW_LWIP $(eval $(call def_vbox_lwip_flags, \ - Storage/DrvVD.cpp, Network/lwip-new)) + VBoxDD, Storage/DrvVD.cpp, Network/lwip-new)) else Storage/DrvVD.cpp_INCS = $(LWIP_INCS) endif diff --git a/src/VBox/Devices/Network/lwip-new/CHANGELOG b/src/VBox/Devices/Network/lwip-new/CHANGELOG index 68954d963..cf7728633 100644 --- a/src/VBox/Devices/Network/lwip-new/CHANGELOG +++ b/src/VBox/Devices/Network/lwip-new/CHANGELOG @@ -6,6 +6,10 @@ HISTORY ++ New features: + 2014-01-17: Jiri Engelthaler + * icmp, icmp6, opt.h: patch #8027: Completed HW checksuming for IPv4 and + IPv6 ICMP's + 2012-03-25: Simon Goldschmidt (idea by Mason) * posix/*: added posix-compatibility include files posix/netdb.h and posix/sys/socket.h which are a simple wrapper to the correct lwIP include files. @@ -80,6 +84,46 @@ HISTORY ++ Bugfixes: + 2014-01-08: Stathis Voukelatos + * memp_std.h: patch #7928 Fixed size calculation in MALLOC memory pool + creation macro + + 2014-01-18: Brian Fahs + * tcp_out.c: patch #8237: tcp_rexmit_rto fails to update pcb->unsent_oversize + when necessary + + 2014-01-17: Grant Erickson, Jay Logue, Simon Goldschmidt + * ipv6.c, netif.c: patch #7913 Enable Support for IPv6 Loopback + + 2014-01-16: Stathis Voukelatos + * netif.c: patch #7902 Fixed netif_poll() operation when LWIP_LOOPBACK_MAX_PBUFS > 0 + + 2014-01-14: "Freddie Chopin" + * snmp.h, mib2.c: fixed constness and spelling of sysdescr + + 2014-01-14: Simon Goldschmidt (patch by Thomas Faber) + * tcpip.c: patch #8241: Fix implicit declaration of ip_input with + LWIP_TCPIP_CORE_LOCKING_INPUT disabled + + 2014-01-14: chrysn + * timers.c: patch #8244 make timeouts usable reliably from outside of the + timeout routine + + 2014-01-10: Simon Goldschmidt + * ip_frag.c, ip6_frag.c: fixed bug #41041 Potential use-after-free in IPv6 reassembly + + 2014-01-10: Simon Goldschmidt + * memp.c: fixed bug #41188 Alignment error in memp_init() when MEMP_SEPARATE_POOLS==1 + + 2014-01-10: Simon Goldschmidt + * tcp.c: fixed bug #39898 tcp_fasttmr() possible lock due to infinte queue process loop + + 2013-06-29: Simon Goldschmidt + * inet.h, sockets.h: partially fixed bug #37585: IPv6 compatibility (in socket structs) + + 2013-06-29: Simon Goldschmidt + * inet6.h: bug #37585/task #12600: fixed struct in6_addr.s6_addr to conform to spec + 2013-04-24: patch by Liam <morepork> * api_msg.c: patch #8008 Fix a potential null pointer dereference in assert diff --git a/src/VBox/Devices/Network/lwip-new/Makefile.kmk b/src/VBox/Devices/Network/lwip-new/Makefile.kmk index 396ec80a3..0a8bee545 100644 --- a/src/VBox/Devices/Network/lwip-new/Makefile.kmk +++ b/src/VBox/Devices/Network/lwip-new/Makefile.kmk @@ -15,13 +15,6 @@ # hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. # -# -# Recommended kmk flags: -# -# VBOX_WITH_NAT_SERVICE=1 -# VBOX_WITH_LWIP_NAT=1 -# - LWIP_INCS += \ src/include \ src/include/ipv4 \ @@ -101,9 +94,6 @@ LWIP_SOURCES += \ # src/netif/ppp/vj.c -define def_vbox_lwip_flags # VAR_BaseName, path/to/lwip/dir - $(strip $1)_INCS += $(foreach incdir, $(LWIP_INCS), $(strip $2)/$(incdir)) -endef define _def_vbox_lwip_use # VAR_BaseName, path/to/lwip/dir $(strip $1)_SOURCES += \ @@ -113,6 +103,25 @@ define _def_vbox_lwip_use # VAR_BaseName, path/to/lwip/dir # $(strip $2)/src/foo/bar.c_CFLAGS += -magic endef + +define def_vbox_lwip_flags # PROTO_BaseName, VAR_BaseName, path/to/lwip/dir + # add anything configured for the component via PROTO_BaseName + $(foreach suffix, INCS DEFS, + $(if $(value $(strip $1)_LWIP_$(suffix)), + $(eval # + $(strip $2)_$(suffix) += $(value $(strip $1)_LWIP_$(suffix)) + ))) + + # add lwip's own includes + $(strip $2)_INCS += $(foreach incdir, $(LWIP_INCS), $(strip $3)/$(incdir)) + + # disable lwip assertions for some build types + $(strip $2)_DEFS.release += LWIP_NOASSERT + $(strip $2)_DEFS.profile += LWIP_NOASSERT + $(strip $2)_DEFS.kprofile += LWIP_NOASSERT +endef + + ### ### Call this if you want to expose lwip to your component as a whole. ### In this case individual lwip files (added to _SOURCES of your @@ -123,9 +132,10 @@ endef ### define def_vbox_lwip_public # VAR_BaseName, path/to/lwip/dir $(eval $(call _def_vbox_lwip_use, $1, $2)) - $(eval $(call def_vbox_lwip_flags, $1, $2)) + $(eval $(call def_vbox_lwip_flags, $1, $1, $2)) endef + ### ### Call this if you want to expose lwip only to a few selected files. ### In this case each lwip file is configured with lwip includes etc @@ -137,7 +147,7 @@ endef define def_vbox_lwip_private # VAR_BaseName, path/to/lwip/dir $(eval $(call _def_vbox_lwip_use, $1, $2)) $(foreach file, $(LWIP_SOURCES), \ - $(eval $(call def_vbox_lwip_flags, $(strip $2)/$(file), $2))) + $(eval $(call def_vbox_lwip_flags, $1, $(strip $2)/$(file), $2))) endef diff --git a/src/VBox/Devices/Network/lwip-new/src/api/tcpip.c b/src/VBox/Devices/Network/lwip-new/src/api/tcpip.c index f959b5830..7d4afbfdf 100644 --- a/src/VBox/Devices/Network/lwip-new/src/api/tcpip.c +++ b/src/VBox/Devices/Network/lwip-new/src/api/tcpip.c @@ -46,6 +46,7 @@ #include "lwip/pbuf.h" #include "lwip/tcpip.h" #include "lwip/init.h" +#include "lwip/ip.h" #include "netif/etharp.h" #include "netif/ppp_oe.h" diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/icmp.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/icmp.c index 464d14e9b..85e67eb87 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/icmp.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/icmp.c @@ -145,6 +145,7 @@ icmp_input(struct pbuf *p, struct netif *inp) LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: bad ICMP echo received\n")); goto lenerr; } +#if CHECKSUM_CHECK_ICMP if (inet_chksum_pbuf(p) != 0) { LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: checksum failed for received ICMP echo\n")); pbuf_free(p); @@ -152,6 +153,7 @@ icmp_input(struct pbuf *p, struct netif *inp) snmp_inc_icmpinerrors(); return; } +#endif #if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN if (pbuf_header(p, (PBUF_IP_HLEN + PBUF_LINK_HLEN))) { /* p is not big enough to contain link headers @@ -427,7 +429,9 @@ icmp_send_response(struct pbuf *p, u8_t type, u8_t code) /* calculate checksum */ icmphdr->chksum = 0; +#if CHECKSUM_GEN_ICMP icmphdr->chksum = inet_chksum(icmphdr, q->len); +#endif ICMP_STATS_INC(icmp.xmit); /* increase number of messages attempted to send */ snmp_inc_icmpoutmsgs(); diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip4.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip4.c index 4cb40fe25..ab051d4b0 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip4.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip4.c @@ -879,11 +879,11 @@ err_t ip_output_if_opt(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, if (ip_addr_cmp(dest, &netif->ip_addr)) { /* Packet to self, enqueue it for loopback */ LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()")); - return netif_loop_output(netif, p, dest); + return netif_loop_output(netif, p); } #if LWIP_IGMP if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) { - netif_loop_output(netif, p, dest); + netif_loop_output(netif, p); } #endif /* LWIP_IGMP */ #endif /* ENABLE_LOOPBACK */ diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip_frag.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip_frag.c index 8d184345d..f68cc351b 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip_frag.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv4/ip_frag.c @@ -481,7 +481,6 @@ ip_reass(struct pbuf *p) struct ip_reass_helper *iprh; u16_t offset, len; u8_t clen; - struct ip_reassdata *ipr_prev = NULL; IPFRAG_STATS_INC(ip_frag.recv); snmp_inc_ipreasmreqds(); @@ -527,7 +526,6 @@ ip_reass(struct pbuf *p) IPFRAG_STATS_INC(ip_frag.cachehit); break; } - ipr_prev = ipr; } if (ipr == NULL) { @@ -565,6 +563,7 @@ ip_reass(struct pbuf *p) /* find the right place to insert this pbuf */ /* @todo: trim pbufs if fragments are overlapping */ if (ip_reass_chain_frag_into_datagram_and_validate(ipr, p)) { + struct ip_reassdata *ipr_prev; /* the totally last fragment (flag more fragments = 0) was received at least * once AND all fragments are received */ ipr->datagram_len += IP_HLEN; @@ -579,7 +578,9 @@ ip_reass(struct pbuf *p) IPH_OFFSET_SET(fraghdr, 0); IPH_CHKSUM_SET(fraghdr, 0); /* @todo: do we need to set calculate the correct checksum? */ +#if CHECKSUM_GEN_IP IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN)); +#endif /* CHECKSUM_GEN_IP */ p = ipr->p; @@ -592,6 +593,14 @@ ip_reass(struct pbuf *p) pbuf_cat(p, r); r = iprh->next_pbuf; } + + /* find the previous entry in the linked list */ + for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr->next) { + if (ipr_prev->next == ipr) { + break; + } + } + /* release the sources allocate for the fragment queue entry */ ip_reass_dequeue_datagram(ipr, ipr_prev); @@ -811,7 +820,9 @@ ip_frag(struct pbuf *p, struct netif *netif, ip_addr_t *dest) IPH_OFFSET_SET(iphdr, htons(tmp)); IPH_LEN_SET(iphdr, htons(cop + IP_HLEN)); IPH_CHKSUM_SET(iphdr, 0); +#if CHECKSUM_GEN_IP IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN)); +#endif /* CHECKSUM_GEN_IP */ #if IP_FRAG_USES_STATIC_BUF if (last) { diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/icmp6.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/icmp6.c index 09d598f82..28d6611d5 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/icmp6.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/icmp6.c @@ -101,7 +101,7 @@ icmp6_input(struct pbuf *p, struct netif *inp) icmp6hdr = (struct icmp6_hdr *)p->payload; -#if LWIP_ICMP6_CHECKSUM_CHECK +#if CHECKSUM_CHECK_ICMP6 if (ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->tot_len, ip6_current_src_addr(), ip6_current_dest_addr()) != 0) { /* Checksum failed */ @@ -110,7 +110,7 @@ icmp6_input(struct pbuf *p, struct netif *inp) ICMP6_STATS_INC(icmp6.drop); return; } -#endif /* LWIP_ICMP6_CHECKSUM_CHECK */ +#endif /* CHECKSUM_CHECK_ICMP6 */ switch (icmp6hdr->type) { case ICMP6_TYPE_NA: /* Neighbor advertisement */ @@ -184,8 +184,10 @@ icmp6_input(struct pbuf *p, struct netif *inp) /* Set fields in reply. */ ((struct icmp6_echo_hdr *)(r->payload))->type = ICMP6_TYPE_EREP; ((struct icmp6_echo_hdr *)(r->payload))->chksum = 0; +#if CHECKSUM_GEN_ICMP6 ((struct icmp6_echo_hdr *)(r->payload))->chksum = ip6_chksum_pseudo(r, IP6_NEXTH_ICMP6, r->tot_len, reply_src, ip6_current_src_addr()); +#endif /* CHECKSUM_GEN_ICMP6 */ /* Send reply. */ ICMP6_STATS_INC(icmp6.xmit); @@ -218,8 +220,6 @@ void icmp6_proxy_input(struct pbuf *p, struct netif *inp) { struct icmp6_hdr *icmp6hdr; - struct pbuf * r; - ip6_addr_t * reply_src; ICMP6_STATS_INC(icmp6.recv); @@ -394,8 +394,10 @@ icmp6_send_response(struct pbuf *p, u8_t code, u32_t data, u8_t type) /* calculate checksum */ icmp6hdr->chksum = 0; +#if CHECKSUM_GEN_ICMP6 icmp6hdr->chksum = ip6_chksum_pseudo(q, IP6_NEXTH_ICMP6, q->tot_len, reply_src, reply_dest); +#endif /* CHECKSUM_GEN_ICMP6 */ ICMP6_STATS_INC(icmp6.xmit); ip6_output_if(q, reply_src, reply_dest, LWIP_ICMP6_HL, 0, IP6_NEXTH_ICMP6, netif); diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/ip6.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/ip6.c index b890073d6..43a1d2164 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/ip6.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/ip6.c @@ -947,10 +947,17 @@ ip6_output_if(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest, ip6_debug_print(p); #if ENABLE_LOOPBACK - /* TODO implement loopback for v6 - if (ip6_addr_cmp(dest, netif_ip6_addr(0))) { - return netif_loop_output(netif, p, dest); - }*/ + { + int i; + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp(dest, netif_ip6_addr(netif, i))) { + /* Packet to self, enqueue it for loopback */ + LWIP_DEBUGF(IP6_DEBUG, ("netif_loop_output()\n")); + return netif_loop_output(netif, p); + } + } + } #endif /* ENABLE_LOOPBACK */ #if LWIP_IPV6_FRAG /* don't fragment if interface has mtu set to 0 [loopif] */ @@ -959,7 +966,7 @@ ip6_output_if(struct pbuf *p, ip6_addr_t *src, ip6_addr_t *dest, } #endif /* LWIP_IPV6_FRAG */ - LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()")); + LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()\n")); return netif->output_ip6(netif, p, dest); } diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/mld6.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/mld6.c index 6b45ca043..f91f7efaa 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/mld6.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/mld6.c @@ -566,8 +566,10 @@ mld6_send(struct mld_group *group, u8_t type) mld_hdr->reserved = 0; ip6_addr_set(&(mld_hdr->multicast_address), &(group->group_address)); +#if CHECKSUM_GEN_ICMP6 mld_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, &(group->group_address)); +#endif /* CHECKSUM_GEN_ICMP6 */ /* Add hop-by-hop headers options: router alert with MLD value. */ ip6_options_add_hbh_ra(p, IP6_NEXTH_ICMP6, IP6_ROUTER_ALERT_VALUE_MLD); diff --git a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/nd6.c b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/nd6.c index e0a063c2a..2eb74a7d3 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/ipv6/nd6.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/ipv6/nd6.c @@ -888,8 +888,10 @@ nd6_send_ns(struct netif * netif, ip6_addr_t * target_addr, u8_t flags) target_addr = &multicast_address; } +#if CHECKSUM_GEN_ICMP6 ns_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, target_addr); +#endif /* CHECKSUM_GEN_ICMP6 */ /* Send the packet out. */ ND6_STATS_INC(nd6.xmit); @@ -960,8 +962,10 @@ nd6_send_na(struct netif * netif, ip6_addr_t * target_addr, u8_t flags) dest_addr = ip6_current_src_addr(); } +#if CHECKSUM_GEN_ICMP6 na_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, dest_addr); +#endif /* CHECKSUM_GEN_ICMP6 */ /* Send the packet out. */ ND6_STATS_INC(nd6.xmit); @@ -1027,8 +1031,10 @@ nd6_send_rs(struct netif * netif) SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); } +#if CHECKSUM_GEN_ICMP6 rs_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, &multicast_address); +#endif /* CHECKSUM_GEN_ICMP6 */ /* Send the packet out. */ ND6_STATS_INC(nd6.xmit); diff --git a/src/VBox/Devices/Network/lwip-new/src/core/memp.c b/src/VBox/Devices/Network/lwip-new/src/core/memp.c index 6d109797f..d2743736b 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/memp.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/memp.c @@ -201,7 +201,7 @@ static const char *memp_desc[MEMP_MAX] = { * extern u8_t __attribute__((section(".onchip_mem"))) memp_memory_UDP_PCB_base[]; */ #define LWIP_MEMPOOL(name,num,size,desc) u8_t memp_memory_ ## name ## _base \ - [((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))]; + [LWIP_MEM_ALIGN_BUFFER((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))]; #include "lwip/memp_std.h" /** This array holds the base of each memory pool. */ @@ -213,7 +213,7 @@ static u8_t *const memp_bases[] = { #else /* MEMP_SEPARATE_POOLS */ /** This is the actual memory used by the pools (all pools in one big block). */ -static u8_t memp_memory[MEM_ALIGNMENT - 1 +static u8_t memp_memory[MEM_ALIGNMENT - 1 /* XXX: LWIP_MEM_ALIGN_BUFFER */ #define LWIP_MEMPOOL(name,num,size,desc) + ( (num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size) ) ) #include "lwip/memp_std.h" ]; @@ -334,7 +334,7 @@ memp_overflow_check_all(void) #endif /* !MEMP_SEPARATE_POOLS */ for (i = 0; i < MEMP_MAX; ++i) { #if MEMP_SEPARATE_POOLS - p = (struct memp *)(memp_bases[i]); + p = (struct memp *)LWIP_MEM_ALIGN(memp_bases[i]); #endif /* MEMP_SEPARATE_POOLS */ for (j = 0; j < memp_num[i]; ++j) { memp_overflow_check_element_overflow(p, i); @@ -346,7 +346,7 @@ memp_overflow_check_all(void) #endif /* !MEMP_SEPARATE_POOLS */ for (i = 0; i < MEMP_MAX; ++i) { #if MEMP_SEPARATE_POOLS - p = (struct memp *)(memp_bases[i]); + p = (struct memp *)LWIP_MEM_ALIGN(memp_bases[i]); #endif /* MEMP_SEPARATE_POOLS */ for (j = 0; j < memp_num[i]; ++j) { memp_overflow_check_element_underflow(p, i); @@ -370,7 +370,7 @@ memp_overflow_init(void) #endif /* !MEMP_SEPARATE_POOLS */ for (i = 0; i < MEMP_MAX; ++i) { #if MEMP_SEPARATE_POOLS - p = (struct memp *)(memp_bases[i]); + p = (struct memp *)LWIP_MEM_ALIGN(memp_bases[i]); #endif /* MEMP_SEPARATE_POOLS */ for (j = 0; j < memp_num[i]; ++j) { #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 @@ -415,7 +415,7 @@ memp_init(void) VALGRIND_CREATE_MEMPOOL(&memp_tab[i], MEMP_VALGRIND_RED_ZONE, 0); #endif #if MEMP_SEPARATE_POOLS - memp = (struct memp*)memp_bases[i]; + memp = (struct memp*)LWIP_MEM_ALIGN(memp_bases[i]); #endif /* MEMP_SEPARATE_POOLS */ /* create a linked list of memp elements */ for (j = 0; j < memp_num[i]; ++j) { diff --git a/src/VBox/Devices/Network/lwip-new/src/core/netif.c b/src/VBox/Devices/Network/lwip-new/src/core/netif.c index 1004ed126..385711fe9 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/netif.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/netif.c @@ -88,7 +88,19 @@ static u8_t netif_num; static err_t netif_null_output_ip6(struct netif *netif, struct pbuf *p, ip6_addr_t *ipaddr); #endif /* LWIP_IPV6 */ +#if LWIP_IPV6 +#define ipX_input(in, netif) (IP6H_V((const struct ip6_hdr *)in->payload) == 6) ? ip6_input(in, netif) : ip_input(in, netif) +#else +#define ipX_input(in, netif) ip_input(in, netif) +#endif + #if LWIP_HAVE_LOOPIF +static err_t netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, ip_addr_t* addr); +#if LWIP_IPV6 +static err_t netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, ip6_addr_t* addr); +#endif + + static struct netif loop_netif; /** @@ -108,7 +120,10 @@ netif_loopif_init(struct netif *netif) netif->name[0] = 'l'; netif->name[1] = 'o'; - netif->output = netif_loop_output; + netif->output = netif_loop_output_ipv4; +#if LWIP_IPV6 + netif->output_ip6 = netif_loop_output_ipv6; +#endif return ERR_OK; } #endif /* LWIP_HAVE_LOOPIF */ @@ -127,6 +142,15 @@ netif_init(void) #else /* NO_SYS */ netif_add(&loop_netif, &loop_ipaddr, &loop_netmask, &loop_gw, NULL, netif_loopif_init, tcpip_input); #endif /* NO_SYS */ + +#if LWIP_IPV6 + loop_netif.ip6_addr[0].addr[0] = 0; + loop_netif.ip6_addr[0].addr[1] = 0; + loop_netif.ip6_addr[0].addr[2] = 0; + loop_netif.ip6_addr[0].addr[3] = PP_HTONL(0x00000001UL); + loop_netif.ip6_addr_state[0] = IP6_ADDR_VALID; +#endif /* LWIP_IPV6 */ + netif_set_up(&loop_netif); #endif /* LWIP_HAVE_LOOPIF */ @@ -655,13 +679,11 @@ void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_ * * @param netif the lwip network interface structure * @param p the (IP) packet to 'send' - * @param ipaddr the ip address to send the packet to (not used) * @return ERR_OK if the packet has been sent * ERR_MEM if the pbuf used to copy the packet couldn't be allocated */ err_t -netif_loop_output(struct netif *netif, struct pbuf *p, - ip_addr_t *ipaddr) +netif_loop_output(struct netif *netif, struct pbuf *p) { struct pbuf *r; err_t err; @@ -679,7 +701,6 @@ netif_loop_output(struct netif *netif, struct pbuf *p, #endif /* LWIP_HAVE_LOOPIF */ #endif /* LWIP_SNMP */ SYS_ARCH_DECL_PROTECT(lev); - LWIP_UNUSED_ARG(ipaddr); /* Allocate a new pbuf */ r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM); @@ -741,6 +762,23 @@ netif_loop_output(struct netif *netif, struct pbuf *p, return ERR_OK; } +static err_t +netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, ip_addr_t* addr) +{ + LWIP_UNUSED_ARG(addr); + return netif_loop_output(netif, p); +} + +#if LWIP_IPV6 +static err_t +netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, ip6_addr_t* addr) +{ + LWIP_UNUSED_ARG(addr); + return netif_loop_output(netif, p); +} +#endif + + /** * Call netif_poll() in the main loop of your application. This is to prevent * reentering non-reentrant functions like tcp_input(). Packets passed to @@ -769,16 +807,22 @@ netif_poll(struct netif *netif) if (in != NULL) { struct pbuf *in_end = in; #if LWIP_LOOPBACK_MAX_PBUFS - u8_t clen = pbuf_clen(in); - /* adjust the number of pbufs on queue */ - LWIP_ASSERT("netif->loop_cnt_current underflow", - ((netif->loop_cnt_current - clen) < netif->loop_cnt_current)); - netif->loop_cnt_current -= clen; + u8_t clen = 1; #endif /* LWIP_LOOPBACK_MAX_PBUFS */ while (in_end->len != in_end->tot_len) { LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL); in_end = in_end->next; +#if LWIP_LOOPBACK_MAX_PBUFS + clen++; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ } +#if LWIP_LOOPBACK_MAX_PBUFS + /* adjust the number of pbufs on queue */ + LWIP_ASSERT("netif->loop_cnt_current underflow", + ((netif->loop_cnt_current - clen) < netif->loop_cnt_current)); + netif->loop_cnt_current -= clen; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + /* 'in_end' now points to the last pbuf from 'in' */ if (in_end == netif->loop_last) { /* this was the last pbuf in the list */ @@ -798,7 +842,7 @@ netif_poll(struct netif *netif) snmp_add_ifinoctets(stats_if, in->tot_len); snmp_inc_ifinucastpkts(stats_if); /* loopback packets are always IP packets! */ - if (ip_input(in, netif) != ERR_OK) { + if (ipX_input(in, netif) != ERR_OK) { pbuf_free(in); } /* Don't reference the packet any more! */ diff --git a/src/VBox/Devices/Network/lwip-new/src/core/snmp/mib2.c b/src/VBox/Devices/Network/lwip-new/src/core/snmp/mib2.c index dcd3b62c1..fe1bf6d71 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/snmp/mib2.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/snmp/mib2.c @@ -772,8 +772,8 @@ static const s32_t sysservices = SNMP_SYSSERVICES; /** mib-2.system.sysDescr */ static const u8_t sysdescr_len_default = 4; static const u8_t sysdescr_default[] = "lwIP"; -static u8_t* sysdescr_len_ptr = (u8_t*)&sysdescr_len_default; -static u8_t* sysdescr_ptr = (u8_t*)&sysdescr_default[0]; +static const u8_t* sysdescr_len_ptr = &sysdescr_len_default; +static const u8_t* sysdescr_ptr = &sysdescr_default[0]; /** mib-2.system.sysContact */ static const u8_t syscontact_len_default = 0; static const u8_t syscontact_default[] = ""; @@ -902,7 +902,7 @@ static u32_t snmpinpkts = 0, * @param src points to source * @param n number of octets to copy. */ -static void ocstrncpy(u8_t *dst, u8_t *src, u16_t n) +static void ocstrncpy(u8_t *dst, const u8_t *src, u16_t n) { u16_t i = n; while (i > 0) { @@ -918,7 +918,7 @@ static void ocstrncpy(u8_t *dst, u8_t *src, u16_t n) * @param src points to source * @param n number of sub identifiers to copy. */ -void objectidncpy(s32_t *dst, s32_t *src, u8_t n) +void objectidncpy(s32_t *dst, const s32_t *src, u8_t n) { u8_t i = n; while(i > 0) { @@ -933,7 +933,7 @@ void objectidncpy(s32_t *dst, s32_t *src, u8_t n) * @param str if non-NULL then copy str pointer * @param len points to string length, excluding zero terminator */ -void snmp_set_sysdesr(u8_t *str, u8_t *len) +void snmp_set_sysdescr(const u8_t *str, const u8_t *len) { if (str != NULL) { diff --git a/src/VBox/Devices/Network/lwip-new/src/core/stats.c b/src/VBox/Devices/Network/lwip-new/src/core/stats.c index 06fbe0f2c..ff97853fa 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/stats.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/stats.c @@ -86,7 +86,7 @@ stats_display_proto(struct stats_proto *proto, const char *name) LWIP_PLATFORM_DIAG(("cachehit: %"STAT_COUNTER_F"\n", proto->cachehit)); } -#if IGMP_STATS +#if IGMP_STATS || MLD6_STATS void stats_display_igmp(struct stats_igmp *igmp, const char *name) { @@ -106,7 +106,7 @@ stats_display_igmp(struct stats_igmp *igmp, const char *name) LWIP_PLATFORM_DIAG(("tx_leave: %"STAT_COUNTER_F"\n\t", igmp->tx_leave)); LWIP_PLATFORM_DIAG(("tx_report: %"STAT_COUNTER_F"\n\t", igmp->tx_report)); } -#endif /* IGMP_STATS */ +#endif /* IGMP_STATS || MLD6_STATS */ #if MEM_STATS || MEMP_STATS void diff --git a/src/VBox/Devices/Network/lwip-new/src/core/tcp.c b/src/VBox/Devices/Network/lwip-new/src/core/tcp.c index 7596562e3..ebf6f48d5 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/tcp.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/tcp.c @@ -1005,7 +1005,12 @@ tcp_slowtmr_start: * (to the real destination - as done by proxy hanlder). */ /* Check if this PCB has stayed too long in SYN-RCVD */ - if (pcb->state == SYN_RCVD || pcb->state == SYN_RCVD_0) { + if (pcb->state == SYN_RCVD +#if LWIP_CONNECTION_PROXY + || pcb->state == SYN_RCVD_0 +#endif + ) + { if ((u32_t)(tcp_ticks - pcb->tmr) > TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) { ++pcb_remove; @@ -1154,6 +1159,8 @@ tcp_fasttmr_start: } } pcb = next; + } else { + pcb = pcb->next; } } } diff --git a/src/VBox/Devices/Network/lwip-new/src/core/tcp_out.c b/src/VBox/Devices/Network/lwip-new/src/core/tcp_out.c index 0fcd0f12a..9884efa2c 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/tcp_out.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/tcp_out.c @@ -1262,11 +1262,16 @@ tcp_rexmit_rto(struct tcp_pcb *pcb) for (seg = pcb->unacked; seg->next != NULL; seg = seg->next); /* concatenate unsent queue after unacked queue */ seg->next = pcb->unsent; +#if TCP_OVERSIZE && TCP_OVERSIZE_DBGCHECK + /* if last unsent changed, we need to update unsent_oversize */ + if (pcb->unsent == NULL) { + pcb->unsent_oversize = seg->oversize_left; + } +#endif /* TCP_OVERSIZE && TCP_OVERSIZE_DBGCHECK*/ /* unsent queue is the concatenated queue (of unacked, unsent) */ pcb->unsent = pcb->unacked; /* unacked queue is now empty */ pcb->unacked = NULL; - /* last unsent hasn't changed, no need to reset unsent_oversize */ /* increment number of retransmissions */ ++pcb->nrtx; diff --git a/src/VBox/Devices/Network/lwip-new/src/core/timers.c b/src/VBox/Devices/Network/lwip-new/src/core/timers.c index 02fef0fdd..601a905f2 100644 --- a/src/VBox/Devices/Network/lwip-new/src/core/timers.c +++ b/src/VBox/Devices/Network/lwip-new/src/core/timers.c @@ -79,7 +79,7 @@ static int tcpip_tcp_timer_active; #if LWIP_CONNECTION_PROXY /** global variable that shows if proxy timer is currently scheduled or not */ static int proxy_udp_timer_active; -#endif /* LWIP_TCP */ +#endif /* LWIP_CONNECTION_PROXY */ #if LWIP_TCP @@ -368,16 +368,34 @@ sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg) #endif /* LWIP_DEBUG_TIMERNAMES */ { struct sys_timeo *timeout, *t; +#if NO_SYS + u32_t now, diff; +#endif timeout = (struct sys_timeo *)memp_malloc(MEMP_SYS_TIMEOUT); if (timeout == NULL) { LWIP_ASSERT("sys_timeout: timeout != NULL, pool MEMP_SYS_TIMEOUT is empty", timeout != NULL); return; } + +#if NO_SYS + now = sys_now(); + if (next_timeout == NULL) { + diff = 0; + timeouts_last_time = now; + } else { + diff = now - timeouts_last_time; + } +#endif + timeout->next = NULL; timeout->h = handler; timeout->arg = arg; +#if NO_SYS + timeout->time = msecs + diff; +#else timeout->time = msecs; +#endif #if LWIP_DEBUG_TIMERNAMES timeout->handler_name = handler_name; LWIP_DEBUGF(TIMERS_DEBUG, ("sys_timeout: %p msecs=%"U32_F" handler=%s arg=%p\n", @@ -479,7 +497,7 @@ sys_check_timeouts(void) if (tmptimeout && (tmptimeout->time <= diff)) { /* timeout has expired */ had_one = 1; - timeouts_last_time = now; + timeouts_last_time += tmptimeout->time; diff -= tmptimeout->time; next_timeout = tmptimeout->next; handler = tmptimeout->h; diff --git a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/autoip.h b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/autoip.h index e62b72e8c..b9f18733f 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/autoip.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/autoip.h @@ -94,6 +94,9 @@ struct autoip /** Set a struct autoip allocated by the application to work with */ void autoip_set_struct(struct netif *netif, struct autoip *autoip); +/** Remove a struct autoip previously set to the netif using autoip_set_struct() */ +#define autoip_remove_struct(netif) do { (netif)->autoip = NULL; } while (0) + /** Start AutoIP client */ err_t autoip_start(struct netif *netif); diff --git a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/inet.h b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/inet.h index 7bff49b59..a6d2eda48 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/inet.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/inet.h @@ -40,9 +40,14 @@ extern "C" { #endif +/* If your port already typedef's in_addr_t, define IN_ADDR_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED) +typedef u32_t in_addr_t; +#endif /** For compatibility with BSD code */ struct in_addr { - u32_t s_addr; + in_addr_t s_addr; }; /** 255.255.255.255 */ @@ -89,6 +94,15 @@ struct in_addr { #define IN_LOOPBACKNET IP_LOOPBACKNET +#ifndef INET_ADDRSTRLEN +#define INET_ADDRSTRLEN IP4ADDR_STRLEN_MAX +#endif +#if LWIP_IPV6 +#ifndef INET6_ADDRSTRLEN +#define INET6_ADDRSTRLEN IP6ADDR_STRLEN_MAX +#endif +#endif + #define inet_addr_from_ipaddr(target_inaddr, source_ipaddr) ((target_inaddr)->s_addr = ip4_addr_get_u32(source_ipaddr)) #define inet_addr_to_ipaddr(target_ipaddr, source_inaddr) (ip4_addr_set_u32(target_ipaddr, (source_inaddr)->s_addr)) /* ATTENTION: the next define only works because both s_addr and ip_addr_t are an u32_t effectively! */ diff --git a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/ip4_addr.h b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/ip4_addr.h index 923d4b066..af76856cf 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/ip4_addr.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/ipv4/lwip/ip4_addr.h @@ -228,6 +228,9 @@ u8_t ip4_addr_netmask_valid(u32_t netmask); #define ip4_addr3_16(ipaddr) ((u16_t)ip4_addr3(ipaddr)) #define ip4_addr4_16(ipaddr) ((u16_t)ip4_addr4(ipaddr)) +#define IP4ADDR_STRLEN_MAX 16 +#define IPADDR_STRLEN_MAX IP4ADDR_STRLEN_MAX + /** For backwards compatibility */ #define ip_ntoa(ipaddr) ipaddr_ntoa(ipaddr) diff --git a/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/inet6.h b/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/inet6.h index dbf98df01..8359521b5 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/inet6.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/inet6.h @@ -58,7 +58,7 @@ struct in6_addr { u8_t u8_addr[16]; u32_t u32_addr[4]; } un; -#define s6_addr un.u32_addr +#define s6_addr un.u8_addr }; #define IN6ADDR_ANY_INIT {0,0,0,0} diff --git a/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/ip6_addr.h b/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/ip6_addr.h index 56da0d34b..4e5f4a25d 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/ip6_addr.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/ipv6/lwip/ip6_addr.h @@ -85,8 +85,6 @@ extern const ip6_addr_t ip6_addr_any; #define IP6_ADDR_ANY ((ip6_addr_t *)&ip6_addr_any) - - #if BYTE_ORDER == BIG_ENDIAN /** Set an IPv6 partial address given by byte-parts. */ #define IP6_ADDR(ip6addr, index, a,b,c,d) \ @@ -146,7 +144,6 @@ Little-endian version, stored in network order (no htonl). */ (dest)->addr[3] = (src) == NULL ? 0 : htonl((src)->addr[3]);}while(0) - /** * Determine if two IPv6 address are on the same network. * @@ -170,6 +167,10 @@ Little-endian version, stored in network order (no htonl). */ ((ip6addr)->addr[2] == 0) && \ ((ip6addr)->addr[3] == 0))) +#define ip6_addr_isloopback(ip6addr) (((ip6addr)->addr[0] == 0UL) && \ + ((ip6addr)->addr[1] == 0UL) && \ + ((ip6addr)->addr[2] == 0UL) && \ + ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) #define ip6_addr_isglobal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xe0000000UL)) == PP_HTONL(0x20000000UL)) @@ -270,6 +271,8 @@ Little-endian version, stored in network order (no htonl). */ ipaddr != NULL ? IP6_ADDR_BLOCK7(ipaddr) : 0, \ ipaddr != NULL ? IP6_ADDR_BLOCK8(ipaddr) : 0)) +#define IP6ADDR_STRLEN_MAX 46 + int ip6addr_aton(const char *cp, ip6_addr_t *addr); /** returns ptr to static buffer; not reentrant! */ char *ip6addr_ntoa(const ip6_addr_t *addr); diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/debug.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/debug.h index 0fe041396..fe66d4e47 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/debug.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/debug.h @@ -76,6 +76,8 @@ #endif /* LWIP_ERROR */ #ifdef LWIP_DEBUG +/* let VBox override it to use logging */ +#ifndef LWIP_DEBUGF /** print debug message only if debug message type is enabled... * AND is of correct type AND is at least LWIP_DBG_LEVEL */ @@ -90,8 +92,12 @@ } \ } \ } while(0) - +#endif /* !LWIP_DEBUGF */ #else /* LWIP_DEBUG */ +#ifdef LWIP_DEBUG +/* sanity check, this is going to fail with undefined variables anyway */ +#error LWIP_DEBUGF is defined without LWIP_DEBUG +#endif #define LWIP_DEBUGF(debug, message) #endif /* LWIP_DEBUG */ diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/memp_std.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/memp_std.h index 592a2824e..8e1c99c40 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/memp_std.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/memp_std.h @@ -12,7 +12,7 @@ #ifndef LWIP_MALLOC_MEMPOOL /* This treats "malloc pools" just like any other pool. The pools are a little bigger to provide 'size' as the amount of user data. */ -#define LWIP_MALLOC_MEMPOOL(num, size) LWIP_MEMPOOL(POOL_##size, num, (size + sizeof(struct memp_malloc_helper)), "MALLOC_"#size) +#define LWIP_MALLOC_MEMPOOL(num, size) LWIP_MEMPOOL(POOL_##size, num, (size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))), "MALLOC_"#size) #define LWIP_MALLOC_MEMPOOL_START #define LWIP_MALLOC_MEMPOOL_END #endif /* LWIP_MALLOC_MEMPOOL */ diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/netif.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/netif.h index 322d2d0ed..b2c8d87a7 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/netif.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/netif.h @@ -359,7 +359,7 @@ void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_ #endif /* LWIP_IGMP */ #if ENABLE_LOOPBACK -err_t netif_loop_output(struct netif *netif, struct pbuf *p, ip_addr_t *dest_ip); +err_t netif_loop_output(struct netif *netif, struct pbuf *p); void netif_poll(struct netif *netif); #if !LWIP_NETIF_LOOPBACK_MULTITHREADING void netif_poll_all(void); diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/netifapi.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/netifapi.h index 33318efaf..648151b6b 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/netifapi.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/netifapi.h @@ -96,6 +96,9 @@ err_t netifapi_netif_common ( struct netif *netif, #define netifapi_netif_set_default(n) netifapi_netif_common(n, netif_set_default, NULL) #define netifapi_dhcp_start(n) netifapi_netif_common(n, NULL, dhcp_start) #define netifapi_dhcp_stop(n) netifapi_netif_common(n, dhcp_stop, NULL) +#define netifapi_dhcp_inform(n) netifapi_netif_common(n, dhcp_inform, NULL) +#define netifapi_dhcp_renew(n) netifapi_netif_common(n, NULL, dhcp_renew) +#define netifapi_dhcp_release(n) netifapi_netif_common(n, NULL, dhcp_release) #define netifapi_autoip_start(n) netifapi_netif_common(n, NULL, autoip_start) #define netifapi_autoip_stop(n) netifapi_netif_common(n, NULL, autoip_stop) diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/opt.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/opt.h index 0da6fad50..1cec8d464 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/opt.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/opt.h @@ -1881,6 +1881,13 @@ #endif /** + * CHECKSUM_GEN_ICMP6==1: Generate checksums in software for outgoing ICMP6 packets. + */ +#ifndef CHECKSUM_GEN_ICMP6 +#define CHECKSUM_GEN_ICMP6 1 +#endif + +/** * CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets. */ #ifndef CHECKSUM_CHECK_IP @@ -1902,6 +1909,20 @@ #endif /** + * CHECKSUM_CHECK_ICMP==1: Check checksums in software for incoming ICMP packets. + */ +#ifndef CHECKSUM_CHECK_ICMP +#define CHECKSUM_CHECK_ICMP 1 +#endif + +/** + * CHECKSUM_CHECK_ICMP6==1: Check checksums in software for incoming ICMPv6 packets + */ +#ifndef CHECKSUM_CHECK_ICMP6 +#define CHECKSUM_CHECK_ICMP6 1 +#endif + +/** * LWIP_CHECKSUM_ON_COPY==1: Calculate checksum when copying data from * application buffers to pbufs. */ @@ -1958,13 +1979,6 @@ #endif /** - * LWIP_ICMP6_CHECKSUM_CHECK==1: verify checksum on ICMPv6 packets - */ -#ifndef LWIP_ICMP6_CHECKSUM_CHECK -#define LWIP_ICMP6_CHECKSUM_CHECK 1 -#endif - -/** * LWIP_IPV6_MLD==1: Enable multicast listener discovery protocol. */ #ifndef LWIP_IPV6_MLD diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/snmp.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/snmp.h index 2ed043dd5..7844cc11e 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/snmp.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/snmp.h @@ -98,7 +98,7 @@ struct snmp_obj_id }; /* system */ -void snmp_set_sysdesr(u8_t* str, u8_t* len); +void snmp_set_sysdescr(const u8_t* str, const u8_t* len); void snmp_set_sysobjid(struct snmp_obj_id *oid); void snmp_get_sysobjid_ptr(struct snmp_obj_id **oid); void snmp_inc_sysuptime(void); @@ -231,7 +231,7 @@ void snmp_get_snmpenableauthentraps(u8_t *value); #else /* system */ -#define snmp_set_sysdesr(str, len) +#define snmp_set_sysdescr(str, len) #define snmp_set_sysobjid(oid); #define snmp_get_sysobjid_ptr(oid) #define snmp_inc_sysuptime() diff --git a/src/VBox/Devices/Network/lwip-new/src/include/lwip/sockets.h b/src/VBox/Devices/Network/lwip-new/src/include/lwip/sockets.h index 73461374b..853beea80 100644 --- a/src/VBox/Devices/Network/lwip-new/src/include/lwip/sockets.h +++ b/src/VBox/Devices/Network/lwip-new/src/include/lwip/sockets.h @@ -48,33 +48,54 @@ extern "C" { #endif +/* If your port already typedef's sa_family_t, define SA_FAMILY_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(sa_family_t) && !defined(SA_FAMILY_T_DEFINED) +typedef u8_t sa_family_t; +#endif +/* If your port already typedef's in_port_t, define IN_PORT_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(in_port_t) && !defined(IN_PORT_T_DEFINED) +typedef u16_t in_port_t; +#endif + /* members are in network byte order */ struct sockaddr_in { - u8_t sin_len; - u8_t sin_family; - u16_t sin_port; - struct in_addr sin_addr; + u8_t sin_len; + sa_family_t sin_family; + in_port_t sin_port; + struct in_addr sin_addr; #define SIN_ZERO_LEN 8 - char sin_zero[SIN_ZERO_LEN]; + char sin_zero[SIN_ZERO_LEN]; }; #if LWIP_IPV6 struct sockaddr_in6 { - u8_t sin6_len; /* length of this structure */ - u8_t sin6_family; /* AF_INET6 */ - u16_t sin6_port; /* Transport layer port # */ - u32_t sin6_flowinfo; /* IPv6 flow information */ - struct in6_addr sin6_addr; /* IPv6 address */ + u8_t sin6_len; /* length of this structure */ + sa_family_t sin6_family; /* AF_INET6 */ + in_port_t sin6_port; /* Transport layer port # */ + u32_t sin6_flowinfo; /* IPv6 flow information */ + struct in6_addr sin6_addr; /* IPv6 address */ }; #endif /* LWIP_IPV6 */ struct sockaddr { - u8_t sa_len; - u8_t sa_family; + u8_t sa_len; + sa_family_t sa_family; #if LWIP_IPV6 - u8_t sa_data[22]; + char sa_data[22]; #else /* LWIP_IPV6 */ - u8_t sa_data[14]; + char sa_data[14]; +#endif /* LWIP_IPV6 */ +}; + +struct sockaddr_storage { + u8_t s2_len; + sa_family_t ss_family; + char s2_data1[2]; + u32_t s2_data2[3]; +#if LWIP_IPV6 + u32_t s2_data3[2]; #endif /* LWIP_IPV6 */ }; @@ -146,10 +167,12 @@ struct linger { #define PF_UNSPEC AF_UNSPEC #define IPPROTO_IP 0 +#define IPPROTO_ICMP 1 #define IPPROTO_TCP 6 #define IPPROTO_UDP 17 #if LWIP_IPV6 #define IPPROTO_IPV6 41 +#define IPPROTO_ICMPV6 58 #endif /* LWIP_IPV6 */ #define IPPROTO_UDPLITE 136 diff --git a/src/VBox/Devices/Network/lwip-new/vbox/VBoxLwipCore.cpp b/src/VBox/Devices/Network/lwip-new/vbox/VBoxLwipCore.cpp index db07f70c7..f848e7b9e 100644 --- a/src/VBox/Devices/Network/lwip-new/vbox/VBoxLwipCore.cpp +++ b/src/VBox/Devices/Network/lwip-new/vbox/VBoxLwipCore.cpp @@ -74,7 +74,7 @@ static DECLCALLBACK(void) lwipCoreUserCallback(void *pvArg) pUserClbk->pfn(pUserClbk->pvUser); /* wake up caller on EMT/main */ - lwip_sys_sem_signal(&g_LwipCore.LwipTcpIpSem); + sys_sem_signal(&g_LwipCore.LwipTcpIpSem); LogFlowFuncLeave(); } @@ -129,14 +129,14 @@ int vboxLwipCoreInitialize(PFNRT1 pfnCallback, void *pvCallbackArg) if (g_LwipCore.iLWIPInitiatorCounter == 0) { - lwipRc = lwip_sys_sem_new(&g_LwipCore.LwipTcpIpSem, 0); + lwipRc = sys_sem_new(&g_LwipCore.LwipTcpIpSem, 0); if (lwipRc != ERR_OK) { LogFlow(("%s: sys_sem_new error %d\n", __FUNCTION__, lwipRc)); goto done; } - lwip_tcpip_init(lwipCoreInitDone, &callback); + tcpip_init(lwipCoreInitDone, &callback); } else { @@ -148,7 +148,7 @@ int vboxLwipCoreInitialize(PFNRT1 pfnCallback, void *pvCallbackArg) } } - lwip_sys_sem_wait(&g_LwipCore.LwipTcpIpSem, 0); + sys_sem_wait(&g_LwipCore.LwipTcpIpSem); ++g_LwipCore.iLWIPInitiatorCounter; } done: @@ -211,7 +211,7 @@ void vboxLwipCoreFinalize(PFNRT1 pfnCallback, void *pvCallbackArg) } if (lwipRc == ERR_OK) - lwip_sys_sem_wait(&g_LwipCore.LwipTcpIpSem, 0); + sys_sem_wait(&g_LwipCore.LwipTcpIpSem); } LogFlowFuncLeave(); diff --git a/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-log.h b/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-log.h new file mode 100644 index 000000000..f66ca8de1 --- /dev/null +++ b/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-log.h @@ -0,0 +1,93 @@ +/* -*- indent-tabs-mode: nil; -*- */ +#ifndef __VBOX_LWIP_LOG_H__ +#define __VBOX_LWIP_LOG_H__ + +#include <VBox/log.h> + +#ifdef LWIP_DEBUG +/* + * All LWIP_DBG_* constants fit into a byte, so we use upper bits to + * encode the VBox log group. + * + * Mapping between FOO_DEBUG and LOG_GROUP_LWIP_FOO is straightforward + * except for IP4 where extra '4' was added to the group names to make + * it possible to specify lwip_ip4* instead of lwip_ip*, where the + * latter would enable both IP4 and IP6 logging. + * + * We ignore LWIP_DBG_STATE &c since in our scheme they would traslate + * into additional log groups and require combinatorial explosion. We + * probably can use LWIP_DBG_TYPES_ON for finer selection if need be + * (for internal debugging only, as it requires recompilation). + * + * Debug levels are mapped to RT debug levels so lwip's default level + * ends up as RT's level4. Non-default levels are currently not used + * much in lwip sources, so enable l4 to get the logs. + */ + +#define LWIP_DEBUGF_LOG_GROUP_SHIFT 8 +#define LWIP_DEBUGF_LOG_GROUP(_g) \ + (((_g) << LWIP_DEBUGF_LOG_GROUP_SHIFT) | LWIP_DBG_ON) + +#define API_LIB_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_API_LIB) +#define API_MSG_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_API_MSG) +#define ETHARP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_ETHARP) +#define ICMP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_ICMP) +#define IGMP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_IGMP) +#define INET_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_INET) +#define IP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_IP4) +#define IP_REASS_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_IP4_REASS) +#define IP6_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_IP6) +#define MEM_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_MEM) +#define MEMP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_MEMP) +#define NETIF_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_NETIF) +#define PBUF_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_PBUF) +#define RAW_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_RAW) +#define SOCKETS_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_SOCKETS) +#define SYS_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_SYS) +#define TCP_CWND_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_CWND) +#define TCP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP) +#define TCP_FR_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_FR) +#define TCP_INPUT_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_INPUT) +#define TCP_OUTPUT_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_OUTPUT) +#define TCP_QLEN_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_QLEN) +#define TCP_RST_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_RST) +#define TCP_RTO_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_RTO) +#define TCP_WND_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCP_WND) +#define TCPIP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TCPIP) +#define TIMERS_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_TIMERS) +#define UDP_DEBUG LWIP_DEBUGF_LOG_GROUP(LOG_GROUP_LWIP_UDP) + +/* + * The following symbols are for debugging of modules that are not + * compiled in. They are listed here for reference but there're no + * log groups defined for them currently. + */ +#undef AUTOIP_DEBUG +#undef DHCP_DEBUG +#undef DNS_DEBUG +#undef PPP_DEBUG +#undef SLIP_DEBUG +#undef SNMP_MIB_DEBUG +#undef SNMP_MSG_DEBUG + +#ifdef LOG_ENABLED + +#define LWIP_DEBUGF(_when, _args) \ + do { \ + const VBOX_LOGGROUP _group = (_when) >> LWIP_DEBUGF_LOG_GROUP_SHIFT; \ + if (_group >= LOG_GROUP_DEFAULT) { \ + /* severe => l1; serious => l2; warning => l3; default => l4 */ \ + const unsigned int _level = \ + 1 << (LWIP_DBG_MASK_LEVEL+1 - ((_when) & LWIP_DBG_MASK_LEVEL)); \ + LogIt(LOG_INSTANCE, _level, _group, _args); \ + } \ + } while (0) + +#else /* !LOG_ENABLED */ + +#define LWIP_DEBUGF(_when, _args) do { } while (0) + +#endif /* !LOG_ENABLED */ + +#endif /* LWIP_DEBUG */ +#endif /* __VBOX_LWIP_LOG_H__ */ diff --git a/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-namespace.h b/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-namespace.h index f5e3f35f0..41c0ffeda 100644 --- a/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-namespace.h +++ b/src/VBox/Devices/Network/lwip-new/vbox/include/lwip-namespace.h @@ -88,11 +88,14 @@ #define netif_set_netmask lwip_netif_set_netmask #define netif_set_up lwip_netif_set_up #if MEM_LIBC_MALLOC == 0 -#define mem_free lwip_mem_free +#if MEM_USE_POOLS == 0 #define mem_init lwip_mem_init +#define mem_trim lwip_mem_trim +#endif /* !MEM_USE_POOLS */ #define mem_malloc lwip_mem_malloc -#define mem_realloc lwip_mem_realloc -#endif +#define mem_calloc lwip_mem_calloc +#define mem_free lwip_mem_free +#endif /* !MEM_LIBC_MALLOC */ #define memp_free lwip_memp_free #define memp_init lwip_memp_init #define memp_malloc lwip_memp_malloc @@ -147,7 +150,7 @@ #define sys_sem_free lwip_sys_sem_free #define sys_sem_new lwip_sys_sem_new #define sys_sem_signal lwip_sys_sem_signal -#define lwip_sys_sem_wait lwip_sys_arch_sem_wait +#define lwip_sys_sem_wait sys_sem_wait #define sys_arch_sem_wait lwip_sys_arch_sem_wait #endif #define sys_timeout_debug lwip_sys_timeout_debug @@ -221,19 +224,4 @@ #define lwip_pbuf_init() #define lwip_etharp_init() -#ifndef htons -# define htons lwip_htons -#endif - -#ifndef ntohs -# define ntohs lwip_ntohs -#endif - -#ifndef htonl -# define htonl lwip_htonl -#endif - -#ifndef ntohl -# define ntohl lwip_ntohl -#endif #endif /* _VBOX_LWIP_NAMESPACE_H_ */ diff --git a/src/VBox/Devices/Network/lwip-new/vbox/include/lwipopts.h b/src/VBox/Devices/Network/lwipopts.h index befb1d2d3..bc7193168 100644 --- a/src/VBox/Devices/Network/lwip-new/vbox/include/lwipopts.h +++ b/src/VBox/Devices/Network/lwipopts.h @@ -110,23 +110,21 @@ #define SYS_LIGHTWEIGHT_PROT 1 /** Attempt to get rid of htons etc. macro issues. */ -#define LWIP_PREFIX_BYTEORDER_FUNCS - -#define LWIP_NOASSERT 0 +#undef LWIP_PREFIX_BYTEORDER_FUNCS #define LWIP_TCPIP_CORE_LOCKING_INPUT 0 #define LWIP_TCPIP_CORE_LOCKING 0 #define LWIP_TCP 1 #define LWIP_SOCKET 1 #define LWIP_ARP 1 -#define ARP_PROXY 1 +#define ARP_PROXY 0 #define LWIP_ETHERNET 1 #define LWIP_COMPAT_SOCKETS 0 #define LWIP_COMPAT_MUTEX 1 #define LWIP_IPV6 1 -#define LWIP_IPV6_FORWARD 1 -#define LWIP_ND6_PROXY 1 +#define LWIP_IPV6_FORWARD 0 +#define LWIP_ND6_PROXY 0 #define LWIP_ND6_ALLOW_RA_UPDATES (!LWIP_IPV6_FORWARD) #define LWIP_IPV6_SEND_ROUTER_SOLICIT (!LWIP_IPV6_FORWARD) @@ -143,8 +141,8 @@ /** * aka Slirp mode. */ -#define LWIP_CONNECTION_PROXY 1 -#define IP_FORWARD 1 +#define LWIP_CONNECTION_PROXY 0 +#define IP_FORWARD 0 /* MEMP_NUM_SYS_TIMEOUT: the number of simultaneously active timeouts. */ @@ -156,51 +154,8 @@ /* Debugging stuff. */ #ifdef DEBUG -/* filter in debugging severity */ -# define DBG_TYPES_ON (LWIP_DBG_ON | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_FRESH | LWIP_DBG_HALT) -# define DBG_MIN_LEVEL 0 - -# define LWIP_DEBUG LWIP_DBG_ON -/* Ethernet & ARP debugging */ -# define ETHARP_DEBUG LWIP_DBG_ON -/* IPv4 debugging */ -# define IP_DEBUG LWIP_DBG_ON -# define IP_REASS_DEBUG LWIP_DBG_ON -/* IPv6 debugging */ -# define IP6_DEBUG LWIP_DBG_ON -/* ICMP debugging */ -# define ICMP_DEBUG LWIP_DBG_ON -/* TCP debugging */ -# define TCP_DEBUG LWIP_DBG_ON -# define TCP_INPUT_DEBUG LWIP_DBG_ON -# define TCP_FR_DEBUG LWIP_DBG_ON -# define TCP_RTO_DEBUG LWIP_DBG_ON -# define TCP_CWND_DEBUG LWIP_DBG_ON -# define TCP_WND_DEBUG LWIP_DBG_ON -# define TCP_OUTPUT_DEBUG LWIP_DBG_ON -# define TCP_RST_DEBUG LWIP_DBG_ON -# define TCP_QLEN_DEBUG LWIP_DBG_ON -/* RAW API debugging */ -/* API debugging */ -# define NETIF_DEBUG LWIP_DBG_ON -# define PBUF_DEBUG LWIP_DBG_ON -# define API_LIB_DEBUG LWIP_DBG_ON -# define API_MSG_DEBUG LWIP_DBG_ON -# define SOCKETS_DEBUG LWIP_DBG_ON - -# define INET_DEBUG LWIP_DBG_ON -# define RAW_DEBUG LWIP_DBG_ON -# define MEM_DEBUG LWIP_DBG_ON -# define MEMP_DEBUG LWIP_DBG_ON -# define SYS_DEBUG LWIP_DBG_ON - -# define UDP_DEBUG LWIP_DBG_ON -# define TCPIP_DEBUG LWIP_DBG_ON -# define DHCP_DEBUG LWIP_DBG_ON - -# define LWIP_PROXY_DEBUG LWIP_DBG_ON -/* Debug checks */ -# define TCP_OVERSIZE_DBGCHECK 1 +# define LWIP_DEBUG +# include "lwip-log.h" #endif /* DEBUG */ /* printf formatter definitions */ diff --git a/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm b/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm index ef96042d3..068c36e71 100644 --- a/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm +++ b/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.asm @@ -965,7 +965,7 @@ section CONST progbits vstart=0xb0 align=1 ; size=0xcf8 class=DATA group=DGROUP section CONST2 progbits vstart=0xda8 align=1 ; size=0x3fa class=DATA group=DGROUP _bios_cvs_version_string: ; 0xf0da8 LB 0x12 - db 'VirtualBox 4.3.8', 000h, 000h + db 'VirtualBox 4.3.10', 000h _bios_prefix_string: ; 0xf0dba LB 0x8 db 'BIOS: ', 000h, 000h _isotag: ; 0xf0dc2 LB 0x6 @@ -16025,4 +16025,4 @@ dummy_iret: ; 0xfff53 LB 0x9d db 'XM' cpu_reset: ; 0xffff0 LB 0x10 jmp far 0f000h:0e05bh ; ea 5b e0 00 f0 - db 030h, 036h, 02fh, 032h, 033h, 02fh, 039h, 039h, 000h, 0fch, 04fh + db 030h, 036h, 02fh, 032h, 033h, 02fh, 039h, 039h, 000h, 0fch, 026h diff --git a/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum b/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum index d8860acb9..3de91992c 100644 --- a/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum +++ b/src/VBox/Devices/PC/BIOS/VBoxBiosAlternative.md5sum @@ -1 +1 @@ -57043783b40423d82ef1605eae6b1822 *VBoxPcBios.rom +bb8dc7f1c69895d10cad2dadc4306b6d *VBoxPcBios.rom diff --git a/src/VBox/Devices/Storage/DrvHostBase.cpp b/src/VBox/Devices/Storage/DrvHostBase.cpp index cca91d27a..5c588f20e 100644 --- a/src/VBox/Devices/Storage/DrvHostBase.cpp +++ b/src/VBox/Devices/Storage/DrvHostBase.cpp @@ -4,7 +4,7 @@ */ /* - * Copyright (C) 2006-2011 Oracle Corporation + * Copyright (C) 2006-2014 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; @@ -872,7 +872,7 @@ static int drvHostBaseOpen(PDRVHOSTBASE pThis, PRTFILE pFileDevice, bool fReadOn else { strcpy(szName1, *pszVendor ? pszVendor : pszProduct); - RTStrPrintf(szName2, sizeof(szName2), "%s %s (#%u)", *pszVendor ? pszVendor : pszProduct, i); + RTStrPrintf(szName2, sizeof(szName2), "%s (#%u)", *pszVendor ? pszVendor : pszProduct, i); } } else diff --git a/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp b/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp index 8ee189c27..ca942b1e1 100644 --- a/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp +++ b/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp @@ -515,6 +515,9 @@ int vmmdevHGCMConnect (PVMMDEV pThis, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS pHGCMConnectCopy->loc.type = VMMDevHGCMLoc_LocalHost_Existing; rc = pThis->pHGCMDrv->pfnConnect (pThis->pHGCMDrv, pCmd, &pHGCMConnectCopy->loc, &pHGCMConnectCopy->u32ClientID); + + if (RT_FAILURE(rc)) + vmmdevHGCMRemoveCommand(pThis, pCmd); } else { @@ -554,6 +557,8 @@ static int vmmdevHGCMConnectSaved (PVMMDEV pThis, VMMDevHGCMConnect *pHGCMConnec { *pfHGCMCalled = true; } + /* else + * ... the caller will also execute vmmdevHGCMRemoveCommand() for us */ } else { @@ -580,6 +585,9 @@ int vmmdevHGCMDisconnect (PVMMDEV pThis, VMMDevHGCMDisconnect *pHGCMDisconnect, pCmd->paLinPtrs = NULL; rc = pThis->pHGCMDrv->pfnDisconnect (pThis->pHGCMDrv, pCmd, pHGCMDisconnect->u32ClientID); + + if (RT_FAILURE(rc)) + vmmdevHGCMRemoveCommand(pThis, pCmd); } else { @@ -614,6 +622,8 @@ static int vmmdevHGCMDisconnectSaved (PVMMDEV pThis, VMMDevHGCMDisconnect *pHGCM { *pfHGCMCalled = true; } + /* else + * ... the caller will also execute vmmdevHGCMRemoveCommand() for us */ } else { @@ -1735,6 +1745,8 @@ static int vmmdevHGCMCallSaved (PVMMDEV pThis, VMMDevHGCMCall *pHGCMCall, RTGCPH { *pfHGCMCalled = true; } + /* else + * ... the caller will also execute vmmdevHGCMRemoveCommand() for us */ } return rc; |