VirtualBox

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

Last change on this file since 98103 was 98103, checked in by vboxsync, 16 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use