VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/init.cpp@ 103914

Last change on this file since 103914 was 100307, checked in by vboxsync, 18 months ago

Runtime,Additions,HostDrivers: Provide API to query the host page size and associated parameters for architectures where the used page size can vary (like on linux.arm64 depending on the kernel config), bugref:10476

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 21.3 KB
Line 
1/* $Id: init.cpp 100307 2023-06-28 10:17:34Z vboxsync $ */
2/** @file
3 * IPRT - Init Ring-3.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#define LOG_GROUP RTLOGGROUP_DEFAULT
42#include <iprt/types.h> /* darwin: UINT32_C and others. */
43
44#ifdef RT_OS_WINDOWS
45# include <iprt/win/windows.h>
46#else
47# include <unistd.h>
48# ifndef RT_OS_OS2
49# include <pthread.h>
50# include <signal.h>
51# include <errno.h>
52# define IPRT_USE_SIG_CHILD_DUMMY
53# endif
54#endif
55#ifdef RT_OS_OS2
56# include <InnoTekLIBC/fork.h>
57# define INCL_DOSMISC
58# include <os2.h>
59#endif
60#ifndef IPRT_NO_CRT
61# include <locale.h>
62#endif
63
64#include <iprt/initterm.h>
65#include <iprt/asm.h>
66#include <iprt/assert.h>
67#include <iprt/env.h>
68#include <iprt/errcore.h>
69#include <iprt/log.h>
70#include <iprt/mem.h>
71#include <iprt/path.h>
72#include <iprt/time.h>
73#include <iprt/string.h>
74#include <iprt/param.h>
75#ifdef RT_OS_WINDOWS
76# include <iprt/getopt.h>
77# include <iprt/utf16.h>
78#endif
79#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
80# include <iprt/file.h>
81# include <VBox/sup.h>
82#endif
83#include <stdlib.h>
84
85#include "init.h"
86#include "internal/alignmentchecks.h"
87#include "internal/initterm.h"
88#include "internal/path.h"
89#include "internal/process.h"
90#include "internal/system.h"
91#include "internal/thread.h"
92#include "internal/time.h"
93
94
95/*********************************************************************************************************************************
96* Global Variables *
97*********************************************************************************************************************************/
98/** The IPRT init flags. */
99static uint32_t g_fInitFlags;
100
101/** The argument count of the program. */
102static int g_crtArgs = -1;
103/** The arguments of the program (UTF-8). This is "leaked". */
104static char ** g_papszrtArgs;
105/** The original argument vector of the program. */
106static char ** g_papszrtOrgArgs;
107
108#ifdef IPRT_WITH_ALIGNMENT_CHECKS
109/**
110 * Whether alignment checks are enabled.
111 * This is set if the environment variable IPRT_ALIGNMENT_CHECKS is 1.
112 */
113RTDATADECL(bool) g_fRTAlignmentChecks = false;
114#endif
115
116
117#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD) || defined(RT_OS_NETBSD) || defined(RT_OS_HAIKU) \
118 || defined(RT_OS_LINUX) || defined(RT_OS_OS2) || defined(RT_OS_SOLARIS) /** @todo add host init hooks everywhere. */
119/* Stubs */
120DECLHIDDEN(int) rtR3InitNativeFirst(uint32_t fFlags) { RT_NOREF_PV(fFlags); return VINF_SUCCESS; }
121DECLHIDDEN(int) rtR3InitNativeFinal(uint32_t fFlags) { RT_NOREF_PV(fFlags); return VINF_SUCCESS; }
122DECLHIDDEN(void) rtR3InitNativeObtrusive(uint32_t fFlags) { RT_NOREF_PV(fFlags); }
123#endif
124
125
126/**
127 * atexit callback.
128 *
129 * This makes sure any loggers are flushed and will later also work the
130 * termination callback chain.
131 */
132static void rtR3ExitCallback(void) RT_NOTHROW_DEF
133{
134 ASMAtomicWriteBool(&g_frtAtExitCalled, true);
135
136 if (g_crtR3Users > 0)
137 {
138 PRTLOGGER pLogger = RTLogGetDefaultInstance();
139 if (pLogger)
140 RTLogFlush(pLogger);
141
142 pLogger = RTLogRelGetDefaultInstance();
143 if (pLogger)
144 RTLogFlush(pLogger);
145 }
146}
147
148
149#ifndef RT_OS_WINDOWS
150/**
151 * Fork callback, child context.
152 */
153static void rtR3ForkChildCallback(void)
154{
155 g_ProcessSelf = getpid();
156}
157#endif /* RT_OS_WINDOWS */
158
159#ifdef RT_OS_OS2
160/** Fork completion callback for OS/2. Only called in the child. */
161static void rtR3ForkOs2ChildCompletionCallback(void *pvArg, int rc, __LIBC_FORKCTX enmCtx)
162{
163 Assert(enmCtx == __LIBC_FORK_CTX_CHILD); NOREF(enmCtx);
164 NOREF(pvArg);
165
166 if (!rc)
167 rtR3ForkChildCallback();
168}
169
170/** Low-level fork callback for OS/2. */
171int rtR3ForkOs2Child(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation)
172{
173 if (enmOperation == __LIBC_FORK_OP_EXEC_CHILD)
174 return pForkHandle->pfnCompletionCallback(pForkHandle, rtR3ForkOs2ChildCompletionCallback, NULL, __LIBC_FORK_CTX_CHILD);
175 return 0;
176}
177
178# define static static volatile /** @todo _FORK_CHILD1 causes unresolved externals in optimized builds. Fix macro. */
179_FORK_CHILD1(0, rtR3ForkOs2Child);
180# undef static
181#endif /* RT_OS_OS2 */
182
183
184
185/**
186 * Internal worker which initializes or re-initializes the
187 * program path, name and directory globals.
188 *
189 * @returns IPRT status code.
190 * @param pszProgramPath The program path, NULL if not specified.
191 */
192static int rtR3InitProgramPath(const char *pszProgramPath)
193{
194 /*
195 * We're reserving 32 bytes here for file names as what not.
196 */
197 if (!pszProgramPath)
198 {
199 int rc = rtProcInitExePath(g_szrtProcExePath, sizeof(g_szrtProcExePath) - 32);
200 if (RT_FAILURE(rc))
201 return rc;
202 }
203 else
204 {
205 size_t cch = strlen(pszProgramPath);
206 Assert(cch > 1);
207 AssertMsgReturn(cch < sizeof(g_szrtProcExePath) - 32, ("%zu\n", cch), VERR_BUFFER_OVERFLOW);
208 memcpy(g_szrtProcExePath, pszProgramPath, cch + 1);
209 }
210
211 /*
212 * Parse the name.
213 */
214 ssize_t offName;
215 g_cchrtProcExePath = RTPathParseSimple(g_szrtProcExePath, &g_cchrtProcExeDir, &offName, NULL);
216 g_offrtProcName = offName;
217 return VINF_SUCCESS;
218}
219
220
221#ifdef RT_OS_WINDOWS
222/**
223 * Checks the two argument vectors contains the same strings.
224 */
225DECLINLINE(bool) rtR3InitArgvEquals(int cArgs, char **papszArgs1, char **papszArgs2)
226{
227 if (papszArgs1 != papszArgs2)
228 while (cArgs-- > 0)
229 if (strcmp(papszArgs1[cArgs], papszArgs2[cArgs]) != 0)
230 return false;
231 return true;
232}
233#endif
234
235
236/**
237 * Internal worker which initializes or re-initializes the
238 * program path, name and directory globals.
239 *
240 * @returns IPRT status code.
241 * @param fFlags Flags, see RTR3INIT_XXX.
242 * @param cArgs Pointer to the argument count.
243 * @param ppapszArgs Pointer to the argument vector pointer. NULL
244 * allowed if @a cArgs is 0.
245 */
246static int rtR3InitArgv(uint32_t fFlags, int cArgs, char ***ppapszArgs)
247{
248 NOREF(fFlags);
249 if (cArgs)
250 {
251 AssertPtr(ppapszArgs);
252 AssertPtr(*ppapszArgs);
253 char **papszOrgArgs = *ppapszArgs;
254
255 /*
256 * Normally we should only be asked to convert arguments once. If we
257 * are though, it should be the already convered arguments.
258 */
259 if (g_crtArgs != -1)
260 {
261 AssertReturn( g_crtArgs == cArgs
262 && g_papszrtArgs == papszOrgArgs,
263 VERR_WRONG_ORDER); /* only init once! */
264 return VINF_SUCCESS;
265 }
266
267#if !defined(IPRT_NO_CRT) || !defined(RT_OS_WINDOWS)
268 if (!(fFlags & RTR3INIT_FLAGS_UTF8_ARGV))
269 {
270 /*
271 * Convert the arguments.
272 */
273 char **papszArgs;
274
275# ifdef RT_OS_WINDOWS
276 /* HACK ALERT! Try convert from unicode versions if possible.
277 Unfortunately for us, __wargv is only initialized if we have a unicode
278 main function. So, use getoptarv.cpp code to do the conversions and
279 hope it gives us the same result. (CommandLineToArgvW was not in NT 3.1.) */
280 if ( cArgs == __argc
281 && rtR3InitArgvEquals(cArgs, papszOrgArgs, __argv))
282 {
283 char *pszCmdLine = NULL;
284 int rc = RTUtf16ToUtf8Tag(GetCommandLineW(), &pszCmdLine, "will-leak:rtR3InitArgv");
285 AssertRCReturn(rc, rc);
286
287 int cArgsFromCmdLine = -1;
288 rc = RTGetOptArgvFromString(&papszArgs, &cArgsFromCmdLine, pszCmdLine,
289 RTGETOPTARGV_CNV_QUOTE_MS_CRT | RTGETOPTARGV_CNV_MODIFY_INPUT, NULL);
290 AssertMsgRCReturn(rc, ("pszCmdLine='%s' rc=%Rrc\n", pszCmdLine, rc), rc);
291 AssertMsg(cArgsFromCmdLine == cArgs,
292 ("cArgsFromCmdLine=%d cArgs=%d pszCmdLine='%s' rc=%Rrc\n", cArgsFromCmdLine, cArgs, pszCmdLine));
293 }
294 else
295# endif
296 {
297 papszArgs = (char **)RTMemAllocZTag((cArgs + 1) * sizeof(char *), "will-leak:rtR3InitArgv");
298 if (!papszArgs)
299 return VERR_NO_MEMORY;
300
301 for (int i = 0; i < cArgs; i++)
302 {
303 int rc = RTStrCurrentCPToUtf8(&papszArgs[i], papszOrgArgs[i]);
304 if (RT_FAILURE(rc))
305 {
306 while (i--)
307 RTStrFree(papszArgs[i]);
308 RTMemFree(papszArgs);
309 return rc;
310 }
311 }
312 }
313
314 papszArgs[cArgs] = NULL;
315
316 g_papszrtOrgArgs = papszOrgArgs;
317 g_papszrtArgs = papszArgs;
318 g_crtArgs = cArgs;
319
320 *ppapszArgs = papszArgs;
321 }
322 else
323#endif /* !IPRT_NO_CRT || !RT_OS_WINDOWS */
324 {
325 /*
326 * The arguments are already UTF-8, no conversion needed.
327 */
328 g_papszrtOrgArgs = papszOrgArgs;
329 g_papszrtArgs = papszOrgArgs;
330 g_crtArgs = cArgs;
331 }
332 }
333
334 return VINF_SUCCESS;
335}
336
337
338#ifdef IPRT_USE_SIG_CHILD_DUMMY
339/**
340 * Dummy SIGCHILD handler.
341 *
342 * Assigned on rtR3Init only when SIGCHILD handler is set SIGIGN or SIGDEF to
343 * ensure waitpid works properly for the terminated processes.
344 */
345static void rtR3SigChildHandler(int iSignal)
346{
347 NOREF(iSignal);
348}
349#endif /* IPRT_USE_SIG_CHILD_DUMMY */
350
351
352/**
353 * rtR3Init worker.
354 */
355static int rtR3InitBody(uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
356{
357 /*
358 * Early native initialization.
359 */
360 int rc = rtR3InitNativeFirst(fFlags);
361 AssertMsgRCReturn(rc, ("rtR3InitNativeFirst failed with %Rrc\n", rc), rc);
362
363 /*
364 * Disable error popups.
365 */
366#if defined(RT_OS_OS2) /** @todo move to private code. */
367 DosError(FERR_DISABLEHARDERR);
368#endif
369
370#ifndef IPRT_NO_CRT
371 /*
372 * Init C runtime locale before we do anything that may end up converting
373 * paths or we'll end up using the "C" locale for path conversion.
374 */
375 setlocale(LC_CTYPE, "");
376#endif
377
378 /*
379 * The Process ID.
380 */
381#ifdef _MSC_VER
382 g_ProcessSelf = GetCurrentProcessId(); /* since NT 3.1, not 3.51+ as listed on geoffchappell.com */
383#else
384 g_ProcessSelf = getpid();
385#endif
386
387 /*
388 * Save the init flags.
389 */
390 g_fInitFlags |= fFlags;
391
392#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
393# ifdef VBOX
394 /*
395 * This MUST be done as the very first thing, before any file is opened.
396 * The log is opened on demand, but the first log entries may be caused
397 * by rtThreadInit() below.
398 */
399 const char *pszDisableHostCache = getenv("VBOX_DISABLE_HOST_DISK_CACHE");
400 if ( pszDisableHostCache != NULL
401 && *pszDisableHostCache
402 && strcmp(pszDisableHostCache, "0") != 0)
403 {
404 RTFileSetForceFlags(RTFILE_O_WRITE, RTFILE_O_WRITE_THROUGH, 0);
405 RTFileSetForceFlags(RTFILE_O_READWRITE, RTFILE_O_WRITE_THROUGH, 0);
406 }
407# endif /* VBOX */
408#endif /* !IN_GUEST && !RT_NO_GIP */
409
410#if defined(RT_ARCH_ARM64) && defined(RT_OS_LINUX)
411 /*
412 * Initialize the page size.
413 */
414 rc = rtSystemInitPageSize();
415 AssertMsgRCReturn(rc, ("Failed to initialize the page size, rc=%Rrc!\n", rc), rc);
416#endif
417
418 /*
419 * Thread Thread database and adopt the caller thread as 'main'.
420 * This must be done before everything else or else we'll call into threading
421 * without having initialized TLS entries and suchlike.
422 */
423 rc = rtThreadInit();
424 AssertMsgRCReturn(rc, ("Failed to initialize threads, rc=%Rrc!\n", rc), rc);
425
426 /*
427 * The executable path before SUPLib (windows requirement).
428 */
429 rc = rtR3InitProgramPath(pszProgramPath);
430 AssertLogRelMsgRCReturn(rc, ("Failed to get executable directory path, rc=%Rrc!\n", rc), rc);
431
432#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
433 /*
434 * Initialize SUPLib here so the GIP can get going as early as possible
435 * (improves accuracy for the first client).
436 */
437 if (fFlags & (RTR3INIT_FLAGS_SUPLIB | RTR3INIT_FLAGS_TRY_SUPLIB))
438 {
439 if (!(fFlags & ((SUPR3INIT_F_UNRESTRICTED | SUPR3INIT_F_LIMITED) << RTR3INIT_FLAGS_SUPLIB_SHIFT)))
440 g_fInitFlags |= fFlags |= SUPR3INIT_F_UNRESTRICTED << RTR3INIT_FLAGS_SUPLIB_SHIFT;
441 rc = SUPR3InitEx(fFlags >> RTR3INIT_FLAGS_SUPLIB_SHIFT, NULL /*ppSession*/);
442 AssertMsgReturn(RT_SUCCESS(rc) || (fFlags & RTR3INIT_FLAGS_TRY_SUPLIB),
443 ("Failed to initialize the support library, rc=%Rrc!\n", rc), rc);
444 }
445#endif
446
447 /*
448 * Convert arguments.
449 */
450 rc = rtR3InitArgv(fFlags, cArgs, ppapszArgs);
451 AssertLogRelMsgRCReturn(rc, ("Failed to convert the arguments, rc=%Rrc!\n", rc), rc);
452
453#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
454 /*
455 * The threading is initialized, so we can safely sleep a bit if GIP
456 * needs some time to start updating itself. Currently limited to
457 * the first mapping of GIP (u32TransactionId <= 4), quite possible we
458 * could just ditch this now.
459 */
460 /** @todo consider dropping this... */
461 PSUPGLOBALINFOPAGE pGip;
462 if ( (fFlags & (RTR3INIT_FLAGS_SUPLIB | RTR3INIT_FLAGS_TRY_SUPLIB))
463 && (pGip = g_pSUPGlobalInfoPage) != NULL
464 && pGip->u32Magic == SUPGLOBALINFOPAGE_MAGIC)
465 {
466 PSUPGIPCPU pGipCpu = SUPGetGipCpuPtr(pGip);
467 if ( pGipCpu
468 && pGipCpu->u32TransactionId <= 4)
469 {
470 RTThreadSleep(pGip->u32UpdateIntervalNS / RT_NS_1MS + 2);
471 RTTimeNanoTS();
472 }
473 }
474#endif
475
476 /*
477 * Init the program start timestamp TS.
478 * Do that here to be sure that the GIP time was properly updated the 1st time.
479 */
480 g_u64ProgramStartNanoTS = RTTimeNanoTS();
481
482 /*
483 * The remainder cannot easily be undone, so it has to go last.
484 */
485
486 /* Fork and exit callbacks. */
487#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
488 rc = pthread_atfork(NULL, NULL, rtR3ForkChildCallback);
489 AssertMsg(rc == 0, ("%d\n", rc));
490#endif
491 atexit(rtR3ExitCallback);
492
493#ifdef IPRT_USE_SIG_CHILD_DUMMY
494 /*
495 * SIGCHLD must not be ignored (that's default), otherwise posix compliant waitpid
496 * implementations won't work right.
497 */
498 for (;;)
499 {
500 struct sigaction saOld;
501 rc = sigaction(SIGCHLD, 0, &saOld); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
502 if ( rc != 0
503 || (saOld.sa_flags & SA_SIGINFO)
504 || ( saOld.sa_handler != SIG_IGN
505 && saOld.sa_handler != SIG_DFL)
506 )
507 break;
508
509 /* Try install dummy handler. */
510 struct sigaction saNew = saOld;
511 saNew.sa_flags = SA_NOCLDSTOP | SA_RESTART;
512 saNew.sa_handler = rtR3SigChildHandler;
513 rc = sigemptyset(&saNew.sa_mask); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
514 struct sigaction saOld2;
515 rc = sigaction(SIGCHLD, &saNew, &saOld2); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
516 if ( rc != 0
517 || ( saOld2.sa_handler == saOld.sa_handler
518 && !(saOld2.sa_flags & SA_SIGINFO))
519 )
520 break;
521
522 /* Race during dynamic load, restore and try again... */
523 sigaction(SIGCHLD, &saOld2, NULL);
524 RTThreadYield();
525 }
526#endif /* IPRT_USE_SIG_CHILD_DUMMY */
527
528#ifdef IPRT_WITH_ALIGNMENT_CHECKS
529 /*
530 * Enable alignment checks.
531 */
532 const char *pszAlignmentChecks = RTEnvGet("IPRT_ALIGNMENT_CHECKS"); /** @todo add RTEnvGetBool */
533 g_fRTAlignmentChecks = pszAlignmentChecks != NULL
534 && pszAlignmentChecks[0] == '1'
535 && pszAlignmentChecks[1] == '\0';
536 if (g_fRTAlignmentChecks)
537 IPRT_ALIGNMENT_CHECKS_ENABLE();
538#endif
539
540 /*
541 * Final native initialization.
542 */
543 rc = rtR3InitNativeFinal(fFlags);
544 AssertMsgRCReturn(rc, ("rtR3InitNativeFinal failed with %Rrc\n", rc), rc);
545
546 return VINF_SUCCESS;
547}
548
549
550/**
551 * Internal initialization worker.
552 *
553 * @returns IPRT status code.
554 * @param fFlags Flags, see RTR3INIT_XXX.
555 * @param cArgs Pointer to the argument count.
556 * @param ppapszArgs Pointer to the argument vector pointer. NULL
557 * allowed if @a cArgs is 0.
558 * @param pszProgramPath The program path. Pass NULL if we're to figure it
559 * out ourselves.
560 */
561static int rtR3Init(uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
562{
563 /* no entry log flow, because prefixes and thread may freak out. */
564 Assert(!(fFlags & ~RTR3INIT_FLAGS_VALID_MASK));
565 Assert(!(fFlags & RTR3INIT_FLAGS_DLL) || cArgs == 0);
566
567 /*
568 * Do reference counting, only initialize the first time around.
569 *
570 * We are ASSUMING that nobody will be able to race RTR3Init* calls when the
571 * first one, the real init, is running (second assertion).
572 */
573 int32_t cUsers = ASMAtomicIncS32(&g_crtR3Users);
574 if (cUsers != 1)
575 {
576 AssertMsg(cUsers > 1, ("%d\n", cUsers));
577 Assert(!g_frtR3Initializing);
578
579#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
580 /* Initialize the support library if requested. We've always ignored the
581 status code here for some reason, making the two flags same. */
582 if (fFlags & (RTR3INIT_FLAGS_SUPLIB | RTR3INIT_FLAGS_TRY_SUPLIB))
583 {
584 if (!(fFlags & ((SUPR3INIT_F_UNRESTRICTED | SUPR3INIT_F_LIMITED) << RTR3INIT_FLAGS_SUPLIB_SHIFT)))
585 fFlags |= SUPR3INIT_F_UNRESTRICTED << RTR3INIT_FLAGS_SUPLIB_SHIFT;
586 SUPR3InitEx(fFlags >> RTR3INIT_FLAGS_SUPLIB_SHIFT, NULL /*ppSession*/);
587 g_fInitFlags |= fFlags & (RTR3INIT_FLAGS_SUPLIB | RTR3INIT_FLAGS_TRY_SUPLIB | RTR3INIT_FLAGS_SUPLIB_MASK);
588 }
589#endif
590 g_fInitFlags |= fFlags & RTR3INIT_FLAGS_UTF8_ARGV;
591
592 if ( !(fFlags & RTR3INIT_FLAGS_UNOBTRUSIVE)
593 && (g_fInitFlags & RTR3INIT_FLAGS_UNOBTRUSIVE))
594 {
595 g_fInitFlags &= ~RTR3INIT_FLAGS_UNOBTRUSIVE;
596 g_fInitFlags |= fFlags & RTR3INIT_FLAGS_STANDALONE_APP;
597 rtR3InitNativeObtrusive(g_fInitFlags | fFlags);
598 rtThreadReInitObtrusive();
599 }
600 else
601 Assert(!(fFlags & RTR3INIT_FLAGS_STANDALONE_APP) || (g_fInitFlags & RTR3INIT_FLAGS_STANDALONE_APP));
602
603 int rc = VINF_SUCCESS;
604 if (pszProgramPath)
605 rc = rtR3InitProgramPath(pszProgramPath);
606 if (RT_SUCCESS(rc))
607 rc = rtR3InitArgv(fFlags, cArgs, ppapszArgs);
608 return rc;
609 }
610
611 /*
612 * Do the initialization.
613 */
614 ASMAtomicWriteBool(&g_frtR3Initializing, true);
615 int rc = rtR3InitBody(fFlags, cArgs, ppapszArgs, pszProgramPath);
616 ASMAtomicWriteBool(&g_frtR3Initializing, false);
617 if (RT_FAILURE(rc))
618 {
619 /* failure */
620 ASMAtomicDecS32(&g_crtR3Users);
621 return rc;
622 }
623
624 /* success */
625 LogFlow(("rtR3Init: returns VINF_SUCCESS\n"));
626 return VINF_SUCCESS;
627}
628
629
630RTR3DECL(int) RTR3InitExe(int cArgs, char ***ppapszArgs, uint32_t fFlags)
631{
632 Assert(!(fFlags & RTR3INIT_FLAGS_DLL));
633 return rtR3Init(fFlags, cArgs, ppapszArgs, NULL);
634}
635
636
637RTR3DECL(int) RTR3InitExeNoArguments(uint32_t fFlags)
638{
639 Assert(!(fFlags & RTR3INIT_FLAGS_DLL));
640 return rtR3Init(fFlags, 0, NULL, NULL);
641}
642
643
644RTR3DECL(int) RTR3InitDll(uint32_t fFlags)
645{
646 Assert(!(fFlags & RTR3INIT_FLAGS_DLL));
647 return rtR3Init(fFlags | RTR3INIT_FLAGS_DLL, 0, NULL, NULL);
648}
649
650
651RTR3DECL(int) RTR3InitEx(uint32_t iVersion, uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
652{
653 AssertReturn(iVersion == RTR3INIT_VER_CUR, VERR_NOT_SUPPORTED);
654 return rtR3Init(fFlags, cArgs, ppapszArgs, pszProgramPath);
655}
656
657
658RTR3DECL(bool) RTR3InitIsInitialized(void)
659{
660 return g_crtR3Users >= 1 && !g_frtR3Initializing;
661}
662
663
664RTR3DECL(bool) RTR3InitIsUnobtrusive(void)
665{
666 return RT_BOOL(g_fInitFlags & RTR3INIT_FLAGS_UNOBTRUSIVE);
667}
668
669
670#if 0 /** @todo implement RTR3Term. */
671RTR3DECL(void) RTR3Term(void)
672{
673}
674#endif
675
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