VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp@ 4989

Last change on this file since 4989 was 4983, checked in by vboxsync, 18 years ago

VBoxBFE.cpp fix
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 68.5 KB
Line 
1/** @file
2 *
3 * VBox frontends: Basic Frontend (BFE):
4 * VBoxBFE main routines
5 *
6 * VBoxBFE is a limited frontend that sits directly on the Virtual Machine
7 * Manager (VMM) and does _not_ use COM to communicate.
8 * On Linux and Windows, VBoxBFE is based on SDL; on L4 it's based on the
9 * L4 console. Much of the code has been copied over from the other frontends
10 * in VBox/Main/ and src/Frontends/VBoxSDL/.
11 */
12
13/*
14 * Copyright (C) 2006-2007 innotek GmbH
15 *
16 * This file is part of VirtualBox Open Source Edition (OSE), as
17 * available from http://www.virtualbox.org. This file is free software;
18 * you can redistribute it and/or modify it under the terms of the GNU
19 * General Public License as published by the Free Software Foundation,
20 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
21 * distribution. VirtualBox OSE is distributed in the hope that it will
22 * be useful, but WITHOUT ANY WARRANTY of any kind.
23 */
24
25/*******************************************************************************
26* Header Files *
27*******************************************************************************/
28#define LOG_GROUP LOG_GROUP_GUI
29
30#ifndef VBOXBFE_WITHOUT_COM
31# include <VBox/com/Guid.h>
32# include <VBox/com/string.h>
33using namespace com;
34#endif
35
36#include <VBox/types.h>
37#include <VBox/err.h>
38#include <VBox/param.h>
39#include <VBox/pdm.h>
40#include <VBox/version.h>
41#ifdef VBOXBFE_WITH_USB
42# include <VBox/vusb.h>
43#endif
44#include <VBox/log.h>
45#include <iprt/path.h>
46#include <iprt/string.h>
47#include <iprt/runtime.h>
48#include <iprt/assert.h>
49#include <iprt/semaphore.h>
50#include <iprt/stream.h>
51#include <iprt/thread.h>
52#include <iprt/uuid.h>
53#include <iprt/file.h>
54#include <iprt/alloca.h>
55#include <iprt/ctype.h>
56
57#include "VBoxBFE.h"
58
59#include <stdio.h>
60#include <stdlib.h> /* putenv */
61#include <errno.h>
62
63#if defined(RT_OS_LINUX) || defined(RT_OS_L4)
64#include <fcntl.h>
65#include <net/if.h>
66#include <sys/ioctl.h>
67#include <linux/if_tun.h>
68#endif
69
70#ifndef RT_OS_L4
71#include <vector>
72#endif
73
74#include "ConsoleImpl.h"
75#include "DisplayImpl.h"
76#include "MouseImpl.h"
77#include "KeyboardImpl.h"
78#include "VMMDevInterface.h"
79#include "StatusImpl.h"
80#include "Framebuffer.h"
81#include "MachineDebuggerImpl.h"
82#ifdef VBOXBFE_WITH_USB
83# include "HostUSBImpl.h"
84#endif
85
86#if defined(USE_SDL) && ! defined(RT_OS_L4)
87#include "SDLConsole.h"
88#include "SDLFramebuffer.h"
89#endif
90
91#ifdef RT_OS_L4
92#include "L4Console.h"
93#include "L4Framebuffer.h"
94#endif
95
96#ifdef RT_OS_L4
97# ifndef L4API_l4v2onv4
98# include <l4/sys/ktrace.h>
99# endif
100# include <l4/vboxserver/file.h>
101#endif
102
103/*******************************************************************************
104* Defined Constants And Macros *
105*******************************************************************************/
106
107#define VBOXSDL_ADVANCED_OPTIONS
108#define MAC_STRING_LEN 12
109
110
111/*******************************************************************************
112* Internal Functions *
113*******************************************************************************/
114static DECLCALLBACK(int) vboxbfeConfigConstructor(PVM pVM, void *pvUser);
115static DECLCALLBACK(void) vmstateChangeCallback(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
116static DECLCALLBACK(void) setVMErrorCallback(PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
117 const char *pszFormat, va_list args);
118static DECLCALLBACK(int) VMPowerUpThread(RTTHREAD Thread, void *pvUser);
119
120
121/*******************************************************************************
122* Global Variables *
123*******************************************************************************/
124
125PVM pVM = NULL;
126Mouse *gMouse = NULL;
127VMDisplay *gDisplay = NULL;
128Keyboard *gKeyboard = NULL;
129VMMDev *gVMMDev = NULL;
130Framebuffer *gFramebuffer = NULL;
131MachineDebugger *gMachineDebugger = NULL;
132VMStatus *gStatus = NULL;
133Console *gConsole = NULL;
134#ifdef VBOXBFE_WITH_USB
135HostUSB *gHostUSB = NULL;
136#endif
137
138VMSTATE machineState = VMSTATE_CREATING;
139
140PPDMLED mapFDLeds[2] = {0};
141PPDMLED mapIDELeds[4] = {0};
142
143/** flag whether keyboard/mouse events are grabbed */
144#ifdef RT_OS_L4
145/** see <l4/input/macros.h> for key definitions */
146int gHostKey; /* not used */
147int gHostKeySym = KEY_RIGHTCTRL;
148#elif defined (DEBUG_dmik)
149// my mini kbd doesn't have RCTRL...
150int gHostKey = KMOD_RSHIFT;
151int gHostKeySym = SDLK_RSHIFT;
152#else
153int gHostKey = KMOD_RCTRL;
154int gHostKeySym = SDLK_RCTRL;
155#endif
156bool gfAllowFullscreenToggle = true;
157
158static bool g_fIOAPIC = false;
159static bool g_fACPI = true;
160static bool g_fAudio = false;
161#ifdef VBOXBFE_WITH_USB
162static bool g_fUSB = false;
163#endif
164static char *g_pszHdaFile = NULL;
165static bool g_fHdaSpf = false;
166static char *g_pszHdbFile = NULL;
167static bool g_fHdbSpf = false;
168static char *g_pszCdromFile = NULL;
169static char *g_pszFdaFile = NULL;
170static const char *pszBootDevice = "IDE";
171static uint32_t g_u32MemorySizeMB = 128;
172static uint32_t g_u32VRamSizeMB = 4;
173#ifdef VBOXSDL_ADVANCED_OPTIONS
174static bool g_fRawR0 = true;
175static bool g_fRawR3 = true;
176static bool g_fPATM = true;
177static bool g_fCSAM = true;
178#endif
179static bool g_fPreAllocRam = false;
180static int g_iBootMenu = 2;
181static bool g_fReleaseLog = true; /**< Set if we should open the release. */
182
183
184/**
185 * Network device config info.
186 */
187typedef struct BFENetworkDevice
188{
189 enum
190 {
191 NOT_CONFIGURED = 0,
192 NONE,
193 NAT,
194 HIF,
195 INTNET
196 } enmType; /**< The type of network driver. */
197 bool fSniff; /**< Set if the network sniffer should be installed. */
198 const char *pszSniff; /**< Output file for the network sniffer. */
199 PDMMAC Mac; /**< The mac address for the device. */
200 const char *pszName; /**< The device name of a HIF device. The name of the internal network. */
201#ifdef RT_OS_OS2
202 bool fHaveConnectTo; /**< Whether fConnectTo is set. */
203 int32_t iConnectTo; /**< The lanX to connect to (bridge with). */
204#elif 1//defined(RT_OS_LINUX)
205 bool fHaveFd; /**< Set if fd is valid. */
206 int32_t fd; /**< The file descriptor of a HIF device.*/
207#endif
208} BFENETDEV, *PBFENETDEV;
209
210/** Array of network device configurations. */
211static BFENETDEV g_aNetDevs[NetworkAdapterCount];
212
213
214/** @todo currently this is only set but never read. */
215static char szError[512];
216
217
218/**
219 * Converts the passed in network option
220 *
221 * @returns Index into g_aNetDevs on success. (positive)
222 * @returns VERR_INVALID_PARAMETER on failure. (negative)
223 * @param pszArg The argument.
224 * @param cchRoot The length of the argument root.
225 */
226static int networkArg2Index(const char *pszArg, int cchRoot)
227{
228 uint32_t n;
229 int rc = RTStrToUInt32Ex(&pszArg[cchRoot], NULL, 10, &n);
230 if (VBOX_FAILURE(rc))
231 {
232 RTPrintf("Error: invalid network device option (rc=%Vrc): %s\n", rc, pszArg);
233 return -1;
234 }
235 if (n < 1 || n > NetworkAdapterCount)
236 {
237 RTPrintf("Error: The network device number is out of range: %RU32 (1 <= 0 <= %u) (%s)\n",
238 n, NetworkAdapterCount, pszArg);
239 return -1;
240 }
241 return n;
242}
243
244/**
245 * Generates a new unique MAC address based on our vendor ID and
246 * parts of a GUID.
247 *
248 * @returns iprt status code
249 * @param pAddress An array into which to store the newly generated address
250 */
251int GenerateMACAddress(char pszAddress[MAC_STRING_LEN + 1])
252{
253 /*
254 * Our strategy is as follows: the first three bytes are our fixed
255 * vendor ID (080027). The remaining 3 bytes will be taken from the
256 * start of a GUID. This is a fairly safe algorithm.
257 */
258 LogFlowFunc(("called\n"));
259 RTUUID uuid;
260 int rc = RTUuidCreate(&uuid);
261 if (RT_FAILURE(rc))
262 {
263 LogFlowFunc(("RTUuidCreate failed, returning %Vrc\n", rc));
264 return rc;
265 }
266 RTStrPrintf(pszAddress, MAC_STRING_LEN + 1, "080027%02X%02X%02X",
267 uuid.au8[0], uuid.au8[1], uuid.au8[2]);
268 LogFlowFunc(("generated MAC: '%s'\n", pszAddress));
269 return VINF_SUCCESS;
270}
271
272/**
273 * Print a syntax error.
274 *
275 * @returns return value for main().
276 * @param pszMsg The message format string.
277 * @param ... Format arguments.
278 */
279static int SyntaxError(const char *pszMsg, ...)
280{
281 va_list va;
282 RTPrintf("error: ");
283 va_start(va, pszMsg);
284 RTPrintfV(pszMsg, va);
285 va_end(va);
286 return 1;
287}
288
289
290/**
291 * Print a fatal error.
292 *
293 * @returns return value for main().
294 * @param pszMsg The message format string.
295 * @param ... Format arguments.
296 */
297static int FatalError(const char *pszMsg, ...)
298{
299 va_list va;
300 RTPrintf("fatal error: ");
301 va_start(va, pszMsg);
302 RTPrintfV(pszMsg, va);
303 va_end(va);
304 return 1;
305}
306
307
308/**
309 * Print program usage.
310 */
311static void show_usage()
312{
313 RTPrintf("Usage:\n"
314 " -hda <file> Set first hard disk to file\n"
315 " -hdb <file> Set second hard disk to file\n"
316 " -fda <file> Set first floppy disk to file\n"
317 " -cdrom <file> Set CDROM to file/device ('none' to unmount)\n"
318 " -boot <a|c|d> Set boot device (a = floppy, c = first hard disk, d = DVD)\n"
319 " -boot menu <0|1|2> Boot menu (0 = disable, 1 = menu only, 2 = message + menu)\n"
320 " -m <size> Set memory size in megabytes (default 128MB)\n"
321 " -vram <size> Set size of video memory in megabytes\n"
322 " -prealloc Force RAM pre-allocation\n"
323 " -fullscreen Start VM in fullscreen mode\n"
324 " -nofstoggle Forbid switching to/from fullscreen mode\n"
325 " -nohostkey Disable hostkey\n"
326 " -[no]acpi Enable or disable ACPI (default: enabled)\n"
327 " -[no]ioapic Enable or disable the IO-APIC (default: disabled)\n"
328 " -audio Enable audio\n"
329#ifndef RT_OS_L4
330 " -natdev<1-N> [mac] Use NAT networking on network adapter <N>. Use hardware\n"
331 " address <mac> if specified.\n"
332#endif
333 " -hifdev<1-N> Use Host Interface Networking with host interface <int>\n"
334 " <int> [mac] on network adapter <N>. Use hardware address <mac> if\n"
335 " specified.\n"
336#ifndef RT_OS_L4
337 " -intnet<1-N> Attach network adapter <N> to internal network <net>. Use\n"
338 " <net> [mac] hardware address <mac> if specified.\n"
339#endif
340#if 0
341 " -netsniff<1-N> Enable packet sniffer\n"
342#endif
343#ifdef RT_OS_OS2
344 " -brdev<1-N> lan<X> Bridge network adaptor <N> with the 'lanX' device.\n"
345#endif
346#ifdef RT_OS_LINUX
347 " -tapfd<1-N> <fd> Use existing TAP device, don't allocate\n"
348#endif
349#ifdef VBOX_VRDP
350 " -vrdp [port] Listen for VRDP connections on port (default if not specified)\n"
351#endif
352#ifdef VBOX_SECURELABEL
353 " -securelabel Display a secure VM label at the top of the screen\n"
354 " -seclabelfnt TrueType (.ttf) font file for secure session label\n"
355 " -seclabelsiz Font point size for secure session label (default 12)\n"
356#endif
357 " -[no]rellog Enable or disable the release log './VBoxBFE.log' (default: enabled)\n"
358#ifdef VBOXSDL_ADVANCED_OPTIONS
359 " -[no]rawr0 Enable or disable raw ring 3\n"
360 " -[no]rawr3 Enable or disable raw ring 0\n"
361 " -[no]patm Enable or disable PATM\n"
362 " -[no]csam Enable or disable CSAM\n"
363#endif
364#ifdef RT_OS_L4
365 " -env <var=value> Set the given environment variable to \"value\"\n"
366#endif
367 "\n");
368}
369
370
371/** entry point */
372int main(int argc, char **argv)
373{
374#ifdef RT_OS_L4
375#ifndef L4API_l4v2onv4
376 /* clear Fiasco kernel trace buffer */
377 fiasco_tbuf_clear();
378#endif
379 /* set the environment. Must be done before the runtime is
380 initialised. Yes, it really must. */
381 for (int i = 0; i < argc; i++)
382 if (strcmp(argv[i], "-env") == 0)
383 {
384 if (++i >= argc)
385 return SyntaxError("missing argument to -env (format: var=value)!\n");
386 /* add it to the environment */
387 if (putenv(argv[i]) != 0)
388 return SyntaxError("Error setting environment string %s.\n", argv[i]);
389 }
390#endif /* RT_OS_L4 */
391
392 /*
393 * Before we do *anything*, we initialize the runtime.
394 */
395 int rc = RTR3Init();
396 if (VBOX_FAILURE(rc))
397 return FatalError("RTR3Init failed rc=%Vrc\n", rc);
398
399
400 bool fFullscreen = false;
401#ifdef VBOX_VRDP
402 int32_t portVRDP = -1;
403#endif
404#ifdef VBOX_SECURELABEL
405 bool fSecureLabel = false;
406 uint32_t secureLabelPointSize = 12;
407 char *secureLabelFontFile = NULL;
408#endif
409 RTPrintf("VirtualBox Simple SDL GUI built %s %s\n", __DATE__, __TIME__);
410
411 // less than one parameter is not possible
412 if (argc < 2)
413 {
414 show_usage();
415 return 1;
416 }
417
418 /*
419 * Parse the command line arguments.
420 */
421 for (int curArg = 1; curArg < argc; curArg++)
422 {
423 const char * const pszArg = argv[curArg];
424 if (strcmp(pszArg, "-boot") == 0)
425 {
426 if (++curArg >= argc)
427 return SyntaxError("missing argument for boot drive!\n");
428 if (strlen(argv[curArg]) != 1)
429 return SyntaxError("invalid argument for boot drive! (%s)\n", argv[curArg]);
430 rc = VINF_SUCCESS;
431 switch (argv[curArg][0])
432 {
433 case 'a':
434 {
435 pszBootDevice = "FLOPPY";
436 break;
437 }
438
439 case 'c':
440 {
441 pszBootDevice = "IDE";
442 break;
443 }
444
445 case 'd':
446 {
447 pszBootDevice = "DVD";
448 break;
449 }
450
451 default:
452 return SyntaxError("wrong argument for boot drive! (%s)\n", argv[curArg]);
453 }
454 }
455 else if (strcmp(pszArg, "-bootmenu") == 0)
456 {
457 if (++curArg >= argc)
458 return SyntaxError("missing argument for boot menu!\n");
459 if (strlen(argv[curArg]) != 1 || *argv[curArg] < '0' || *argv[curArg] > '2')
460 return SyntaxError("invalid argument for boot menu! (%s)\n", argv[curArg]);
461 rc = VINF_SUCCESS;
462 g_iBootMenu = *argv[curArg] - 0;
463 }
464 else if (strcmp(pszArg, "-m") == 0)
465 {
466 if (++curArg >= argc)
467 return SyntaxError("missing argument for memory size!\n");
468 rc = RTStrToUInt32Ex(argv[curArg], NULL, 0, &g_u32MemorySizeMB);
469 if (VBOX_FAILURE(rc))
470 return SyntaxError("bad memory size: %s (error %Vrc)\n",
471 argv[curArg], rc);
472 }
473 else if (strcmp(pszArg, "-vram") == 0)
474 {
475 if (++curArg >= argc)
476 return SyntaxError("missing argument for vram size!\n");
477 rc = RTStrToUInt32Ex(argv[curArg], NULL, 0, &g_u32VRamSizeMB);
478 if (VBOX_FAILURE(rc))
479 return SyntaxError("bad video ram size: %s (error %Vrc)\n",
480 argv[curArg], rc);
481 }
482 else if (strcmp(pszArg, "-fullscreen") == 0)
483 fFullscreen = true;
484 else if (strcmp(pszArg, "-nofstoggle") == 0)
485 gfAllowFullscreenToggle = false;
486 else if (strcmp(pszArg, "-nohostkey") == 0)
487 {
488 gHostKey = 0;
489 gHostKeySym = 0;
490 }
491 else if (strcmp(pszArg, "-acpi") == 0)
492 g_fACPI = true;
493 else if (strcmp(pszArg, "-noacpi") == 0)
494 g_fACPI = false;
495 else if (strcmp(pszArg, "-ioapic") == 0)
496 g_fIOAPIC = true;
497 else if (strcmp(pszArg, "-noioapic") == 0)
498 g_fIOAPIC = false;
499 else if (strcmp(pszArg, "-audio") == 0)
500 g_fAudio = true;
501#ifdef VBOXBFE_WITH_USB
502 else if (strcmp(pszArg, "-usb") == 0)
503 g_fUSB = true;
504#endif
505 else if (strcmp(pszArg, "-hda") == 0)
506 {
507 if (++curArg >= argc)
508 return SyntaxError("missing file name for first hard disk!\n");
509
510 /* resolve it. */
511 if (RTPathExists(argv[curArg]))
512 g_pszHdaFile = RTPathRealDup(argv[curArg]);
513 if (!g_pszHdaFile)
514 return SyntaxError("The path to the specified harddisk, '%s', could not be resolved.\n", argv[curArg]);
515 }
516 else if (strcmp(pszArg, "-hdaspf") == 0)
517 {
518 g_fHdaSpf = true;
519 }
520 else if (strcmp(pszArg, "-hdb") == 0)
521 {
522 if (++curArg >= argc)
523 return SyntaxError("missing file name for second hard disk!\n");
524
525 /* resolve it. */
526 if (RTPathExists(argv[curArg]))
527 g_pszHdbFile = RTPathRealDup(argv[curArg]);
528 if (!g_pszHdbFile)
529 return SyntaxError("The path to the specified harddisk, '%s', could not be resolved.\n", argv[curArg]);
530 }
531 else if (strcmp(pszArg, "-hdbspf") == 0)
532 {
533 g_fHdbSpf = true;
534 }
535 else if (strcmp(pszArg, "-fda") == 0)
536 {
537 if (++curArg >= argc)
538 return SyntaxError("missing file/device name for first floppy disk!\n");
539
540 /* resolve it. */
541 if (RTPathExists(argv[curArg]))
542 g_pszFdaFile = RTPathRealDup(argv[curArg]);
543 if (!g_pszFdaFile)
544 return SyntaxError("The path to the specified floppy disk, '%s', could not be resolved.\n", argv[curArg]);
545 }
546 else if (strcmp(pszArg, "-cdrom") == 0)
547 {
548 if (++curArg >= argc)
549 return SyntaxError("missing file/device name for first hard disk!\n");
550
551 /* resolve it. */
552 if (RTPathExists(argv[curArg]))
553 g_pszCdromFile = RTPathRealDup(argv[curArg]);
554 if (!g_pszCdromFile)
555 return SyntaxError("The path to the specified cdrom, '%s', could not be resolved.\n", argv[curArg]);
556 }
557#ifdef RT_OS_L4
558 /* This is leaving a lot of dead code in the L4 version of course,
559 but I don't think that that is a major problem. We may even
560 activate it sometime... */
561 else if ( strncmp(pszArg, "-hifdev", 7) == 0
562 || strncmp(pszArg, "-nonetd", 7) == 0)
563#else
564 else if ( strncmp(pszArg, "-natdev", 7) == 0
565 || strncmp(pszArg, "-hifdev", 7) == 0
566 || strncmp(pszArg, "-nonetd", 7) == 0
567 || strncmp(pszArg, "-intnet", 7) == 0)
568#endif
569 {
570 int i = networkArg2Index(pszArg, 7);
571 if (i < 0)
572 return 1;
573 g_aNetDevs[i].enmType = !strncmp(pszArg, "-natdev", 7)
574 ? BFENETDEV::NAT
575 : !strncmp(pszArg, "-hifdev", 7)
576 ? BFENETDEV::HIF
577 : !strncmp(pszArg, "-intnet", 7)
578 ? BFENETDEV::INTNET
579 : BFENETDEV::NONE;
580
581 /* The HIF device name / The Internal Network name. */
582 g_aNetDevs[i].pszName = NULL;
583 if ( g_aNetDevs[i].enmType == BFENETDEV::HIF
584 || g_aNetDevs[i].enmType == BFENETDEV::INTNET)
585 {
586 if (curArg + 1 >= argc)
587 return SyntaxError(g_aNetDevs[i].enmType == BFENETDEV::HIF
588 ? "The TAP network device name is missing! (%s)\n"
589 : "The internal network name is missing! (%s)\n"
590 , pszArg);
591 g_aNetDevs[i].pszName = argv[++curArg];
592 }
593
594 /* The MAC address. */
595 const char *pszMac;
596 char szMacGen[MAC_STRING_LEN + 1];
597 if ((curArg + 1 < argc) && (argv[curArg + 1][0] != '-'))
598 pszMac = argv[++curArg];
599 else
600 {
601 rc = GenerateMACAddress(szMacGen);
602 if (RT_FAILURE(rc))
603 return SyntaxError("failed to generate a hardware address for network device %d (error %Vrc)\n",
604 i, rc);
605 pszMac = szMacGen;
606 }
607 if (strlen(pszMac) != MAC_STRING_LEN)
608 return SyntaxError("The network MAC address has an invalid length: %s (%s)\n", pszMac, pszArg);
609 for (unsigned j = 0; j < RT_ELEMENTS(g_aNetDevs[i].Mac.au8); j++)
610 {
611 char c1 = toupper(*pszMac++) - '0';
612 if (c1 > 9)
613 c1 -= 7;
614 char c2 = toupper(*pszMac++) - '0';
615 if (c2 > 9)
616 c2 -= 7;
617 if (c2 > 16 || c1 > 16)
618 return SyntaxError("Invalid MAC address: %s\n", argv[curArg]);
619 g_aNetDevs[i].Mac.au8[j] = ((c1 & 0x0f) << 4) | (c2 & 0x0f);
620 }
621 }
622 else if (strncmp(pszArg, "-netsniff", 9) == 0)
623 {
624 int i = networkArg2Index(pszArg, 9);
625 if (i < 0)
626 return 1;
627 g_aNetDevs[i].fSniff = true;
628 /** @todo filename */
629 }
630#ifdef RT_OS_OS2
631 else if (strncmp(pszArg, "-brdev", 6) == 0)
632 {
633 int i = networkArg2Index(pszArg, 6);
634 if (i < 0)
635 return 1;
636 if (g_aNetDevs[i].enmType != BFENETDEV::HIF)
637 return SyntaxError("%d is not a hif device! Make sure you put the -hifdev argument first.\n", i);
638 if (++curArg >= argc)
639 return SyntaxError("missing argument for %s!\n", pszArg);
640 if ( strncmp(argv[curArg], "lan", 3)
641 || argv[curArg][3] < '0'
642 || argv[curArg][3] >= '8'
643 || argv[curArg][4])
644 return SyntaxError("bad interface name '%s' specified with '%s'. Expected 'lan0', 'lan1' and similar.\n",
645 argv[curArg], pszArg);
646 g_aNetDevs[i].iConnectTo = argv[curArg][3] - '0';
647 g_aNetDevs[i].fHaveConnectTo = true;
648 }
649#endif
650#ifdef RT_OS_LINUX
651 else if (strncmp(pszArg, "-tapfd", 6) == 0)
652 {
653 int i = networkArg2Index(pszArg, 6);
654 if (i < 0)
655 return 1;
656 if (++curArg >= argc)
657 return SyntaxError("missing argument for %s!\n", pszArg);
658 rc = RTStrToInt32Ex(argv[curArg], NULL, 0, &g_aNetDevs[i].fd);
659 if (VBOX_FAILURE(rc))
660 return SyntaxError("bad tap file descriptor: %s (error %VRc)\n", argv[curArg], rc);
661 g_aNetDevs[i].fHaveFd = true;
662 }
663#endif /* RT_OS_LINUX */
664#ifdef VBOX_VRDP
665 else if (strcmp(pszArg, "-vrdp") == 0)
666 {
667 // -vrdp might take a port number (positive).
668 portVRDP = 0; // indicate that it was encountered.
669 if (curArg + 1 < argc && argv[curArg + 1][0] != '-')
670 {
671 rc = RTStrToInt32Ex(argv[curArg], NULL, 0, &portVRDP);
672 if (VBOX_FAILURE(rc))
673 return SyntaxError("cannot vrpd port: %s (%VRc)\n", argv[curArg], rc);
674 if (portVRDP < 0 || portVRDP >= 0x10000)
675 return SyntaxError("vrdp port number is out of range: %RI32\n", portVRDP);
676 }
677 }
678#endif /* VBOX_VRDP */
679#ifdef VBOX_SECURELABEL
680 else if (strcmp(pszArg, "-securelabel") == 0)
681 {
682 fSecureLabel = true;
683 LogFlow(("Secure labelling turned on\n"));
684 }
685 else if (strcmp(pszArg, "-seclabelfnt") == 0)
686 {
687 if (++curArg >= argc)
688 return SyntaxError("missing font file name for secure label!\n");
689 secureLabelFontFile = argv[curArg];
690 }
691 else if (strcmp(pszArg, "-seclabelsiz") == 0)
692 {
693 if (++curArg >= argc)
694 return SyntaxError("missing font point size for secure label!\n");
695 secureLabelPointSize = atoi(argv[curArg]);
696 }
697#endif
698 else if (strcmp(pszArg, "-rellog") == 0)
699 g_fReleaseLog = true;
700 else if (strcmp(pszArg, "-norellog") == 0)
701 g_fReleaseLog = false;
702 else if (strcmp(pszArg, "-prealloc") == 0)
703 g_fPreAllocRam = true;
704#ifdef VBOXSDL_ADVANCED_OPTIONS
705 else if (strcmp(pszArg, "-rawr0") == 0)
706 g_fRawR0 = true;
707 else if (strcmp(pszArg, "-norawr0") == 0)
708 g_fRawR0 = false;
709 else if (strcmp(pszArg, "-rawr3") == 0)
710 g_fRawR3 = true;
711 else if (strcmp(pszArg, "-norawr3") == 0)
712 g_fRawR3 = false;
713 else if (strcmp(pszArg, "-patm") == 0)
714 g_fPATM = true;
715 else if (strcmp(pszArg, "-nopatm") == 0)
716 g_fPATM = false;
717 else if (strcmp(pszArg, "-csam") == 0)
718 g_fCSAM = true;
719 else if (strcmp(pszArg, "-nocsam") == 0)
720 g_fCSAM = false;
721#endif /* VBOXSDL_ADVANCED_OPTIONS */
722#ifdef RT_OS_L4
723 else if (strcmp(pszArg, "-env") == 0)
724 ++curArg;
725#endif /* RT_OS_L4 */
726 /* just show the help screen */
727 else
728 {
729 SyntaxError("unrecognized argument '%s'\n", pszArg);
730 show_usage();
731 return 1;
732 }
733 }
734
735 gMachineDebugger = new MachineDebugger();
736 gStatus = new VMStatus();
737 gKeyboard = new Keyboard();
738 gMouse = new Mouse();
739 gVMMDev = new VMMDev();
740 gDisplay = new VMDisplay();
741#if defined(USE_SDL)
742 /* First console, then framebuffer!! */
743 gConsole = new SDLConsole();
744 gFramebuffer = new SDLFramebuffer();
745#elif defined(RT_OS_L4)
746 gConsole = new L4Console();
747 gFramebuffer = new L4Framebuffer();
748#else
749#error "todo"
750#endif
751 if (!gConsole->initialized())
752 goto leave;
753 gDisplay->RegisterExternalFramebuffer(gFramebuffer);
754
755 /* start with something in the titlebar */
756 gConsole->updateTitlebar();
757
758 /*
759 * Start the VM execution thread. This has to be done
760 * asynchronously as powering up can take some time
761 * (accessing devices such as the host DVD drive). In
762 * the meantime, we have to service the SDL event loop.
763 */
764
765 RTTHREAD thread;
766 rc = RTThreadCreate(&thread, VMPowerUpThread, 0, 0, RTTHREADTYPE_MAIN_WORKER, 0, "PowerUp");
767 if (VBOX_FAILURE(rc))
768 {
769 RTPrintf("Error: Thread creation failed with %d\n", rc);
770 return -1;
771 }
772
773 /* loop until the powerup processing is done */
774 do
775 {
776#if defined(VBOXBFE_WITH_X11) && defined(USE_SDL)
777 if ( machineState == VMSTATE_CREATING
778 || machineState == VMSTATE_LOADING)
779 {
780 int event = gConsole->eventWait();
781
782 switch (event)
783 {
784 case CONEVENT_USR_SCREENRESIZE:
785 LogFlow(("CONEVENT_USR_SCREENRESIZE\n"));
786 gFramebuffer->resize();
787 /* notify the display that the resize has been completed */
788 gDisplay->ResizeCompleted();
789 break;
790
791 case CONEVENT_USR_QUIT:
792 RTPrintf("Error: failed to power up VM! No error text available.\n");
793 goto leave;
794 }
795 }
796 else
797#endif
798 RTThreadSleep(1000);
799 }
800 while ( machineState == VMSTATE_CREATING
801 || machineState == VMSTATE_LOADING);
802
803 if (machineState == VMSTATE_TERMINATED)
804 goto leave;
805
806 /* did the power up succeed? */
807 if (machineState != VMSTATE_RUNNING)
808 {
809 RTPrintf("Error: failed to power up VM! No error text available (rc = 0x%x state = %d)\n", rc, machineState);
810 goto leave;
811 }
812
813 gConsole->updateTitlebar();
814
815#ifdef RT_OS_L4
816 /* The L4 console provides (currently) a fixed resolution. */
817 if (g_u32VRamSizeMB * _1M >= gFramebuffer->getHostXres()
818 * gFramebuffer->getHostYres()
819 * (gDisplay->getBitsPerPixel() / 8))
820 gDisplay->SetVideoModeHint(gFramebuffer->getHostXres(), gFramebuffer->getHostYres(), 0, 0);
821#endif
822
823 /*
824 * Main event loop
825 */
826 LogFlow(("VBoxSDL: Entering big event loop\n"));
827
828 while (1)
829 {
830 int event = gConsole->eventWait();
831
832 switch (event)
833 {
834 case CONEVENT_NONE:
835 /* Handled internally */
836 break;
837
838 case CONEVENT_QUIT:
839 case CONEVENT_USR_QUIT:
840 goto leave;
841
842 case CONEVENT_SCREENUPDATE:
843 /// @todo that somehow doesn't seem to work!
844 gFramebuffer->repaint();
845 break;
846
847 case CONEVENT_USR_TITLEBARUPDATE:
848 gConsole->updateTitlebar();
849 break;
850
851 case CONEVENT_USR_SCREENRESIZE:
852 {
853 LogFlow(("CONEVENT_USR_SCREENRESIZE\n"));
854 gFramebuffer->resize();
855 /* notify the display that the resize has been completed */
856 gDisplay->ResizeCompleted();
857 break;
858 }
859
860#ifdef VBOX_SECURELABEL
861 case CONEVENT_USR_SECURELABELUPDATE:
862 {
863 /*
864 * Query the new label text
865 */
866 Bstr key = VBOXSDL_SECURELABEL_EXTRADATA;
867 Bstr label;
868 gMachine->COMGETTER(ExtraData)(key, label.asOutParam());
869 Utf8Str labelUtf8 = label;
870 /*
871 * Now update the label
872 */
873 gFramebuffer->setSecureLabelText(labelUtf8.raw());
874 break;
875 }
876#endif /* VBOX_SECURELABEL */
877
878 }
879
880 }
881
882leave:
883 LogFlow(("Returning from main()!\n"));
884
885 if (pVM)
886 {
887 /*
888 * If get here because the guest terminated using ACPI off we don't have to
889 * switch off the VM because we were notified via vmstateChangeCallback()
890 * that this already happened. In any other case stop the VM before killing her.
891 */
892 if (machineState != VMSTATE_OFF)
893 {
894 /* Power off VM */
895 PVMREQ pReq;
896 rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOff, 1, pVM);
897 }
898
899 /* And destroy it */
900 rc = VMR3Destroy(pVM);
901 AssertRC(rc);
902 }
903
904 delete gFramebuffer;
905 delete gConsole;
906 delete gDisplay;
907 delete gKeyboard;
908 delete gMouse;
909 delete gStatus;
910 delete gMachineDebugger;
911
912 RTLogFlush(NULL);
913 return VBOX_FAILURE (rc) ? 1 : 0;
914}
915
916
917
918/**
919 * VM state callback function. Called by the VMM
920 * using its state machine states.
921 *
922 * Primarily used to handle VM initiated power off, suspend and state saving,
923 * but also for doing termination completed work (VMSTATE_TERMINATE).
924 *
925 * In general this function is called in the context of the EMT.
926 *
927 * @todo machineState is set to VMSTATE_RUNNING before all devices have received power on events
928 * this can prematurely allow the main thread to enter the event loop
929 *
930 * @param pVM The VM handle.
931 * @param enmState The new state.
932 * @param enmOldState The old state.
933 * @param pvUser The user argument.
934 */
935static DECLCALLBACK(void) vmstateChangeCallback(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
936{
937 LogFlow(("vmstateChangeCallback: changing state from %d to %d\n", enmOldState, enmState));
938 machineState = enmState;
939
940 switch (enmState)
941 {
942 /*
943 * The VM has terminated
944 */
945 case VMSTATE_OFF:
946 {
947 gConsole->eventQuit();
948 break;
949 }
950
951 /*
952 * The VM has been completely destroyed.
953 *
954 * Note: This state change can happen at two points:
955 * 1) At the end of VMR3Destroy() if it was not called from EMT.
956 * 2) At the end of vmR3EmulationThread if VMR3Destroy() was called by EMT.
957 */
958 case VMSTATE_TERMINATED:
959 {
960 break;
961 }
962
963 default: /* shut up gcc */
964 break;
965 }
966}
967
968
969/**
970 * VM error callback function. Called by the various VM components.
971 *
972 * @param pVM The VM handle.
973 * @param pvUser The user argument.
974 * @param rc VBox status code.
975 * @param pszError Error message format string.
976 * @param args Error message arguments.
977 * @thread EMT.
978 */
979DECLCALLBACK(void) setVMErrorCallback(PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
980 const char *pszFormat, va_list args)
981{
982 /** @todo accessing shared resource without any kind of synchronization */
983 if (VBOX_SUCCESS(rc))
984 szError[0] = '\0';
985 else
986 {
987 va_list va2;
988 va_copy(va2, args); /* Have to make a copy here or GCC will break. */
989 RTStrPrintf(szError, sizeof(szError),
990 "%N!\nVBox status code: %d (%Vrc)", pszFormat, &va2, rc, rc);
991 RTPrintf("%s\n", szError);
992 va_end(va2);
993 }
994}
995
996
997/**
998 * VM Runtime error callback function. Called by the various VM components.
999 *
1000 * @param pVM The VM handle.
1001 * @param pvUser The user argument.
1002 * @param fFata Wheather it is a fatal error or not.
1003 * @param pszErrorId Error ID string.
1004 * @param pszError Error message format string.
1005 * @param args Error message arguments.
1006 * @thread EMT.
1007 */
1008DECLCALLBACK(void) setVMRuntimeErrorCallback(PVM pVM, void *pvUser, bool fFatal,
1009 const char *pszErrorId,
1010 const char *pszFormat, va_list args)
1011{
1012 va_list va2;
1013 va_copy(va2, args); /* Have to make a copy here or GCC will break. */
1014 RTPrintf("%s: %s!\n%N!\n", fFatal ? "Error" : "Warning", pszErrorId, pszFormat, &va2);
1015 va_end(va2);
1016}
1017
1018
1019/** VM asynchronous operations thread */
1020DECLCALLBACK(int) VMPowerUpThread(RTTHREAD Thread, void *pvUser)
1021{
1022 int rc = VINF_SUCCESS;
1023 int rc2;
1024
1025 /*
1026 * Setup the release log instance in current directory.
1027 */
1028 if (g_fReleaseLog)
1029 {
1030 static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
1031 static char szError[RTPATH_MAX + 128] = "";
1032 PRTLOGGER pLogger;
1033 rc2 = RTLogCreateEx(&pLogger, RTLOGFLAGS_PREFIX_TIME_PROG, "all",
1034 "VBOX_RELEASE_LOG", ELEMENTS(s_apszGroups), s_apszGroups,
1035 RTLOGDEST_FILE, szError, sizeof(szError), "./VBoxBFE.log");
1036 if (VBOX_SUCCESS(rc2))
1037 {
1038 /* some introductory information */
1039 RTTIMESPEC TimeSpec;
1040 char szNowUct[64];
1041 RTTimeSpecToString(RTTimeNow(&TimeSpec), szNowUct, sizeof(szNowUct));
1042 RTLogRelLogger(pLogger, 0, ~0U,
1043 "VBoxBFE %s (%s %s) release log\n"
1044 "Log opened %s\n",
1045 VBOX_VERSION_STRING, __DATE__, __TIME__,
1046 szNowUct);
1047
1048 /* register this logger as the release logger */
1049 RTLogRelSetDefaultInstance(pLogger);
1050 }
1051 else
1052 RTPrintf("Could not open release log (%s)\n", szError);
1053 }
1054
1055 /*
1056 * Start VM (also from saved state) and track progress
1057 */
1058 LogFlow(("VMPowerUp\n"));
1059
1060 /*
1061 * Create empty VM.
1062 */
1063 rc = VMR3Create(setVMErrorCallback, NULL, vboxbfeConfigConstructor, NULL, &pVM);
1064 if (VBOX_FAILURE(rc))
1065 {
1066 RTPrintf("Error: VM creation failed with %Vrc.\n", rc);
1067 goto failure;
1068 }
1069
1070
1071 /*
1072 * Register VM state change handler
1073 */
1074 rc = VMR3AtStateRegister(pVM, vmstateChangeCallback, NULL);
1075 if (VBOX_FAILURE(rc))
1076 {
1077 RTPrintf("Error: VMR3AtStateRegister failed with %Vrc.\n", rc);
1078 goto failure;
1079 }
1080
1081#ifdef VBOXBFE_WITH_USB
1082 /*
1083 * Capture USB devices.
1084 */
1085 if (g_fUSB)
1086 {
1087 gHostUSB = new HostUSB();
1088 gHostUSB->init(pVM);
1089 }
1090#endif /* VBOXBFE_WITH_USB */
1091
1092#ifdef RT_OS_L4
1093 /* L4 console cannot draw a host cursor */
1094 gMouse->setHostCursor(false);
1095#else
1096 gMouse->setHostCursor(true);
1097#endif
1098
1099 /*
1100 * Power on the VM (i.e. start executing).
1101 */
1102 if (VBOX_SUCCESS(rc))
1103 {
1104 PVMREQ pReq;
1105 rc = VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)VMR3PowerOn, 1, pVM);
1106 if (VBOX_SUCCESS(rc))
1107 {
1108 rc = pReq->iStatus;
1109 AssertRC(rc);
1110 VMR3ReqFree(pReq);
1111 }
1112 else
1113 AssertMsgFailed(("VMR3PowerOn failed, rc=%Vrc\n", rc));
1114 }
1115
1116 /*
1117 * On failure destroy the VM.
1118 */
1119 if (VBOX_FAILURE(rc))
1120 goto failure;
1121
1122 return 0;
1123
1124failure:
1125 if (pVM)
1126 {
1127 rc2 = VMR3Destroy(pVM);
1128 AssertRC(rc2);
1129 pVM = NULL;
1130 }
1131 machineState = VMSTATE_TERMINATED;
1132
1133 return 0;
1134}
1135
1136/**
1137 * Register the main drivers.
1138 *
1139 * @returns VBox status code.
1140 * @param pCallbacks Pointer to the callback table.
1141 * @param u32Version VBox version number.
1142 */
1143DECLCALLBACK(int) VBoxDriversRegister(PCPDMDRVREGCB pCallbacks, uint32_t u32Version)
1144{
1145 int rc;
1146
1147 LogFlow(("VBoxDriversRegister: u32Version=%#x\n", u32Version));
1148 AssertReleaseMsg(u32Version == VBOX_VERSION, ("u32Version=%#x VBOX_VERSION=%#x\n", u32Version, VBOX_VERSION));
1149
1150 rc = pCallbacks->pfnRegister(pCallbacks, &Mouse::DrvReg);
1151 AssertRC(rc);
1152 if (VBOX_FAILURE(rc))
1153 return rc;
1154 rc = pCallbacks->pfnRegister(pCallbacks, &Keyboard::DrvReg);
1155 AssertRC(rc);
1156 if (VBOX_FAILURE(rc))
1157 return rc;
1158
1159 rc = pCallbacks->pfnRegister(pCallbacks, &VMDisplay::DrvReg);
1160 AssertRC(rc);
1161 if (VBOX_FAILURE(rc))
1162 return rc;
1163 rc = pCallbacks->pfnRegister(pCallbacks, &VMMDev::DrvReg);
1164 AssertRC(rc);
1165 if (VBOX_FAILURE(rc))
1166 return rc;
1167
1168 rc = pCallbacks->pfnRegister(pCallbacks, &VMStatus::DrvReg);
1169 if (VBOX_FAILURE(rc))
1170 return rc;
1171
1172 return VINF_SUCCESS;
1173}
1174
1175
1176/**
1177 * Constructs the VMM configuration tree.
1178 *
1179 * @returns VBox status code.
1180 * @param pVM VM handle.
1181 */
1182static DECLCALLBACK(int) vboxbfeConfigConstructor(PVM pVM, void *pvUser)
1183{
1184 int rcAll = VINF_SUCCESS;
1185 int rc;
1186
1187#define UPDATE_RC() do { if (VBOX_FAILURE(rc) && VBOX_SUCCESS(rcAll)) rcAll = rc; } while (0)
1188
1189 /*
1190 * Root values.
1191 */
1192 PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
1193 rc = CFGMR3InsertString(pRoot, "Name", "Default VM"); UPDATE_RC();
1194 rc = CFGMR3InsertInteger(pRoot, "RamSize", g_u32MemorySizeMB * _1M); UPDATE_RC();
1195 if (g_fPreAllocRam)
1196 {
1197 rc = CFGMR3InsertInteger(pRoot, "RamPreAlloc", 1); UPDATE_RC();
1198 }
1199 rc = CFGMR3InsertInteger(pRoot, "TimerMillies", 10); UPDATE_RC();
1200#ifdef VBOXSDL_ADVANCED_OPTIONS
1201 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", g_fRawR3); UPDATE_RC();
1202 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", g_fRawR0); UPDATE_RC();
1203 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", g_fPATM); UPDATE_RC();
1204 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", g_fCSAM); UPDATE_RC();
1205#else
1206 rc = CFGMR3InsertInteger(pRoot, "RawR3Enabled", 1); UPDATE_RC();
1207 rc = CFGMR3InsertInteger(pRoot, "RawR0Enabled", 1); UPDATE_RC();
1208 rc = CFGMR3InsertInteger(pRoot, "PATMEnabled", 1); UPDATE_RC();
1209 rc = CFGMR3InsertInteger(pRoot, "CSAMEnabled", 1); UPDATE_RC();
1210#endif
1211
1212 /*
1213 * PDM.
1214 */
1215 rc = PDMR3RegisterDrivers(pVM, VBoxDriversRegister); UPDATE_RC();
1216
1217 /*
1218 * Devices
1219 */
1220 PCFGMNODE pDevices = NULL;
1221 rc = CFGMR3InsertNode(pRoot, "Devices", &pDevices); UPDATE_RC();
1222 /* device */
1223 PCFGMNODE pDev = NULL;
1224 PCFGMNODE pInst = NULL;
1225 PCFGMNODE pCfg = NULL;
1226 PCFGMNODE pLunL0 = NULL;
1227 PCFGMNODE pLunL1 = NULL;
1228 PCFGMNODE pDrv = NULL;
1229
1230 /*
1231 * PC Arch.
1232 */
1233 rc = CFGMR3InsertNode(pDevices, "pcarch", &pDev); UPDATE_RC();
1234 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1235 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1236 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1237
1238 /*
1239 * PC Bios.
1240 */
1241 rc = CFGMR3InsertNode(pDevices, "pcbios", &pDev); UPDATE_RC();
1242 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1243 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1244 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1245 rc = CFGMR3InsertInteger(pCfg, "RamSize", g_u32MemorySizeMB * _1M); UPDATE_RC();
1246 rc = CFGMR3InsertString(pCfg, "BootDevice0", pszBootDevice); UPDATE_RC();
1247 rc = CFGMR3InsertString(pCfg, "BootDevice1", "NONE"); UPDATE_RC();
1248 rc = CFGMR3InsertString(pCfg, "BootDevice2", "NONE"); UPDATE_RC();
1249 rc = CFGMR3InsertString(pCfg, "BootDevice3", "NONE"); UPDATE_RC();
1250 rc = CFGMR3InsertString(pCfg, "HardDiskDevice", "piix3ide"); UPDATE_RC();
1251 rc = CFGMR3InsertString(pCfg, "FloppyDevice", "i82078"); UPDATE_RC();
1252 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", g_fIOAPIC); UPDATE_RC();
1253 RTUUID Uuid;
1254 RTUuidClear(&Uuid);
1255 rc = CFGMR3InsertBytes(pCfg, "UUID", &Uuid, sizeof(Uuid)); UPDATE_RC();
1256
1257 /* Default: no bios logo. */
1258 rc = CFGMR3InsertInteger(pCfg, "FadeIn", 1); UPDATE_RC();
1259 rc = CFGMR3InsertInteger(pCfg, "FadeOut", 0); UPDATE_RC();
1260 rc = CFGMR3InsertInteger(pCfg, "LogoTime", 0); UPDATE_RC();
1261 rc = CFGMR3InsertString(pCfg, "LogoFile", ""); UPDATE_RC();
1262
1263 /* Boot menu */
1264 rc = CFGMR3InsertInteger(pCfg, "ShowBootMenu", g_iBootMenu); UPDATE_RC();
1265
1266 /*
1267 * ACPI
1268 */
1269 if (g_fACPI)
1270 {
1271 rc = CFGMR3InsertNode(pDevices, "acpi", &pDev); UPDATE_RC();
1272 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1273 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1274 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1275 rc = CFGMR3InsertInteger(pCfg, "RamSize", g_u32MemorySizeMB * _1M); UPDATE_RC();
1276 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", g_fIOAPIC); UPDATE_RC();
1277 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 7); UPDATE_RC();
1278 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1279
1280 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1281 rc = CFGMR3InsertString(pLunL0, "Driver", "ACPIHost"); UPDATE_RC();
1282 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1283 }
1284
1285 /*
1286 * PCI bus.
1287 */
1288 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */ UPDATE_RC();
1289 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1290 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1291 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1292 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", g_fIOAPIC); UPDATE_RC();
1293
1294 /*
1295 * DMA
1296 */
1297 rc = CFGMR3InsertNode(pDevices, "8237A", &pDev); UPDATE_RC();
1298 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1299 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1300
1301 /*
1302 * PCI bus.
1303 */
1304 rc = CFGMR3InsertNode(pDevices, "pci", &pDev); /* piix3 */ UPDATE_RC();
1305 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1306 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1307 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1308
1309 /*
1310 * PS/2 keyboard & mouse.
1311 */
1312 rc = CFGMR3InsertNode(pDevices, "pckbd", &pDev); UPDATE_RC();
1313 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1314 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1315 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1316
1317 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1318 rc = CFGMR3InsertString(pLunL0, "Driver", "KeyboardQueue"); UPDATE_RC();
1319 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1320 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 64); UPDATE_RC();
1321
1322 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pDrv); UPDATE_RC();
1323 rc = CFGMR3InsertString(pDrv, "Driver", "MainKeyboard"); UPDATE_RC();
1324 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1325 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)gKeyboard); UPDATE_RC();
1326
1327 rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL0); UPDATE_RC();
1328 rc = CFGMR3InsertString(pLunL0, "Driver", "MouseQueue"); UPDATE_RC();
1329 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1330 rc = CFGMR3InsertInteger(pCfg, "QueueSize", 128); UPDATE_RC();
1331
1332 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pDrv); UPDATE_RC();
1333 rc = CFGMR3InsertString(pDrv, "Driver", "MainMouse"); UPDATE_RC();
1334 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1335 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)gMouse); UPDATE_RC();
1336
1337
1338 /*
1339 * i82078 Floppy drive controller
1340 */
1341 rc = CFGMR3InsertNode(pDevices, "i82078", &pDev); UPDATE_RC();
1342 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1343 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); UPDATE_RC();
1344 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1345 rc = CFGMR3InsertInteger(pCfg, "IRQ", 6); UPDATE_RC();
1346 rc = CFGMR3InsertInteger(pCfg, "DMA", 2); UPDATE_RC();
1347 rc = CFGMR3InsertInteger(pCfg, "MemMapped", 0 ); UPDATE_RC();
1348 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f0); UPDATE_RC();
1349
1350 /* Attach the status driver */
1351 rc = CFGMR3InsertNode(pInst, "LUN#999", &pLunL0); UPDATE_RC();
1352 rc = CFGMR3InsertString(pLunL0, "Driver", "MainStatus"); UPDATE_RC();
1353 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1354 rc = CFGMR3InsertInteger(pCfg, "papLeds", (uintptr_t)&mapFDLeds[0]); UPDATE_RC();
1355 rc = CFGMR3InsertInteger(pCfg, "First", 0); UPDATE_RC();
1356 rc = CFGMR3InsertInteger(pCfg, "Last", 0); UPDATE_RC();
1357
1358 if (g_pszFdaFile)
1359 {
1360 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1361 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); UPDATE_RC();
1362 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1363 rc = CFGMR3InsertString(pCfg, "Type", "Floppy 1.44"); UPDATE_RC();
1364 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); UPDATE_RC();
1365
1366 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pDrv); UPDATE_RC();
1367 rc = CFGMR3InsertString(pDrv, "Driver", "RawImage"); UPDATE_RC();
1368 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1369 rc = CFGMR3InsertString(pCfg, "Path", g_pszFdaFile); UPDATE_RC();
1370 }
1371
1372 /*
1373 * i8254 Programmable Interval Timer And Dummy Speaker
1374 */
1375 rc = CFGMR3InsertNode(pDevices, "i8254", &pDev); UPDATE_RC();
1376 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1377 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1378#ifdef DEBUG
1379 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1380#endif
1381
1382 /*
1383 * i8259 Programmable Interrupt Controller.
1384 */
1385 rc = CFGMR3InsertNode(pDevices, "i8259", &pDev); UPDATE_RC();
1386 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1387 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1388 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1389
1390 /*
1391 * Advanced Programmable Interrupt Controller.
1392 */
1393 rc = CFGMR3InsertNode(pDevices, "apic", &pDev); UPDATE_RC();
1394 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1395 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1396 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1397 rc = CFGMR3InsertInteger(pCfg, "IOAPIC", g_fIOAPIC); UPDATE_RC();
1398
1399 /*
1400 * I/O Advanced Programmable Interrupt Controller.
1401 */
1402 if (g_fIOAPIC)
1403 {
1404 rc = CFGMR3InsertNode(pDevices, "ioapic", &pDev); UPDATE_RC();
1405 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1406 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1407 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1408 }
1409
1410 /*
1411 * RTC MC146818.
1412 */
1413 rc = CFGMR3InsertNode(pDevices, "mc146818", &pDev); UPDATE_RC();
1414 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1415 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1416
1417 /*
1418 * Serial ports
1419 */
1420 rc = CFGMR3InsertNode(pDevices, "serial", &pDev); UPDATE_RC();
1421 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1422 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1423 rc = CFGMR3InsertInteger(pCfg, "IRQ", 4); UPDATE_RC();
1424 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x3f8); UPDATE_RC();
1425
1426 rc = CFGMR3InsertNode(pDev, "1", &pInst); UPDATE_RC();
1427 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1428 rc = CFGMR3InsertInteger(pCfg, "IRQ", 3); UPDATE_RC();
1429 rc = CFGMR3InsertInteger(pCfg, "IOBase", 0x2f8); UPDATE_RC();
1430
1431 /*
1432 * VGA.
1433 */
1434 rc = CFGMR3InsertNode(pDevices, "vga", &pDev); UPDATE_RC();
1435 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1436 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1437 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 2); UPDATE_RC();
1438 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1439 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1440 rc = CFGMR3InsertInteger(pCfg, "VRamSize", g_u32VRamSizeMB * _1M); UPDATE_RC();
1441
1442#ifdef RT_OS_L4
1443 /* XXX hard-coded */
1444 rc = CFGMR3InsertInteger(pCfg, "HeightReduction", 18); UPDATE_RC();
1445 rc = CFGMR3InsertInteger(pCfg, "CustomVideoModes", 1); UPDATE_RC();
1446 char szBuf[64];
1447 /* Tell the guest which is the ideal video mode to use */
1448 RTStrPrintf(szBuf, sizeof(szBuf), "%dx%dx%d",
1449 gFramebuffer->getHostXres(),
1450 gFramebuffer->getHostYres(),
1451 gFramebuffer->getHostBitsPerPixel());
1452 rc = CFGMR3InsertString(pCfg, "CustomVideoMode1", szBuf); UPDATE_RC();
1453#endif
1454
1455 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1456 rc = CFGMR3InsertString(pLunL0, "Driver", "MainDisplay"); UPDATE_RC();
1457 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1458 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)gDisplay); UPDATE_RC();
1459
1460 /*
1461 * IDE (update this when the main interface changes)
1462 */
1463 rc = CFGMR3InsertNode(pDevices, "piix3ide", &pDev); /* piix3 */ UPDATE_RC();
1464 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1465 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1466 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 1); UPDATE_RC();
1467 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 1); UPDATE_RC();
1468 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1469
1470 if (g_pszHdaFile)
1471 {
1472 const char *szDriver;
1473 if (0 == strcmp(RTPathExt(g_pszHdaFile), ".vdi"))
1474 szDriver = "VBoxHDD"; /* .vdi */
1475 else
1476 szDriver = "VD"; /* .vmdk */
1477
1478 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1479 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); UPDATE_RC();
1480 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1481 rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); UPDATE_RC();
1482 rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); UPDATE_RC();
1483
1484 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pDrv); UPDATE_RC();
1485 rc = CFGMR3InsertString(pDrv, "Driver", szDriver); UPDATE_RC();
1486 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1487 rc = CFGMR3InsertString(pCfg, "Path", g_pszHdaFile); UPDATE_RC();
1488
1489 if (g_fHdaSpf)
1490 {
1491 rc = CFGMR3InsertString(pCfg, "Format", "SPF"); UPDATE_RC();
1492 }
1493 }
1494
1495 if (g_pszHdbFile)
1496 {
1497 const char *szDriver;
1498 if (0 == strcmp(RTPathExt(g_pszHdbFile), ".vdi"))
1499 szDriver = "VBoxHDD"; /* .vdi */
1500 else
1501 szDriver = "VD"; /* .vmdk */
1502
1503 rc = CFGMR3InsertNode(pInst, "LUN#1", &pLunL1); UPDATE_RC();
1504 rc = CFGMR3InsertString(pLunL1, "Driver", "Block"); UPDATE_RC();
1505 rc = CFGMR3InsertNode(pLunL1, "Config", &pCfg); UPDATE_RC();
1506 rc = CFGMR3InsertString(pCfg, "Type", "HardDisk"); UPDATE_RC();
1507 rc = CFGMR3InsertInteger(pCfg, "Mountable", 0); UPDATE_RC();
1508
1509 rc = CFGMR3InsertNode(pLunL1, "AttachedDriver", &pDrv); UPDATE_RC();
1510 rc = CFGMR3InsertString(pDrv, "Driver", szDriver); UPDATE_RC();
1511 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1512 rc = CFGMR3InsertString(pCfg, "Path", g_pszHdbFile); UPDATE_RC();
1513
1514 if (g_fHdbSpf)
1515 {
1516 rc = CFGMR3InsertString(pCfg, "Format", "SPF"); UPDATE_RC();
1517 }
1518 }
1519
1520 if (g_pszCdromFile)
1521 {
1522 // ASSUME: DVD drive is always attached to LUN#2 (i.e. secondary IDE master)
1523 rc = CFGMR3InsertNode(pInst, "LUN#2", &pLunL0); UPDATE_RC();
1524 rc = CFGMR3InsertString(pLunL0, "Driver", "Block"); UPDATE_RC();
1525 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1526 rc = CFGMR3InsertString(pCfg, "Type", "DVD"); UPDATE_RC();
1527 rc = CFGMR3InsertInteger(pCfg, "Mountable", 1); UPDATE_RC();
1528
1529 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pDrv); UPDATE_RC();
1530 rc = CFGMR3InsertString(pDrv, "Driver", "MediaISO"); UPDATE_RC();
1531 rc = CFGMR3InsertNode(pDrv, "Config", &pCfg); UPDATE_RC();
1532 rc = CFGMR3InsertString(pCfg, "Path", g_pszCdromFile); UPDATE_RC();
1533 }
1534
1535 /*
1536 * Network adapters
1537 */
1538 rc = CFGMR3InsertNode(pDevices, "pcnet", &pDev); UPDATE_RC();
1539 for (ULONG ulInstance = 0; ulInstance < NetworkAdapterCount; ulInstance++)
1540 {
1541 if (g_aNetDevs[ulInstance].enmType != BFENETDEV::NOT_CONFIGURED)
1542 {
1543 char szInstance[4];
1544 RTStrPrintf(szInstance, sizeof(szInstance), "%lu", ulInstance);
1545 rc = CFGMR3InsertNode(pDev, szInstance, &pInst); UPDATE_RC();
1546 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); UPDATE_RC();
1547 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo",
1548 !ulInstance ? 3 : ulInstance - 1 + 8); UPDATE_RC();
1549 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1550 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1551 rc = CFGMR3InsertBytes(pCfg, "MAC", &g_aNetDevs[ulInstance].Mac, sizeof(PDMMAC));
1552 UPDATE_RC();
1553
1554 /*
1555 * Enable the packet sniffer if requested.
1556 */
1557 if (g_aNetDevs[ulInstance].fSniff)
1558 {
1559 /* insert the sniffer filter driver. */
1560 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1561 rc = CFGMR3InsertString(pLunL0, "Driver", "NetSniffer"); UPDATE_RC();
1562 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1563 if (g_aNetDevs[ulInstance].pszSniff)
1564 {
1565 rc = CFGMR3InsertString(pCfg, "File", g_aNetDevs[ulInstance].pszSniff);
1566 UPDATE_RC();
1567 }
1568 }
1569
1570 /*
1571 * Create the driver config (if any).
1572 */
1573 if (g_aNetDevs[ulInstance].enmType != BFENETDEV::NONE)
1574 {
1575 if (g_aNetDevs[ulInstance].fSniff)
1576 {
1577 rc = CFGMR3InsertNode(pLunL0, "AttachedDriver", &pLunL0); UPDATE_RC();
1578 }
1579 else
1580 {
1581 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1582 }
1583 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1584 }
1585
1586 /*
1587 * Configure the driver.
1588 */
1589 if (g_aNetDevs[ulInstance].enmType == BFENETDEV::NAT)
1590 {
1591 rc = CFGMR3InsertString(pLunL0, "Driver", "NAT"); UPDATE_RC();
1592 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1593 /* (Port forwarding goes here.) */
1594 }
1595 else if (g_aNetDevs[ulInstance].enmType == BFENETDEV::HIF)
1596 {
1597 rc = CFGMR3InsertString(pLunL0, "Driver", "HostInterface"); UPDATE_RC();
1598 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1599
1600#if defined(RT_OS_LINUX)
1601 if (g_aNetDevs[ulInstance].fHaveFd)
1602 {
1603 rc = CFGMR3InsertString(pCfg, "Device", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1604 rc = CFGMR3InsertInteger(pCfg, "FileHandle", g_aNetDevs[ulInstance].fd); UPDATE_RC();
1605 }
1606 else
1607#endif
1608 {
1609#if defined(RT_OS_LINUX) || defined(RT_OS_L4)
1610 /*
1611 * Create/Open the TAP the device.
1612 */
1613 RTFILE tapFD;
1614 rc = RTFileOpen(&tapFD, "/dev/net/tun",
1615 RTFILE_O_READWRITE | RTFILE_O_OPEN |
1616 RTFILE_O_DENY_NONE | RTFILE_O_INHERIT);
1617 if (VBOX_FAILURE(rc))
1618 {
1619 FatalError("Failed to open /dev/net/tun: %Vrc\n", rc);
1620 return rc;
1621 }
1622
1623 struct ifreq IfReq;
1624 memset(&IfReq, 0, sizeof(IfReq));
1625 if (g_aNetDevs[ulInstance].pszName && g_aNetDevs[ulInstance].pszName[0])
1626 {
1627 size_t cch = strlen(g_aNetDevs[ulInstance].pszName);
1628 if (cch >= sizeof(IfReq.ifr_name))
1629 {
1630 FatalError("HIF name too long for device #%d: %s\n",
1631 ulInstance + 1, g_aNetDevs[ulInstance].pszName);
1632 return VERR_BUFFER_OVERFLOW;
1633 }
1634 memcpy(IfReq.ifr_name, g_aNetDevs[ulInstance].pszName, cch + 1);
1635 }
1636 else
1637 strcpy(IfReq.ifr_name, "tun%d");
1638 IfReq.ifr_flags = IFF_TAP | IFF_NO_PI;
1639 rc = ioctl(tapFD, TUNSETIFF, &IfReq);
1640 if (rc)
1641 {
1642 int rc2 = RTErrConvertFromErrno(errno);
1643 FatalError("ioctl TUNSETIFF '%s' failed: errno=%d rc=%d (%Vrc)\n",
1644 IfReq.ifr_name, errno, rc, rc2);
1645 return rc2;
1646 }
1647
1648 rc = fcntl(tapFD, F_SETFL, O_NONBLOCK);
1649 if (rc)
1650 {
1651 int rc2 = RTErrConvertFromErrno(errno);
1652 FatalError("fcntl F_SETFL/O_NONBLOCK '%s' failed: errno=%d rc=%d (%Vrc)\n",
1653 IfReq.ifr_name, errno, rc, rc2);
1654 return rc2;
1655 }
1656
1657 rc = CFGMR3InsertString(pCfg, "Device", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1658 rc = CFGMR3InsertInteger(pCfg, "FileHandle", (RTFILE)tapFD); UPDATE_RC();
1659
1660#elif defined(RT_OS_OS2)
1661 /*
1662 * The TAP driver does all the opening and setting up,
1663 * as it was originally was ment to be (stupid fork() problems).
1664 */
1665 rc = CFGMR3InsertString(pCfg, "Device", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1666 if (g_aNetDevs[ulInstance].fHaveConnectTo)
1667 {
1668 rc = CFGMR3InsertInteger(pCfg, "ConnectTo", g_aNetDevs[ulInstance].iConnectTo);
1669 UPDATE_RC();
1670 }
1671#elif defined(RT_OS_WINDOWS)
1672 /*
1673 * We need the GUID too here...
1674 */
1675 rc = CFGMR3InsertString(pCfg, "Device", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1676 rc = CFGMR3InsertString(pCfg, "HostInterfaceName", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1677 rc = CFGMR3InsertString(pCfg, "GUID", g_aNetDevs[ulInstance].pszName /*pszGUID*/); UPDATE_RC();
1678
1679
1680#else /* !RT_OS_LINUX && !RT_OS_L4 */
1681 FatalError("Name based HIF devices not implemented yet for this host platform\n");
1682 return VERR_NOT_IMPLEMENTED;
1683#endif
1684 }
1685 }
1686 else if (g_aNetDevs[ulInstance].enmType == BFENETDEV::INTNET)
1687 {
1688 /*
1689 * Internal networking.
1690 */
1691 rc = CFGMR3InsertString(pCfg, "Network", g_aNetDevs[ulInstance].pszName); UPDATE_RC();
1692 }
1693 }
1694 }
1695
1696 /*
1697 * VMM Device
1698 */
1699 rc = CFGMR3InsertNode(pDevices, "VMMDev", &pDev); UPDATE_RC();
1700 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1701 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1702 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1703 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 4); UPDATE_RC();
1704 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1705
1706 /* the VMM device's Main driver */
1707 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1708 rc = CFGMR3InsertString(pLunL0, "Driver", "MainVMMDev"); UPDATE_RC();
1709 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1710 rc = CFGMR3InsertInteger(pCfg, "Object", (uintptr_t)gVMMDev); UPDATE_RC();
1711
1712 /*
1713 * AC'97 ICH audio
1714 */
1715 if (g_fAudio)
1716 {
1717 rc = CFGMR3InsertNode(pDevices, "ichac97", &pDev); UPDATE_RC();
1718 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1719 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1720 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 5); UPDATE_RC();
1721 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1722 rc = CFGMR3InsertNode(pInst, "Config", &pCfg);
1723
1724 /* the Audio driver */
1725 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1726 rc = CFGMR3InsertString(pLunL0, "Driver", "AUDIO"); UPDATE_RC();
1727 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1728#ifdef RT_OS_WINDOWS
1729 rc = CFGMR3InsertString(pCfg, "AudioDriver", "winmm"); UPDATE_RC();
1730#elif defined(RT_OS_DARWIN)
1731 rc = CFGMR3InsertString(pCfg, "AudioDriver", "coreaudio"); UPDATE_RC();
1732#elif defined(RT_OS_LINUX)
1733 rc = CFGMR3InsertString(pCfg, "AudioDriver", "oss"); UPDATE_RC();
1734#elif defined(RT_OS_L4)
1735 rc = CFGMR3InsertString(pCfg, "AudioDriver", "oss"); UPDATE_RC();
1736#else /* portme */
1737 rc = CFGMR3InsertString(pCfg, "AudioDriver", "none"); UPDATE_RC();
1738#endif /* !RT_OS_WINDOWS */
1739 }
1740
1741#ifdef VBOXBFE_WITH_USB
1742 /*
1743 * The USB Controller.
1744 */
1745 if (g_fUSB)
1746 {
1747 rc = CFGMR3InsertNode(pDevices, "usb-ohci", &pDev); UPDATE_RC();
1748 rc = CFGMR3InsertNode(pDev, "0", &pInst); UPDATE_RC();
1749 rc = CFGMR3InsertNode(pInst, "Config", &pCfg); UPDATE_RC();
1750 rc = CFGMR3InsertInteger(pInst, "Trusted", 1); /* boolean */ UPDATE_RC();
1751 rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo", 6); UPDATE_RC();
1752 rc = CFGMR3InsertInteger(pInst, "PCIFunctionNo", 0); UPDATE_RC();
1753
1754 rc = CFGMR3InsertNode(pInst, "LUN#0", &pLunL0); UPDATE_RC();
1755 rc = CFGMR3InsertString(pLunL0, "Driver", "VUSBRootHub"); UPDATE_RC();
1756 rc = CFGMR3InsertNode(pLunL0, "Config", &pCfg); UPDATE_RC();
1757 }
1758#endif /* VBOXBFE_WITH_USB */
1759
1760#undef UPDATE_RC
1761#undef UPDATE_RC
1762
1763 VMR3AtRuntimeErrorRegister (pVM, setVMRuntimeErrorCallback, NULL);
1764
1765 return rc;
1766}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette