VirtualBox

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

Last change on this file since 32292 was 28903, checked in by vboxsync, 15 years ago

IPRT: iconv cache.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.8 KB
Line 
1/* $Id: init.cpp 28903 2010-04-29 14:58:12Z vboxsync $ */
2/** @file
3 * IPRT - Init Ring-3.
4 */
5
6/*
7 * Copyright (C) 2006-2009 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#define LOG_GROUP RTLOGGROUP_DEFAULT
32#include <iprt/types.h> /* darwin: UINT32_C and others. */
33
34#ifdef RT_OS_WINDOWS
35# include <process.h>
36#else
37# include <unistd.h>
38# ifndef RT_OS_OS2
39# include <pthread.h>
40# include <signal.h>
41# include <errno.h>
42# define IPRT_USE_SIG_CHILD_DUMMY
43# endif
44#endif
45#ifdef RT_OS_OS2
46# include <InnoTekLIBC/fork.h>
47#endif
48#include <locale.h>
49
50#include <iprt/initterm.h>
51#include <iprt/asm.h>
52#include <iprt/assert.h>
53#include <iprt/err.h>
54#include <iprt/log.h>
55#include <iprt/path.h>
56#include <iprt/time.h>
57#include <iprt/string.h>
58#include <iprt/param.h>
59#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
60# include <iprt/file.h>
61# include <VBox/sup.h>
62#endif
63#include <stdlib.h>
64
65#include "internal/alignmentchecks.h"
66#include "internal/path.h"
67#include "internal/process.h"
68#include "internal/thread.h"
69#include "internal/thread.h"
70#include "internal/time.h"
71
72
73/*******************************************************************************
74* Global Variables *
75*******************************************************************************/
76/** The number of calls to RTR3Init. */
77static int32_t volatile g_cUsers = 0;
78/** Whether we're currently initializing the IPRT. */
79static bool volatile g_fInitializing = false;
80
81/** The process path.
82 * This is used by RTPathExecDir and RTProcGetExecutableName and set by rtProcInitName. */
83char g_szrtProcExePath[RTPATH_MAX];
84/** The length of g_szrtProcExePath. */
85size_t g_cchrtProcExePath;
86/** The length of directory path component of g_szrtProcExePath. */
87size_t g_cchrtProcDir;
88/** The offset of the process name into g_szrtProcExePath. */
89size_t g_offrtProcName;
90
91/**
92 * Program start nanosecond TS.
93 */
94uint64_t g_u64ProgramStartNanoTS;
95
96/**
97 * Program start microsecond TS.
98 */
99uint64_t g_u64ProgramStartMicroTS;
100
101/**
102 * Program start millisecond TS.
103 */
104uint64_t g_u64ProgramStartMilliTS;
105
106/**
107 * The process identifier of the running process.
108 */
109RTPROCESS g_ProcessSelf = NIL_RTPROCESS;
110
111/**
112 * The current process priority.
113 */
114RTPROCPRIORITY g_enmProcessPriority = RTPROCPRIORITY_DEFAULT;
115
116#ifdef IPRT_WITH_ALIGNMENT_CHECKS
117/**
118 * Whether alignment checks are enabled.
119 * This is set if the environment variable IPRT_ALIGNMENT_CHECKS is 1.
120 */
121RTDATADECL(bool) g_fRTAlignmentChecks = false;
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)
132{
133 if (g_cUsers > 0)
134 {
135 PRTLOGGER pLogger = RTLogGetDefaultInstance();
136 if (pLogger)
137 RTLogFlush(pLogger);
138
139 pLogger = RTLogRelDefaultInstance();
140 if (pLogger)
141 RTLogFlush(pLogger);
142 }
143}
144
145
146#ifndef RT_OS_WINDOWS
147/**
148 * Fork callback, child context.
149 */
150static void rtR3ForkChildCallback(void)
151{
152 g_ProcessSelf = getpid();
153}
154#endif /* RT_OS_WINDOWS */
155
156#ifdef RT_OS_OS2
157/** Fork completion callback for OS/2. Only called in the child. */
158static void rtR3ForkOs2ChildCompletionCallback(void *pvArg, int rc, __LIBC_FORKCTX enmCtx)
159{
160 Assert(enmCtx == __LIBC_FORK_CTX_CHILD); NOREF(enmCtx);
161 NOREF(pvArg);
162
163 if (!rc)
164 rtR3ForkChildCallback();
165}
166
167/** Low-level fork callback for OS/2. */
168int rtR3ForkOs2Child(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation)
169{
170 if (enmOperation == __LIBC_FORK_OP_EXEC_CHILD)
171 return pForkHandle->pfnCompletionCallback(pForkHandle, rtR3ForkOs2ChildCompletionCallback, NULL, __LIBC_FORK_CTX_CHILD);
172 return 0;
173}
174
175_FORK_CHILD1(0, rtR3ForkOs2Child);
176#endif /* RT_OS_OS2 */
177
178
179
180/**
181 * Internal worker which initializes or re-initializes the
182 * program path, name and directory globals.
183 *
184 * @returns IPRT status code.
185 * @param pszProgramPath The program path, NULL if not specified.
186 */
187static int rtR3InitProgramPath(const char *pszProgramPath)
188{
189 /*
190 * We're reserving 32 bytes here for file names as what not.
191 */
192 if (!pszProgramPath)
193 {
194 int rc = rtProcInitExePath(g_szrtProcExePath, sizeof(g_szrtProcExePath) - 32);
195 if (RT_FAILURE(rc))
196 return rc;
197 }
198 else
199 {
200 size_t cch = strlen(pszProgramPath);
201 Assert(cch > 1);
202 AssertMsgReturn(cch < sizeof(g_szrtProcExePath) - 32, ("%zu\n", cch), VERR_BUFFER_OVERFLOW);
203 memcpy(g_szrtProcExePath, pszProgramPath, cch + 1);
204 }
205
206 /*
207 * Parse the name.
208 */
209 ssize_t offName;
210 g_cchrtProcExePath = RTPathParse(g_szrtProcExePath, &g_cchrtProcDir, &offName, NULL);
211 g_offrtProcName = offName;
212 return VINF_SUCCESS;
213}
214
215
216#ifdef IPRT_USE_SIG_CHILD_DUMMY
217/**
218 * Dummy SIGCHILD handler.
219 *
220 * Assigned on rtR3Init only when SIGCHILD handler is set SIGIGN or SIGDEF to
221 * ensure waitpid works properly for the terminated processes.
222 */
223static void rtR3SigChildHandler(int iSignal)
224{
225 NOREF(iSignal);
226}
227#endif /* IPRT_USE_SIG_CHILD_DUMMY */
228
229
230/**
231 * rtR3Init worker.
232 */
233static int rtR3InitBody(bool fInitSUPLib, const char *pszProgramPath)
234{
235 /*
236 * Init C runtime locale before we do anything that may end up converting
237 * paths or we'll end up using the "C" locale for path conversion.
238 */
239 setlocale(LC_CTYPE, "");
240
241 /*
242 * The Process ID.
243 */
244#ifdef _MSC_VER
245 g_ProcessSelf = _getpid(); /* crappy ansi compiler */
246#else
247 g_ProcessSelf = getpid();
248#endif
249
250#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
251# ifdef VBOX
252 /*
253 * This MUST be done as the very first thing, before any file is opened.
254 * The log is opened on demand, but the first log entries may be caused
255 * by rtThreadInit() below.
256 */
257 const char *pszDisableHostCache = getenv("VBOX_DISABLE_HOST_DISK_CACHE");
258 if ( pszDisableHostCache != NULL
259 && *pszDisableHostCache
260 && strcmp(pszDisableHostCache, "0") != 0)
261 {
262 RTFileSetForceFlags(RTFILE_O_WRITE, RTFILE_O_WRITE_THROUGH, 0);
263 RTFileSetForceFlags(RTFILE_O_READWRITE, RTFILE_O_WRITE_THROUGH, 0);
264 }
265# endif /* VBOX */
266#endif /* !IN_GUEST && !RT_NO_GIP */
267
268 /*
269 * Thread Thread database and adopt the caller thread as 'main'.
270 * This must be done before everything else or else we'll call into threading
271 * without having initialized TLS entries and suchlike.
272 */
273 int rc = rtThreadInit();
274 AssertMsgRCReturn(rc, ("Failed to initialize threads, rc=%Rrc!\n", rc), rc);
275
276#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
277 if (fInitSUPLib)
278 {
279 /*
280 * Init GIP first.
281 * (The more time for updates before real use, the better.)
282 */
283 rc = SUPR3Init(NULL);
284 AssertMsgRCReturn(rc, ("Failed to initializeble the support library, rc=%Rrc!\n", rc), rc);
285 }
286#endif
287
288 /*
289 * The executable path, name and directory.
290 */
291 rc = rtR3InitProgramPath(pszProgramPath);
292 AssertLogRelMsgRCReturn(rc, ("Failed to get executable directory path, rc=%Rrc!\n", rc), rc);
293
294#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
295 /*
296 * The threading is initialized we can safely sleep a bit if GIP
297 * needs some time to update itself updating.
298 */
299 if (fInitSUPLib && g_pSUPGlobalInfoPage)
300 {
301 RTThreadSleep(20);
302 RTTimeNanoTS();
303 }
304#endif
305
306 /*
307 * Init the program start TSes.
308 * Do that here to be sure that the GIP time was properly updated the 1st time.
309 */
310 g_u64ProgramStartNanoTS = RTTimeNanoTS();
311 g_u64ProgramStartMicroTS = g_u64ProgramStartNanoTS / 1000;
312 g_u64ProgramStartMilliTS = g_u64ProgramStartNanoTS / 1000000;
313
314 /*
315 * The remainder cannot easily be undone, so it has to go last.
316 */
317
318 /* Fork and exit callbacks. */
319#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
320 rc = pthread_atfork(NULL, NULL, rtR3ForkChildCallback);
321 AssertMsg(rc == 0, ("%d\n", rc));
322#endif
323 atexit(rtR3ExitCallback);
324
325#ifdef IPRT_USE_SIG_CHILD_DUMMY
326 /*
327 * SIGCHLD must not be ignored (that's default), otherwise posix compliant waitpid
328 * implementations won't work right.
329 */
330 for (;;)
331 {
332 struct sigaction saOld;
333 rc = sigaction(SIGCHLD, 0, &saOld); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
334 if ( rc != 0
335 || (saOld.sa_flags & SA_SIGINFO)
336 || ( saOld.sa_handler != SIG_IGN
337 && saOld.sa_handler != SIG_DFL)
338 )
339 break;
340
341 /* Try install dummy handler. */
342 struct sigaction saNew = saOld;
343 saNew.sa_flags = SA_NOCLDSTOP | SA_RESTART;
344 saNew.sa_handler = rtR3SigChildHandler;
345 rc = sigemptyset(&saNew.sa_mask); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
346 struct sigaction saOld2;
347 rc = sigaction(SIGCHLD, &saNew, &saOld2); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
348 if ( rc != 0
349 || ( saOld2.sa_handler == saOld.sa_handler
350 && !(saOld2.sa_flags & SA_SIGINFO))
351 )
352 break;
353
354 /* Race during dynamic load, restore and try again... */
355 sigaction(SIGCHLD, &saOld2, NULL);
356 RTThreadYield();
357 }
358#endif /* IPRT_USE_SIG_CHILD_DUMMY */
359
360#ifdef IPRT_WITH_ALIGNMENT_CHECKS
361 /*
362 * Enable alignment checks.
363 */
364 const char *pszAlignmentChecks = getenv("IPRT_ALIGNMENT_CHECKS");
365 g_fRTAlignmentChecks = pszAlignmentChecks != NULL
366 && pszAlignmentChecks[0] == '1'
367 && pszAlignmentChecks[1] == '\0';
368 if (g_fRTAlignmentChecks)
369 IPRT_ALIGNMENT_CHECKS_ENABLE();
370#endif
371
372 return VINF_SUCCESS;
373}
374
375
376/**
377 * Internal initialization worker.
378 *
379 * @returns IPRT status code.
380 * @param fInitSUPLib Whether to call SUPR3Init.
381 * @param pszProgramPath The program path, NULL if not specified.
382 */
383static int rtR3Init(bool fInitSUPLib, const char *pszProgramPath)
384{
385 /* no entry log flow, because prefixes and thread may freak out. */
386
387 /*
388 * Do reference counting, only initialize the first time around.
389 *
390 * We are ASSUMING that nobody will be able to race RTR3Init calls when the
391 * first one, the real init, is running (second assertion).
392 */
393 int32_t cUsers = ASMAtomicIncS32(&g_cUsers);
394 if (cUsers != 1)
395 {
396 AssertMsg(cUsers > 1, ("%d\n", cUsers));
397 Assert(!g_fInitializing);
398#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
399 if (fInitSUPLib)
400 SUPR3Init(NULL);
401#endif
402 if (!pszProgramPath)
403 return VINF_SUCCESS;
404 return rtR3InitProgramPath(pszProgramPath);
405 }
406 ASMAtomicWriteBool(&g_fInitializing, true);
407
408 /*
409 * Do the initialization.
410 */
411 int rc = rtR3InitBody(fInitSUPLib, pszProgramPath);
412 if (RT_FAILURE(rc))
413 {
414 /* failure */
415 ASMAtomicWriteBool(&g_fInitializing, false);
416 ASMAtomicDecS32(&g_cUsers);
417 return rc;
418 }
419
420 /* success */
421 LogFlow(("RTR3Init: returns VINF_SUCCESS\n"));
422 ASMAtomicWriteBool(&g_fInitializing, false);
423 return VINF_SUCCESS;
424}
425
426
427RTR3DECL(int) RTR3Init(void)
428{
429 return rtR3Init(false /* fInitSUPLib */, NULL);
430}
431
432
433RTR3DECL(int) RTR3InitEx(uint32_t iVersion, const char *pszProgramPath, bool fInitSUPLib)
434{
435 AssertReturn(iVersion == 0, VERR_NOT_SUPPORTED);
436 return rtR3Init(fInitSUPLib, pszProgramPath);
437}
438
439
440RTR3DECL(int) RTR3InitWithProgramPath(const char *pszProgramPath)
441{
442 return rtR3Init(false /* fInitSUPLib */, pszProgramPath);
443}
444
445
446RTR3DECL(int) RTR3InitAndSUPLib(void)
447{
448 return rtR3Init(true /* fInitSUPLib */, NULL /* pszProgramPath */);
449}
450
451
452RTR3DECL(int) RTR3InitAndSUPLibWithProgramPath(const char *pszProgramPath)
453{
454 return rtR3Init(true /* fInitSUPLib */, pszProgramPath);
455}
456
457
458#if 0 /** @todo implement RTR3Term. */
459RTR3DECL(void) RTR3Term(void)
460{
461}
462#endif
463
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