sys_shared.c

   1 #include "quakedef.h"
   2
   3 #define SUPPORTDLL
   4
   5 #ifdef WIN32
   6 # include <windows.h>
   7 # include <mmsystem.h> // timeGetTime
   8 # include <time.h> // localtime
   9 #else
  10 # include <unistd.h>
  11 # include <fcntl.h>
  12 # include <sys/time.h>
  13 # include <time.h>
  14 # ifdef SUPPORTDLL
  15 #  include <dlfcn.h>
  16 # endif
  17 #endif
  18
  19 static char sys_timestring[128];
  20 char *Sys_TimeString(const char *timeformat)
  21 {
  22         time_t mytime = time(NULL);
  23 #if _MSC_VER >= 1400
  24         struct tm mytm;
  25         localtime_s(&mytm, &mytime);
  26         strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm);
  27 #else
  28         strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime));
  29 #endif
  30         return sys_timestring;
  31 }
  32
  33
  34 extern qboolean host_shuttingdown;
  35 void Sys_Quit (int returnvalue)
  36 {
  37         if (COM_CheckParm("-profilegameonly"))
  38                 Sys_AllowProfiling(false);
  39         host_shuttingdown = true;
  40         Host_Shutdown();
  41         exit(returnvalue);
  42 }
  43
  44 #if defined(__linux__) || defined(__FreeBSD__)
  45 #ifdef __cplusplus
  46 extern "C"
  47 #endif
  48 int moncontrol(int);
  49 #endif
  50
  51 void Sys_AllowProfiling(qboolean enable)
  52 {
  53 #if defined(__linux__) || defined(__FreeBSD__)
  54         moncontrol(enable);
  55 #endif
  56 }
  57
  58
  59 /*
  60 ===============================================================================
  61
  62 DLL MANAGEMENT
  63
  64 ===============================================================================
  65 */
  66
  67 static qboolean Sys_LoadLibraryFunctions(dllhandle_t dllhandle, const dllfunction_t *fcts, qboolean complain, qboolean has_next)
  68 {
  69         const dllfunction_t *func;
  70         if(dllhandle)
  71         {
  72                 for (func = fcts; func && func->name != NULL; func++)
  73                         if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
  74                         {
  75                                 if(complain)
  76                                 {
  77                                         Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
  78                                         if(has_next)
  79                                                 Con_DPrintf("\nContinuing with");
  80                                 }
  81                                 goto notfound;
  82                         }
  83                 return true;
  84
  85         notfound:
  86                 for (func = fcts; func && func->name != NULL; func++)
  87                         *func->funcvariable = NULL;
  88         }
  89         return false;
  90 }
  91
  92 qboolean Sys_LoadLibrary (const char** dllnames, dllhandle_t* handle, const dllfunction_t *fcts)
  93 {
  94 #ifdef SUPPORTDLL
  95         const dllfunction_t *func;
  96         dllhandle_t dllhandle = 0;
  97         unsigned int i;
  98
  99         if (handle == NULL)
 100                 return false;
 101
 102 #ifndef WIN32
 103 #ifdef PREFER_PRELOAD
 104         dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
 105         if(Sys_LoadLibraryFunctions(dllhandle, fcts, false, false))
 106         {
 107                 Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
 108                 *handle = dllhandle;
 109                 return true;
 110         }
 111         else
 112                 Sys_UnloadLibrary(&dllhandle);
 113 notfound:
 114 #endif
 115 #endif
 116
 117         // Initializations
 118         for (func = fcts; func && func->name != NULL; func++)
 119                 *func->funcvariable = NULL;
 120
 121         // Try every possible name
 122         Con_DPrintf ("Trying to load library...");
 123         for (i = 0; dllnames[i] != NULL; i++)
 124         {
 125                 Con_DPrintf (" \"%s\"", dllnames[i]);
 126 #ifdef WIN32
 127                 dllhandle = LoadLibrary (dllnames[i]);
 128 #else
 129                 dllhandle = dlopen (dllnames[i], RTLD_LAZY | RTLD_GLOBAL);
 130 #endif
 131                 if (Sys_LoadLibraryFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(com_argv[0], '/'))))
 132                         break;
 133                 else
 134                         Sys_UnloadLibrary (&dllhandle);
 135         }
 136
 137         // see if the names can be loaded relative to the executable path
 138         // (this is for Mac OSX which does not check next to the executable)
 139         if (!dllhandle && strrchr(com_argv[0], '/'))
 140         {
 141                 char path[MAX_OSPATH];
 142                 strlcpy(path, com_argv[0], sizeof(path));
 143                 strrchr(path, '/')[1] = 0;
 144                 for (i = 0; dllnames[i] != NULL; i++)
 145                 {
 146                         char temp[MAX_OSPATH];
 147                         strlcpy(temp, path, sizeof(temp));
 148                         strlcat(temp, dllnames[i], sizeof(temp));
 149                         Con_DPrintf (" \"%s\"", temp);
 150 #ifdef WIN32
 151                         dllhandle = LoadLibrary (temp);
 152 #else
 153                         dllhandle = dlopen (temp, RTLD_LAZY | RTLD_GLOBAL);
 154 #endif
 155                         if (Sys_LoadLibraryFunctions(dllhandle, fcts, true, dllnames[i+1] != NULL))
 156                                 break;
 157                         else
 158                                 Sys_UnloadLibrary (&dllhandle);
 159                 }
 160         }
 161
 162         // No DLL found
 163         if (! dllhandle)
 164         {
 165                 Con_DPrintf(" - failed.\n");
 166                 return false;
 167         }
 168
 169         Con_DPrintf(" - loaded.\n");
 170
 171         *handle = dllhandle;
 172         return true;
 173 #else
 174         return false;
 175 #endif
 176 }
 177
 178 void Sys_UnloadLibrary (dllhandle_t* handle)
 179 {
 180 #ifdef SUPPORTDLL
 181         if (handle == NULL || *handle == NULL)
 182                 return;
 183
 184 #ifdef WIN32
 185         FreeLibrary (*handle);
 186 #else
 187         dlclose (*handle);
 188 #endif
 189
 190         *handle = NULL;
 191 #endif
 192 }
 193
 194 void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
 195 {
 196 #ifdef SUPPORTDLL
 197 #ifdef WIN32
 198         return (void *)GetProcAddress (handle, name);
 199 #else
 200         return (void *)dlsym (handle, name);
 201 #endif
 202 #else
 203         return NULL;
 204 #endif
 205 }
 206
 207 #ifdef WIN32
 208 # define HAVE_TIMEGETTIME 1
 209 # define HAVE_QUERYPERFORMANCECOUNTER 1
 210 # define HAVE_Sleep 1
 211 #endif
 212
 213 #if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
 214 # define HAVE_CLOCKGETTIME 1
 215 #endif
 216
 217 #ifndef WIN32
 218 // FIXME improve this check, manpage hints to DST_NONE
 219 # define HAVE_GETTIMEOFDAY 1
 220 #endif
 221
 222 #ifdef FD_SET
 223 # define HAVE_SELECT 1
 224 #endif
 225
 226 #ifndef WIN32
 227 // FIXME improve this check
 228 # define HAVE_USLEEP 1
 229 #endif
 230
 231 // this one is referenced elsewhere
 232 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."};
 233
 234 // these are not
 235 static cvar_t sys_debugsleep = {0, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};
 236 static cvar_t sys_usesdlgetticks = {CVAR_SAVE, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (less accurate, for debugging)"};
 237 static cvar_t sys_usesdldelay = {CVAR_SAVE, "sys_usesdldelay", "0", "use SDL_Delay() (less accurate, for debugging)"};
 238 #if HAVE_QUERYPERFORMANCECOUNTER
 239 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)"};
 240 #endif
 241 #if HAVE_CLOCKGETTIME
 242 static cvar_t sys_useclockgettime = {CVAR_SAVE, "sys_useclockgettime", "0", "use POSIX clock_gettime function (which has issues if the system clock speed is far off, as it can't get fixed by NTP) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"};
 243 #endif
 244
 245 static unsigned long benchmark_time;
 246
 247 void Sys_Init_Commands (void)
 248 {
 249         Cvar_RegisterVariable(&sys_debugsleep);
 250         Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
 251 #if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
 252         if(sys_supportsdlgetticks)
 253         {
 254                 Cvar_RegisterVariable(&sys_usesdlgetticks);
 255                 Cvar_RegisterVariable(&sys_usesdldelay);
 256         }
 257 #endif
 258 #if HAVE_QUERYPERFORMANCECOUNTER
 259         Cvar_RegisterVariable(&sys_usequeryperformancecounter);
 260 #endif
 261 #if HAVE_CLOCKGETTIME
 262         Cvar_RegisterVariable(&sys_useclockgettime);
 263 #endif
 264 }
 265
 266 double Sys_DoubleTime(void)
 267 {
 268         static int first = true;
 269         static double oldtime = 0.0, curtime = 0.0;
 270         double newtime;
 271         if(sys_usenoclockbutbenchmark.integer)
 272         {
 273                 benchmark_time += 1;
 274                 return ((double) benchmark_time) / 1e6;
 275         }
 276
 277         // first all the OPTIONAL timers
 278
 279 #if HAVE_QUERYPERFORMANCECOUNTER
 280         else if (sys_usequeryperformancecounter.integer)
 281         {
 282                 // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
 283                 // QueryPerformanceCounter
 284                 // platform:
 285                 // Windows 95/98/ME/NT/2000/XP
 286                 // features:
 287                 // very accurate (CPU cycles)
 288                 // known issues:
 289                 // does not necessarily match realtime too well (tends to get faster and faster in win98)
 290                 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
 291                 double timescale;
 292                 LARGE_INTEGER PerformanceFreq;
 293                 LARGE_INTEGER PerformanceCount;
 294
 295                 if (!QueryPerformanceFrequency (&PerformanceFreq))
 296                 {
 297                         Con_Printf ("No hardware timer available\n");
 298                         // fall back to timeGetTime
 299                         Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
 300                         return Sys_DoubleTime();
 301                 }
 302                 QueryPerformanceCounter (&PerformanceCount);
 303
 304                 #ifdef __BORLANDC__
 305                 timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
 306                 newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
 307                 #else
 308                 timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
 309                 newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
 310                 #endif
 311         }
 312 #endif
 313
 314 #if HAVE_CLOCKGETTIME
 315         else if (sys_useclockgettime.integer)
 316         {
 317                 struct timespec ts;
 318 #  ifdef CLOCK_MONOTONIC
 319                 // linux
 320                 clock_gettime(CLOCK_MONOTONIC, &ts);
 321 #  else
 322                 // sunos
 323                 clock_gettime(CLOCK_HIGHRES, &ts);
 324 #  endif
 325                 newtime = (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
 326         }
 327 #endif
 328
 329         // now all the FALLBACK timers
 330         else if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
 331         {
 332                 newtime = (double) Sys_SDL_GetTicks() / 1000.0;
 333         }
 334 #if HAVE_GETTIMEOFDAY
 335         else
 336         {
 337                 struct timeval tp;
 338                 gettimeofday(&tp, NULL);
 339                 newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
 340         }
 341 #elif HAVE_TIMEGETTIME
 342         else
 343         {
 344                 static int firsttimegettime = true;
 345                 // timeGetTime
 346                 // platform:
 347                 // Windows 95/98/ME/NT/2000/XP
 348                 // features:
 349                 // reasonable accuracy (millisecond)
 350                 // issues:
 351                 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
 352
 353                 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
 354                 if (firsttimegettime)
 355                 {
 356                         timeBeginPeriod (1);
 357                         firsttimegettime = false;
 358                 }
 359
 360                 newtime = (double) timeGetTime () / 1000.0;
 361         }
 362 #else
 363         // fallback for using the SDL timer if no other timer is available
 364         else
 365         {
 366                 newtime = (double) Sys_SDL_GetTicks() / 1000.0;
 367                 // this calls Sys_Error() if not linking against SDL
 368         }
 369 #endif
 370
 371         if (first)
 372         {
 373                 first = false;
 374                 oldtime = newtime;
 375         }
 376
 377         if (newtime < oldtime)
 378         {
 379                 // warn if it's significant
 380                 if (newtime - oldtime < -0.01)
 381                         Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
 382         }
 383         else if (newtime > oldtime + 1800)
 384         {
 385                 Con_Printf("Sys_DoubleTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
 386         }
 387         else
 388                 curtime += newtime - oldtime;
 389         oldtime = newtime;
 390
 391         return curtime;
 392 }
 393
 394 void Sys_Sleep(int microseconds)
 395 {
 396         double t = 0;
 397         if(sys_usenoclockbutbenchmark.integer)
 398         {
 399                 benchmark_time += microseconds;
 400                 return;
 401         }
 402         if(sys_debugsleep.integer)
 403         {
 404                 t = Sys_DoubleTime();
 405         }
 406         if(sys_supportsdlgetticks && sys_usesdldelay.integer)
 407         {
 408                 Sys_SDL_Delay(microseconds / 1000);
 409         }
 410 #if HAVE_SELECT
 411         else
 412         {
 413                 struct timeval tv;
 414                 tv.tv_sec = microseconds / 1000000;
 415                 tv.tv_usec = microseconds % 1000000;
 416                 select(0, NULL, NULL, NULL, &tv);
 417         }
 418 #elif HAVE_USLEEP
 419         else
 420         {
 421                 usleep(microseconds);
 422         }
 423 #elif HAVE_Sleep
 424         else
 425         {
 426                 Sleep(microseconds / 1000);
 427         }
 428 #else
 429         else
 430         {
 431                 Sys_SDL_Delay(microseconds / 1000);
 432         }
 433 #endif
 434         if(sys_debugsleep.integer)
 435         {
 436                 t = Sys_DoubleTime() - t;
 437                 printf("%d %d # debugsleep\n", microseconds, (unsigned int)(t * 1000000));
 438         }
 439 }
 440
 441 const char *Sys_FindInPATH(const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
 442 {
 443         const char *p = PATH;
 444         const char *q;
 445         if(p && name)
 446         {
 447                 while((q = strchr(p, ':')))
 448                 {
 449                         dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
 450                         if(FS_SysFileExists(buf))
 451                                 return buf;
 452                         p = q + 1;
 453                 }
 454                 if(!q) // none found - try the last item
 455                 {
 456                         dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
 457                         if(FS_SysFileExists(buf))
 458                                 return buf;
 459                 }
 460         }
 461         return name;
 462 }
 463
 464 const char *Sys_FindExecutableName(void)
 465 {
 466 #if defined(WIN32)
 467         return com_argv[0];
 468 #else
 469         static char exenamebuf[MAX_OSPATH+1];
 470         ssize_t n = -1;
 471 #if defined(__FreeBSD__)
 472         n = readlink("/proc/curproc/file", exenamebuf, sizeof(exenamebuf)-1);
 473 #elif defined(__linux__)
 474         n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
 475 #endif
 476         if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
 477         {
 478                 exenamebuf[n] = 0;
 479                 return exenamebuf;
 480         }
 481         if(strchr(com_argv[0], '/'))
 482                 return com_argv[0]; // possibly a relative path
 483         else
 484                 return Sys_FindInPATH(com_argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
 485 #endif
 486 }
 487
 488 void Sys_ProvideSelfFD(void)
 489 {
 490         if(com_selffd != -1)
 491                 return;
 492         com_selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
 493 }