VirtualBox

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

Last change on this file since 8290 was 8155, checked in by vboxsync, 17 years ago

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

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