ml_apc.c

   1 #include <caml/fail.h>
   2 #include <caml/alloc.h>
   3 #include <caml/memory.h>
   4 #include <caml/custom.h>
   5 #include <caml/signals.h>
   6 #include <caml/mlvalues.h>
   7 #include <caml/bigarray.h>
   8
   9 #include <math.h>
  10 #include <stdio.h>
  11 #include <stdarg.h>
  12
  13 enum {
  14     LINUX_TAG,
  15     WINDOWS_TAG,
  16     SOLARIS_TAG,
  17     MACOSX_TAG
  18 };
  19
  20 #ifdef _MSC_VER
  21 #define vsnprintf _vsnprintf
  22 #endif
  23
  24 static void failwith_fmt (const char *fmt, ...) Noreturn;
  25 static void failwith_fmt (const char *fmt, ...)
  26 {
  27     va_list ap;
  28     char buf[1024];
  29
  30     va_start (ap, fmt);
  31     vsnprintf (buf, sizeof (buf), fmt, ap);
  32     va_end (ap);
  33
  34     failwith (buf);
  35 }
  36
  37 #if defined __linux__
  38 #define _GNU_SOURCE
  39 #include <alloca.h>
  40 #include <unistd.h>
  41 #include <sys/time.h>
  42 #include <sys/time.h>
  43 #include <sys/sysinfo.h>
  44 #include <signal.h>
  45 #include <string.h>
  46 #include <errno.h>
  47
  48 CAMLprim value ml_sysinfo (value unit_v)
  49 {
  50     CAMLparam1 (unit_v);
  51     CAMLlocal2 (res_v, loads_v);
  52     struct sysinfo si;
  53
  54     if (sysinfo (&si)) {
  55         failwith_fmt ("sysinfo: %s", strerror (errno));
  56     }
  57
  58     loads_v = caml_alloc_tuple (3);
  59     Store_field (loads_v, 0, caml_copy_int64 (si.loads[0]));
  60     Store_field (loads_v, 1, caml_copy_int64 (si.loads[1]));
  61     Store_field (loads_v, 2, caml_copy_int64 (si.loads[2]));
  62
  63     res_v = caml_alloc_tuple (9);
  64     Store_field (res_v, 0, caml_copy_int64 (si.uptime));
  65     Store_field (res_v, 1, loads_v);
  66     Store_field (res_v, 2, caml_copy_int64 (si.totalram));
  67     Store_field (res_v, 3, caml_copy_int64 (si.freeram));
  68     Store_field (res_v, 4, caml_copy_int64 (si.sharedram));
  69     Store_field (res_v, 5, caml_copy_int64 (si.bufferram));
  70     Store_field (res_v, 6, caml_copy_int64 (si.totalswap));
  71     Store_field (res_v, 7, caml_copy_int64 (si.freeswap));
  72     Store_field (res_v, 8, caml_copy_int64 (si.procs));
  73
  74     CAMLreturn (res_v);
  75 }
  76
  77 CAMLprim value ml_get_nprocs (value unit_v)
  78 {
  79     CAMLparam1 (unit_v);
  80     int nprocs;
  81
  82     nprocs = get_nprocs ();
  83     if (nprocs <= 0) {
  84         failwith_fmt ("get_nprocs: %s", strerror (errno));
  85     }
  86
  87     CAMLreturn (Val_int (nprocs));
  88 }
  89
  90 CAMLprim value ml_idletimeofday (value fd_v, value nprocs_v)
  91 {
  92     CAMLparam2 (fd_v, nprocs_v);
  93     CAMLlocal1 (res_v);
  94     struct timeval tv;
  95     int fd = Int_val (fd_v);
  96     int nprocs = Int_val (nprocs_v);
  97     size_t n = nprocs * sizeof (tv);
  98     ssize_t m;
  99     struct timeval *buf;
 100     int i;
 101
 102     buf = alloca (n);
 103     if (!buf) {
 104         failwith_fmt ("alloca: %s", strerror (errno));
 105     }
 106
 107     m = read (fd, buf, n);
 108     if (n - m) {
 109         failwith_fmt ("read [n=%zu, m=%zi]: %s", n, m, strerror (errno));
 110     }
 111
 112     res_v = caml_alloc (nprocs * Double_wosize, Double_array_tag);
 113     for (i = 0; i < nprocs; ++i) {
 114         double d;
 115
 116         d = buf[i].tv_sec + buf[i].tv_usec * 1e-6;
 117         Store_double_field (res_v, i, d);
 118     }
 119     CAMLreturn (res_v);
 120 }
 121
 122 CAMLprim value ml_os_type (value unit_v)
 123 {
 124     CAMLparam1 (unit_v);
 125     CAMLreturn (Val_int (LINUX_TAG));
 126 }
 127
 128 #elif defined _WIN32
 129
 130 #pragma warning (disable:4152 4127 4189)
 131 #define WIN32_LEAN_AND_MEAN
 132 #include <windows.h>
 133
 134 #define DDKFASTAPI __fastcall
 135 #define NTSTATUS long
 136 #define BOOLEAN int
 137
 138 /* Following (mildly modified) structure definitions, macros, enums,
 139    etc are taken from binutils w32api (http://sourceware.org/binutils/)
 140    Headers claim:
 141  */
 142 /*
 143  * ntpoapi.h
 144  * ntddk.h
 145  ...
 146  * This file is part of the w32api package.
 147  *
 148  * Contributors:
 149  *   Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
 150  *
 151  * THIS SOFTWARE IS NOT COPYRIGHTED
 152  *
 153  * This source code is offered for use in the public domain. You may
 154  * use, modify or distribute it freely.
 155  *
 156  * This code is distributed in the hope that it will be useful but
 157  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 158  * DISCLAIMED. This includes but is not limited to warranties of
 159  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 160  *
 161  */
 162
 163 typedef struct _SYSTEM_BASIC_INFORMATION {
 164     ULONG  Unknown;
 165     ULONG  MaximumIncrement;
 166     ULONG  PhysicalPageSize;
 167     ULONG  NumberOfPhysicalPages;
 168     ULONG  LowestPhysicalPage;
 169     ULONG  HighestPhysicalPage;
 170     ULONG  AllocationGranularity;
 171     ULONG  LowestUserAddress;
 172     ULONG  HighestUserAddress;
 173     ULONG  ActiveProcessors;
 174     UCHAR  NumberProcessors;
 175 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 176
 177 typedef struct _SYSTEM_PROCESSOR_TIMES {
 178     LARGE_INTEGER  IdleTime;
 179     LARGE_INTEGER  KernelTime;
 180     LARGE_INTEGER  UserTime;
 181     LARGE_INTEGER  DpcTime;
 182     LARGE_INTEGER  InterruptTime;
 183     ULONG  InterruptCount;
 184 } SYSTEM_PROCESSOR_TIMES, *PSYSTEM_PROCESSOR_TIMES;
 185
 186 typedef long (__stdcall *QuerySystemInformationProc)
 187     (SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
 188
 189 static struct {
 190     HMODULE hmod;
 191     QuerySystemInformationProc QuerySystemInformation;
 192     ULONG nprocs;
 193 } glob;
 194
 195 static void init (void)
 196 {
 197     if (!glob.hmod) {
 198         glob.hmod = LoadLibrary ("ntdll.dll");
 199         if (!glob.hmod) {
 200             failwith_fmt ("could not load ntdll.dll: %#lx", GetLastError ());
 201         }
 202
 203         *(void **) &glob.QuerySystemInformation =
 204             GetProcAddress (glob.hmod, "ZwQuerySystemInformation");
 205         if (!glob.QuerySystemInformation) {
 206             failwith_fmt (
 207                 "could not obtain ZwQuerySystemInformation entry point: %#lx",
 208                 GetLastError ());
 209         }
 210     }
 211 }
 212
 213 static void qsi (int c, PVOID buf, ULONG size)
 214 {
 215     ULONG retsize = 0;
 216     long status;
 217
 218     init ();
 219     status = glob.QuerySystemInformation (c, buf, size, &retsize);
 220     if (status < 0) {
 221         failwith_fmt ("could not query system information %ld retsize %ld",
 222                       c, retsize);
 223     }
 224     if (retsize != size) {
 225         fprintf (stderr, "class=%d status=%ld size=%d retsize=%d\n",
 226                  c, status, size, retsize);
 227     }
 228 #ifdef DEBUG
 229     printf ("class=%d status=%ld size=%d retsize=%d\n",
 230             c, status, size, retsize);
 231 #endif
 232 }
 233
 234 CAMLprim value ml_waitalrm (value unit_v)
 235 {
 236     CAMLparam1 (unit_v);
 237
 238     failwith ("waitalrm not supported on Windows");
 239     CAMLreturn (Val_unit);
 240 }
 241
 242 static void get_nprocs (void)
 243 {
 244     SYSTEM_BASIC_INFORMATION sbi;
 245
 246     qsi (0, &sbi, sizeof (sbi));
 247     glob.nprocs = sbi.NumberProcessors;
 248 }
 249
 250 CAMLprim value ml_get_nprocs (value unit_v)
 251 {
 252     CAMLparam1 (unit_v);
 253
 254     get_nprocs ();
 255     CAMLreturn (Val_int (glob.nprocs));
 256 }
 257
 258 CAMLprim value ml_windows_processor_times (value nprocs_v)
 259 {
 260     CAMLparam1 (nprocs_v);
 261     CAMLlocal1 (res_v);
 262     int nprocs = Int_val (nprocs_v);
 263     PSYSTEM_PROCESSOR_TIMES buf, b;
 264     size_t n = nprocs * sizeof (*buf);
 265     int i, j;
 266
 267     buf = _alloca (n);
 268     if (!buf) {
 269         failwith_fmt ("alloca: %s", strerror (errno));
 270     }
 271
 272     qsi (8, buf, n);
 273
 274     res_v = caml_alloc (nprocs * 5 * Double_wosize, Double_array_tag);
 275     b = buf;
 276     for (i = 0, j = 0; i < nprocs; ++i, ++b) {
 277         double d = b->IdleTime.QuadPart * 1e-7;
 278
 279         Store_double_field (res_v, j, d); j += 1;
 280
 281         d = b->KernelTime.QuadPart * 1e-7 - d;
 282         Store_double_field (res_v, j, d); j += 1;
 283
 284         Store_double_field (res_v, j, b->UserTime.QuadPart * 1e-7); j += 1;
 285         Store_double_field (res_v, j, b->DpcTime.QuadPart * 1e-7); j += 1;
 286         Store_double_field (res_v, j, b->InterruptTime.QuadPart * 1e-7); j += 1;
 287     }
 288     CAMLreturn (res_v);
 289 }
 290
 291 CAMLprim value ml_get_hz (value unit_v)
 292 {
 293     CAMLparam1 (unit_v);
 294     CAMLreturn (Val_int (100));
 295 }
 296
 297 CAMLprim value ml_nice (value nice_v)
 298 {
 299     CAMLparam1 (nice_v);
 300     int niceval = Int_val (nice_v);
 301
 302     failwith_fmt ("nice: not implemented on Windows");
 303     CAMLreturn (Val_unit);
 304 }
 305
 306 CAMLprim value ml_seticon (value data_v)
 307 {
 308     CAMLparam1 (data_v);
 309     CAMLreturn (Val_unit);
 310 }
 311
 312 CAMLprim value ml_delay (value secs_v)
 313 {
 314     CAMLparam1 (secs_v);
 315     DWORD millis = (DWORD) (Double_val (secs_v) * 1e4);
 316
 317     caml_enter_blocking_section ();
 318     {
 319         Sleep (millis);
 320     }
 321     caml_leave_blocking_section ();
 322     CAMLreturn (Val_unit);
 323 }
 324
 325 CAMLprim value ml_os_type (value unit_v)
 326 {
 327     CAMLparam1 (unit_v);
 328     OSVERSIONINFO ovi;
 329
 330     ovi.dwOSVersionInfoSize = sizeof (ovi);
 331     if (!GetVersionEx (&ovi)) {
 332         failwith_fmt ("Could not get version information: %#lx",
 333                       GetLastError ());
 334     }
 335
 336     if (ovi.dwPlatformId != VER_PLATFORM_WIN32_NT) {
 337         caml_failwith ("Only NT family of Windows is supported by APC");
 338     }
 339
 340     CAMLreturn (Val_int (WINDOWS_TAG));
 341 }
 342
 343 #elif defined __sun__
 344 #define _POSIX_PTHREAD_SEMANTICS
 345 #include <alloca.h>
 346 #include <unistd.h>
 347 #include <sys/time.h>
 348 #include <sys/time.h>
 349 #include <sys/sysinfo.h>
 350 #include <kstat.h>
 351 #include <sys/stat.h>
 352 #include <signal.h>
 353 #include <string.h>
 354 #include <errno.h>
 355
 356 static long get_nprocs (void)
 357 {
 358     long nprocs = sysconf (_SC_NPROCESSORS_CONF);
 359     if (nprocs <= 0) {
 360         failwith_fmt ("sysconf (_SC_NPROCESSORS_CONF) = %ld: %s",
 361                       nprocs, strerror (errno));
 362     }
 363     return nprocs;
 364 }
 365
 366 CAMLprim value ml_get_nprocs (value unit_v)
 367 {
 368     CAMLparam1 (unit_v);
 369     CAMLreturn (Val_int (get_nprocs ()));
 370 }
 371
 372 CAMLprim value ml_solaris_kstat (value nprocs_v)
 373 {
 374     /* Based on lib/cpustat.cc from sinfo package by Juergen Rinas */
 375     CAMLparam1 (nprocs_v);
 376     CAMLlocal1 (res_v);
 377     int i = 0, j = 0;
 378     int nprocs = Int_val (nprocs_v);
 379     struct kstat_ctl *kc;
 380     kstat_t *ksp;
 381
 382     kc = kstat_open ();
 383     if (!kc) {
 384         failwith_fmt ("kstat_open failed: %s", strerror (errno));
 385     }
 386
 387     res_v = caml_alloc (nprocs * 4 * Double_wosize, Double_array_tag);
 388     for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
 389         if (!strncmp (ksp->ks_name, "cpu_stat", 8)) {
 390             cpu_stat_t cstat;
 391
 392             i += 1;
 393             if (i > nprocs) {
 394                 failwith_fmt ("number of processors changed?");
 395             }
 396
 397             if (kstat_read (kc, ksp, 0) == -1) {
 398                 failwith_fmt ("kstat_read (update) failed: %s", strerror (errno));
 399             }
 400
 401             if (kstat_read (kc, ksp, &cstat) == -1) {
 402                 failwith_fmt ("kstat_read (read) failed: %s", strerror (errno));
 403             }
 404
 405             Store_double_field (res_v, j, cstat.cpu_sysinfo.cpu[0]); j += 1;
 406             Store_double_field (res_v, j, cstat.cpu_sysinfo.cpu[1]); j += 1;
 407             Store_double_field (res_v, j, cstat.cpu_sysinfo.cpu[2]); j += 1;
 408             Store_double_field (res_v, j, cstat.cpu_sysinfo.cpu[3]); j += 1;
 409         }
 410     }
 411
 412     kstat_close (kc);
 413     CAMLreturn (res_v);
 414 }
 415
 416 CAMLprim value ml_os_type (value unit_v)
 417 {
 418     CAMLparam1 (unit_v);
 419     CAMLreturn (Val_int (SOLARIS_TAG));
 420 }
 421 #elif defined __APPLE__
 422 #include <mach/mach.h>
 423 #include <sys/sysctl.h>
 424 #include <unistd.h>
 425 #include <errno.h>
 426 #include <string.h>
 427
 428 CAMLprim value ml_seticon (value data_v)
 429 {
 430     CAMLparam1 (data_v);
 431     CAMLreturn (Val_unit);
 432 }
 433
 434 static long get_nprocs (void)
 435 {
 436     int n, err;
 437     size_t size;
 438     int mib[] = { CTL_HW, HW_NCPU };
 439
 440     size = sizeof (int);
 441     err = sysctl (mib, 2, &n, &size, NULL, 0);
 442     if (err < 0) {
 443         failwith_fmt ("sysctl (HW_NCPU) failed: %s", strerror (errno));
 444     }
 445     return n;
 446 }
 447
 448 CAMLprim value ml_get_nprocs (value unit_v)
 449 {
 450     CAMLparam1 (unit_v);
 451     CAMLreturn (Val_int (get_nprocs ()));
 452 }
 453
 454 CAMLprim value ml_macosx_host_processor_info (value nprocs_v)
 455 {
 456     CAMLparam1 (nprocs_v);
 457     CAMLlocal1 (res_v);
 458     int i, j = 0;
 459     int nprocs = Int_val (nprocs_v);
 460     unsigned int nprocs1;
 461     kern_return_t kr;
 462     processor_cpu_load_info_t cpu_load, c;
 463     mach_msg_type_number_t cpu_msg_count;
 464
 465     kr = host_processor_info (mach_host_self (), PROCESSOR_CPU_LOAD_INFO,
 466                               &nprocs1,
 467                               (processor_info_array_t *) &cpu_load,
 468                               &cpu_msg_count);
 469     if (kr != KERN_SUCCESS) {
 470         failwith_fmt ("host_processor_info failed: %s",
 471                       mach_error_string (kr));
 472     }
 473
 474     if (nprocs1 != nprocs){
 475         failwith_fmt ("host_processor_info claims CPUs=%d expected %d",
 476                       nprocs1, nprocs);
 477     }
 478
 479     res_v = caml_alloc (nprocs * 4 * Double_wosize, Double_array_tag);
 480     c = cpu_load;
 481     for (i = 0; i < nprocs; ++i, ++c) {
 482         Store_double_field (res_v, j, c->cpu_ticks[CPU_STATE_IDLE]); j += 1;
 483         Store_double_field (res_v, j, c->cpu_ticks[CPU_STATE_USER]); j += 1;
 484         Store_double_field (res_v, j, c->cpu_ticks[CPU_STATE_SYSTEM]); j += 1;
 485         Store_double_field (res_v, j, c->cpu_ticks[CPU_STATE_NICE]); j += 1;
 486     }
 487
 488     kr = vm_deallocate (mach_task_self (), (vm_address_t) cpu_load,
 489                         cpu_msg_count * sizeof (*cpu_load));
 490     if (kr != KERN_SUCCESS) {
 491         failwith_fmt ("vm_deallocate failed: %s", mach_error_string (kr));
 492     }
 493     CAMLreturn (res_v);
 494 }
 495
 496 CAMLprim value ml_os_type (value unit_v)
 497 {
 498     CAMLparam1 (unit_v);
 499     CAMLreturn (Val_int (MACOSX_TAG));
 500 }
 501 #else
 502 #error This operating system is not supported
 503 #endif
 504
 505 #if defined __linux__ || defined __sun__
 506 #include <X11/X.h>
 507 #include <X11/Xmd.h>
 508 #include <X11/Xlib.h>
 509 #include <X11/Xatom.h>
 510
 511 #include <GL/glx.h>
 512
 513 struct X11State {
 514     Display *dpy;
 515     Window id;
 516     Atom property;
 517     int error;
 518 };
 519
 520 CAMLprim value ml_seticon (value data_v)
 521 {
 522     CAMLparam1 (data_v);
 523     static struct X11State static_state;
 524     struct X11State *s = &static_state;
 525     void *ptr = String_val (data_v);
 526     CARD32 *p = ptr;
 527     unsigned char *data = ptr;
 528
 529     if (!s->error) {
 530         if (!s->dpy) {
 531             s->dpy = XOpenDisplay (NULL);
 532             if (!s->dpy) {
 533                 goto err0;
 534             }
 535             else {
 536                 /* "tiny bit" hackish */
 537                 s->id = glXGetCurrentDrawable ();
 538                 if (s->id == None) {
 539                     goto err1;
 540                 }
 541
 542                 s->property = XInternAtom (s->dpy, "_NET_WM_ICON", False);
 543                 if (s->property == None){
 544                     goto err1;
 545                 }
 546
 547 #ifdef DEBUG
 548                 printf ("id = %#x, property = %d\n",
 549                         (int) s->id, (int) s->property);
 550 #endif
 551             }
 552         }
 553     }
 554     else {
 555         CAMLreturn (Val_unit);
 556     }
 557
 558     p[0] = 32;
 559     p[1] = 32;
 560     XChangeProperty (s->dpy, s->id, s->property, XA_CARDINAL,
 561                      32, PropModeReplace, data, 32 * 32 + 2);
 562
 563     CAMLreturn (Val_unit);
 564
 565  err1:
 566     XCloseDisplay (s->dpy);
 567  err0:
 568     s->error = 1;
 569     CAMLreturn (Val_unit);
 570 }
 571 #endif
 572
 573 #ifndef _WIN32
 574 CAMLprim value ml_waitalrm (value unit_v)
 575 {
 576     CAMLparam1 (unit_v);
 577     sigset_t set;
 578     int signr, ret, errno_code;
 579
 580     sigemptyset (&set);
 581     sigaddset (&set, SIGALRM);
 582
 583     caml_enter_blocking_section ();
 584     {
 585         ret = sigwait (&set, &signr);
 586         errno_code = errno;
 587     }
 588     caml_leave_blocking_section ();
 589
 590     if (ret) {
 591         failwith_fmt ("sigwait: %s", strerror (errno_code));
 592     }
 593     CAMLreturn (Val_unit);
 594 }
 595
 596 CAMLprim value ml_get_hz (value unit_v)
 597 {
 598     CAMLparam1 (unit_v);
 599     long clk_tck;
 600
 601     clk_tck = sysconf (_SC_CLK_TCK);
 602     if (clk_tck <= 0) {
 603         failwith_fmt ("sysconf (SC_CLK_TCK): %s", strerror (errno));
 604     }
 605     CAMLreturn (Val_int (clk_tck));
 606 }
 607
 608 CAMLprim value ml_delay (value secs_v)
 609 {
 610     CAMLparam1 (secs_v);
 611     failwith ("delay is not implemented on non-Windows");
 612     CAMLreturn (Val_unit);
 613 }
 614
 615 CAMLprim value ml_nice (value nice_v)
 616 {
 617     CAMLparam1 (nice_v);
 618     int niceval = Int_val (nice_v);
 619
 620 #ifdef __linux__
 621     errno = 0;
 622 #endif
 623     if (nice (niceval) < 0) {
 624 #ifdef __linux__
 625         if (errno)
 626 #endif
 627             failwith_fmt ("nice %d: %s", niceval, strerror (errno));
 628     }
 629
 630     CAMLreturn (Val_unit);
 631 }
 632 #endif
 633
 634 #ifndef _WIN32
 635 CAMLprim value ml_windows_processor_times (value nprocs_v)
 636 {
 637     CAMLparam1 (nprocs_v);
 638     failwith ("ml_windows_processor_times is not implemented on non-Windows");
 639     CAMLreturn (Val_unit);
 640 }
 641 #endif
 642
 643 #ifndef __sun__
 644 CAMLprim value ml_solaris_kstat (value nprocs_v)
 645 {
 646     CAMLparam1 (nprocs_v);
 647     failwith ("ml_solaris_kstat is not implemented on non-Solaris");
 648     CAMLreturn (Val_unit);
 649 }
 650 #endif
 651
 652 #ifndef __APPLE__
 653 CAMLprim value ml_macosx_host_processor_info (value nprocs_v)
 654 {
 655     CAMLparam1 (nprocs_v);
 656     failwith ("ml_macosx_host_processor_info is not implemented on non-MacOSX");
 657     CAMLreturn (Val_unit);
 658 }
 659 #endif
 660
 661 #ifndef __linux__
 662 CAMLprim value ml_sysinfo (value unit_v)
 663 {
 664     CAMLparam1 (unit_v);
 665     CAMLlocal2 (res_v, loads_v);
 666     long nprocs;
 667
 668 #ifdef _WIN32
 669     nprocs = glob.nprocs;
 670 #else
 671     nprocs = get_nprocs ();
 672 #endif
 673
 674     loads_v = caml_alloc_tuple (3);
 675     Store_field (loads_v, 0, caml_copy_int64 (0));
 676     Store_field (loads_v, 1, caml_copy_int64 (0));
 677     Store_field (loads_v, 2, caml_copy_int64 (0));
 678
 679     res_v = caml_alloc_tuple (9);
 680     Store_field (res_v, 0, 0);
 681     Store_field (res_v, 1, loads_v);
 682     Store_field (res_v, 2, 0);
 683     Store_field (res_v, 3, 0);
 684     Store_field (res_v, 4, 0);
 685     Store_field (res_v, 5, 0);
 686     Store_field (res_v, 6, 0);
 687     Store_field (res_v, 7, 0);
 688     Store_field (res_v, 8, nprocs);
 689
 690     CAMLreturn (res_v);
 691 }
 692
 693 CAMLprim value ml_idletimeofday (value fd_v, value nprocs_v)
 694 {
 695     CAMLparam2 (fd_v, nprocs_v);
 696     failwith_fmt ("idletimeofday is not implemented on non-Linux");
 697     CAMLreturn (Val_unit);
 698 }
 699 #endif