2 # ifndef DONT_USE_SETDLLDIRECTORY
3 # define _WIN32_WINNT 0x0502
11 # include <mmsystem.h> // timeGetTime
12 # include <time.h> // localtime
13 # include <conio.h> // _kbhit, _getch, _putch
14 # include <io.h> // write; Include this BEFORE darkplaces.h because it uses strncpy which trips DP_STATIC_ASSERT
16 #pragma comment(lib, "winmm.lib")
20 # include <sys/sysctl.h>
23 # include <android/log.h>
27 # include <sys/time.h>
37 #include "taskqueue.h"
44 static char sys_timestring[128];
45 char *Sys_TimeString(const char *timeformat)
47 time_t mytime = time(NULL);
50 localtime_s(&mytm, &mytime);
51 strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm);
53 strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime));
55 return sys_timestring;
62 void Sys_AllowProfiling(qbool enable)
66 extern void monstartup(const char *libname);
67 extern void moncleanup(void);
69 monstartup("libmain.so");
73 #elif (defined(__linux__) && (defined(__GLIBC__) || defined(__GNU_LIBRARY__))) || defined(__FreeBSD__)
74 extern int moncontrol(int);
81 ===============================================================================
85 ===============================================================================
88 static qbool Sys_LoadDependencyFunctions(dllhandle_t dllhandle, const dllfunction_t *fcts, qbool complain, qbool has_next)
90 const dllfunction_t *func;
93 for (func = fcts; func && func->name != NULL; func++)
94 if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
98 Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
100 Con_DPrintf("\nContinuing with");
107 for (func = fcts; func && func->name != NULL; func++)
108 *func->funcvariable = NULL;
113 qbool Sys_LoadSelf(dllhandle_t *handle)
115 dllhandle_t dllhandle = 0;
120 dllhandle = LoadLibrary (NULL);
122 dllhandle = dlopen (NULL, RTLD_NOW | RTLD_GLOBAL);
128 qbool Sys_LoadDependency (const char** dllnames, dllhandle_t* handle, const dllfunction_t *fcts)
131 const dllfunction_t *func;
132 dllhandle_t dllhandle = 0;
139 #ifdef PREFER_PRELOAD
140 dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
141 if(Sys_LoadDependencyFunctions(dllhandle, fcts, false, false))
143 Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
148 Sys_FreeLibrary(&dllhandle);
154 for (func = fcts; func && func->name != NULL; func++)
155 *func->funcvariable = NULL;
157 // Try every possible name
158 Con_DPrintf ("Trying to load library...");
159 for (i = 0; dllnames[i] != NULL; i++)
161 Con_DPrintf (" \"%s\"", dllnames[i]);
163 # ifndef DONT_USE_SETDLLDIRECTORY
165 SetDllDirectory("bin64");
167 SetDllDirectory("bin32");
171 if(Sys_LoadLibrary(dllnames[i], &dllhandle))
173 if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
176 Sys_FreeLibrary (&dllhandle);
180 // see if the names can be loaded relative to the executable path
181 // (this is for Mac OSX which does not check next to the executable)
182 if (!dllhandle && strrchr(sys.argv[0], '/'))
184 char path[MAX_OSPATH];
185 dp_strlcpy(path, sys.argv[0], sizeof(path));
186 strrchr(path, '/')[1] = 0;
187 for (i = 0; dllnames[i] != NULL; i++)
189 char temp[MAX_OSPATH];
190 dp_strlcpy(temp, path, sizeof(temp));
191 dp_strlcat(temp, dllnames[i], sizeof(temp));
192 Con_DPrintf (" \"%s\"", temp);
194 if(Sys_LoadLibrary(temp, &dllhandle))
196 if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
199 Sys_FreeLibrary (&dllhandle);
207 Con_DPrintf(" - failed.\n");
211 Con_DPrintf(" - loaded.\n");
212 Con_Printf("Loaded library \"%s\"\n", dllnames[i]);
221 qbool Sys_LoadLibrary(const char *name, dllhandle_t *handle)
223 dllhandle_t dllhandle = 0;
230 dllhandle = LoadLibrary (name);
232 dllhandle = dlopen (name, RTLD_LAZY | RTLD_GLOBAL);
242 void Sys_FreeLibrary (dllhandle_t* handle)
245 if (handle == NULL || *handle == NULL)
249 FreeLibrary (*handle);
258 void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
262 return (void *)GetProcAddress (handle, name);
264 return (void *)dlsym (handle, name);
272 # define HAVE_TIMEGETTIME 1
273 # define HAVE_QUERYPERFORMANCECOUNTER 1
274 # define HAVE_WIN32_USLEEP 1
275 # define HAVE_Sleep 1
279 #if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
280 # define HAVE_CLOCKGETTIME 1
282 // FIXME improve this check, manpage hints to DST_NONE
283 # define HAVE_GETTIMEOFDAY 1
287 # define HAVE_SELECT 1
291 // FIXME improve this check
292 # define HAVE_USLEEP 1
295 // these are referenced elsewhere
296 cvar_t sys_usenoclockbutbenchmark = {CF_SHARED, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."};
297 cvar_t sys_libdir = {CF_READONLY | CF_SHARED, "sys_libdir", "", "Default engine library directory"};
300 static cvar_t sys_debugsleep = {CF_SHARED, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};
301 static cvar_t sys_usesdlgetticks = {CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (low precision, for debugging)"};
302 static cvar_t sys_usesdldelay = {CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (low precision, for debugging)"};
303 #if HAVE_QUERYPERFORMANCECOUNTER
304 static cvar_t sys_usequeryperformancecounter = {CF_SHARED | CF_ARCHIVE, "sys_usequeryperformancecounter", "1", "use windows QueryPerformanceCounter timer (which has issues on systems lacking constant-rate TSCs synchronised across all cores, such as ancient PCs or VMs) for timing rather than timeGetTime function (which is low precision and had issues on some old motherboards)"};
306 #if HAVE_CLOCKGETTIME
307 static cvar_t sys_useclockgettime = {CF_SHARED | CF_ARCHIVE, "sys_useclockgettime", "1", "use POSIX clock_gettime function (not adjusted by NTP on some older Linux kernels) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"};
310 static cvar_t sys_stdout = {CF_SHARED, "sys_stdout", "1", "0: nothing is written to stdout (-nostdout cmdline option sets this), 1: normal messages are written to stdout, 2: normal messages are written to stderr (-stderr cmdline option sets this)"};
312 static cvar_t sys_stdout_blocks = {CF_SHARED, "sys_stdout_blocks", "0", "1: writes to stdout and stderr streams will block (causing a stutter or complete halt) if the buffer is full, ensuring no messages are lost at a price"};
315 static double benchmark_time; // actually always contains an integer amount of milliseconds, will eventually "overflow"
321 Returns the position (1 to argc-1) in the program's argument list
322 where the given parameter apears, or 0 if not present
325 int Sys_CheckParm (const char *parm)
329 for (i=1 ; i<sys.argc ; i++)
332 continue; // NEXTSTEP sometimes clears appkit vars.
333 if (!strcmp (parm,sys.argv[i]))
340 static void Sys_UpdateOutFD_c(cvar_t *var)
342 switch (sys_stdout.integer)
344 case 0: sys.outfd = -1; break;
346 case 1: sys.outfd = fileno(stdout); break;
347 case 2: sys.outfd = fileno(stderr); break;
351 void Sys_Init_Commands (void)
353 Cvar_RegisterVariable(&sys_debugsleep);
354 Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
355 Cvar_RegisterVariable(&sys_libdir);
356 #if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
357 if(sys_supportsdlgetticks)
359 Cvar_RegisterVariable(&sys_usesdlgetticks);
360 Cvar_RegisterVariable(&sys_usesdldelay);
363 #if HAVE_QUERYPERFORMANCECOUNTER
364 Cvar_RegisterVariable(&sys_usequeryperformancecounter);
366 #if HAVE_CLOCKGETTIME
367 Cvar_RegisterVariable(&sys_useclockgettime);
369 Cvar_RegisterVariable(&sys_stdout);
370 Cvar_RegisterCallback(&sys_stdout, Sys_UpdateOutFD_c);
372 Cvar_RegisterVariable(&sys_stdout_blocks);
377 static LARGE_INTEGER PerformanceFreq;
378 /// Windows default timer resolution is only 15.625ms,
379 /// this affects (at least) timeGetTime() and all forms of sleeping.
380 static void Sys_SetTimerResolution(void)
382 NTSTATUS(NTAPI *qNtQueryTimerResolution)(OUT PULONG MinRes, OUT PULONG MaxRes, OUT PULONG CurrentRes);
383 NTSTATUS(NTAPI *qNtSetTimerResolution)(IN ULONG DesiredRes, IN BOOLEAN SetRes, OUT PULONG ActualRes);
384 const char* ntdll_names [] =
389 dllfunction_t ntdll_funcs[] =
391 {"NtQueryTimerResolution", (void **) &qNtQueryTimerResolution},
392 {"NtSetTimerResolution", (void **) &qNtSetTimerResolution},
396 unsigned long WorstRes, BestRes, CurrentRes;
398 timeBeginPeriod(1); // 1ms, documented
400 // the best Windows can manage (typically 0.5ms)
401 // http://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FTime%2FNtSetTimerResolution.html
402 if (Sys_LoadDependency(ntdll_names, &ntdll, ntdll_funcs))
404 qNtQueryTimerResolution(&WorstRes, &BestRes, &CurrentRes); // no pointers may be NULL
405 if (CurrentRes > BestRes)
406 qNtSetTimerResolution(BestRes, true, &CurrentRes);
408 Sys_FreeLibrary(&ntdll);
411 // Microsoft says the freq is fixed at boot and consistent across all processors
412 // and that it need only be queried once and cached.
413 QueryPerformanceFrequency (&PerformanceFreq);
417 double Sys_DirtyTime(void)
419 // first all the OPTIONAL timers
421 // benchmark timer (fake clock)
422 if(sys_usenoclockbutbenchmark.integer)
424 double old_benchmark_time = benchmark_time;
426 if(benchmark_time == old_benchmark_time)
427 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
428 return benchmark_time * 0.000001;
430 #if HAVE_QUERYPERFORMANCECOUNTER
431 if (sys_usequeryperformancecounter.integer)
433 // QueryPerformanceCounter
435 // Windows 95/98/ME/NT/2000/XP
437 // + very accurate (constant-rate TSCs on modern systems)
439 // - does not necessarily match realtime too well (tends to get faster and faster in win98)
440 // - wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
441 // - higher access latency on Vista
442 // Microsoft says on Win 7 or later, latency and overhead are very low, synchronisation is excellent.
443 LARGE_INTEGER PerformanceCount;
445 if (PerformanceFreq.QuadPart)
447 QueryPerformanceCounter (&PerformanceCount);
448 return (double)PerformanceCount.QuadPart * (1.0 / (double)PerformanceFreq.QuadPart);
452 Con_Printf("No hardware timer available\n");
453 // fall back to other clock sources
454 Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
459 #if HAVE_CLOCKGETTIME
460 if (sys_useclockgettime.integer)
463 # ifdef CLOCK_MONOTONIC
465 clock_gettime(CLOCK_MONOTONIC, &ts);
468 clock_gettime(CLOCK_HIGHRES, &ts);
470 return (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
474 // now all the FALLBACK timers
475 if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
476 return (double) Sys_SDL_GetTicks() / 1000.0;
477 #if HAVE_GETTIMEOFDAY
480 gettimeofday(&tp, NULL);
481 return (double) tp.tv_sec + tp.tv_usec / 1000000.0;
483 #elif HAVE_TIMEGETTIME
487 // Windows 95/98/ME/NT/2000/XP
489 // reasonable accuracy (millisecond)
491 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
492 // requires Sys_SetTimerResolution()
493 return (double) timeGetTime() / 1000.0;
496 // fallback for using the SDL timer if no other timer is available
497 // this calls Sys_Error() if not linking against SDL
498 return (double) Sys_SDL_GetTicks() / 1000.0;
502 extern cvar_t host_maxwait;
503 double Sys_Sleep(double time)
506 uint32_t microseconds;
508 // convert to microseconds
511 if(host_maxwait.value <= 0)
512 time = min(time, 1000000.0);
514 time = min(time, host_maxwait.value * 1000.0);
516 if (time < 1 || host.restless)
517 return 0; // not sleeping this frame
519 microseconds = time; // post-validation to prevent overflow
521 if(sys_usenoclockbutbenchmark.integer)
523 double old_benchmark_time = benchmark_time;
524 benchmark_time += microseconds;
525 if(benchmark_time == old_benchmark_time)
526 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
530 if(sys_debugsleep.integer)
531 Con_Printf("sys_debugsleep: requesting %u ", microseconds);
532 dt = Sys_DirtyTime();
534 // less important on newer libcurl so no need to disturb dedicated servers
535 if (cls.state != ca_dedicated && Curl_Select(microseconds))
537 // a transfer is ready or we finished sleeping
539 else if(sys_supportsdlgetticks && sys_usesdldelay.integer)
540 Sys_SDL_Delay(microseconds / 1000);
542 else if (cls.state == ca_dedicated && sv_checkforpacketsduringsleep.integer)
550 List_For_Each_Entry(s, &lhnet_socketlist.list, lhnetsocket_t, list)
552 if (s->address.addresstype == LHNETADDRESSTYPE_INET4 || s->address.addresstype == LHNETADDRESSTYPE_INET6)
554 if (lastfd < s->inetsocket)
555 lastfd = s->inetsocket;
556 #if defined(WIN32) && !defined(_MSC_VER)
557 FD_SET((int)s->inetsocket, &fdreadset);
559 FD_SET((unsigned int)s->inetsocket, &fdreadset);
563 tv.tv_sec = microseconds / 1000000;
564 tv.tv_usec = microseconds % 1000000;
565 // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN
566 // (so much for POSIX...), not with an empty fd_set either.
567 select(lastfd + 1, &fdreadset, NULL, NULL, &tv);
572 usleep(microseconds);
573 #elif HAVE_WIN32_USLEEP // Windows XP/2003 minimum
577 LARGE_INTEGER sleeptime;
579 // takes 100ns units, negative indicates relative time
580 sleeptime.QuadPart = -(10 * (int64_t)microseconds);
581 timer = CreateWaitableTimer(NULL, true, NULL);
582 SetWaitableTimer(timer, &sleeptime, 0, NULL, NULL, 0);
583 WaitForSingleObject(timer, INFINITE);
588 Sleep(microseconds / 1000);
591 Sys_SDL_Delay(microseconds / 1000);
594 dt = Sys_DirtyTime() - dt;
595 if(sys_debugsleep.integer)
596 Con_Printf(" got %u oversleep %d\n", (unsigned int)(dt * 1000000), (unsigned int)(dt * 1000000) - microseconds);
597 return (dt < 0 || dt >= 1800) ? 0 : dt;
602 ===============================================================================
606 ===============================================================================
609 // NOTE: use only POSIX async-signal-safe library functions here (see: man signal-safety)
610 void Sys_Print(const char *text, size_t textlen)
613 if (developer.integer > 0)
615 __android_log_write(ANDROID_LOG_DEBUG, sys.argv[0], text);
621 // BUG: for some reason, NDELAY also affects stdout (1) when used on stdin (0).
622 // this is because both go to /dev/tty by default!
624 int origflags = fcntl(sys.outfd, F_GETFL, 0);
625 if (sys_stdout_blocks.integer)
626 fcntl(sys.outfd, F_SETFL, origflags & ~O_NONBLOCK);
632 fs_offset_t written = (fs_offset_t)write(sys.outfd, text, textlen);
634 break; // sorry, I cannot do anything about this error - without an output
638 if (sys_stdout_blocks.integer)
639 fcntl(sys.outfd, F_SETFL, origflags);
642 //fprintf(stdout, "%s", text);
646 void Sys_Printf(const char *fmt, ...)
649 char msg[MAX_INPUTLINE];
652 va_start(argptr,fmt);
653 msglen = dpvsnprintf(msg, sizeof(msg), fmt, argptr);
657 Sys_Print(msg, msglen);
660 /// Reads a line from POSIX stdin or the Windows console
661 char *Sys_ConsoleInput(void)
663 static char text[MAX_INPUTLINE];
665 static unsigned int len = 0;
690 if (len < sizeof (text) - 1)
699 struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
702 FD_SET(fileno(stdin), &fdset);
703 if (select(1, &fdset, NULL, NULL, &timeout) != -1 && FD_ISSET(fileno(stdin), &fdset))
704 return fgets(text, sizeof(text), stdin);
711 ===============================================================================
715 ===============================================================================
718 void Sys_Error (const char *error, ...)
721 char string[MAX_INPUTLINE];
724 // Disable Sys_HandleSignal() but not Sys_HandleCrash()
725 host.state = host_shutdown;
727 // set output to blocking stderr
728 sys.outfd = fileno(stderr);
730 fcntl(sys.outfd, F_SETFL, fcntl(sys.outfd, F_GETFL, 0) & ~O_NONBLOCK);
733 va_start (argptr,error);
734 dpvsnprintf (string, sizeof (string), error, argptr);
737 Con_Printf(CON_ERROR "Engine Aborted: %s\n^9%s\n", string, engineversion);
739 dp_strlcat(string, "\n\n", sizeof(string));
740 dp_strlcat(string, engineversion, sizeof(string));
742 // Most shutdown funcs can't be called here as they could error while we error.
744 // DP8 TODO: send a disconnect message indicating we aborted, see Host_Error() and Sys_HandleCrash()
746 if (cls.demorecording)
747 CL_Stop_f(cmd_local);
750 sv.active = false; // make SV_DropClient() skip the QC stuff to avoid recursive errors
751 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
752 if (host_client->active)
753 SV_DropClient(false, "Server aborted!"); // closes demo file
755 // don't want a dead window left blocking the OS UI or the abort dialog
759 host.state = host_failed; // make Sys_HandleSignal() call _Exit()
760 Sys_SDL_Dialog("Engine Aborted", string);
767 static const char *Sys_FindInPATH(const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
769 const char *p = PATH;
773 while((q = strchr(p, ':')))
775 dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
776 if(FS_SysFileExists(buf))
780 if(!q) // none found - try the last item
782 dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
783 if(FS_SysFileExists(buf))
791 static const char *Sys_FindExecutableName(void)
796 static char exenamebuf[MAX_OSPATH+1];
798 #if defined(__FreeBSD__)
799 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
800 size_t exenamebuflen = sizeof(exenamebuf)-1;
801 if (sysctl(mib, 4, exenamebuf, &exenamebuflen, NULL, 0) == 0)
805 #elif defined(__linux__)
806 n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
808 if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
813 if(strchr(sys.argv[0], '/'))
814 return sys.argv[0]; // possibly a relative path
816 return Sys_FindInPATH(sys.argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
820 void Sys_ProvideSelfFD(void)
824 sys.selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
827 // for x86 cpus only... (x64 has SSE2_PRESENT)
828 #if defined(SSE_POSSIBLE) && !defined(SSE2_PRESENT)
829 // code from SDL, shortened as we can expect CPUID to work
830 static int CPUID_Features(void)
833 # if (defined(__GNUC__) || defined(__clang__) || defined(__TINYC__)) && defined(__i386__)
835 " movl %%ebx,%%edi\n"
836 " xorl %%eax,%%eax \n"
838 " cpuid # Get family/model/stepping/features\n"
840 " movl %%edi,%%ebx\n"
843 : "%eax", "%ecx", "%edx", "%edi"
845 # elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
849 cpuid ; Get family/model/stepping/features
853 # error SSE_POSSIBLE set but no CPUID implementation
860 qbool Sys_HaveSSE(void)
862 // COMMANDLINEOPTION: SSE: -nosse disables SSE support and detection
863 if(Sys_CheckParm("-nosse"))
868 // COMMANDLINEOPTION: SSE: -forcesse enables SSE support and disables detection
869 if(Sys_CheckParm("-forcesse") || Sys_CheckParm("-forcesse2"))
871 if(CPUID_Features() & (1 << 25))
877 qbool Sys_HaveSSE2(void)
879 // COMMANDLINEOPTION: SSE2: -nosse2 disables SSE2 support and detection
880 if(Sys_CheckParm("-nosse") || Sys_CheckParm("-nosse2"))
885 // COMMANDLINEOPTION: SSE2: -forcesse2 enables SSE2 support and disables detection
886 if(Sys_CheckParm("-forcesse2"))
888 if((CPUID_Features() & (3 << 25)) == (3 << 25)) // SSE is 1<<25, SSE2 is 1<<26
895 /// called to set process priority for dedicated servers
896 #if defined(__linux__)
897 #include <sys/resource.h>
900 void Sys_InitProcessNice (void)
903 sys.nicepossible = false;
904 if(Sys_CheckParm("-nonice"))
907 sys.nicelevel = getpriority(PRIO_PROCESS, 0);
910 Con_Printf("Kernel does not support reading process priority - cannot use niceness\n");
913 if(getrlimit(RLIMIT_NICE, &lim))
915 Con_Printf("Kernel does not support lowering nice level again - cannot use niceness\n");
918 if(lim.rlim_cur != RLIM_INFINITY && sys.nicelevel < (int) (20 - lim.rlim_cur))
920 Con_Printf("Current nice level is below the soft limit - cannot use niceness\n");
923 sys.nicepossible = true;
926 void Sys_MakeProcessNice (void)
928 if(!sys.nicepossible)
932 Con_DPrintf("Process is becoming 'nice'...\n");
933 if(setpriority(PRIO_PROCESS, 0, 19))
934 Con_Printf(CON_ERROR "Failed to raise nice level to %d\n", 19);
937 void Sys_MakeProcessMean (void)
939 if(!sys.nicepossible)
943 Con_DPrintf("Process is becoming 'mean'...\n");
944 if(setpriority(PRIO_PROCESS, 0, sys.nicelevel))
945 Con_Printf(CON_ERROR "Failed to lower nice level to %d\n", sys.nicelevel);
949 void Sys_InitProcessNice (void)
952 void Sys_MakeProcessNice (void)
955 void Sys_MakeProcessMean (void)
961 static const char *Sys_SigDesc(int sig)
965 // Windows only supports the C99 signals
966 case SIGINT: return "Interrupt";
967 case SIGILL: return "Illegal instruction";
968 case SIGABRT: return "Aborted";
969 case SIGFPE: return "Floating point exception";
970 case SIGSEGV: return "Segmentation fault";
971 case SIGTERM: return "Termination";
973 // POSIX has several others worth catching
974 case SIGHUP: return "Hangup";
975 case SIGQUIT: return "Quit";
976 case SIGBUS: return "Bus error (bad memory access)";
977 case SIGPIPE: return "Broken pipe";
979 default: return "Yo dawg, we bugged out while bugging out";
983 /** Halt and try not to catch fire.
984 * Writing to any file could corrupt it,
985 * any uneccessary code could crash while we crash.
986 * Try to use only POSIX async-signal-safe library functions here (see: man signal-safety).
988 static void Sys_HandleCrash(int sig)
990 #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
991 // Before doing anything else grab the stack frame addresses
992 #include <execinfo.h>
993 void *stackframes[32];
994 int framecount = backtrace(stackframes, 32);
997 char dialogtext[3072];
1000 // Break any loop and disable Sys_HandleSignal()
1001 if (host.state == host_failing || host.state == host_failed)
1003 host.state = host_failing;
1005 sigdesc = Sys_SigDesc(sig);
1007 // set output to blocking stderr and print header, backtrace, version
1008 sys.outfd = fileno(stderr); // not async-signal-safe :(
1010 fcntl(sys.outfd, F_SETFL, fcntl(sys.outfd, F_GETFL, 0) & ~O_NONBLOCK);
1011 Sys_Print("\n\n\e[1;37;41m Engine Crash: ", 30);
1012 Sys_Print(sigdesc, strlen(sigdesc));
1013 Sys_Print(" \e[m\n", 8);
1014 #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
1015 // the first two addresses will be in this function and in signal() in libc
1016 backtrace_symbols_fd(stackframes + 2, framecount - 2, sys.outfd);
1018 Sys_Print("\e[1m", 4);
1019 Sys_Print(engineversion, strlen(engineversion));
1020 Sys_Print("\e[m\n", 4);
1021 #else // Windows console doesn't support colours
1022 Sys_Print("\n\nEngine Crash: ", 16);
1023 Sys_Print(sigdesc, strlen(sigdesc));
1025 Sys_Print(engineversion, strlen(engineversion));
1029 // DP8 TODO: send a disconnect message indicating we crashed, see Sys_Error() and Host_Error()
1031 // don't want a dead window left blocking the OS UI or the crash dialog
1035 // prepare the dialogtext: signal, backtrace, version
1036 // the dp_st* funcs are POSIX async-signal-safe IF we don't trigger their warnings
1037 dp_strlcpy(dialogtext, sigdesc, sizeof(dialogtext));
1038 dp_strlcat(dialogtext, "\n\n", sizeof(dialogtext));
1039 #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
1040 btstrings = backtrace_symbols(stackframes + 2, framecount - 2); // calls malloc :(
1042 for (int i = 0; i < framecount - 2; ++i)
1044 dp_strlcat(dialogtext, btstrings[i], sizeof(dialogtext));
1045 dp_strlcat(dialogtext, "\n", sizeof(dialogtext));
1048 dp_strlcat(dialogtext, "\n", sizeof(dialogtext));
1049 dp_strlcat(dialogtext, engineversion, sizeof(dialogtext));
1051 host.state = host_failed; // make Sys_HandleSignal() call _Exit()
1052 Sys_SDL_Dialog("Engine Crash", dialogtext);
1054 fflush(stderr); // not async-signal-safe :(
1056 // Continue execution with default signal handling.
1057 // A real crash will be re-triggered so the platform can handle it,
1058 // a fake crash (kill -SEGV) will cause a graceful shutdown.
1059 signal(sig, SIG_DFL);
1062 static void Sys_HandleSignal(int sig)
1064 const char *sigdesc;
1066 // Break any loop, eg if each Sys_Print triggers a SIGPIPE
1067 if (host.state == host_shutdown || host.state == host_failing)
1070 sigdesc = Sys_SigDesc(sig);
1071 Sys_Print("\nReceived ", 10);
1072 Sys_Print(sigdesc, strlen(sigdesc));
1073 Sys_Print(" signal, exiting...\n", 20);
1074 if (host.state == host_failed)
1076 // user is trying to kill the process while the SDL dialog is open
1077 fflush(stderr); // not async-signal-safe :(
1080 host.state = host_shutdown;
1083 /// SDL2 only handles SIGINT and SIGTERM by default and doesn't log anything
1084 static void Sys_InitSignals(void)
1086 // Windows only supports the C99 signals
1087 signal(SIGINT, Sys_HandleSignal);
1088 signal(SIGILL, Sys_HandleCrash);
1089 signal(SIGABRT, Sys_HandleCrash);
1090 signal(SIGFPE, Sys_HandleCrash);
1091 signal(SIGSEGV, Sys_HandleCrash);
1092 signal(SIGTERM, Sys_HandleSignal);
1094 // POSIX has several others worth catching
1095 signal(SIGHUP, Sys_HandleSignal);
1096 signal(SIGQUIT, Sys_HandleSignal);
1097 signal(SIGBUS, Sys_HandleCrash);
1098 signal(SIGPIPE, Sys_HandleSignal);
1102 int main (int argc, char **argv)
1105 sys.argv = (const char **)argv;
1107 // COMMANDLINEOPTION: Console: -nostdout disables text output to the terminal the game was launched from
1108 // COMMANDLINEOPTION: -noterminal disables console output on stdout
1109 if(Sys_CheckParm("-noterminal") || Sys_CheckParm("-nostdout"))
1110 sys_stdout.string = "0";
1111 // COMMANDLINEOPTION: -stderr moves console output to stderr
1112 else if(Sys_CheckParm("-stderr"))
1113 sys_stdout.string = "2";
1114 // too early for Cvar_SetQuick
1115 sys_stdout.value = sys_stdout.integer = atoi(sys_stdout.string);
1116 Sys_UpdateOutFD_c(&sys_stdout);
1118 fcntl(fileno(stdin), F_SETFL, fcntl(fileno(stdin), F_GETFL, 0) | O_NONBLOCK);
1119 // stdout/stderr will be set to blocking in Sys_Print() if so configured, or during a fatal error.
1120 fcntl(fileno(stdout), F_SETFL, fcntl(fileno(stdout), F_GETFL, 0) | O_NONBLOCK);
1121 fcntl(fileno(stderr), F_SETFL, fcntl(fileno(stderr), F_GETFL, 0) | O_NONBLOCK);
1125 Sys_ProvideSelfFD(); // may call Con_Printf() so must be after sys.outfd is set
1128 Sys_AllowProfiling(true);
1134 Sys_SetTimerResolution();
1140 Sys_AllowProfiling(false);
1144 fcntl(fileno(stdout), F_SETFL, fcntl(fileno(stdout), F_GETFL, 0) & ~O_NONBLOCK);
1145 fcntl(fileno(stderr), F_SETFL, fcntl(fileno(stderr), F_GETFL, 0) & ~O_NONBLOCK);