sleepy_penguin 3.4.1 → 3.5.0

data/ext/sleepy_penguin/inotify.c

@@ -26,10 +26,8 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 
 	fd = inotify_init1(flags);
 	if (fd < 0) {
-		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
-			rb_gc();
+		if (rb_sp_gc_for_fd(errno))
 			fd = inotify_init1(flags);
-		}
 		if (fd < 0)
 			rb_sys_fail("inotify_init1");
 	}
@@ -136,8 +134,11 @@ static VALUE event_new(struct inotify_event *e)
 }
 
 struct inread_args {
+	VALUE self;
 	int fd;
+	int nonblock_p;
 	size_t size;
+	VALUE tmp;
 	void *buf;
 };
 
@@ -160,6 +161,7 @@ static void resize_internal_buffer(struct inread_args *args)
 
 	if (newlen > 0) {
 		args->size = (size_t)newlen;
+		rb_sp_puttlsbuf((VALUE)args->buf);
 		args->buf = rb_sp_gettlsbuf(&args->size);
 	}
 
@@ -171,56 +173,35 @@ static void resize_internal_buffer(struct inread_args *args)
 		newlen);
 }
 
-/*
- * call-seq:
- *	ino.take([nonblock]) -> Inotify::Event or nil
- *
- * Returns the next Inotify::Event processed.  May return +nil+ if +nonblock+
- * is +true+.
- */
-static VALUE take(int argc, VALUE *argv, VALUE self)
+static VALUE do_take(VALUE p)
 {
-	struct inread_args args;
-	VALUE tmp = rb_ivar_get(self, id_inotify_tmp);
-	struct inotify_event *e, *end;
-	ssize_t r;
+	struct inread_args *args = (struct inread_args *)p;
 	VALUE rv = Qnil;
-	VALUE nonblock;
-
-	if (RARRAY_LEN(tmp) > 0)
-		return rb_ary_shift(tmp);
-
-	rb_scan_args(argc, argv, "01", &nonblock);
-
-	args.fd = rb_sp_fileno(self);
-	args.size = 128;
-	args.buf = rb_sp_gettlsbuf(&args.size);
+	struct inotify_event *e, *end;
 
-	if (RTEST(nonblock))
-		rb_sp_set_nonblock(args.fd);
-	else
-		blocking_io_prepare(args.fd);
+	args->buf = rb_sp_gettlsbuf(&args->size);
 	do {
-		r = (ssize_t)rb_sp_fd_region(inread, &args, args.fd);
+		ssize_t r = (ssize_t)rb_sp_fd_region(inread, args, args->fd);
 		if (r == 0 /* Linux < 2.6.21 */
 		    ||
 		    (r < 0 && errno == EINVAL) /* Linux >= 2.6.21 */
 		   ) {
-			resize_internal_buffer(&args);
+			resize_internal_buffer(args);
 		} else if (r < 0) {
-			if (errno == EAGAIN && RTEST(nonblock))
+			if (errno == EAGAIN && args->nonblock_p)
 				return Qnil;
-			if (!rb_sp_wait(rb_io_wait_readable, self, &args.fd))
+			if (!rb_sp_wait(rb_io_wait_readable, args->self,
+					&args->fd))
 				rb_sys_fail("read(inotify)");
 		} else {
 			/* buffer in userspace to minimize read() calls */
-			end = (struct inotify_event *)((char *)args.buf + r);
-			for (e = args.buf; e < end; ) {
+			end = (struct inotify_event *)((char *)args->buf + r);
+			for (e = args->buf; e < end; ) {
 				VALUE event = event_new(e);
 				if (NIL_P(rv))
 					rv = event;
 				else
-					rb_ary_push(tmp, event);
+					rb_ary_push(args->tmp, event);
 				e = (struct inotify_event *)
 				    ((char *)e + event_len(e));
 			}
@@ -230,6 +211,37 @@ static VALUE take(int argc, VALUE *argv, VALUE self)
 	return rv;
 }
 
+/*
+ * call-seq:
+ *	ino.take([nonblock]) -> Inotify::Event or nil
+ *
+ * Returns the next Inotify::Event processed.  May return +nil+ if +nonblock+
+ * is +true+.
+ */
+static VALUE take(int argc, VALUE *argv, VALUE self)
+{
+	struct inread_args args;
+	VALUE nonblock;
+
+	args.tmp = rb_ivar_get(self, id_inotify_tmp);
+	if (RARRAY_LEN(args.tmp) > 0)
+		return rb_ary_shift(args.tmp);
+
+	rb_scan_args(argc, argv, "01", &nonblock);
+
+	args.self = self;
+	args.fd = rb_sp_fileno(self);
+	args.size = 128;
+	args.nonblock_p = RTEST(nonblock);
+
+	if (args.nonblock_p)
+		rb_sp_set_nonblock(args.fd);
+
+	args.buf = 0;
+	return rb_ensure(do_take, (VALUE)&args,
+			 rb_sp_puttlsbuf, (VALUE)args.buf);
+}
+
 /*
  * call-seq:
  *	inotify_event.events => [ :MOVED_TO, ... ]

data/ext/sleepy_penguin/kqueue.c

@@ -43,6 +43,7 @@ static VALUE mEv, mEvFilt, mNote, mVQ;
 
 struct kq_per_thread {
 	VALUE io;
+	VALUE changelist;
 	int fd;
 	int nchanges;
 	int nevents;
@@ -72,7 +73,7 @@ static int kq_fd_check(struct kq_per_thread *kpt)
 	return 1;
 }
 
-static struct kq_per_thread *kpt_get(VALUE self, int nchanges, int nevents)
+static struct kq_per_thread *kpt_get(int nchanges, int nevents)
 {
 	struct kq_per_thread *kpt;
 	size_t size;
@@ -89,8 +90,6 @@ static struct kq_per_thread *kpt_get(VALUE self, int nchanges, int nevents)
 	kpt->capa = max;
 	kpt->nchanges = nchanges;
 	kpt->nevents = nevents;
-	kpt->io = self;
-	kpt->fd = rb_sp_fileno(kpt->io);
 
 	return kpt;
 }
@@ -102,11 +101,10 @@ static struct kq_per_thread *kpt_get(VALUE self, int nchanges, int nevents)
  * Creates a new Kqueue::IO object.  This is a wrapper around the kqueue(2)
  * system call which creates a Ruby IO object around the kqueue descriptor.
  *
- * kqueue descriptors are automatically invalidated across fork, so care
- * must be taken when forking.
+ * kqueue descriptors are automatically invalidated by the OS across fork,
+ * so care must be taken when forking.
  * Setting IO#autoclose=false is recommended for applications which fork
- * after kqueue creation.  Ruby 1.8 does not have IO#autoclose=, so using
- * this class is not recommended under Ruby 1.8
+ * after kqueue creation.
  */
 static VALUE s_new(VALUE klass)
 {
@@ -203,11 +201,16 @@ static VALUE nogvl_kevent(void *args)
 	return (VALUE)nevents;
 }
 
+static void changelist_prepare(struct kevent *, VALUE);
+
 static VALUE do_kevent(struct kq_per_thread *kpt)
 {
 	long nevents;
 	struct timespec expire_at;
 
+	if (kpt->nchanges)
+		changelist_prepare(kpt->events, kpt->changelist);
+
 	if (kpt->ts) {
 		clock_gettime(CLOCK_MONOTONIC, &expire_at);
 
@@ -333,7 +336,7 @@ static void changelist_prepare(struct kevent *events, VALUE changelist)
  */
 static VALUE sp_kevent(int argc, VALUE *argv, VALUE self)
 {
-	struct timespec ts;
+	struct timespec ts, *t;
 	VALUE changelist, events, timeout;
 	struct kq_per_thread *kpt;
 	int nchanges, nevents;
@@ -362,12 +365,14 @@ static VALUE sp_kevent(int argc, VALUE *argv, VALUE self)
 		nevents = 0;
 	}
 
-	kpt = kpt_get(self, nchanges, nevents);
-	kpt->ts = NIL_P(timeout) ? NULL : value2timespec(&ts, timeout);
-	if (nchanges)
-		changelist_prepare(kpt->events, changelist);
+	t = NIL_P(timeout) ? NULL : value2timespec(&ts, timeout);
+	kpt = kpt_get(nchanges, nevents);
+	kpt->ts = t;
+	kpt->changelist = changelist;
+	kpt->io = self;
+	kpt->fd = rb_sp_fileno(kpt->io);
 
-	return do_kevent(kpt);
+	return rb_ensure(do_kevent, (VALUE)kpt, rb_sp_puttlsbuf, (VALUE)kpt);
 }
 
 /* initialize constants in the SleepyPenguin::Ev namespace */
@@ -651,13 +656,9 @@ void sleepy_penguin_init_kqueue(void)
 
 	id_for_fd = rb_intern("for_fd");
 
-	if (RB_SP_GREEN_THREAD)
-		rb_require("sleepy_penguin/kqueue/io");
-
-	/* the high-level interface is implemented in Ruby: */
-	rb_require("sleepy_penguin/kqueue");
-
-	/* Kevent helper struct */
-	rb_require("sleepy_penguin/kevent");
+	/*
+         * the high-level interface is implemented in Ruby
+         * see lib/sleepy_penguin/kevent.rb
+         */
 }
 #endif /* HAVE_SYS_EVENT_H */

data/ext/sleepy_penguin/sendfile.c

@@ -0,0 +1,120 @@
+#include "sleepy_penguin.h"
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+
+#if defined(HAVE_SYS_SENDFILE_H) && !defined(HAVE_BSD_SENDFILE)
+#  include <sys/sendfile.h>
+#endif
+
+#if defined(__linux__) && defined(HAVE_SENDFILE)
+#  define linux_sendfile(in_fd, out_fd, offset, count) \
+		sendfile((in_fd),(out_fd),(offset),(count))
+
+/* all good */
+#elif defined(HAVE_SENDFILE) && \
+      (defined(__FreeBSD__) || defined(__DragonFly__))
+/*
+ * make BSD sendfile look like Linux for now...
+ * we can support SF_NODISKIO later
+ */
+static ssize_t linux_sendfile(int sockfd, int filefd, off_t *off, size_t count)
+{
+	off_t sbytes = 0;
+        off_t offset = off ? *off : lseek(filefd, 0, SEEK_CUR);
+
+	int rc = sendfile(filefd, sockfd, offset, count, NULL, &sbytes, 0);
+	if (sbytes > 0) {
+		if (off)
+			*off += sbytes;
+		else
+			lseek(filefd, sbytes, SEEK_CUR);
+		return (ssize_t)sbytes;
+	}
+
+	return (ssize_t)rc;
+}
+#else /* emulate sendfile using (read|pread) + write */
+static ssize_t pread_sendfile(int sockfd, int filefd, off_t *off, size_t count)
+{
+	size_t max_read = 16384;
+	void *buf;
+	ssize_t r;
+	ssize_t w;
+
+	max_read = count > max_read ? max_read : count;
+	buf = xmalloc(max_read);
+
+	do {
+		r = off ? pread(filefd, buf, max_read, *off) :
+			  read(filefd, buf, max_read);
+	} while (r < 0 && errno == EINTR);
+
+	if (r <= 0) {
+		int err = errno;
+		xfree(buf);
+		errno = err;
+		return r;
+	}
+	w = write(sockfd, buf, r);
+	if (w > 0 && off)
+		*off += w;
+	xfree(buf);
+	return w;
+}
+#    define linux_sendfile(out_fd, in_fd, offset, count) \
+            pread_sendfile((out_fd),(in_fd),(offset),(count))
+#endif
+
+struct sf_args {
+	int dst_fd;
+	int src_fd;
+	off_t *off;
+	size_t count;
+};
+
+static VALUE sym_wait_writable;
+
+static VALUE nogvl_sf(void *ptr)
+{
+	struct sf_args *a = ptr;
+
+	return (VALUE)linux_sendfile(a->dst_fd, a->src_fd, a->off, a->count);
+}
+
+static VALUE lsf(VALUE mod, VALUE dst, VALUE src, VALUE src_off, VALUE count)
+{
+	off_t off = 0;
+	struct sf_args a;
+	ssize_t bytes;
+	int retried = 0;
+
+	a.off = NIL_P(src_off) ? NULL : (off = NUM2OFFT(src_off), &off);
+	a.count = NUM2SIZET(count);
+again:
+	a.src_fd = rb_sp_fileno(src);
+	a.dst_fd = rb_sp_fileno(dst);
+	bytes = (ssize_t)rb_sp_fd_region(nogvl_sf, &a, a.dst_fd);
+	if (bytes < 0) {
+		switch (errno) {
+		case EAGAIN:
+			return sym_wait_writable;
+		case ENOMEM:
+		case ENOBUFS:
+			if (!retried) {
+				rb_gc();
+				retried = 1;
+				goto again;
+			}
+		}
+		rb_sys_fail("sendfile");
+	}
+	return SSIZET2NUM(bytes);
+}
+
+void sleepy_penguin_init_sendfile(void)
+{
+	VALUE m = rb_define_module("SleepyPenguin");
+	rb_define_singleton_method(m, "__lsf", lsf, 4);
+	sym_wait_writable = ID2SYM(rb_intern("wait_writable"));
+}

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -19,16 +19,6 @@ int rb_sp_io_closed(VALUE io);
 int rb_sp_fileno(VALUE io);
 void rb_sp_set_nonblock(int fd);
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || \
-    defined(HAVE_RB_THREAD_IO_BLOCKING_REGION) || \
-    defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-#  define RB_SP_GREEN_THREAD 0
-#  define blocking_io_prepare(fd) ((void)(fd))
-#else
-#  define RB_SP_GREEN_THREAD 1
-#  define blocking_io_prepare(fd) rb_sp_set_nonblock((fd))
-#endif
-
 #ifdef HAVE_RB_THREAD_IO_BLOCKING_REGION
 /* Ruby 1.9.3 and 2.0.0 */
 VALUE rb_thread_io_blocking_region(rb_blocking_function_t *, void *, int);
@@ -46,24 +36,7 @@ VALUE rb_thread_io_blocking_region(rb_blocking_function_t *, void *, int);
 #  define rb_sp_fd_region(fn,data,fd) \
 	rb_thread_blocking_region((fn),(data),RUBY_UBF_IO,NULL)
 #else
-/*
- * Ruby 1.8 does not have a GVL, we'll just enable signal interrupts
- * here in case we make interruptible syscalls.
- *
- * Note: epoll_wait with timeout=0 was interruptible until Linux 2.6.39
- */
-#  include <rubysig.h>
-static inline VALUE fake_blocking_region(VALUE (*fn)(void *), void *data)
-{
-	VALUE rv;
-
-	TRAP_BEG;
-	rv = fn(data);
-	TRAP_END;
-
-	return rv;
-}
-#  define rb_sp_fd_region(fn,data,fd) fake_blocking_region((fn),(data))
+#  error Ruby <= 1.8 not supported
 #endif
 
 #define NODOC_CONST(klass,name,value) \
@@ -78,6 +51,7 @@ static inline VALUE fake_blocking_region(VALUE (*fn)(void *), void *data)
 typedef int rb_sp_waitfn(int fd);
 int rb_sp_wait(rb_sp_waitfn waiter, VALUE obj, int *fd);
 void *rb_sp_gettlsbuf(size_t *size);
+VALUE rb_sp_puttlsbuf(VALUE);
 
 /* Flexible array elements are standard in C99 */
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
@@ -90,4 +64,17 @@ void *rb_sp_gettlsbuf(size_t *size);
 # endif
 #endif
 
+int rb_sp_gc_for_fd(int err);
+
+#ifndef HAVE_COPY_FILE_RANGE
+#  include <sys/syscall.h>
+#  if !defined(__NR_copy_file_range) && defined(__linux__)
+#    if defined(__x86_64__)
+#      define __NR_copy_file_range 326
+#    elif defined(__i386__)
+#      define __NR_copy_file_range 377
+#    endif /* supported arches */
+#  endif /* __NR_copy_file_range */
+#endif
+
 #endif /* SLEEPY_PENGUIN_H */

data/ext/sleepy_penguin/sp_copy.h

@@ -0,0 +1,33 @@
+/* common splice and copy_file_range-related definitions */
+
+#ifndef SSIZET2NUM
+#  define SSIZET2NUM(x) LONG2NUM(x)
+#endif
+#ifndef NUM2SIZET
+#  define NUM2SIZET(x) NUM2ULONG(x)
+#endif
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
+/* Ruby 2.0+ */
+#  include <ruby/thread.h>
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+        rb_thread_call_without_gvl((fn),(a),(ubf),(b))
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+typedef VALUE (*my_blocking_fn_t)(void*);
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+	rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),(ubf),(b))
+
+#else /* Ruby 1.8 */
+#  error Ruby 1.8 not supported
+#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+
+#define IO_RUN(fn,data) WITHOUT_GVL((fn),(data),RUBY_UBF_IO,0)
+
+struct copy_args {
+	int fd_in;
+	int fd_out;
+	off_t *off_in;
+	off_t *off_out;
+	size_t len;
+	unsigned flags;
+};