관리-도구

편집 파일: passenger_native_support.c

/* * Phusion Passenger - https://www.phusionpassenger.com/ * Copyright (c) 2010-2017 Phusion Holding B.V. * * "Passenger", "Phusion Passenger" and "Union Station" are registered * trademarks of Phusion Holding B.V. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "ruby.h" #ifdef HAVE_RUBY_IO_H /* Ruby 1.9 */ #include "ruby/intern.h" #include "ruby/io.h" #else /* Ruby 1.8 */ #include "rubysig.h" #include "rubyio.h" #include "version.h" #endif #ifdef HAVE_RUBY_VERSION_H #include "ruby/version.h" #endif #ifdef HAVE_RUBY_THREAD_H #include "ruby/thread.h" #endif #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <sys/wait.h> #include <sys/un.h> #include <sys/socket.h> #include <sys/uio.h> #include <sys/time.h> #include <sys/resource.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <limits.h> #include <grp.h> #include <signal.h> #include <pthread.h> #ifdef HAVE_ALLOCA_H #include <alloca.h> #endif #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) #define HAVE_KQUEUE #include <sys/event.h> #include <sys/time.h> #endif #define MIN(a, b) (((a) < (b)) ? (a) : (b)) #ifndef RARRAY_LEN #define RARRAY_LEN(ary) RARRAY(ary)->len #endif #ifndef RSTRING_PTR #define RSTRING_PTR(str) RSTRING(str)->ptr #endif #ifndef RSTRING_LEN #define RSTRING_LEN(str) RSTRING(str)->len #endif #if !defined(RUBY_UBF_IO) && defined(RB_UBF_DFL) /* MacRuby compatibility */ #define RUBY_UBF_IO RB_UBF_DFL #endif #ifndef IOV_MAX /* Linux doesn't define IOV_MAX in limits.h for some reason. */ #define IOV_MAX sysconf(_SC_IOV_MAX) #endif #ifdef HAVE_RB_THREAD_IO_BLOCKING_REGION /* Ruby doesn't define this function in its headers */ VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd); #endif static VALUE mPassenger; static VALUE mNativeSupport; static VALUE S_ProcessTimes; #ifdef HAVE_KQUEUE static VALUE cFileSystemWatcher; #endif /* * call-seq: disable_stdio_buffering * * Disables any kind of buffering on the C +stdout+ and +stderr+ variables, * so that +fprintf()+ on +stdout+ and +stderr+ have immediate effect. */ static VALUE disable_stdio_buffering(VALUE self) { setvbuf(stdout, NULL, _IONBF, 0); setvbuf(stderr, NULL, _IONBF, 0); return Qnil; } /** * Split the given string into an hash. Keys and values are obtained by splitting the * string using the null character as the delimitor. */ static VALUE split_by_null_into_hash(VALUE self, VALUE data) { const char *cdata = RSTRING_PTR(data); unsigned long len = RSTRING_LEN(data); const char *begin = cdata; const char *current = cdata; const char *end = cdata + len; VALUE result, key, value; result = rb_hash_new(); while (current < end) { if (*current == '\0') { key = rb_str_substr(data, begin - cdata, current - begin); begin = current = current + 1; while (current < end) { if (*current == '\0') { value = rb_str_substr(data, begin - cdata, current - begin);; begin = current = current + 1; rb_hash_aset(result, key, value); break; } else { current++; } } } else { current++; } } return result; } typedef struct { /* The IO vectors in this group. */ struct iovec *io_vectors; /* The number of IO vectors in io_vectors. */ unsigned int count; /* The combined size of all IO vectors in this group. */ ssize_t total_size; } IOVectorGroup; /* Given that _bytes_written_ bytes in _group_ had been successfully written, * update the information in _group_ so that the next writev() call doesn't * write the already written bytes. */ static void update_group_written_info(IOVectorGroup *group, ssize_t bytes_written) { unsigned int i; size_t counter; struct iovec *current_vec; /* Find the last vector that contains data that had already been written. */ counter = 0; for (i = 0; i < group->count; i++) { counter += group->io_vectors[i].iov_len; if (counter == (size_t) bytes_written) { /* Found. In fact, all vectors up to this one contain exactly * bytes_written bytes. So discard all these vectors. */ group->io_vectors += i + 1; group->count -= i + 1; group->total_size -= bytes_written; return; } else if (counter > (size_t) bytes_written) { /* Found. Discard all vectors before this one, and * truncate this vector. */ group->io_vectors += i; group->count -= i; group->total_size -= bytes_written; current_vec = &group->io_vectors[0]; current_vec->iov_base = ((char *) current_vec->iov_base) + current_vec->iov_len - (counter - bytes_written); current_vec->iov_len = counter - bytes_written; return; } } rb_raise(rb_eRuntimeError, "writev() returned an unexpected result"); } #ifndef TRAP_BEG typedef struct { int filedes; const struct iovec *iov; int iovcnt; } WritevWrapperData; #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) static void * writev_wrapper(void *ptr) { WritevWrapperData *data = (WritevWrapperData *) ptr; return (void *) writev(data->filedes, data->iov, data->iovcnt); } #else static VALUE writev_wrapper(void *ptr) { WritevWrapperData *data = (WritevWrapperData *) ptr; return (VALUE) writev(data->filedes, data->iov, data->iovcnt); } #endif #endif static VALUE f_generic_writev(VALUE fd, VALUE *array_of_components, unsigned int count) { VALUE components, str; unsigned int total_size, total_components, ngroups; IOVectorGroup *groups; unsigned int i, j, group_offset, vector_offset; unsigned long long ssize_max; ssize_t ret; int done, fd_num, e; #ifndef TRAP_BEG WritevWrapperData writev_wrapper_data; #endif /* First determine the number of components that we have. */ total_components = 0; for (i = 0; i < count; i++) { Check_Type(array_of_components[i], T_ARRAY); total_components += (unsigned int) RARRAY_LEN(array_of_components[i]); } if (total_components == 0) { return NUM2INT(0); } /* A single writev() call can only accept IOV_MAX vectors, so we * may have to split the components into groups and perform * multiple writev() calls, one per group. Determine the number * of groups needed, how big each group should be and allocate * memory for them. */ if (total_components % IOV_MAX == 0) { ngroups = total_components / IOV_MAX; groups = alloca(ngroups * sizeof(IOVectorGroup)); if (groups == NULL) { rb_raise(rb_eNoMemError, "Insufficient stack space."); } memset(groups, 0, ngroups * sizeof(IOVectorGroup)); for (i = 0; i < ngroups; i++) { groups[i].io_vectors = alloca(IOV_MAX * sizeof(struct iovec)); if (groups[i].io_vectors == NULL) { rb_raise(rb_eNoMemError, "Insufficient stack space."); } groups[i].count = IOV_MAX; } } else { ngroups = total_components / IOV_MAX + 1; groups = alloca(ngroups * sizeof(IOVectorGroup)); if (groups == NULL) { rb_raise(rb_eNoMemError, "Insufficient stack space."); } memset(groups, 0, ngroups * sizeof(IOVectorGroup)); for (i = 0; i < ngroups - 1; i++) { groups[i].io_vectors = alloca(IOV_MAX * sizeof(struct iovec)); if (groups[i].io_vectors == NULL) { rb_raise(rb_eNoMemError, "Insufficient stack space."); } groups[i].count = IOV_MAX; } groups[ngroups - 1].io_vectors = alloca((total_components % IOV_MAX) * sizeof(struct iovec)); if (groups[ngroups - 1].io_vectors == NULL) { rb_raise(rb_eNoMemError, "Insufficient stack space."); } groups[ngroups - 1].count = total_components % IOV_MAX; } /* Now distribute the components among the groups, filling the iovec * array in each group. Also calculate the total data size while we're * at it. */ total_size = 0; group_offset = 0; vector_offset = 0; for (i = 0; i < count; i++) { components = array_of_components[i]; for (j = 0; j < (unsigned int) RARRAY_LEN(components); j++) { str = rb_ary_entry(components, j); str = rb_obj_as_string(str); total_size += (unsigned int) RSTRING_LEN(str); /* I know writev() doesn't write to iov_base, but on some * platforms it's still defined as non-const char * * :-( */ groups[group_offset].io_vectors[vector_offset].iov_base = (char *) RSTRING_PTR(str); groups[group_offset].io_vectors[vector_offset].iov_len = RSTRING_LEN(str); groups[group_offset].total_size += RSTRING_LEN(str); vector_offset++; if (vector_offset == groups[group_offset].count) { group_offset++; vector_offset = 0; } } } /* We don't compare to SSIZE_MAX directly in order to shut up a compiler warning on OS X Snow Leopard. */ ssize_max = SSIZE_MAX; if (total_size > ssize_max) { rb_raise(rb_eArgError, "The total size of the components may not be larger than SSIZE_MAX."); } /* Write the data. */ fd_num = NUM2INT(fd); for (i = 0; i < ngroups; i++) { /* Wait until the file descriptor becomes writable before writing things. */ rb_thread_fd_writable(fd_num); done = 0; while (!done) { #ifdef TRAP_BEG TRAP_BEG; ret = writev(fd_num, groups[i].io_vectors, groups[i].count); TRAP_END; #else writev_wrapper_data.filedes = fd_num; writev_wrapper_data.iov = groups[i].io_vectors; writev_wrapper_data.iovcnt = groups[i].count; #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) ret = (ssize_t) rb_thread_call_without_gvl(writev_wrapper, &writev_wrapper_data, RUBY_UBF_IO, NULL); #elif defined(HAVE_RB_THREAD_IO_BLOCKING_REGION) ret = (ssize_t) rb_thread_io_blocking_region(writev_wrapper, &writev_wrapper_data, fd_num); #else ret = (ssize_t) rb_thread_blocking_region(writev_wrapper, &writev_wrapper_data, RUBY_UBF_IO, 0); #endif #endif if (ret == -1) { /* If the error is something like EAGAIN, yield to another * thread until the file descriptor becomes writable again. * In case of other errors, raise an exception. */ if (!rb_io_wait_writable(fd_num)) { rb_sys_fail("writev()"); } } else if (ret < groups[i].total_size) { /* Not everything in this group has been written. Retry without * writing the bytes that been successfully written. */ e = errno; update_group_written_info(&groups[i], ret); errno = e; rb_io_wait_writable(fd_num); } else { done = 1; } } } return INT2NUM(total_size); } /** * Writes all of the strings in the +components+ array into the given file * descriptor using the +writev()+ system call. Unlike IO#write, this method * does not require one to concatenate all those strings into a single buffer * in order to send the data in a single system call. Thus, #writev is a great * way to perform zero-copy I/O. * * Unlike the raw writev() system call, this method ensures that all given * data is written before returning, by performing multiple writev() calls * and whatever else is necessary. * * writev(@socket.fileno, ["hello ", "world", "\n"]) */ static VALUE f_writev(VALUE self, VALUE fd, VALUE components) { return f_generic_writev(fd, &components, 1); } /** * Like #writev, but accepts two arrays. The data is written in the given order. * * writev2(@socket.fileno, ["hello ", "world", "\n"], ["another ", "message\n"]) */ static VALUE f_writev2(VALUE self, VALUE fd, VALUE components1, VALUE components2) { VALUE array_of_components[2] = { components1, components2 }; return f_generic_writev(fd, array_of_components, 2); } /** * Like #writev, but accepts three arrays. The data is written in the given order. * * writev3(@socket.fileno, * ["hello ", "world", "\n"], * ["another ", "message\n"], * ["yet ", "another ", "one", "\n"]) */ static VALUE f_writev3(VALUE self, VALUE fd, VALUE components1, VALUE components2, VALUE components3) { VALUE array_of_components[3] = { components1, components2, components3 }; return f_generic_writev(fd, array_of_components, 3); } static VALUE process_times(VALUE self) { struct rusage usage; unsigned long long utime, stime; if (getrusage(RUSAGE_SELF, &usage) == -1) { rb_sys_fail("getrusage()"); } utime = (unsigned long long) usage.ru_utime.tv_sec * 1000000 + usage.ru_utime.tv_usec; stime = (unsigned long long) usage.ru_stime.tv_sec * 1000000 + usage.ru_stime.tv_usec; return rb_struct_new(S_ProcessTimes, rb_ull2inum(utime), rb_ull2inum(stime)); } static void * detach_process_main(void *arg) { pid_t pid = (pid_t) (long) arg; int ret; do { ret = waitpid(pid, NULL, 0); } while (ret == -1 && errno == EINTR); return NULL; } static VALUE detach_process(VALUE self, VALUE pid) { pthread_t thr; pthread_attr_t attr; size_t stack_size = 96 * 1024; unsigned long min_stack_size; int stack_min_size_defined; int round_stack_size; #ifdef PTHREAD_STACK_MIN // PTHREAD_STACK_MIN may not be a constant macro so we need // to evaluate it dynamically. min_stack_size = PTHREAD_STACK_MIN; stack_min_size_defined = 1; #else // Assume minimum stack size is 128 KB. min_stack_size = 128 * 1024; stack_min_size_defined = 0; #endif if (stack_size != 0 && stack_size < min_stack_size) { stack_size = min_stack_size; round_stack_size = !stack_min_size_defined; } else { round_stack_size = 1; } if (round_stack_size) { // Round stack size up to page boundary. long page_size; #if defined(_SC_PAGESIZE) page_size = sysconf(_SC_PAGESIZE); #elif defined(_SC_PAGE_SIZE) page_size = sysconf(_SC_PAGE_SIZE); #elif defined(PAGESIZE) page_size = sysconf(PAGESIZE); #elif defined(PAGE_SIZE) page_size = sysconf(PAGE_SIZE); #else page_size = getpagesize(); #endif if (stack_size % page_size != 0) { stack_size = stack_size - (stack_size % page_size) + page_size; } } pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, 1); pthread_attr_setstacksize(&attr, stack_size); pthread_create(&thr, &attr, detach_process_main, (void *) NUM2LONG(pid)); pthread_attr_destroy(&attr); return Qnil; } /** * Freeze the current process forever. On Ruby 1.9 this never unlocks the GIL. * Useful for testing purposes. */ static VALUE freeze_process(VALUE self) { while (1) { usleep(60 * 1000000); } return Qnil; } #if defined(HAVE_KQUEUE) || defined(IN_DOXYGEN) typedef struct { VALUE klass; VALUE filenames; VALUE termination_pipe; /* File descriptor of termination_pipe. */ int termination_fd; /* Whether something went wrong during initialization. */ int preparation_error; /* Information for kqueue. */ unsigned int events_len; int *fds; unsigned int fds_len; int kq; /* When the watcher thread is done it'll write to this pipe * to signal the main (Ruby) thread. */ int notification_fd[2]; /* When the main (Ruby) thread is interrupted it'll write to * this pipe to tell the watcher thread to exit. */ int interruption_fd[2]; } FSWatcher; typedef struct { int fd; ssize_t ret; char byte; int error; } FSWatcherReadByteData; static void fs_watcher_real_close(FSWatcher *watcher) { unsigned int i; if (watcher->kq != -1) { close(watcher->kq); watcher->kq = -1; } if (watcher->notification_fd[0] != -1) { close(watcher->notification_fd[0]); watcher->notification_fd[0] = -1; } if (watcher->notification_fd[1] != -1) { close(watcher->notification_fd[1]); watcher->notification_fd[1] = -1; } if (watcher->interruption_fd[0] != -1) { close(watcher->interruption_fd[0]); watcher->interruption_fd[0] = -1; } if (watcher->interruption_fd[1] != -1) { close(watcher->interruption_fd[1]); watcher->interruption_fd[1] = -1; } if (watcher->fds != NULL) { for (i = 0; i < watcher->fds_len; i++) { close(watcher->fds[i]); } free(watcher->fds); watcher->fds = NULL; watcher->fds_len = 0; } } static void fs_watcher_free(void *obj) { FSWatcher *watcher = (FSWatcher *) obj; fs_watcher_real_close(watcher); free(watcher); } static VALUE fs_watcher_init(VALUE arg) { FSWatcher *watcher = (FSWatcher *) arg; struct kevent *events; VALUE filename; unsigned int i; uint32_t fflags; VALUE filenum; struct stat buf; int fd; /* Open each file in the filenames list and add each one to the events array. */ /* +2 for the termination pipe and the interruption pipe. */ events = alloca((RARRAY_LEN(watcher->filenames) + 2) * sizeof(struct kevent)); watcher->fds = malloc(RARRAY_LEN(watcher->filenames) * sizeof(int)); if (watcher->fds == NULL) { rb_raise(rb_eNoMemError, "Cannot allocate memory."); return Qnil; } for (i = 0; i < RARRAY_LEN(watcher->filenames); i++) { filename = rb_ary_entry(watcher->filenames, i); if (TYPE(filename) != T_STRING) { filename = rb_obj_as_string(filename); } if (stat(RSTRING_PTR(filename), &buf) == -1) { watcher->preparation_error = 1; goto end; } #ifdef O_EVTONLY fd = open(RSTRING_PTR(filename), O_EVTONLY); #else fd = open(RSTRING_PTR(filename), O_RDONLY); #endif if (fd == -1) { watcher->preparation_error = 1; goto end; } watcher->fds[i] = fd; watcher->fds_len++; fflags = NOTE_WRITE | NOTE_EXTEND | NOTE_RENAME | NOTE_DELETE | NOTE_REVOKE; EV_SET(&events[i], fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR, fflags, 0, 0); } watcher->events_len = watcher->fds_len; /* Create pipes for inter-thread communication. */ if (pipe(watcher->notification_fd) == -1) { rb_sys_fail("pipe()"); return Qnil; } if (pipe(watcher->interruption_fd) == -1) { rb_sys_fail("pipe()"); return Qnil; } /* Create a kqueue and register all events. */ watcher->kq = kqueue(); if (watcher->kq == -1) { rb_sys_fail("kqueue()"); return Qnil; } if (watcher->termination_pipe != Qnil) { filenum = rb_funcall(watcher->termination_pipe, rb_intern("fileno"), 0); EV_SET(&events[watcher->events_len], NUM2INT(filenum), EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0); watcher->termination_fd = NUM2INT(filenum); watcher->events_len++; } EV_SET(&events[watcher->events_len], watcher->interruption_fd[0], EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0); watcher->events_len++; if (kevent(watcher->kq, events, watcher->events_len, NULL, 0, NULL) == -1) { rb_sys_fail("kevent()"); return Qnil; } end: if (watcher->preparation_error) { for (i = 0; i < watcher->fds_len; i++) { close(watcher->fds[i]); } free(watcher->fds); watcher->fds = NULL; watcher->fds_len = 0; } return Data_Wrap_Struct(watcher->klass, NULL, fs_watcher_free, watcher); } static VALUE fs_watcher_new(VALUE klass, VALUE filenames, VALUE termination_pipe) { FSWatcher *watcher; VALUE result; int status; Check_Type(filenames, T_ARRAY); watcher = (FSWatcher *) calloc(1, sizeof(FSWatcher)); if (watcher == NULL) { rb_raise(rb_eNoMemError, "Cannot allocate memory."); return Qnil; } watcher->klass = klass; watcher->filenames = filenames; watcher->termination_pipe = termination_pipe; watcher->termination_fd = -1; watcher->kq = -1; watcher->notification_fd[0] = -1; watcher->notification_fd[1] = -1; watcher->interruption_fd[0] = -1; watcher->interruption_fd[1] = -1; result = rb_protect(fs_watcher_init, (VALUE) watcher, &status); if (status) { fs_watcher_free(watcher); rb_jump_tag(status); return Qnil; } else { return result; } } static void * fs_watcher_wait_on_kqueue(void *arg) { FSWatcher *watcher = (FSWatcher *) arg; struct kevent *events; int nevents; ssize_t ret; events = alloca(sizeof(struct kevent) * watcher->events_len); nevents = kevent(watcher->kq, NULL, 0, events, watcher->events_len, NULL); if (nevents == -1) { ret = write(watcher->notification_fd[1], "e", 1); } else if (nevents >= 1 && ( events[0].ident == (uintptr_t) watcher->termination_fd || events[0].ident == (uintptr_t) watcher->interruption_fd[0] )) { ret = write(watcher->notification_fd[1], "t", 1); } else { ret = write(watcher->notification_fd[1], "f", 1); } if (ret == -1) { close(watcher->notification_fd[1]); watcher->notification_fd[1] = -1; } return NULL; } static VALUE fs_watcher_wait_fd(VALUE _fd) { int fd = (int) _fd; rb_thread_wait_fd(fd); return Qnil; } #ifndef TRAP_BEG #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) static void * fs_watcher_read_byte_from_fd_wrapper(void *_arg) { FSWatcherReadByteData *data = (FSWatcherReadByteData *) _arg; data->ret = read(data->fd, &data->byte, 1); data->error = errno; return NULL; } #else static VALUE fs_watcher_read_byte_from_fd_wrapper(void *_arg) { FSWatcherReadByteData *data = (FSWatcherReadByteData *) _arg; data->ret = read(data->fd, &data->byte, 1); data->error = errno; return Qnil; } #endif #endif static VALUE fs_watcher_read_byte_from_fd(VALUE _arg) { FSWatcherReadByteData *data = (FSWatcherReadByteData *) _arg; #if defined(TRAP_BEG) TRAP_BEG; data->ret = read(data->fd, &data->byte, 1); TRAP_END; data->error = errno; #elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) rb_thread_call_without_gvl2(fs_watcher_read_byte_from_fd_wrapper, data, RUBY_UBF_IO, NULL); #elif defined(HAVE_RB_THREAD_IO_BLOCKING_REGION) rb_thread_io_blocking_region(fs_watcher_read_byte_from_fd_wrapper, data, data->fd); #else rb_thread_blocking_region(fs_watcher_read_byte_from_fd_wrapper, data, RUBY_UBF_IO, 0); #endif return Qnil; } static VALUE fs_watcher_wait_for_change(VALUE self) { FSWatcher *watcher; pthread_t thr; ssize_t ret; int e, interrupted = 0; FSWatcherReadByteData read_data; Data_Get_Struct(self, FSWatcher, watcher); if (watcher->preparation_error) { return Qfalse; } /* Spawn a thread, and let the thread perform the blocking kqueue * wait. When kevent() returns the thread will write its status to the * notification pipe. In the mean time we let the Ruby interpreter wait * on the other side of the pipe for us so that we don't block Ruby * threads. */ e = pthread_create(&thr, NULL, fs_watcher_wait_on_kqueue, watcher); if (e != 0) { errno = e; rb_sys_fail("pthread_create()"); return Qnil; } /* Note that rb_thread_wait() does not wait for the fd when the app * is single threaded, so we must join the thread after we've read * from the notification fd. */ rb_protect(fs_watcher_wait_fd, (VALUE) watcher->notification_fd[0], &interrupted); if (interrupted) { /* We got interrupted so tell the watcher thread to exit. */ ret = write(watcher->interruption_fd[1], "x", 1); if (ret == -1) { e = errno; fs_watcher_real_close(watcher); errno = e; rb_sys_fail("write() to interruption pipe"); return Qnil; } pthread_join(thr, NULL); /* Now clean up stuff. */ fs_watcher_real_close(watcher); rb_jump_tag(interrupted); return Qnil; } read_data.fd = watcher->notification_fd[0]; rb_protect(fs_watcher_read_byte_from_fd, (VALUE) &read_data, &interrupted); if (interrupted) { /* We got interrupted so tell the watcher thread to exit. */ ret = write(watcher->interruption_fd[1], "x", 1); if (ret == -1) { e = errno; fs_watcher_real_close(watcher); errno = e; rb_sys_fail("write() to interruption pipe"); return Qnil; } pthread_join(thr, NULL); /* Now clean up stuff. */ fs_watcher_real_close(watcher); rb_jump_tag(interrupted); return Qnil; } pthread_join(thr, NULL); if (read_data.ret == -1) { fs_watcher_real_close(watcher); errno = read_data.error; rb_sys_fail("read()"); return Qnil; } else if (read_data.ret == 0) { fs_watcher_real_close(watcher); errno = read_data.error; rb_raise(rb_eRuntimeError, "Unknown error: unexpected EOF"); return Qnil; } else if (read_data.byte == 't') { /* termination_fd or interruption_fd became readable */ return Qnil; } else if (read_data.byte == 'f') { /* a file or directory changed */ return Qtrue; } else { fs_watcher_real_close(watcher); errno = read_data.error; rb_raise(rb_eRuntimeError, "Unknown error: unexpected notification data"); return Qnil; } } static VALUE fs_watcher_close(VALUE self) { FSWatcher *watcher; Data_Get_Struct(self, FSWatcher, watcher); fs_watcher_real_close(watcher); return Qnil; } #endif /***************************/ void Init_passenger_native_support() { struct sockaddr_un addr; /* Only defined on Ruby >= 1.9.3 */ #ifdef RUBY_API_VERSION_CODE if (ruby_api_version[0] != RUBY_API_VERSION_MAJOR || ruby_api_version[1] != RUBY_API_VERSION_MINOR || ruby_api_version[2] != RUBY_API_VERSION_TEENY) { fprintf(stderr, " --> passenger_native_support was compiled for Ruby API version %d.%d.%d, " "but you're currently running a Ruby interpreter with API version %d.%d.%d.\n", RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR, RUBY_API_VERSION_TEENY, ruby_api_version[0], ruby_api_version[1], ruby_api_version[2]); fprintf(stderr, " Refusing to load existing passenger_native_support.\n"); return; } /* Because native extensions may be linked to libruby, loading * a Ruby 1.9 native extension may not fail on Ruby 1.8 (even though * the extension will crash later on). We detect such a case here and * abort early. */ if (strlen(ruby_version) >= sizeof("1.8.7") - 1 && ruby_version[0] == '1' && ruby_version[1] == '.' && ruby_version[2] == '8') { fprintf(stderr, " --> passenger_native_support was compiled for Ruby %d.%d, " "but you're currently running Ruby %s\n", RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR, ruby_version); fprintf(stderr, " Refusing to load existing passenger_native_support.\n"); return; } #else /* Ruby 1.8 - 1.9.2 */ /* We may not have included Ruby 1.8's version.h because of compiler * header file search paths, so we can't rely on RUBY_VERSION being * defined. */ #ifdef RUBY_VERSION #define ESTIMATED_RUBY_VERSION RUBY_VERSION #else #ifdef HAVE_RUBY_IO_H #define ESTIMATED_RUBY_VERSION "1.9.1 or 1.9.2" #else #define ESTIMATED_RUBY_VERSION "1.8" #endif #endif #ifdef HAVE_RUBY_IO_H #define ESTIMATED_RUBY_MINOR_VERSION '9' #else #define ESTIMATED_RUBY_MINOR_VERSION '8' #endif #ifdef HAVE_RUBY_VERSION if (strlen(ruby_version) < sizeof("1.8.7") - 1 || ruby_version[0] != '1' || ruby_version[1] != '.' || ruby_version[2] != ESTIMATED_RUBY_MINOR_VERSION) { fprintf(stderr, " --> passenger_native_support was compiled for Ruby %s, " "but you're currently running Ruby %s\n", ESTIMATED_RUBY_VERSION, ruby_version); fprintf(stderr, " Refusing to load existing passenger_native_support.\n"); return; } #endif #endif mPassenger = rb_define_module("PhusionPassenger"); /* * Utility functions for accessing system functionality. */ mNativeSupport = rb_define_module_under(mPassenger, "NativeSupport"); S_ProcessTimes = rb_struct_define("ProcessTimes", "utime", "stime", NULL); rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0); rb_define_singleton_method(mNativeSupport, "split_by_null_into_hash", split_by_null_into_hash, 1); rb_define_singleton_method(mNativeSupport, "writev", f_writev, 2); rb_define_singleton_method(mNativeSupport, "writev2", f_writev2, 3); rb_define_singleton_method(mNativeSupport, "writev3", f_writev3, 4); rb_define_singleton_method(mNativeSupport, "process_times", process_times, 0); rb_define_singleton_method(mNativeSupport, "detach_process", detach_process, 1); rb_define_singleton_method(mNativeSupport, "freeze_process", freeze_process, 0); #ifdef HAVE_KQUEUE cFileSystemWatcher = rb_define_class_under(mNativeSupport, "FileSystemWatcher", rb_cObject); rb_define_singleton_method(cFileSystemWatcher, "_new", fs_watcher_new, 2); rb_define_method(cFileSystemWatcher, "wait_for_change", fs_watcher_wait_for_change, 0); rb_define_method(cFileSystemWatcher, "close", fs_watcher_close, 0); rb_undef_alloc_func(cFileSystemWatcher); #endif /* The maximum length of a Unix socket path, including terminating null. */ rb_define_const(mNativeSupport, "UNIX_PATH_MAX", INT2NUM(sizeof(addr.sun_path))); /* The maximum size of the data that may be passed to #writev. */ rb_define_const(mNativeSupport, "SSIZE_MAX", LL2NUM(SSIZE_MAX)); }