winsup/cygwin/times.cc

   1 /* times.cc
   2
   3 This file is part of Cygwin.
   4
   5 This software is a copyrighted work licensed under the terms of the
   6 Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   7 details. */
   8
   9 #define __timezonefunc__
  10 #include "winsup.h"
  11 #include <sys/times.h>
  12 #include <sys/timeb.h>
  13 #include <sys/param.h>
  14 #include <utime.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include "cygerrno.h"
  18 #include "security.h"
  19 #include "path.h"
  20 #include "fhandler.h"
  21 #include "dtable.h"
  22 #include "cygheap.h"
  23 #include "pinfo.h"
  24 #include "thread.h"
  25 #include "cygtls.h"
  26 #include "ntdll.h"
  27 #include "spinlock.h"
  28
  29 static inline void __attribute__ ((always_inline))
  30 get_system_time (PLARGE_INTEGER systime)
  31 {
  32   GetSystemTimePreciseAsFileTime ((LPFILETIME) systime);
  33 }
  34
  35 /* Cygwin internal */
  36 static uint64_t
  37 __to_clock_t (PLARGE_INTEGER src, int flag)
  38 {
  39   uint64_t total = src->QuadPart;
  40   /* Convert into clock ticks - the total is in 10ths of a usec.  */
  41   if (flag)
  42     total -= FACTOR;
  43
  44   total /= NS100PERSEC / CLOCKS_PER_SEC;
  45   return total;
  46 }
  47
  48 /* times: POSIX 4.5.2.1 */
  49 extern "C" clock_t
  50 times (struct tms *buf)
  51 {
  52   static SYSTEM_TIMEOFDAY_INFORMATION stodi;
  53   KERNEL_USER_TIMES kut;
  54   LARGE_INTEGER ticks;
  55   clock_t tc = (clock_t) -1;
  56
  57   __try
  58     {
  59       /* Fetch boot time if we haven't already. */
  60       if (!stodi.BootTime.QuadPart)
  61         NtQuerySystemInformation (SystemTimeOfDayInformation,
  62                                   &stodi, sizeof stodi, NULL);
  63
  64       NtQueryInformationProcess (NtCurrentProcess (), ProcessTimes,
  65                                  &kut, sizeof kut, NULL);
  66       get_system_time (&ticks);
  67
  68       /* uptime */
  69       ticks.QuadPart -= stodi.BootTime.QuadPart;
  70       /* ticks is in in 100ns, convert to clock ticks. */
  71       tc = (clock_t) (ticks.QuadPart * CLOCKS_PER_SEC / NS100PERSEC);
  72
  73       /* Linux allows a NULL buf and just returns tc in that case, so
  74          mimic that */
  75       if (buf)
  76         {
  77           buf->tms_stime = __to_clock_t (&kut.KernelTime, 0);
  78           buf->tms_utime = __to_clock_t (&kut.UserTime, 0);
  79           timeval_to_filetime (&myself->rusage_children.ru_stime, &kut.KernelTime);
  80           buf->tms_cstime = __to_clock_t (&kut.KernelTime, 1);
  81           timeval_to_filetime (&myself->rusage_children.ru_utime, &kut.UserTime);
  82           buf->tms_cutime = __to_clock_t (&kut.UserTime, 1);
  83         }
  84     }
  85   __except (EFAULT)
  86     {
  87       tc = (clock_t) -1;
  88     }
  89   __endtry
  90   syscall_printf ("%D = times(%p)", tc, buf);
  91   return tc;
  92 }
  93
  94 /* settimeofday: BSD */
  95 extern "C" int
  96 settimeofday (const struct timeval *tv, const struct timezone *tz)
  97 {
  98   SYSTEMTIME st;
  99   struct tm *ptm;
 100   int res = -1;
 101
 102   __try
 103     {
 104       if (tv->tv_usec < 0 || tv->tv_usec >= USPERSEC)
 105         {
 106           set_errno (EINVAL);
 107           return -1;
 108         }
 109
 110       ptm = gmtime (&tv->tv_sec);
 111       st.wYear     = ptm->tm_year + 1900;
 112       st.wMonth    = ptm->tm_mon + 1;
 113       st.wDayOfWeek    = ptm->tm_wday;
 114       st.wDay      = ptm->tm_mday;
 115       st.wHour     = ptm->tm_hour;
 116       st.wMinute       = ptm->tm_min;
 117       st.wSecond       = ptm->tm_sec;
 118       st.wMilliseconds = tv->tv_usec / (USPERSEC / MSPERSEC);
 119
 120       res = -!SetSystemTime (&st);
 121       if (res)
 122         set_errno (EPERM);
 123     }
 124   __except (EFAULT)
 125     {
 126       res = -1;
 127     }
 128   __endtry
 129   syscall_printf ("%R = settimeofday(%p, %p)", res, tv, tz);
 130   return res;
 131 }
 132
 133 /* stime: SVr4 */
 134 extern "C" int
 135 stime (const time_t *t)
 136 {
 137   struct timeval tv = { *t, 0 };
 138   return settimeofday(&tv, NULL);
 139 }
 140
 141 /* timezone: standards? */
 142 extern "C" char *
 143 timezone (void)
 144 {
 145   char *b = _my_tls.locals.timezone_buf;
 146
 147   tzset ();
 148   __small_sprintf (b,"GMT%+d:%02d", (int) (-_timezone / 3600), (int) (abs (_timezone / 60) % 60));
 149   return b;
 150 }
 151
 152 /* Cygwin internal */
 153 void
 154 totimeval (struct timeval *dst, PLARGE_INTEGER src, int sub, int flag)
 155 {
 156   int64_t x = __to_clock_t (src, flag);
 157
 158   x *= (int64_t) USPERSEC / CLOCKS_PER_SEC; /* Turn x into usecs */
 159   x -= (int64_t) sub * USPERSEC;
 160
 161   dst->tv_usec = x % USPERSEC; /* And split */
 162   dst->tv_sec = x / USPERSEC;
 163 }
 164
 165 /* FIXME: Make thread safe */
 166 extern "C" int
 167 gettimeofday (struct timeval *__restrict tv, void *__restrict tzvp)
 168 {
 169   struct timezone *tz = (struct timezone *) tzvp;
 170   static bool tzflag;
 171   LONGLONG now = get_clock (CLOCK_REALTIME)->usecs ();
 172
 173   if (tv)
 174     {
 175       tv->tv_sec = now / USPERSEC;
 176       tv->tv_usec = now % USPERSEC;
 177     }
 178
 179   if (tz)
 180     {
 181       if (!tzflag)
 182         {
 183           tzset ();
 184           tzflag = true;
 185         }
 186       tz->tz_minuteswest = _timezone / 60;
 187       tz->tz_dsttime = _daylight;
 188     }
 189
 190   return 0;
 191 }
 192
 193 /* Cygwin internal */
 194 void
 195 timespec_to_filetime (const struct timespec *time_in, PLARGE_INTEGER out)
 196 {
 197   if (time_in->tv_nsec == UTIME_OMIT)
 198     out->QuadPart = 0;
 199   else
 200     out->QuadPart = time_in->tv_sec * NS100PERSEC
 201                     + time_in->tv_nsec / (NSPERSEC/NS100PERSEC) + FACTOR;
 202 }
 203
 204 /* Cygwin internal */
 205 void
 206 timeval_to_filetime (const struct timeval *time_in, PLARGE_INTEGER out)
 207 {
 208   out->QuadPart = time_in->tv_sec * NS100PERSEC
 209                   + time_in->tv_usec * (NS100PERSEC/USPERSEC) + FACTOR;
 210 }
 211
 212 /* Cygwin internal */
 213 bool
 214 timeval_to_ms (const struct timeval *time_in, DWORD &ms)
 215 {
 216   if (time_in->tv_sec < 0 || time_in->tv_usec < 0
 217       || time_in->tv_usec >= USPERSEC)
 218     return false;
 219   if ((time_in->tv_sec == 0 && time_in->tv_usec == 0)
 220       || time_in->tv_sec >= (time_t) (INFINITE / MSPERSEC))
 221     ms = INFINITE;
 222   else
 223     ms = time_in->tv_sec * MSPERSEC
 224          + (time_in->tv_usec + (USPERSEC / MSPERSEC) - 1)
 225            / (USPERSEC / MSPERSEC);
 226   return true;
 227 }
 228
 229 /* Cygwin internal */
 230 static timeval
 231 time_t_to_timeval (time_t in)
 232 {
 233   timeval res;
 234   res.tv_sec = in;
 235   res.tv_usec = 0;
 236   return res;
 237 }
 238
 239 /* Cygwin internal */
 240 static const struct timespec *
 241 timeval_to_timespec (const struct timeval *tvp, struct timespec *tmp)
 242 {
 243   if (!tvp)
 244     return NULL;
 245
 246   tmp[0].tv_sec = tvp[0].tv_sec;
 247   tmp[0].tv_nsec = tvp[0].tv_usec * (NSPERSEC/USPERSEC);
 248   if (tmp[0].tv_nsec < 0)
 249     tmp[0].tv_nsec = 0;
 250   else if (tmp[0].tv_nsec >= NSPERSEC)
 251     tmp[0].tv_nsec = NSPERSEC - 1;
 252
 253   tmp[1].tv_sec = tvp[1].tv_sec;
 254   tmp[1].tv_nsec = tvp[1].tv_usec * (NSPERSEC/USPERSEC);
 255   if (tmp[1].tv_nsec < 0)
 256     tmp[1].tv_nsec = 0;
 257   else if (tmp[1].tv_nsec >= NSPERSEC)
 258     tmp[1].tv_nsec = NSPERSEC - 1;
 259
 260   return tmp;
 261 }
 262
 263 /* Cygwin internal */
 264 /* Convert a Win32 time to "UNIX" format. */
 265 time_t
 266 to_time_t (PLARGE_INTEGER ptr)
 267 {
 268   /* A file time is the number of 100ns since jan 1 1601
 269      stuffed into two long words.
 270      A time_t is the number of seconds since jan 1 1970.  */
 271
 272   int64_t x = ptr->QuadPart;
 273
 274   /* pass "no time" as epoch */
 275   if (x == 0)
 276     return 0;
 277
 278   x -= FACTOR;                  /* number of 100ns between 1601 and 1970 */
 279   x /= NS100PERSEC;             /* number of 100ns in a second */
 280   return x;
 281 }
 282
 283 /* Cygwin internal */
 284 /* Convert a Win32 time to "UNIX" timestruc_t format. */
 285 void
 286 to_timestruc_t (PLARGE_INTEGER ptr, timestruc_t *out)
 287 {
 288   /* A file time is the number of 100ns since jan 1 1601
 289      stuffed into two long words.
 290      A timestruc_t is the number of seconds and microseconds since jan 1 1970
 291      stuffed into a time_t and a long.  */
 292   int64_t x = ptr->QuadPart;
 293
 294   /* pass "no time" as epoch */
 295   if (x == 0)
 296     {
 297       out->tv_sec = 0;
 298       out->tv_nsec = 0;
 299       return;
 300     }
 301
 302   x -= FACTOR;                  /* number of 100ns between 1601 and 1970 */
 303   out->tv_sec = x / NS100PERSEC;
 304   out->tv_nsec = (x % NS100PERSEC) * (NSPERSEC/NS100PERSEC);
 305 }
 306
 307 /* Cygwin internal */
 308 /* Get the current time as a "UNIX" timestruc_t format. */
 309 void
 310 time_as_timestruc_t (timestruc_t * out)
 311 {
 312   LARGE_INTEGER systime;
 313
 314   get_system_time (&systime);
 315   to_timestruc_t (&systime, out);
 316 }
 317
 318 /* time: POSIX 4.5.1.1, C 4.12.2.4 */
 319 /* Return number of seconds since 00:00 UTC on jan 1, 1970 */
 320 extern "C" time_t
 321 time (time_t * ptr)
 322 {
 323   time_t res;
 324   LARGE_INTEGER systime;
 325
 326   get_system_time (&systime);
 327   res = to_time_t (&systime);
 328   if (ptr)
 329     *ptr = res;
 330
 331   syscall_printf ("%d = time(%p)", res, ptr);
 332
 333   return res;
 334 }
 335
 336 int
 337 utimens_worker (path_conv &win32, const struct timespec *tvp)
 338 {
 339   int res = -1;
 340
 341   if (win32.error)
 342     set_errno (win32.error);
 343   else
 344     {
 345       fhandler_base *fh = NULL;
 346       bool fromfd = false;
 347
 348       cygheap_fdenum cfd (true);
 349       while (cfd.next () >= 0)
 350         if (cfd->get_access () & (FILE_WRITE_ATTRIBUTES | GENERIC_WRITE)
 351             && RtlEqualUnicodeString (cfd->pc.get_nt_native_path (),
 352                                       win32.get_nt_native_path (),
 353                                       cfd->pc.objcaseinsensitive ()))
 354           {
 355             fh = cfd;
 356             fromfd = true;
 357             break;
 358           }
 359
 360       if (!fh)
 361         {
 362           if (!(fh = build_fh_pc (win32)))
 363             goto error;
 364
 365           if (fh->error ())
 366             {
 367               debug_printf ("got %d error from build_fh_pc", fh->error ());
 368               set_errno (fh->error ());
 369             }
 370         }
 371
 372       res = fh->utimens (tvp);
 373
 374       if (!fromfd)
 375         delete fh;
 376     }
 377
 378 error:
 379   syscall_printf ("%R = utimes(%S, %p)", res, win32.get_nt_native_path (), tvp);
 380   return res;
 381 }
 382
 383 /* utimes: POSIX/SUSv3 */
 384 extern "C" int
 385 utimes (const char *path, const struct timeval tvp[2])
 386 {
 387   path_conv win32 (path, PC_POSIX | PC_SYM_FOLLOW, stat_suffixes);
 388   struct timespec tmp[2];
 389   return utimens_worker (win32, timeval_to_timespec (tvp, tmp));
 390 }
 391
 392 /* BSD */
 393 extern "C" int
 394 lutimes (const char *path, const struct timeval tvp[2])
 395 {
 396   path_conv win32 (path, PC_POSIX | PC_SYM_NOFOLLOW, stat_suffixes);
 397   struct timespec tmp[2];
 398   return utimens_worker (win32, timeval_to_timespec (tvp, tmp));
 399 }
 400
 401 /* futimens: POSIX/SUSv4 */
 402 extern "C" int
 403 futimens (int fd, const struct timespec tvp[2])
 404 {
 405   int res;
 406
 407   cygheap_fdget cfd (fd);
 408   if (cfd < 0)
 409     res = -1;
 410   else if (cfd->get_access () & (FILE_WRITE_ATTRIBUTES | GENERIC_WRITE))
 411     res = cfd->utimens (tvp);
 412   else
 413     res = utimens_worker (cfd->pc, tvp);
 414   syscall_printf ("%d = futimens(%d, %p)", res, fd, tvp);
 415   return res;
 416 }
 417
 418 /* BSD */
 419 extern "C" int
 420 futimes (int fd, const struct timeval tvp[2])
 421 {
 422   struct timespec tmp[2];
 423   return futimens (fd,  timeval_to_timespec (tvp, tmp));
 424 }
 425
 426 /* utime: POSIX 5.6.6.1 */
 427 extern "C" int
 428 utime (const char *path, const struct utimbuf *buf)
 429 {
 430   struct timeval tmp[2];
 431
 432   if (buf == 0)
 433     return utimes (path, 0);
 434
 435   debug_printf ("incoming utime act %lx", buf->actime);
 436   tmp[0] = time_t_to_timeval (buf->actime);
 437   tmp[1] = time_t_to_timeval (buf->modtime);
 438
 439   return utimes (path, tmp);
 440 }
 441
 442 /* ftime: standards? */
 443 extern "C" int
 444 ftime (struct timeb *tp)
 445 {
 446   struct timeval tv;
 447   struct timezone tz;
 448
 449   if (gettimeofday (&tv, &tz) < 0)
 450     return -1;
 451
 452   tp->time = tv.tv_sec;
 453   tp->millitm = tv.tv_usec / 1000;
 454   tp->timezone = tz.tz_minuteswest;
 455   tp->dstflag = tz.tz_dsttime;
 456
 457   return 0;
 458 }
 459
 460 extern "C" int
 461 clock_gettime (clockid_t clk_id, struct timespec *tp)
 462 {
 463   clk_t *clock = get_clock (clk_id);
 464
 465   if (!clock)
 466     {
 467       set_errno (EINVAL);
 468       return -1;
 469     }
 470   __try
 471     {
 472       return clock->nsecs (clk_id, tp);
 473     }
 474   __except (EFAULT) {}
 475   __endtry
 476   return -1;
 477 }
 478
 479 extern "C" int
 480 clock_settime (clockid_t clk_id, const struct timespec *tp)
 481 {
 482   struct timeval tv;
 483
 484   if (CLOCKID_IS_PROCESS (clk_id) || CLOCKID_IS_THREAD (clk_id))
 485     /* According to POSIX, the privileges to set a particular clock
 486      * are implementation-defined.  On Linux, CPU-time clocks are not
 487      * settable; do the same here.
 488      */
 489     {
 490       set_errno (EPERM);
 491       return -1;
 492     }
 493
 494   if (clk_id != CLOCK_REALTIME_COARSE && clk_id != CLOCK_REALTIME)
 495     {
 496       set_errno (EINVAL);
 497       return -1;
 498     }
 499
 500   __try
 501     {
 502       tv.tv_sec = tp->tv_sec;
 503       tv.tv_usec = tp->tv_nsec / 1000;
 504     }
 505   __except (EFAULT)
 506     {
 507       return -1;
 508     }
 509   __endtry
 510
 511   return settimeofday (&tv, NULL);
 512 }
 513
 514 extern "C" int
 515 clock_getres (clockid_t clk_id, struct timespec *tp)
 516 {
 517   clk_t *clock = get_clock (clk_id);
 518
 519   if (!clock)
 520     {
 521       set_errno (EINVAL);
 522       return -1;
 523     }
 524   __try
 525     {
 526       clock->resolution (tp);
 527     }
 528   __except (EFAULT)
 529     {
 530       return -1;
 531     }
 532   __endtry
 533   return 0;
 534 }
 535
 536 extern "C" int
 537 clock_setres (clockid_t clk_id, struct timespec *tp)
 538 {
 539   /* Don't use this function.  It only exists in QNX.  Just return
 540      success on CLOCK_REALTIME for backward compat. */
 541   if (clk_id != CLOCK_REALTIME)
 542     {
 543       set_errno (EINVAL);
 544       return -1;
 545     }
 546   return 0;
 547 }
 548
 549 extern "C" int
 550 clock_getcpuclockid (pid_t pid, clockid_t *clk_id)
 551 {
 552   if (pid != 0)
 553     {
 554       pinfo p (pid);
 555       if (!p || !p->exists ())
 556         return (ESRCH);
 557     }
 558   *clk_id = (clockid_t) PID_TO_CLOCKID (pid);
 559   return 0;
 560 }
 561
 562 extern "C" int
 563 timespec_get (struct timespec *ts, int base)
 564 {
 565   if (base != TIME_UTC)
 566     return 0;
 567   clock_gettime (CLOCK_REALTIME, ts);
 568   return base;
 569 }
 570
 571 EXPORT_ALIAS (gettimeofday, _gettimeofday)
 572 EXPORT_ALIAS (times, _times)