sleepy_penguin 1.4.0 → 2.0.0

data/ext/sleepy_penguin/missing_epoll.h

@@ -0,0 +1,30 @@
+#ifndef EPOLL_CLOEXEC
+#  define EPOLL_CLOEXEC (int)(02000000)
+#endif
+
+#ifndef HAVE_EPOLL_CREATE1
+/*
+ * fake epoll_create1() since some systems don't have it.
+ * Don't worry about thread-safety since current Ruby 1.9 won't
+ * call this without GVL.
+ */
+static int my_epoll_create1(int flags)
+{
+	int fd = epoll_create(1024); /* size ignored since 2.6.8 */
+
+	if (fd < 0 || flags == 0)
+		return fd;
+
+	if ((flags & EPOLL_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1))
+		goto err;
+	return fd;
+err:
+	{
+		int saved_errno = errno;
+		close(fd);
+		errno = saved_errno;
+		return -1;
+	}
+}
+#  define epoll_create1 my_epoll_create1
+#endif

data/ext/sleepy_penguin/missing_inotify.h

@@ -0,0 +1,57 @@
+#ifndef IN_CLOEXEC
+#  define IN_CLOEXEC 02000000
+#endif
+#ifndef IN_NONBLOCK
+#  define IN_NONBLOCK O_NONBLOCK
+#endif
+#ifndef IN_ATTRIB
+#  define IN_ATTRIB 0x00000004
+#endif
+#ifndef IN_ONLYDIR
+#  define IN_ONLYDIR 0x01000000
+#endif
+#ifndef IN_DONT_FOLLOW
+#  define IN_DONT_FOLLOW 0x02000000
+#endif
+#ifndef IN_EXCL_UNLINK
+#  define IN_EXCL_UNLINK 0x04000000
+#endif
+#ifndef IN_MASK_ADD
+#  define IN_MASK_ADD 0x20000000
+#endif
+#ifndef IN_ONESHOT
+#  define IN_ONESHOT 0x80000000
+#endif
+
+#ifndef HAVE_INOTIFY_INIT1
+/*
+ * fake inotify_init1() since some systems don't have it
+ * Don't worry about thread-safety since current Ruby 1.9 won't
+ * call this without GVL.
+ */
+static int my_inotify_init1(int flags)
+{
+	int fd = inotify_init();
+	int tmp;
+
+	if (fd < 0)
+		return fd;
+	if ((flags & IN_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1))
+		goto fcntl_err;
+	if (flags & IN_NONBLOCK) {
+		tmp = fcntl(fd, F_GETFL);
+		if (tmp == -1)
+			goto fcntl_err;
+		if ((fcntl(fd, F_SETFL, tmp | O_NONBLOCK) != 0))
+			goto fcntl_err;
+	}
+
+	return fd;
+fcntl_err:
+	tmp = errno;
+	close(fd);
+	errno = tmp;
+	rb_sys_fail("fcntl");
+}
+# define inotify_init1 my_inotify_init1
+#endif /* HAVE_INOTIFY_INIT1 */

data/ext/sleepy_penguin/signalfd.c

