src/runtime/linux-os.c

   1 /*
   2  * the Linux incarnation of OS-dependent routines.  See also
   3  * $(sbcl_arch)-linux-os.c
   4  *
   5  * This file (along with os.h) exports an OS-independent interface to
   6  * the operating system VM facilities. Surprise surprise, this
   7  * interface looks a lot like the Mach interface (but simpler in some
   8  * places). For some operating systems, a subset of these functions
   9  * will have to be emulated.
  10  */
  11
  12 /*
  13  * This software is part of the SBCL system. See the README file for
  14  * more information.
  15  *
  16  * This software is derived from the CMU CL system, which was
  17  * written at Carnegie Mellon University and released into the
  18  * public domain. The software is in the public domain and is
  19  * provided with absolutely no warranty. See the COPYING and CREDITS
  20  * files for more information.
  21  */
  22
  23 #include <stdio.h>
  24 #include <sys/param.h>
  25 #include <sys/file.h>
  26 #include "sbcl.h"
  27 #include "./signal.h"
  28 #include "os.h"
  29 #include "arch.h"
  30 #include "globals.h"
  31 #include "interrupt.h"
  32 #include "interr.h"
  33 #include "lispregs.h"
  34 #include "runtime.h"
  35 #include "genesis/static-symbols.h"
  36 #include "genesis/fdefn.h"
  37
  38 #include <sys/socket.h>
  39 #include <sys/utsname.h>
  40 #include <errno.h>
  41
  42 #include <sys/types.h>
  43 #include <signal.h>
  44 /* #include <sys/sysinfo.h> */
  45 #include <sys/time.h>
  46 #include <sys/stat.h>
  47 #include <unistd.h>
  48 #include <linux/version.h>
  49
  50 #include "validate.h"
  51 #include "thread.h"
  52 #include "gc.h"
  53 #if defined LISP_FEATURE_GENCGC
  54 #include "gencgc-internal.h"
  55 #else
  56 #include "cheneygc-internal.h"
  57 #endif
  58 #include <fcntl.h>
  59 #ifdef LISP_FEATURE_SB_WTIMER
  60 # include <sys/timerfd.h>
  61 #endif
  62
  63 #ifdef LISP_FEATURE_X86
  64 /* Prototype for personality(2). Done inline here since the header file
  65  * for this isn't available on old versions of glibc. */
  66 int personality (unsigned long);
  67 #endif
  68
  69 size_t os_vm_page_size;
  70
  71 #if defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_SB_FUTEX) && !defined(LISP_FEATURE_SB_PTHREAD_FUTEX)
  72 #include <sys/syscall.h>
  73 #include <unistd.h>
  74 #include <errno.h>
  75
  76 /* values taken from the kernel's linux/futex.h.  This header file
  77    doesn't exist in userspace, which is our excuse for not grovelling
  78    them automatically */
  79 #define FUTEX_WAIT 0
  80 #define FUTEX_WAKE 1
  81 /* This is also copied from linux/futex.h so that a binary compiled on
  82  * a not so recent Linux system can still take advantage of private
  83  * futexes when available.*/
  84 #define FUTEX_WAIT_PRIVATE (0+128)
  85 #define FUTEX_WAKE_PRIVATE (1+128)
  86 #define FUTEX_FD (2)
  87 #define FUTEX_REQUEUE (3)
  88
  89 /* Not static so that Lisp may query it. */
  90 boolean futex_private_supported_p;
  91
  92 static inline int
  93 futex_wait_op()
  94 {
  95     return (futex_private_supported_p ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT);
  96 }
  97
  98 static inline int
  99 futex_wake_op()
 100 {
 101     return (futex_private_supported_p ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE);
 102 }
 103
 104 #define sys_futex sbcl_sys_futex
 105 static inline int sys_futex (void *futex, int op, int val, struct timespec *rel)
 106 {
 107     return syscall (SYS_futex, futex, op, val, rel);
 108 }
 109
 110 static void
 111 futex_init()
 112 {
 113     int x = 0;
 114     sys_futex(&x, FUTEX_WAIT, 1, 0);
 115     if (errno == ENOSYS)
 116         lose("This version of SBCL is compiled with threading support, but your kernel\n"
 117              "is too old to support this. Please use a more recent kernel or\n"
 118              "a version of SBCL without threading support.\n");
 119     sys_futex(&x, FUTEX_WAIT_PRIVATE, 1, 0);
 120     if (errno == EWOULDBLOCK) {
 121         futex_private_supported_p = 1;
 122     } else {
 123         futex_private_supported_p = 0;
 124         SHOW("No futex private suppport\n");
 125     }
 126 }
 127
 128 int
 129 futex_wait(int *lock_word, int oldval, long sec, unsigned long usec)
 130 {
 131   struct timespec timeout;
 132   int t;
 133
 134   if (sec<0) {
 135       t = sys_futex(lock_word, futex_wait_op(), oldval, 0);
 136   }
 137   else {
 138       timeout.tv_sec = sec;
 139       timeout.tv_nsec = usec * 1000;
 140       t = sys_futex(lock_word, futex_wait_op(), oldval, &timeout);
 141   }
 142   if (t==0)
 143       return 0;
 144   else if (errno==ETIMEDOUT)
 145       return 1;
 146   else if (errno==EINTR)
 147       return 2;
 148   else
 149       /* EWOULDBLOCK and others, need to check the lock */
 150       return -1;
 151 }
 152
 153 int
 154 futex_wake(int *lock_word, int n)
 155 {
 156     return sys_futex(lock_word, futex_wake_op(),n,0);
 157 }
 158 #endif
 159
 160 \f
 161 int linux_sparc_siginfo_bug = 0;
 162
 163 /* This variable was in real use for a few months, basically for
 164  * storing autodetected information about whether the Linux
 165  * installation was recent enough to support SBCL threads, and make
 166  * some run-time decisions based on that. But this turned out to be
 167  * unstable, so now we just flat-out refuse to start on the old installations
 168  * when thread support has been compiled in.
 169  *
 170  * Unfortunately, in the meanwhile Slime started depending on this
 171  * variable for deciding which communication style to use. So even
 172  * though this variable looks unused, it shouldn't be deleted until
 173  * it's no longer used in the versions of Slime that people are
 174  * likely to download first. -- JES, 2006-06-07
 175  */
 176 int linux_no_threads_p = 0;
 177
 178 #ifdef LISP_FEATURE_SB_THREAD
 179 int
 180 isnptl (void)
 181 {
 182   size_t n = confstr (_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
 183   if (n > 0) {
 184       char *buf = alloca (n);
 185       confstr (_CS_GNU_LIBPTHREAD_VERSION, buf, n);
 186       if (strstr (buf, "NPTL")) {
 187           return 1;
 188       }
 189   }
 190   return 0;
 191 }
 192 #endif
 193
 194 void
 195 os_init(char *argv[], char *envp[])
 196 {
 197     /* Conduct various version checks: do we have enough mmap(), is
 198      * this a sparc running 2.2, can we do threads? */
 199     struct utsname name;
 200     int major_version;
 201     int minor_version;
 202     int patch_version;
 203     char *p;
 204     uname(&name);
 205
 206     p=name.release;
 207     major_version = atoi(p);
 208     minor_version = patch_version = 0;
 209     p=strchr(p,'.');
 210     if (p != NULL) {
 211             minor_version = atoi(++p);
 212             p=strchr(p,'.');
 213             if (p != NULL)
 214                     patch_version = atoi(++p);
 215     }
 216
 217     if (major_version<2) {
 218         lose("linux kernel version too old: major version=%d (can't run in version < 2.0.0)\n",
 219              major_version);
 220     }
 221     if (!(major_version>2 || minor_version >= 4)) {
 222 #ifdef LISP_FEATURE_SPARC
 223         FSHOW((stderr,"linux kernel %d.%d predates 2.4;\n enabling workarounds for SPARC kernel bugs in signal handling.\n", major_version,minor_version));
 224         linux_sparc_siginfo_bug = 1;
 225 #endif
 226     }
 227 #ifdef LISP_FEATURE_SB_THREAD
 228 #if defined(LISP_FEATURE_SB_FUTEX) && !defined(LISP_FEATURE_SB_PTHREAD_FUTEX)
 229     futex_init();
 230 #endif
 231     if(! isnptl()) {
 232        lose("This version of SBCL only works correctly with the NPTL threading\n"
 233             "library. Please use a newer glibc, use an older SBCL, or stop using\n"
 234             "LD_ASSUME_KERNEL\n");
 235     }
 236 #endif
 237
 238     /* Don't use getpagesize(), since it's not constant across Linux
 239      * kernel versions on some architectures (for example PPC). FIXME:
 240      * possibly the same should be done on other architectures too.
 241      */
 242     os_vm_page_size = BACKEND_PAGE_BYTES;
 243
 244     /* KLUDGE: Disable memory randomization on new Linux kernels
 245      * by setting a personality flag and re-executing. (We need
 246      * to re-execute, since the memory maps that can conflict with
 247      * the SBCL spaces have already been done at this point).
 248      *
 249      * Since randomization is currently implemented only on x86 kernels,
 250      * don't do this trick on other platforms.
 251      */
 252 #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
 253     if ((major_version == 2
 254          /* Some old kernels will apparently lose unsupported personality flags
 255           * on exec() */
 256          && ((minor_version == 6 && patch_version >= 11)
 257              || (minor_version > 6)
 258              /* This is what RHEL 3 reports */
 259              || (minor_version == 4 && patch_version > 20)))
 260         || major_version >= 3)
 261     {
 262         int pers = personality(0xffffffffUL);
 263         /* 0x40000 aka. ADDR_NO_RANDOMIZE */
 264         if (!(pers & 0x40000)) {
 265             int retval = personality(pers | 0x40000);
 266             /* Allegedly some Linux kernels (the reported case was
 267              * "hardened Linux 2.6.7") won't set the new personality,
 268              * but nor will they return -1 for an error. So as a
 269              * workaround query the new personality...
 270              */
 271             int newpers = personality(0xffffffffUL);
 272             /* ... and don't re-execute if either the setting resulted
 273              * in an error or if the value didn't change. Otherwise
 274              * this might result in an infinite loop.
 275              */
 276             if (retval != -1 && newpers != pers) {
 277                 /* Use /proc/self/exe instead of trying to figure out
 278                  * the executable path from PATH and argv[0], since
 279                  * that's unreliable. We follow the symlink instead of
 280                  * executing the file directly in order to prevent top
 281                  * from displaying the name of the process as "exe". */
 282                 char runtime[PATH_MAX+1];
 283                 int i = readlink("/proc/self/exe", runtime, PATH_MAX);
 284                 if (i != -1) {
 285                     runtime[i] = '\0';
 286                     execve(runtime, argv, envp);
 287                 }
 288             }
 289             /* Either changing the personality or execve() failed. Either
 290              * way we might as well continue, and hope that the random
 291              * memory maps are ok this time around.
 292              */
 293             fprintf(stderr, "WARNING: Couldn't re-execute SBCL with the proper personality flags (maybe /proc isn't mounted?). Trying to continue anyway.\n");
 294         }
 295     }
 296 #ifdef LISP_FEATURE_X86
 297     /* Use SSE detector.  Recent versions of Linux enable SSE support
 298      * on SSE capable CPUs.  */
 299     /* FIXME: Are there any old versions that does not support SSE?  */
 300     fast_bzero_pointer = fast_bzero_detect;
 301 #endif
 302 #endif
 303 }
 304
 305
 306 #ifdef LISP_FEATURE_ALPHA
 307 /* The Alpha is a 64 bit CPU.  SBCL is a 32 bit application.  Due to all
 308  * the places that assume we can get a pointer into a fixnum with no
 309  * information loss, we have to make sure it allocates all its ram in the
 310  * 0-2Gb region.  */
 311
 312 static void * under_2gb_free_pointer=DYNAMIC_1_SPACE_END;
 313 #endif
 314
 315 os_vm_address_t
 316 os_validate(os_vm_address_t addr, os_vm_size_t len)
 317 {
 318     int flags =  MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
 319     os_vm_address_t actual;
 320
 321 #ifdef LISP_FEATURE_ALPHA
 322     if (!addr) {
 323         addr=under_2gb_free_pointer;
 324     }
 325 #endif
 326     actual = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0);
 327     if (actual == MAP_FAILED) {
 328         perror("mmap");
 329         return 0;               /* caller should check this */
 330     }
 331
 332     if (addr && (addr!=actual)) {
 333         fprintf(stderr, "mmap: wanted %lu bytes at %p, actually mapped at %p\n",
 334                 (unsigned long) len, addr, actual);
 335         return 0;
 336     }
 337
 338 #ifdef LISP_FEATURE_ALPHA
 339
 340     len=(len+(os_vm_page_size-1))&(~(os_vm_page_size-1));
 341     under_2gb_free_pointer+=len;
 342 #endif
 343
 344     return actual;
 345 }
 346
 347 void
 348 os_invalidate(os_vm_address_t addr, os_vm_size_t len)
 349 {
 350     if (munmap(addr,len) == -1) {
 351         perror("munmap");
 352     }
 353 }
 354
 355 os_vm_address_t
 356 os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
 357 {
 358     os_vm_address_t actual;
 359
 360     actual = mmap(addr, len, OS_VM_PROT_ALL, MAP_PRIVATE | MAP_FIXED,
 361                   fd, (off_t) offset);
 362     if (actual == MAP_FAILED || (addr && (addr != actual))) {
 363         perror("mmap");
 364         lose("unexpected mmap(..) failure\n");
 365     }
 366
 367     return actual;
 368 }
 369
 370 void
 371 os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
 372 {
 373     if (mprotect(address, length, prot) == -1) {
 374         if (errno == ENOMEM) {
 375             lose("An mprotect call failed with ENOMEM. This probably means that the maximum amount\n"
 376                  "of separate memory mappings was exceeded. To fix the problem, either increase\n"
 377                  "the maximum with e.g. 'echo 262144 > /proc/sys/vm/max_map_count' or recompile\n"
 378                  "SBCL with a larger value for GENCGC-CARD-BYTES in\n"
 379                  "'src/compiler/target/backend-parms.lisp'.");
 380         } else {
 381             perror("mprotect");
 382         }
 383     }
 384 }
 385 \f
 386 boolean
 387 is_valid_lisp_addr(os_vm_address_t addr)
 388 {
 389     struct thread *th;
 390     size_t ad = (size_t) addr;
 391
 392     if ((READ_ONLY_SPACE_START <= ad && ad < READ_ONLY_SPACE_END)
 393         || (STATIC_SPACE_START <= ad && ad < STATIC_SPACE_END)
 394 #if defined LISP_FEATURE_GENCGC
 395         || (DYNAMIC_SPACE_START <= ad && ad < DYNAMIC_SPACE_END)
 396 #else
 397         || (DYNAMIC_0_SPACE_START <= ad && ad < DYNAMIC_0_SPACE_END)
 398         || (DYNAMIC_1_SPACE_START <= ad && ad < DYNAMIC_1_SPACE_END)
 399 #endif
 400         )
 401         return 1;
 402     for_each_thread(th) {
 403         if((size_t)(th->control_stack_start) <= ad
 404            && ad < (size_t)(th->control_stack_end))
 405             return 1;
 406         if((size_t)(th->binding_stack_start) <= ad
 407            && ad < (size_t)(th->binding_stack_start + BINDING_STACK_SIZE))
 408             return 1;
 409     }
 410     return 0;
 411 }
 412 \f
 413 /*
 414  * any OS-dependent special low-level handling for signals
 415  */
 416
 417 /*
 418  * The GC needs to be hooked into whatever signal is raised for
 419  * page fault on this OS.
 420  */
 421 static void
 422 sigsegv_handler(int signal, siginfo_t *info, os_context_t *context)
 423 {
 424     os_vm_address_t addr = arch_get_bad_addr(signal, info, context);
 425
 426 #ifdef LISP_FEATURE_ALPHA
 427     /* Alpha stuff: This is the end of a pseudo-atomic section during
 428        which a signal was received.  We must deal with the pending
 429        interrupt (see also interrupt.c, ../code/interrupt.lisp)
 430
 431        (how we got here: when interrupting, we set bit 63 in reg_ALLOC.
 432        At the end of the atomic section we tried to write to reg_ALLOC,
 433        got a SIGSEGV (there's nothing mapped there) so ended up here. */
 434     if (addr != NULL &&
 435         *os_context_register_addr(context, reg_ALLOC) & (1L<<63)) {
 436         *os_context_register_addr(context, reg_ALLOC) -= (1L<<63);
 437         interrupt_handle_pending(context);
 438         return;
 439     }
 440 #endif
 441
 442 #ifdef LISP_FEATURE_SB_SAFEPOINT
 443     if (!handle_safepoint_violation(context, addr))
 444 #endif
 445
 446 #ifdef LISP_FEATURE_GENCGC
 447     if (!gencgc_handle_wp_violation(addr))
 448 #else
 449     if (!cheneygc_handle_wp_violation(context, addr))
 450 #endif
 451         if (!handle_guard_page_triggered(context, addr))
 452             lisp_memory_fault_error(context, addr);
 453 }
 454
 455 void
 456 os_install_interrupt_handlers(void)
 457 {
 458     undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT,
 459                                                  sigsegv_handler);
 460
 461     /* OAOOM c.f. sunos-os.c.
 462      * Should we have a reusable function gc_install_interrupt_handlers? */
 463 #ifdef LISP_FEATURE_SB_THREAD
 464 # ifdef LISP_FEATURE_SB_SAFEPOINT
 465 #  ifdef LISP_FEATURE_SB_THRUPTION
 466     undoably_install_low_level_interrupt_handler(SIGPIPE, thruption_handler);
 467 #  endif
 468 # else
 469     undoably_install_low_level_interrupt_handler(SIG_STOP_FOR_GC,
 470                                                  sig_stop_for_gc_handler);
 471 # endif
 472 #endif
 473 }
 474
 475 char *
 476 os_get_runtime_executable_path(int external)
 477 {
 478     char path[PATH_MAX + 1];
 479     int size;
 480
 481     size = readlink("/proc/self/exe", path, sizeof(path)-1);
 482     if (size < 0)
 483         return NULL;
 484     else
 485         path[size] = '\0';
 486
 487     return copied_string(path);
 488 }
 489
 490 #ifdef LISP_FEATURE_SB_WTIMER
 491 /*
 492  * Waitable timer implementation for the safepoint-based (SIGALRM-free)
 493  * timer facility using timerfd_create().
 494  */
 495 int
 496 os_create_wtimer()
 497 {
 498     int fd = timerfd_create(CLOCK_MONOTONIC, 0);
 499     if (fd == -1)
 500         lose("os_create_wtimer: timerfd_create");
 501
 502     /* Cannot count on TFD_CLOEXEC availability, so do it manually: */
 503     if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
 504         lose("os_create_wtimer: fcntl");
 505
 506     return fd;
 507 }
 508
 509 int
 510 os_wait_for_wtimer(int fd)
 511 {
 512     unsigned char buf[8];
 513     int n = read(fd, buf, sizeof(buf));
 514     if (n == -1) {
 515         if (errno == EINTR)
 516             return -1;
 517         lose("os_wtimer_listen failed");
 518     }
 519     if (n != sizeof(buf))
 520         lose("os_wtimer_listen read too little");
 521     return 0;
 522 }
 523
 524 void
 525 os_close_wtimer(int fd)
 526 {
 527     if (close(fd) == -1)
 528         lose("os_close_wtimer failed");
 529 }
 530
 531 void
 532 os_set_wtimer(int fd, int sec, int nsec)
 533 {
 534     struct itimerspec spec = { {0,0}, {0,0} };
 535     spec.it_value.tv_sec = sec;
 536     spec.it_value.tv_nsec = nsec;
 537     if (timerfd_settime(fd, 0, &spec, 0) == -1)
 538         lose("timerfd_settime");
 539 }
 540
 541 void
 542 os_cancel_wtimer(int fd)
 543 {
 544     os_set_wtimer(fd, 0, 0);
 545 }
 546 #endif