vm/os-unix.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 bool set_memory_locked(cell base, cell size, bool locked) {
   6   int prot = locked ? PROT_NONE : PROT_READ | PROT_WRITE;
   7   int status = mprotect((char*)base, size, prot);
   8   return status != -1;
   9 }
  10
  11 THREADHANDLE start_thread(void* (*start_routine)(void*), void* args) {
  12   pthread_attr_t attr;
  13   pthread_t thread;
  14   if (pthread_attr_init(&attr) != 0)
  15     fatal_error("pthread_attr_init() failed", 0);
  16   if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) != 0)
  17     fatal_error("pthread_attr_setdetachstate() failed", 0);
  18   if (pthread_create(&thread, &attr, start_routine, args) != 0)
  19     fatal_error("pthread_create() failed", 0);
  20   pthread_attr_destroy(&attr);
  21   return thread;
  22 }
  23
  24 static void* null_dll;
  25
  26 void sleep_nanos(uint64_t nsec) {
  27   timespec ts;
  28   timespec ts_rem;
  29   int ret;
  30   ts.tv_sec = nsec / 1000000000;
  31   ts.tv_nsec = nsec % 1000000000;
  32   ret = nanosleep(&ts, &ts_rem);
  33   while (ret == -1 && errno == EINTR) {
  34     memcpy(&ts, &ts_rem, sizeof(ts));
  35     ret = nanosleep(&ts, &ts_rem);
  36   }
  37
  38   if (ret == -1)
  39     fatal_error("nanosleep failed", 0);
  40 }
  41
  42 void factor_vm::init_ffi() { null_dll = dlopen(NULL, RTLD_LAZY); }
  43
  44 void factor_vm::ffi_dlopen(dll* dll) {
  45   dll->handle = dlopen(alien_offset(dll->path), RTLD_LAZY | RTLD_GLOBAL);
  46 }
  47
  48 cell factor_vm::ffi_dlsym_raw(dll* dll, symbol_char* symbol) {
  49   return (cell)dlsym(dll ? dll->handle : null_dll, symbol);
  50 }
  51
  52 cell factor_vm::ffi_dlsym(dll* dll, symbol_char* symbol) {
  53   return FUNCTION_CODE_POINTER(ffi_dlsym_raw(dll, symbol));
  54 }
  55
  56 void factor_vm::ffi_dlclose(dll* dll) {
  57   if (dlclose(dll->handle))
  58     general_error(ERROR_FFI, false_object, false_object);
  59   dll->handle = NULL;
  60 }
  61
  62 void factor_vm::primitive_existsp() {
  63   struct stat sb;
  64   char* path = (char*)(untag_check<byte_array>(ctx->pop()) + 1);
  65   ctx->push(tag_boolean(stat(path, &sb) >= 0));
  66 }
  67
  68 bool move_file(const vm_char* path1, const vm_char* path2) {
  69   int ret = 0;
  70   do {
  71     ret = rename((path1), (path2));
  72   } while (ret < 0 && errno == EINTR);
  73
  74   return ret == 0;
  75 }
  76
  77 segment::segment(cell size_, bool executable_p) {
  78   size = size_;
  79
  80   int pagesize = getpagesize();
  81
  82   int prot;
  83   if (executable_p)
  84     prot = PROT_READ | PROT_WRITE | PROT_EXEC;
  85   else
  86     prot = PROT_READ | PROT_WRITE;
  87
  88   cell alloc_size = 2 * pagesize + size;
  89   char* array = (char*)mmap(NULL, alloc_size, prot,
  90                             MAP_ANON | MAP_PRIVATE, -1, 0);
  91
  92   if (array == (char*)-1)
  93     fatal_error("Out of memory in mmap", alloc_size);
  94
  95   start = (cell)(array + pagesize);
  96   end = start + size;
  97
  98   set_border_locked(true);
  99 }
 100
 101 segment::~segment() {
 102   int pagesize = getpagesize();
 103   int retval = munmap((void*)(start - pagesize), 2 * pagesize + size);
 104   if (retval)
 105     fatal_error("Segment deallocation failed", 0);
 106 }
 107
 108 void factor_vm::start_sampling_profiler_timer() {
 109   struct itimerval timer;
 110   memset((void*)&timer, 0, sizeof(struct itimerval));
 111   timer.it_value.tv_usec = 1000000 / samples_per_second;
 112   timer.it_interval.tv_usec = 1000000 / samples_per_second;
 113   setitimer(ITIMER_REAL, &timer, NULL);
 114 }
 115
 116 void factor_vm::end_sampling_profiler_timer() {
 117   struct itimerval timer;
 118   memset((void*)&timer, 0, sizeof(struct itimerval));
 119   setitimer(ITIMER_REAL, &timer, NULL);
 120 }
 121
 122 void factor_vm::dispatch_signal(void* uap, void(handler)()) {
 123   dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap),
 124                           (cell*)&UAP_PROGRAM_COUNTER(uap),
 125                           (cell)FUNCTION_CODE_POINTER(handler));
 126   UAP_SET_TOC_POINTER(uap, (cell)FUNCTION_TOC_POINTER(handler));
 127 }
 128
 129 void memory_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 130
 131   cell fault_addr = (cell)siginfo->si_addr;
 132   cell fault_pc = (cell)UAP_PROGRAM_COUNTER(uap);
 133   factor_vm* vm = current_vm();
 134   vm->set_memory_protection_error(fault_addr, fault_pc);
 135   vm->dispatch_signal(uap, factor::memory_signal_handler_impl);
 136 }
 137
 138 void synchronous_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 139   if (factor_vm::fatal_erroring_p)
 140     return;
 141
 142   factor_vm* vm = current_vm_p();
 143   if (!vm)
 144     fatal_error("Foreign thread received signal", signal);
 145   vm->signal_number = signal;
 146   vm->dispatch_signal(uap, factor::synchronous_signal_handler_impl);
 147 }
 148
 149 void safe_write_nonblock(int fd, void* data, ssize_t size);
 150
 151 static void enqueue_signal(factor_vm* vm, int signal) {
 152   if (vm->signal_pipe_output != 0)
 153     safe_write_nonblock(vm->signal_pipe_output, &signal, sizeof(int));
 154 }
 155
 156 void enqueue_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 157   if (factor_vm::fatal_erroring_p)
 158     return;
 159
 160   factor_vm* vm = current_vm_p();
 161   if (vm)
 162     enqueue_signal(vm, signal);
 163 }
 164
 165 void fep_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 166   if (factor_vm::fatal_erroring_p)
 167     return;
 168
 169   factor_vm* vm = current_vm_p();
 170   if (vm) {
 171     vm->enqueue_fep();
 172     enqueue_signal(vm, signal);
 173   } else
 174     fatal_error("Foreign thread received signal", signal);
 175 }
 176
 177 void sample_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 178   factor_vm* vm = current_vm_p();
 179   bool foreign_thread = false;
 180   if (vm == NULL) {
 181     foreign_thread = true;
 182     vm = thread_vms.begin()->second;
 183   }
 184   if (atomic::load(&vm->sampling_profiler_p))
 185     vm->enqueue_samples(1, (cell)UAP_PROGRAM_COUNTER(uap), foreign_thread);
 186   else if (!foreign_thread)
 187     enqueue_signal(vm, signal);
 188 }
 189
 190 void ignore_signal_handler(int signal, siginfo_t* siginfo, void* uap) {}
 191
 192 void fpe_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
 193   factor_vm* vm = current_vm();
 194   vm->signal_number = signal;
 195   vm->signal_fpu_status = fpu_status(uap_fpu_status(uap));
 196   uap_clear_fpu_status(uap);
 197
 198   vm->dispatch_signal(
 199       uap, (siginfo->si_code == FPE_INTDIV || siginfo->si_code == FPE_INTOVF)
 200                ? factor::synchronous_signal_handler_impl
 201                : factor::fp_signal_handler_impl);
 202 }
 203
 204 static void sigaction_safe(int signum, const struct sigaction* act,
 205                            struct sigaction* oldact) {
 206   int ret;
 207   do {
 208     ret = sigaction(signum, act, oldact);
 209   } while (ret == -1 && errno == EINTR);
 210
 211   if (ret == -1)
 212     fatal_error("sigaction failed", errno);
 213 }
 214
 215 static void init_sigaction_with_handler(struct sigaction* act,
 216                                         void (*handler)(int, siginfo_t*,
 217                                                         void*)) {
 218   memset(act, 0, sizeof(struct sigaction));
 219   sigemptyset(&act->sa_mask);
 220   act->sa_sigaction = handler;
 221   act->sa_flags = SA_SIGINFO | SA_ONSTACK;
 222 }
 223
 224 static void safe_pipe(int* in, int* out) {
 225   int filedes[2];
 226
 227   if (pipe(filedes) < 0)
 228     fatal_error("Error opening pipe", errno);
 229
 230   *in = filedes[0];
 231   *out = filedes[1];
 232
 233   if (fcntl(*in, F_SETFD, FD_CLOEXEC) < 0)
 234     fatal_error("Error with fcntl", errno);
 235
 236   if (fcntl(*out, F_SETFD, FD_CLOEXEC) < 0)
 237     fatal_error("Error with fcntl", errno);
 238 }
 239
 240 static void init_signal_pipe(factor_vm* vm) {
 241   safe_pipe(&vm->signal_pipe_input, &vm->signal_pipe_output);
 242
 243   if (fcntl(vm->signal_pipe_output, F_SETFL, O_NONBLOCK) < 0)
 244     fatal_error("Error with fcntl", errno);
 245
 246   vm->special_objects[OBJ_SIGNAL_PIPE] = tag_fixnum(vm->signal_pipe_input);
 247 }
 248
 249 void factor_vm::unix_init_signals() {
 250   init_signal_pipe(this);
 251
 252   signal_callstack_seg = new segment(callstack_size, false);
 253
 254   stack_t signal_callstack;
 255   signal_callstack.ss_sp = (char*)signal_callstack_seg->start;
 256   signal_callstack.ss_size = signal_callstack_seg->size;
 257   signal_callstack.ss_flags = 0;
 258
 259   if (sigaltstack(&signal_callstack, (stack_t*)NULL) < 0)
 260     fatal_error("sigaltstack() failed", 0);
 261
 262   {
 263     struct sigaction memory_sigaction;
 264     init_sigaction_with_handler(&memory_sigaction, memory_signal_handler);
 265     sigaction_safe(SIGBUS, &memory_sigaction, NULL);
 266     sigaction_safe(SIGSEGV, &memory_sigaction, NULL);
 267     sigaction_safe(SIGTRAP, &memory_sigaction, NULL);
 268   }
 269
 270   {
 271     struct sigaction fpe_sigaction;
 272     init_sigaction_with_handler(&fpe_sigaction, fpe_signal_handler);
 273     sigaction_safe(SIGFPE, &fpe_sigaction, NULL);
 274   }
 275
 276   {
 277     struct sigaction synchronous_sigaction;
 278     init_sigaction_with_handler(&synchronous_sigaction,
 279                                 synchronous_signal_handler);
 280     sigaction_safe(SIGILL, &synchronous_sigaction, NULL);
 281     sigaction_safe(SIGABRT, &synchronous_sigaction, NULL);
 282   }
 283
 284   {
 285     struct sigaction enqueue_sigaction;
 286     init_sigaction_with_handler(&enqueue_sigaction, enqueue_signal_handler);
 287     sigaction_safe(SIGWINCH, &enqueue_sigaction, NULL);
 288     sigaction_safe(SIGUSR1, &enqueue_sigaction, NULL);
 289     sigaction_safe(SIGCONT, &enqueue_sigaction, NULL);
 290     sigaction_safe(SIGURG, &enqueue_sigaction, NULL);
 291     sigaction_safe(SIGIO, &enqueue_sigaction, NULL);
 292     sigaction_safe(SIGPROF, &enqueue_sigaction, NULL);
 293     sigaction_safe(SIGVTALRM, &enqueue_sigaction, NULL);
 294 #ifdef SIGINFO
 295     sigaction_safe(SIGINFO, &enqueue_sigaction, NULL);
 296 #endif
 297   }
 298
 299   handle_ctrl_c();
 300
 301   {
 302     struct sigaction sample_sigaction;
 303     init_sigaction_with_handler(&sample_sigaction, sample_signal_handler);
 304     sigaction_safe(SIGALRM, &sample_sigaction, NULL);
 305   }
 306
 307   // We don't use SA_IGN here because then the ignore action is inherited
 308   // by subprocesses, which we don't want. There is a unit test in
 309   // io.launcher.unix for this.
 310   {
 311     struct sigaction ignore_sigaction;
 312     init_sigaction_with_handler(&ignore_sigaction, ignore_signal_handler);
 313     sigaction_safe(SIGPIPE, &ignore_sigaction, NULL);
 314     // We send SIGUSR2 to the stdin_loop thread to interrupt it on FEP
 315     sigaction_safe(SIGUSR2, &ignore_sigaction, NULL);
 316   }
 317 }
 318
 319 // On Unix, shared fds such as stdin cannot be set to non-blocking mode
 320 // (http://homepages.tesco.net/J.deBoynePollard/FGA/dont-set-shared-file-descriptors-to-non-blocking-mode.html)
 321 // so we kludge around this by spawning a thread, which waits on a control pipe
 322 // for a signal, upon receiving this signal it reads one block of data from
 323 // stdin and writes it to a data pipe. Upon completion, it writes a 4-byte
 324 // integer to the size pipe, indicating how much data was written to the data
 325 // pipe.
 326
 327 // The read end of the size pipe can be set to non-blocking.
 328 extern "C" {
 329 int stdin_read;
 330 int stdin_write;
 331
 332 int control_read;
 333 int control_write;
 334
 335 int size_read;
 336 int size_write;
 337
 338 bool stdin_thread_initialized_p = false;
 339 THREADHANDLE stdin_thread;
 340 pthread_mutex_t stdin_mutex;
 341 }
 342
 343 void safe_close(int fd) {
 344   if (close(fd) < 0)
 345     fatal_error("error closing fd", errno);
 346 }
 347
 348 bool check_write(int fd, void* data, ssize_t size) {
 349   if (write(fd, data, size) == size)
 350     return true;
 351   if (errno == EINTR)
 352     return check_write(fd, data, size);
 353   return false;
 354 }
 355
 356 void safe_write(int fd, void* data, ssize_t size) {
 357   if (!check_write(fd, data, size))
 358     fatal_error("error writing fd", errno);
 359 }
 360
 361 void safe_write_nonblock(int fd, void* data, ssize_t size) {
 362   if (!check_write(fd, data, size) && errno != EAGAIN)
 363     fatal_error("error writing fd", errno);
 364 }
 365
 366 bool safe_read(int fd, void* data, ssize_t size) {
 367   ssize_t bytes = read(fd, data, size);
 368   if (bytes < 0) {
 369     if (errno == EINTR)
 370       return safe_read(fd, data, size);
 371     else {
 372       fatal_error("error reading fd", errno);
 373       return false;
 374     }
 375   } else
 376     return (bytes == size);
 377 }
 378
 379 void* stdin_loop(void* arg) {
 380   unsigned char buf[4096];
 381   bool loop_running = true;
 382
 383   sigset_t mask;
 384   sigfillset(&mask);
 385   sigdelset(&mask, SIGUSR2);
 386   sigdelset(&mask, SIGTTIN);
 387   sigdelset(&mask, SIGTERM);
 388   sigdelset(&mask, SIGQUIT);
 389   pthread_sigmask(SIG_SETMASK, &mask, NULL);
 390
 391   int unused;
 392   pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &unused);
 393   pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &unused);
 394
 395   while (loop_running) {
 396     if (!safe_read(control_read, buf, 1))
 397       break;
 398
 399     if (buf[0] != 'X')
 400       fatal_error("stdin_loop: bad data on control fd", buf[0]);
 401
 402     for (;;) {
 403       // If we fep, the parent thread will grab stdin_mutex and send us
 404       // SIGUSR2 to interrupt the read() call.
 405       pthread_mutex_lock(&stdin_mutex);
 406       pthread_mutex_unlock(&stdin_mutex);
 407       ssize_t bytes = read(0, buf, sizeof(buf));
 408       if (bytes < 0) {
 409         if (errno == EINTR)
 410           continue;
 411         else {
 412           loop_running = false;
 413           break;
 414         }
 415       } else if (bytes >= 0) {
 416         safe_write(size_write, &bytes, sizeof(bytes));
 417
 418         if (!check_write(stdin_write, buf, bytes))
 419           loop_running = false;
 420         break;
 421       }
 422     }
 423   }
 424
 425   safe_close(stdin_write);
 426   safe_close(control_read);
 427
 428   return NULL;
 429 }
 430
 431 void open_console() {
 432   FACTOR_ASSERT(!stdin_thread_initialized_p);
 433   safe_pipe(&control_read, &control_write);
 434   safe_pipe(&size_read, &size_write);
 435   safe_pipe(&stdin_read, &stdin_write);
 436   stdin_thread = start_thread(stdin_loop, NULL);
 437   stdin_thread_initialized_p = true;
 438   pthread_mutex_init(&stdin_mutex, NULL);
 439 }
 440
 441 // This method is used to kill the stdin_loop before exiting from factor.
 442 // An Nvidia driver bug on Linux is the reason this has to be done, see:
 443 //   http://www.nvnews.net/vbulletin/showthread.php?t=164619
 444 void close_console() {
 445   if (stdin_thread_initialized_p) {
 446     pthread_cancel(stdin_thread);
 447     pthread_join(stdin_thread, 0);
 448   }
 449 }
 450
 451 void lock_console() {
 452   FACTOR_ASSERT(stdin_thread_initialized_p);
 453   // Lock the stdin_mutex and send the stdin_loop thread a signal to interrupt
 454   // any read() it has in progress. When the stdin loop iterates again, it will
 455   // try to lock the same mutex and wait until unlock_console() is called.
 456   pthread_mutex_lock(&stdin_mutex);
 457   pthread_kill(stdin_thread, SIGUSR2);
 458 }
 459
 460 void unlock_console() {
 461   FACTOR_ASSERT(stdin_thread_initialized_p);
 462   pthread_mutex_unlock(&stdin_mutex);
 463 }
 464
 465 void ignore_ctrl_c() {
 466   sig_t ret;
 467   do {
 468     ret = signal(SIGINT, SIG_DFL);
 469   } while (ret == SIG_ERR && errno == EINTR);
 470 }
 471
 472 void handle_ctrl_c() {
 473   struct sigaction fep_sigaction;
 474   init_sigaction_with_handler(&fep_sigaction, fep_signal_handler);
 475   sigaction_safe(SIGINT, &fep_sigaction, NULL);
 476 }
 477
 478 void abort() {
 479   sig_t ret;
 480   do {
 481     ret = signal(SIGABRT, SIG_DFL);
 482   } while (ret == SIG_ERR && errno == EINTR);
 483
 484   close_console();
 485   ::abort();
 486 }
 487
 488 }