Remove the CONFIG_CD macro, and enable faketracks unconditionally.
[xonotic/darkplaces.git] / sys_shared.c
1 #ifdef WIN32
2 # ifndef DONT_USE_SETDLLDIRECTORY
3 #  define _WIN32_WINNT 0x0502
4 # endif
5 #endif
6
7 #include "quakedef.h"
8 #include "thread.h"
9
10 #define SUPPORTDLL
11
12 #ifdef WIN32
13 # include <windows.h>
14 # include <mmsystem.h> // timeGetTime
15 # include <time.h> // localtime
16 #ifdef _MSC_VER
17 #pragma comment(lib, "winmm.lib")
18 #endif
19 #else
20 # include <unistd.h>
21 # include <fcntl.h>
22 # include <sys/time.h>
23 # include <time.h>
24 # ifdef SUPPORTDLL
25 #  include <dlfcn.h>
26 # endif
27 #endif
28
29 static char sys_timestring[128];
30 char *Sys_TimeString(const char *timeformat)
31 {
32         time_t mytime = time(NULL);
33 #if _MSC_VER >= 1400
34         struct tm mytm;
35         localtime_s(&mytm, &mytime);
36         strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm);
37 #else
38         strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime));
39 #endif
40         return sys_timestring;
41 }
42
43
44 extern qboolean host_shuttingdown;
45 void Sys_Quit (int returnvalue)
46 {
47         // Unlock mutexes because the quit command may jump directly here, causing a deadlock
48         Cbuf_UnlockThreadMutex();
49         SV_UnlockThreadMutex();
50
51         if (COM_CheckParm("-profilegameonly"))
52                 Sys_AllowProfiling(false);
53         host_shuttingdown = true;
54         Host_Shutdown();
55         exit(returnvalue);
56 }
57
58 #ifdef __cplusplus
59 extern "C"
60 #endif
61 void Sys_AllowProfiling(qboolean enable)
62 {
63 #ifdef __ANDROID__
64 #ifdef USE_PROFILER
65         extern void monstartup(const char *libname);
66         extern void moncleanup(void);
67         if (enable)
68                 monstartup("libmain.so");
69         else
70                 moncleanup();
71 #endif
72 #elif defined(__linux__) || defined(__FreeBSD__)
73         extern int moncontrol(int);
74         moncontrol(enable);
75 #endif
76 }
77
78
79 /*
80 ===============================================================================
81
82 DLL MANAGEMENT
83
84 ===============================================================================
85 */
86
87 static qboolean Sys_LoadLibraryFunctions(dllhandle_t dllhandle, const dllfunction_t *fcts, qboolean complain, qboolean has_next)
88 {
89         const dllfunction_t *func;
90         if(dllhandle)
91         {
92                 for (func = fcts; func && func->name != NULL; func++)
93                         if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
94                         {
95                                 if(complain)
96                                 {
97                                         Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
98                                         if(has_next)
99                                                 Con_DPrintf("\nContinuing with");
100                                 }
101                                 goto notfound;
102                         }
103                 return true;
104
105         notfound:
106                 for (func = fcts; func && func->name != NULL; func++)
107                         *func->funcvariable = NULL;
108         }
109         return false;
110 }
111
112 qboolean Sys_LoadLibrary (const char** dllnames, dllhandle_t* handle, const dllfunction_t *fcts)
113 {
114 #ifdef SUPPORTDLL
115         const dllfunction_t *func;
116         dllhandle_t dllhandle = 0;
117         unsigned int i;
118
119         if (handle == NULL)
120                 return false;
121
122 #ifndef WIN32
123 #ifdef PREFER_PRELOAD
124         dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
125         if(Sys_LoadLibraryFunctions(dllhandle, fcts, false, false))
126         {
127                 Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
128                 *handle = dllhandle;
129                 return true;
130         }
131         else
132                 Sys_UnloadLibrary(&dllhandle);
133 notfound:
134 #endif
135 #endif
136
137         // Initializations
138         for (func = fcts; func && func->name != NULL; func++)
139                 *func->funcvariable = NULL;
140
141         // Try every possible name
142         Con_DPrintf ("Trying to load library...");
143         for (i = 0; dllnames[i] != NULL; i++)
144         {
145                 Con_DPrintf (" \"%s\"", dllnames[i]);
146 #ifdef WIN32
147 # ifndef DONT_USE_SETDLLDIRECTORY
148 #  ifdef _WIN64
149                 SetDllDirectory("bin64");
150 #  else
151                 SetDllDirectory("bin32");
152 #  endif
153 # endif
154                 dllhandle = LoadLibrary (dllnames[i]);
155                 // no need to unset this - we want ALL dlls to be loaded from there, anyway
156 #else
157                 dllhandle = dlopen (dllnames[i], RTLD_LAZY | RTLD_GLOBAL);
158 #endif
159                 if (Sys_LoadLibraryFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(com_argv[0], '/'))))
160                         break;
161                 else
162                         Sys_UnloadLibrary (&dllhandle);
163         }
164
165         // see if the names can be loaded relative to the executable path
166         // (this is for Mac OSX which does not check next to the executable)
167         if (!dllhandle && strrchr(com_argv[0], '/'))
168         {
169                 char path[MAX_OSPATH];
170                 strlcpy(path, com_argv[0], sizeof(path));
171                 strrchr(path, '/')[1] = 0;
172                 for (i = 0; dllnames[i] != NULL; i++)
173                 {
174                         char temp[MAX_OSPATH];
175                         strlcpy(temp, path, sizeof(temp));
176                         strlcat(temp, dllnames[i], sizeof(temp));
177                         Con_DPrintf (" \"%s\"", temp);
178 #ifdef WIN32
179                         dllhandle = LoadLibrary (temp);
180 #else
181                         dllhandle = dlopen (temp, RTLD_LAZY | RTLD_GLOBAL);
182 #endif
183                         if (Sys_LoadLibraryFunctions(dllhandle, fcts, true, dllnames[i+1] != NULL))
184                                 break;
185                         else
186                                 Sys_UnloadLibrary (&dllhandle);
187                 }
188         }
189
190         // No DLL found
191         if (! dllhandle)
192         {
193                 Con_DPrintf(" - failed.\n");
194                 return false;
195         }
196
197         Con_DPrintf(" - loaded.\n");
198
199         *handle = dllhandle;
200         return true;
201 #else
202         return false;
203 #endif
204 }
205
206 void Sys_UnloadLibrary (dllhandle_t* handle)
207 {
208 #ifdef SUPPORTDLL
209         if (handle == NULL || *handle == NULL)
210                 return;
211
212 #ifdef WIN32
213         FreeLibrary (*handle);
214 #else
215         dlclose (*handle);
216 #endif
217
218         *handle = NULL;
219 #endif
220 }
221
222 void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
223 {
224 #ifdef SUPPORTDLL
225 #ifdef WIN32
226         return (void *)GetProcAddress (handle, name);
227 #else
228         return (void *)dlsym (handle, name);
229 #endif
230 #else
231         return NULL;
232 #endif
233 }
234
235 #ifdef WIN32
236 # define HAVE_TIMEGETTIME 1
237 # define HAVE_QUERYPERFORMANCECOUNTER 1
238 # define HAVE_Sleep 1
239 #endif
240
241 #ifndef WIN32
242 #if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
243 # define HAVE_CLOCKGETTIME 1
244 #endif
245 // FIXME improve this check, manpage hints to DST_NONE
246 # define HAVE_GETTIMEOFDAY 1
247 #endif
248
249 #ifndef WIN32
250 // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN
251 // (so much for POSIX...)
252 # ifdef FD_SET
253 #  define HAVE_SELECT 1
254 # endif
255 #endif
256
257 #ifndef WIN32
258 // FIXME improve this check
259 # define HAVE_USLEEP 1
260 #endif
261
262 // this one is referenced elsewhere
263 cvar_t sys_usenoclockbutbenchmark = {CVAR_SAVE, "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."};
264
265 // these are not
266 static cvar_t sys_debugsleep = {0, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};
267 static cvar_t sys_usesdlgetticks = {CVAR_SAVE, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (less accurate, for debugging)"};
268 static cvar_t sys_usesdldelay = {CVAR_SAVE, "sys_usesdldelay", "0", "use SDL_Delay() (less accurate, for debugging)"};
269 #if HAVE_QUERYPERFORMANCECOUNTER
270 static cvar_t sys_usequeryperformancecounter = {CVAR_SAVE, "sys_usequeryperformancecounter", "0", "use windows QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power) for timing rather than timeGetTime function (which has issues on some motherboards)"};
271 #endif
272 #if HAVE_CLOCKGETTIME
273 static cvar_t sys_useclockgettime = {CVAR_SAVE, "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)"};
274 #endif
275
276 static double benchmark_time; // actually always contains an integer amount of milliseconds, will eventually "overflow"
277
278 void Sys_Init_Commands (void)
279 {
280         Cvar_RegisterVariable(&sys_debugsleep);
281         Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
282 #if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
283         if(sys_supportsdlgetticks)
284         {
285                 Cvar_RegisterVariable(&sys_usesdlgetticks);
286                 Cvar_RegisterVariable(&sys_usesdldelay);
287         }
288 #endif
289 #if HAVE_QUERYPERFORMANCECOUNTER
290         Cvar_RegisterVariable(&sys_usequeryperformancecounter);
291 #endif
292 #if HAVE_CLOCKGETTIME
293         Cvar_RegisterVariable(&sys_useclockgettime);
294 #endif
295 }
296
297 double Sys_DirtyTime(void)
298 {
299         // first all the OPTIONAL timers
300
301         // benchmark timer (fake clock)
302         if(sys_usenoclockbutbenchmark.integer)
303         {
304                 double old_benchmark_time = benchmark_time;
305                 benchmark_time += 1;
306                 if(benchmark_time == old_benchmark_time)
307                         Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
308                 return benchmark_time * 0.000001;
309         }
310 #if HAVE_QUERYPERFORMANCECOUNTER
311         if (sys_usequeryperformancecounter.integer)
312         {
313                 // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
314                 // QueryPerformanceCounter
315                 // platform:
316                 // Windows 95/98/ME/NT/2000/XP
317                 // features:
318                 // very accurate (CPU cycles)
319                 // known issues:
320                 // does not necessarily match realtime too well (tends to get faster and faster in win98)
321                 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
322                 double timescale;
323                 LARGE_INTEGER PerformanceFreq;
324                 LARGE_INTEGER PerformanceCount;
325
326                 if (QueryPerformanceFrequency (&PerformanceFreq))
327                 {
328                         QueryPerformanceCounter (&PerformanceCount);
329         
330                         #ifdef __BORLANDC__
331                         timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
332                         return ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
333                         #else
334                         timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
335                         return ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
336                         #endif
337                 }
338                 else
339                 {
340                         Con_Printf("No hardware timer available\n");
341                         // fall back to other clock sources
342                         Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
343                 }
344         }
345 #endif
346
347 #if HAVE_CLOCKGETTIME
348         if (sys_useclockgettime.integer)
349         {
350                 struct timespec ts;
351 #  ifdef CLOCK_MONOTONIC
352                 // linux
353                 clock_gettime(CLOCK_MONOTONIC, &ts);
354 #  else
355                 // sunos
356                 clock_gettime(CLOCK_HIGHRES, &ts);
357 #  endif
358                 return (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
359         }
360 #endif
361
362         // now all the FALLBACK timers
363         if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
364                 return (double) Sys_SDL_GetTicks() / 1000.0;
365 #if HAVE_GETTIMEOFDAY
366         {
367                 struct timeval tp;
368                 gettimeofday(&tp, NULL);
369                 return (double) tp.tv_sec + tp.tv_usec / 1000000.0;
370         }
371 #elif HAVE_TIMEGETTIME
372         {
373                 static int firsttimegettime = true;
374                 // timeGetTime
375                 // platform:
376                 // Windows 95/98/ME/NT/2000/XP
377                 // features:
378                 // reasonable accuracy (millisecond)
379                 // issues:
380                 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
381
382                 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
383                 if (firsttimegettime)
384                 {
385                         timeBeginPeriod(1);
386                         firsttimegettime = false;
387                 }
388
389                 return (double) timeGetTime() / 1000.0;
390         }
391 #else
392         // fallback for using the SDL timer if no other timer is available
393         // this calls Sys_Error() if not linking against SDL
394         return (double) Sys_SDL_GetTicks() / 1000.0;
395 #endif
396 }
397
398 void Sys_Sleep(int microseconds)
399 {
400         double t = 0;
401         if(sys_usenoclockbutbenchmark.integer)
402         {
403                 if(microseconds)
404                 {
405                         double old_benchmark_time = benchmark_time;
406                         benchmark_time += microseconds;
407                         if(benchmark_time == old_benchmark_time)
408                                 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
409                 }
410                 return;
411         }
412         if(sys_debugsleep.integer)
413         {
414                 t = Sys_DirtyTime();
415         }
416         if(sys_supportsdlgetticks && sys_usesdldelay.integer)
417         {
418                 Sys_SDL_Delay(microseconds / 1000);
419         }
420 #if HAVE_SELECT
421         else
422         {
423                 struct timeval tv;
424                 tv.tv_sec = microseconds / 1000000;
425                 tv.tv_usec = microseconds % 1000000;
426                 select(0, NULL, NULL, NULL, &tv);
427         }
428 #elif HAVE_USLEEP
429         else
430         {
431                 usleep(microseconds);
432         }
433 #elif HAVE_Sleep
434         else
435         {
436                 Sleep(microseconds / 1000);
437         }
438 #else
439         else
440         {
441                 Sys_SDL_Delay(microseconds / 1000);
442         }
443 #endif
444         if(sys_debugsleep.integer)
445         {
446                 t = Sys_DirtyTime() - t;
447                 Sys_PrintfToTerminal("%d %d # debugsleep\n", microseconds, (unsigned int)(t * 1000000));
448         }
449 }
450
451 void Sys_PrintfToTerminal(const char *fmt, ...)
452 {
453         va_list argptr;
454         char msg[MAX_INPUTLINE];
455
456         va_start(argptr,fmt);
457         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
458         va_end(argptr);
459
460         Sys_PrintToTerminal(msg);
461 }
462
463 #ifndef WIN32
464 static const char *Sys_FindInPATH(const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
465 {
466         const char *p = PATH;
467         const char *q;
468         if(p && name)
469         {
470                 while((q = strchr(p, ':')))
471                 {
472                         dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
473                         if(FS_SysFileExists(buf))
474                                 return buf;
475                         p = q + 1;
476                 }
477                 if(!q) // none found - try the last item
478                 {
479                         dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
480                         if(FS_SysFileExists(buf))
481                                 return buf;
482                 }
483         }
484         return name;
485 }
486 #endif
487
488 static const char *Sys_FindExecutableName(void)
489 {
490 #if defined(WIN32)
491         return com_argv[0];
492 #else
493         static char exenamebuf[MAX_OSPATH+1];
494         ssize_t n = -1;
495 #if defined(__FreeBSD__)
496         n = readlink("/proc/curproc/file", exenamebuf, sizeof(exenamebuf)-1);
497 #elif defined(__linux__)
498         n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
499 #endif
500         if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
501         {
502                 exenamebuf[n] = 0;
503                 return exenamebuf;
504         }
505         if(strchr(com_argv[0], '/'))
506                 return com_argv[0]; // possibly a relative path
507         else
508                 return Sys_FindInPATH(com_argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
509 #endif
510 }
511
512 void Sys_ProvideSelfFD(void)
513 {
514         if(com_selffd != -1)
515                 return;
516         com_selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
517 }
518
519 // for x86 cpus only...  (x64 has SSE2_PRESENT)
520 #if defined(SSE_POSSIBLE) && !defined(SSE2_PRESENT)
521 // code from SDL, shortened as we can expect CPUID to work
522 static int CPUID_Features(void)
523 {
524         int features = 0;
525 # if defined(__GNUC__) && defined(__i386__)
526         __asm__ (
527 "        movl    %%ebx,%%edi\n"
528 "        xorl    %%eax,%%eax                                           \n"
529 "        incl    %%eax                                                 \n"
530 "        cpuid                       # Get family/model/stepping/features\n"
531 "        movl    %%edx,%0                                              \n"
532 "        movl    %%edi,%%ebx\n"
533         : "=m" (features)
534         :
535         : "%eax", "%ecx", "%edx", "%edi"
536         );
537 # elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
538         __asm {
539         xor     eax, eax
540         inc     eax
541         cpuid                       ; Get family/model/stepping/features
542         mov     features, edx
543         }
544 # else
545 #  error SSE_POSSIBLE set but no CPUID implementation
546 # endif
547         return features;
548 }
549 #endif
550
551 #ifdef SSE_POSSIBLE
552 qboolean Sys_HaveSSE(void)
553 {
554         // COMMANDLINEOPTION: SSE: -nosse disables SSE support and detection
555         if(COM_CheckParm("-nosse"))
556                 return false;
557 #ifdef SSE_PRESENT
558         return true;
559 #else
560         // COMMANDLINEOPTION: SSE: -forcesse enables SSE support and disables detection
561         if(COM_CheckParm("-forcesse") || COM_CheckParm("-forcesse2"))
562                 return true;
563         if(CPUID_Features() & (1 << 25))
564                 return true;
565         return false;
566 #endif
567 }
568
569 qboolean Sys_HaveSSE2(void)
570 {
571         // COMMANDLINEOPTION: SSE2: -nosse2 disables SSE2 support and detection
572         if(COM_CheckParm("-nosse") || COM_CheckParm("-nosse2"))
573                 return false;
574 #ifdef SSE2_PRESENT
575         return true;
576 #else
577         // COMMANDLINEOPTION: SSE2: -forcesse2 enables SSE2 support and disables detection
578         if(COM_CheckParm("-forcesse2"))
579                 return true;
580         if((CPUID_Features() & (3 << 25)) == (3 << 25)) // SSE is 1<<25, SSE2 is 1<<26
581                 return true;
582         return false;
583 #endif
584 }
585 #endif
586
587 /// called to set process priority for dedicated servers
588 #if defined(__linux__)
589 #include <sys/resource.h>
590 #include <errno.h>
591 static int nicelevel;
592 static qboolean nicepossible;
593 static qboolean isnice;
594 void Sys_InitProcessNice (void)
595 {
596         struct rlimit lim;
597         nicepossible = false;
598         if(COM_CheckParm("-nonice"))
599                 return;
600         errno = 0;
601         nicelevel = getpriority(PRIO_PROCESS, 0);
602         if(errno)
603         {
604                 Con_Printf("Kernel does not support reading process priority - cannot use niceness\n");
605                 return;
606         }
607         if(getrlimit(RLIMIT_NICE, &lim))
608         {
609                 Con_Printf("Kernel does not support lowering nice level again - cannot use niceness\n");
610                 return;
611         }
612         if(lim.rlim_cur != RLIM_INFINITY && nicelevel < (int) (20 - lim.rlim_cur))
613         {
614                 Con_Printf("Current nice level is below the soft limit - cannot use niceness\n");
615                 return;
616         }
617         nicepossible = true;
618         isnice = false;
619 }
620 void Sys_MakeProcessNice (void)
621 {
622         if(!nicepossible)
623                 return;
624         if(isnice)
625                 return;
626         Con_DPrintf("Process is becoming 'nice'...\n");
627         if(setpriority(PRIO_PROCESS, 0, 19))
628                 Con_Printf("Failed to raise nice level to %d\n", 19);
629         isnice = true;
630 }
631 void Sys_MakeProcessMean (void)
632 {
633         if(!nicepossible)
634                 return;
635         if(!isnice)
636                 return;
637         Con_DPrintf("Process is becoming 'mean'...\n");
638         if(setpriority(PRIO_PROCESS, 0, nicelevel))
639                 Con_Printf("Failed to lower nice level to %d\n", nicelevel);
640         isnice = false;
641 }
642 #else
643 void Sys_InitProcessNice (void)
644 {
645 }
646 void Sys_MakeProcessNice (void)
647 {
648 }
649 void Sys_MakeProcessMean (void)
650 {
651 }
652 #endif