@@ -0,0 +1,335 @@
+#ifdef HAVE_SYS_SIGNALFD_H
+#include "sleepy_penguin.h"
+#include <signal.h>
+#include <sys/signalfd.h>
+static ID id_for_fd, id_list;
+static VALUE ssi_members;
+static VALUE cSigInfo;
+
+/* converts a Symbol, String, or Fixnum to an integer signal */
+static int sig2int(VALUE sig)
+{
+	static VALUE list;
+	const char *ptr;
+	long len;
+
+	if (TYPE(sig) == T_FIXNUM)
+		return FIX2INT(sig);
+
+	sig = rb_obj_as_string(sig);
+	len = RSTRING_LEN(sig);
+	ptr = RSTRING_PTR(sig);
+
+	if (len > 3 && !memcmp("SIG", ptr, 3))
+		sig = rb_str_new(ptr + 3, len - 3);
+
+	if (!list) {
+		VALUE tmp = rb_const_get(rb_cObject, rb_intern("Signal"));
+
+		list = rb_funcall(tmp, rb_intern("list"), 0, 0);
+		rb_global_variable(&list);
+	}
+
+	sig = rb_hash_aref(list, sig);
+	if (NIL_P(sig))
+		rb_raise(rb_eArgError, "invalid signal: %s", ptr);
+
+	return NUM2INT(sig);
+}
+
+/* fills sigset_t with an Array of signals */
+static void value2sigset(sigset_t *mask, VALUE set)
+{
+	sigemptyset(mask);
+
+	switch (TYPE(set)) {
+	case T_NIL: return;
+	case T_ARRAY: {
+		VALUE *ptr = RARRAY_PTR(set);
+		long len = RARRAY_LEN(set);
+
+		while (--len >= 0)
+			sigaddset(mask, sig2int(*ptr++));
+		}
+		break;
+	default:
+		sigaddset(mask, sig2int(set));
+	}
+}
+
+static int cur_flags(int fd)
+{
+	int rv = 0;
+#ifdef SFD_CLOEXEC
+	{
+		int flags = fcntl(fd, F_GETFD);
+		if (flags == -1) rb_sys_fail("fcntl(F_GETFD)");
+		if (flags & FD_CLOEXEC) rv |= SFD_CLOEXEC;
+	}
+#endif
+#ifdef SFD_NONBLOCK
+	{
+		int flags = fcntl(fd, F_GETFL);
+		if (flags == -1) rb_sys_fail("fcntl(F_GETFL)");
+		if (flags & O_NONBLOCK) rv |= SFD_NONBLOCK;
+	}
+#endif
+	return rv;
+}
+
+/*
+ * call-seq:
+ *	sfd.update!(signals[, flags])	-> sfd
+ *
+ * Updates the signal mask watched for by the given +sfd+.
+ * Takes the same arguments as SignalFD.new.
+ */
+static VALUE update_bang(int argc, VALUE *argv, VALUE self)
+{
+	VALUE vmask, vflags;
+	sigset_t mask;
+	int flags;
+	int fd = rb_sp_fileno(self);
+	int rc;
+
+	rb_scan_args(argc, argv, "02", &vmask, &vflags);
+	flags = NIL_P(vflags) ? cur_flags(fd) : rb_sp_get_flags(self, vflags);
+	value2sigset(&mask, vmask);
+
+	rc = signalfd(fd, &mask, flags);
+	if (rc == -1)
+		rb_sys_fail("signalfd");
+	return self;
+}
+
+/*
+ * call-seq:
+ *	SignalFD.new(signals[, flags])	-> SignalFD IO object
+ *
+ * Creates a new SignalFD object to watch given +signals+ with +flags+.
+ *
+ * +signals+ is an Array of signal names or a single signal name that
+ * Signal.trap understands:
+ *
+ *	signals = [ :USR1, "USR2" ]
+ *	signals = :USR1
+ *	signals = 15
+ *
+ * Starting with Linux 2.6.27, +flags+ may be a mask that consists of any
+ * of the following:
+ *
+ * - :CLOEXEC - set the close-on-exec flag on the new object
+ * - :NONBLOCK - set the non-blocking I/O flag on the new object
+ */
+static VALUE s_new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE vmask, vflags;
+	sigset_t mask;
+	int flags;
+	int fd;
+
+	rb_scan_args(argc, argv, "02", &vmask, &vflags);
+	flags = rb_sp_get_flags(klass, vflags);
+	value2sigset(&mask, vmask);
+
+	fd = signalfd(-1, &mask, flags);
+	if (fd == -1) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+			rb_gc();
+			fd = signalfd(-1, &mask, flags);
+		}
+		if (fd == -1)
+			rb_sys_fail("signalfd");
+	}
+
+	return rb_funcall(klass, id_for_fd, 1, INT2NUM(fd));
+}
+
+static VALUE ssi_alloc(VALUE klass)
+{
+	struct signalfd_siginfo *ssi = ALLOC(struct signalfd_siginfo);
+
+	return Data_Wrap_Struct(klass, NULL, -1, ssi);
+}
+
+/* :nodoc: */
+static VALUE ssi_init(VALUE self)
+{
+	struct signalfd_siginfo *ssi = DATA_PTR(self);
+
+	memset(ssi, 0, sizeof(struct signalfd_siginfo));
+	return self;
+}
+
+static VALUE sfd_read(void *args)
+{
+	struct signalfd_siginfo *ssi = args;
+	int fd = ssi->ssi_fd;
+	ssize_t r = read(fd, ssi, sizeof(struct signalfd_siginfo));
+
+	return (VALUE)r;
+}
+
+/*
+ * call-seq:
+ *	sfd.take([nonblock]) -> SignalFD::SigInfo object or +nil+
+ *
+ * Returns the next SigInfo object representing a received signal.
+ * If +nonblock+ is specified and true, this may return +nil+
+ */
+static VALUE sfd_take(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rv = ssi_alloc(cSigInfo);
+	struct signalfd_siginfo *ssi = DATA_PTR(rv);
+	ssize_t r;
+	int fd;
+	VALUE nonblock;
+
+	rb_scan_args(argc, argv, "01", &nonblock);
+	fd = rb_sp_fileno(self);
+	if (RTEST(nonblock))
+		rb_sp_set_nonblock(fd);
+	else
+		blocking_io_prepare(fd);
+retry:
+	ssi->ssi_fd = fd;
+	r = (ssize_t)rb_sp_io_region(sfd_read, ssi);
+	if (r == -1) {
+		if (errno == EAGAIN && RTEST(nonblock))
+			return Qnil;
+		if (rb_io_wait_readable(fd))
+			goto retry;
+		rb_sys_fail("read(signalfd)");
+	}
+	if (r == 0)
+		rb_eof_error(); /* does this ever happen? */
+	return rv;
+}
+
+#define SSI_READER_FUNC(FN, FIELD) \
+	static VALUE ssi_##FIELD(VALUE self) { \
+		struct signalfd_siginfo *ssi = DATA_PTR(self); \
+		return FN(ssi->ssi_##FIELD); \
+	}
+
+SSI_READER_FUNC(UINT2NUM,signo)
+SSI_READER_FUNC(INT2NUM,errno)
+SSI_READER_FUNC(INT2NUM,code)
+SSI_READER_FUNC(UINT2NUM,pid)
+SSI_READER_FUNC(UINT2NUM,uid)
+SSI_READER_FUNC(INT2NUM,fd)
+SSI_READER_FUNC(UINT2NUM,tid)
+SSI_READER_FUNC(UINT2NUM,band)
+SSI_READER_FUNC(UINT2NUM,overrun)
+SSI_READER_FUNC(UINT2NUM,trapno)
+SSI_READER_FUNC(INT2NUM,status)
+SSI_READER_FUNC(INT2NUM,int)
+SSI_READER_FUNC(ULL2NUM,ptr)
+SSI_READER_FUNC(ULL2NUM,utime)
+SSI_READER_FUNC(ULL2NUM,stime)
+SSI_READER_FUNC(ULL2NUM,addr)
+
+void sleepy_penguin_init_signalfd(void)
+{
+	VALUE mSleepyPenguin, cSignalFD;
+
+	mSleepyPenguin = rb_define_module("SleepyPenguin");
+
+	/*
+	 * Document-class: SleepyPenguin::SignalFD
+	 *
+	 * A SignalFD is an IO object for accepting signals.  It provides
+	 * an alternative to Signal.trap that may be monitored using
+	 * IO.select or Epoll.
+	 *
+	 * SignalFD appears interact unpredictably with YARV (Ruby 1.9) signal
+	 * handling and has been unreliable in our testing. Since Ruby has a
+	 * decent signal handling interface anyways, this class is less useful
+	 * than signalfd() in a C-only environment.
+	 *
+	 * It is not supported at all under (Matz) Ruby 1.8.
+	 */
+	cSignalFD = rb_define_class_under(mSleepyPenguin, "SignalFD", rb_cIO);
+
+	/*
+	 * Document-class: SleepyPenguin::SignalFD::SigInfo
+	 *
+	 * This class is returned by SignalFD#take.  It consists of the
+	 * following read-only members:
+	 *
+	 * - signo - signal number
+	 * - errno - error number
+	 * - code - signal code
+	 * - pid - PID of sender
+	 * - uid - real UID of sender
+	 * - fd - file descriptor (SIGIO)
+	 * - tid - kernel timer ID (POSIX timers)
+	 * - band - band event (SIGIO)
+	 * - overrun - POSIX timer overrun count
+	 * - trapno - trap number that caused hardware-generated signal
+	 * - exit status or signal (SIGCHLD)
+	 * - int - integer sent by sigqueue(2)
+	 * - ptr - Pointer sent by sigqueue(2)
+	 * - utime - User CPU time consumed (SIGCHLD)
+	 * - stime - System CPU time consumed (SIGCHLD)
+	 * - addr - address that generated a hardware-generated signal
+	 */
+	cSigInfo = rb_define_class_under(cSignalFD, "SigInfo", rb_cObject);
+	rb_define_alloc_func(cSigInfo, ssi_alloc);
+	rb_define_private_method(cSigInfo, "initialize", ssi_init, 0);
+
+	/* TODO:  si_code values */
+
+	rb_define_singleton_method(cSignalFD, "new", s_new, -1);
+#ifdef SFD_NONBLOCK
+	NODOC_CONST(cSignalFD, "NONBLOCK", INT2NUM(SFD_NONBLOCK));
+#endif
+#ifdef SFD_CLOEXEC
+	NODOC_CONST(cSignalFD, "CLOEXEC", INT2NUM(SFD_CLOEXEC));
+#endif
+
+	rb_define_method(cSignalFD, "take", sfd_take, -1);
+	rb_define_method(cSignalFD, "update!", update_bang, -1);
+	id_for_fd = rb_intern("for_fd");
+	ssi_members = rb_ary_new();
+
+	NODOC_CONST(cSigInfo, "MEMBERS", ssi_members);
+
+	/*
+	 * the minimum signal number for real-time signals,
+	 * 34 on NPTL-based systems
+	 */
+	rb_define_const(cSignalFD, "RTMIN", INT2NUM(SIGRTMIN));
+
+	/*
+	 * the maximum signal number for real-time signals,
+	 * 64 on NPTL-based systems
+	 */
+	rb_define_const(cSignalFD, "RTMAX", INT2NUM(SIGRTMAX));
+
+#define SSI_READER(FIELD) do { \
+	  rb_define_method(cSigInfo, #FIELD, ssi_##FIELD, 0); \
+	  rb_ary_push(ssi_members, ID2SYM(rb_intern(#FIELD))); \
+	} while (0)
+
+	SSI_READER(signo);
+	SSI_READER(errno);
+	SSI_READER(code);
+	SSI_READER(pid);
+	SSI_READER(uid);
+	SSI_READER(fd);
+	SSI_READER(tid);
+	SSI_READER(band);
+	SSI_READER(overrun);
+	SSI_READER(trapno);
+	SSI_READER(status);
+	SSI_READER(int);
+	SSI_READER(ptr);
+	SSI_READER(utime);
+	SSI_READER(stime);
+	SSI_READER(addr);
+	rb_obj_freeze(ssi_members);
+
+	rb_require("sleepy_penguin/signalfd/sig_info");
+}
+#endif /* HAVE_SYS_SIGNALFD_H */

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -12,64 +12,24 @@
 #include <assert.h>
 #include <unistd.h>
 
-#if ! HAVE_RB_IO_T
-#  define rb_io_t OpenFile
-#endif
-
-#ifdef GetReadFile
-#  define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
-#else
-#  if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
-#    define FPTR_TO_FD(fptr) fileno(fptr->f)
-#  else
-#    define FPTR_TO_FD(fptr) fptr->fd
-#  endif
-#endif
-
-static int fixint_closed_p(VALUE io)
+unsigned rb_sp_get_uflags(VALUE klass, VALUE flags);
+int rb_sp_get_flags(VALUE klass, VALUE flags);
+int rb_sp_io_closed(VALUE io);
+int rb_sp_fileno(VALUE io);
+void rb_sp_set_nonblock(int fd);
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+static inline VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data)
 {
-	return (fcntl(FIX2INT(io), F_GETFD) == -1 && errno == EBADF);
-}
-
-#if defined(RFILE) && defined(HAVE_ST_FD)
-static int my_rb_io_closed(VALUE io)
-{
-	return RFILE(io)->fptr->fd < 0;
+	return rb_thread_blocking_region(func, data, RUBY_UBF_IO, 0);
 }
+#  define blocking_io_prepare(fd) ((void)(fd))
 #else
-static int my_rb_io_closed(VALUE io)
-{
-	return rb_funcall(io, rb_intern("closed?"), 0) == Qtrue;
-}
+typedef VALUE rb_blocking_function_t(void *);
+VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data);
+#  define blocking_io_prepare(fd) rb_sp_set_nonblock((fd))
 #endif
 
-static int my_io_closed(VALUE io)
-{
-	switch (TYPE(io)) {
-	case T_FIXNUM:
-		return fixint_closed_p(io);
-	case T_FILE:
-		break;
-	default:
-		io = rb_convert_type(io, T_FILE, "IO", "to_io");
-	}
-
-	return my_rb_io_closed(io);
-}
-
-static int my_fileno(VALUE io)
-{
-	rb_io_t *fptr;
-
-	switch (TYPE(io)) {
-	case T_FIXNUM: return FIX2INT(io);
-	case T_FILE:
-		GetOpenFile(io, fptr);
-		return FPTR_TO_FD(fptr);
-	}
-	io = rb_convert_type(io, T_FILE, "IO", "to_io");
-	GetOpenFile(io, fptr);
-	return FPTR_TO_FD(fptr);
-}
-
+#define NODOC_CONST(klass,name,value) \
+  rb_define_const((klass),(name),(value))
 #endif /* SLEEPY_PENGUIN_H */