raindrops 0.13.0 → 0.20.0

data/ext/raindrops/linux_inet_diag.c

@@ -1,45 +1,24 @@
 #include <ruby.h>
-#ifdef HAVE_RUBY_ST_H
-#  include <ruby/st.h>
-#else
-#  include <st.h>
-#endif
+#include <stdarg.h>
+#include <ruby/st.h>
 #include "my_fileno.h"
 #ifdef __linux__
 
-/* Ruby 1.8.6+ macros (for compatibility with Ruby 1.9) */
-#ifndef RSTRING_LEN
-#  define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
-
-/* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && \
-    !defined(HAVE_RB_THREAD_IO_BLOCKING_REGION)
-#  include <rubysig.h>
-#  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
-typedef void rb_unblock_function_t(void *);
-typedef VALUE rb_blocking_function_t(void *);
-static VALUE
-rb_thread_blocking_region(
-	rb_blocking_function_t *func, void *data1,
-	rb_unblock_function_t *ubf, void *data2)
-{
-	VALUE rv;
-
-	TRAP_BEG;
-	rv = func(data1);
-	TRAP_END;
-
-	return rv;
-}
-#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
-
 #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);
+#  define rd_fd_region(fn,data,fd) \
+	rb_thread_io_blocking_region((fn),(data),(fd))
+#elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+	defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
+/* in case Ruby 2.0+ ever drops rb_thread_io_blocking_region: */
+#  include <ruby/thread.h>
+#  define COMPAT_FN (void *(*)(void *))
+#  define rd_fd_region(fn,data,fd) \
+	rb_thread_call_without_gvl(COMPAT_FN(fn),(data),RUBY_UBF_IO,NULL)
 #else
-#  define rb_thread_io_blocking_region(fn,data,fd) \
-      rb_thread_blocking_region((fn),(data),RUBY_UBF_IO,0)
-#endif /* HAVE_RB_THREAD_IO_BLOCKING_REGION */
+#  error Ruby <= 1.8 not supported
+#endif
 
 #include <assert.h>
 #include <errno.h>
@@ -213,91 +192,89 @@ static const char *addr_any(sa_family_t family)
 	return ipv6;
 }
 
-static void bug_warn(void)
+#ifdef __GNUC__
+static void bug_warn_nogvl(const char *, ...)
+	__attribute__((format(printf,1,2)));
+#endif
+static void bug_warn_nogvl(const char *fmt, ...)
 {
+	va_list ap;
+
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
 	fprintf(stderr, "Please report how you produced this at "\
-	                "raindrops@librelist.org\n");
+	                "raindrops-public@yhbt.net\n");
 	fflush(stderr);
 }
 
 static struct listen_stats *stats_for(st_table *table, struct inet_diag_msg *r)
 {
-	char *key, *port, *old_key;
+	char *host, *key, *port, *old_key;
 	size_t alloca_len;
 	struct listen_stats *stats;
-	size_t keylen;
-	size_t portlen = sizeof("65535");
-	union any_addr sa;
-	socklen_t len = sizeof(struct sockaddr_storage);
-	int rc;
-	int flags = NI_NUMERICHOST | NI_NUMERICSERV;
-
-	switch ((sa.ss.ss_family = r->idiag_family)) {
+	socklen_t hostlen;
+	socklen_t portlen = (socklen_t)sizeof("65535");
+	int n;
+	const void *src = r->id.idiag_src;
+
+	switch (r->idiag_family) {
 	case AF_INET: {
-		sa.in.sin_port = r->id.idiag_sport;
-		sa.in.sin_addr.s_addr = r->id.idiag_src[0];
-		keylen = INET_ADDRSTRLEN;
-		alloca_len = keylen + 1 + portlen;
-		key = alloca(alloca_len);
-		key[keylen] = 0; /* will be ':' later */
-		port = key + keylen + 1;
-		rc = getnameinfo(&sa.sa, len,
-				 key, keylen, port, portlen, flags);
+		hostlen = INET_ADDRSTRLEN;
+		alloca_len = hostlen + portlen;
+		host = key = alloca(alloca_len);
 		break;
 		}
 	case AF_INET6: {
-		sa.in6.sin6_port = r->id.idiag_sport;
-		memcpy(&sa.in6.sin6_addr, &r->id.idiag_src, sizeof(__be32[4]));
-		keylen = INET6_ADDRSTRLEN;
-		          /* [            ] */
-		alloca_len = 1 + keylen + 1 + 1 + portlen;
+		hostlen = INET6_ADDRSTRLEN;
+		alloca_len = 1 + hostlen + 1 + portlen;
 		key = alloca(alloca_len);
-		*key = '[';
-		key[1 + keylen + 1] = 0; /* will be ':' later */
-		port = 1 + key + keylen + 1 + 1;
-		rc = getnameinfo(&sa.sa, len,
-				 key + 1, keylen, port, portlen, flags);
+		host = key + 1;
 		break;
 		}
 	default:
 		assert(0 && "unsupported address family, could that be IPv7?!");
 	}
-	if (rc != 0) {
-		fprintf(stderr, "BUG: getnameinfo: %s\n", gai_strerror(rc));
-		bug_warn();
-		*key = 0;
+	if (!inet_ntop(r->idiag_family, src, host, hostlen)) {
+		bug_warn_nogvl("BUG: inet_ntop: %s\n", strerror(errno));
+		*key = '\0';
+		*host = '\0';
 	}
-
-	keylen = strlen(key);
-	portlen = strlen(port);
-
-	switch (sa.ss.ss_family) {
+	hostlen = (socklen_t)strlen(host);
+	switch (r->idiag_family) {
 	case AF_INET:
-		key[keylen] = ':';
-		memmove(key + keylen + 1, port, portlen + 1);
+		host[hostlen] = ':';
+		port = host + hostlen + 1;
 		break;
 	case AF_INET6:
-		key[keylen] = ']';
-		key[keylen + 1] = ':';
-		memmove(key + keylen + 2, port, portlen + 1);
-		keylen++;
+		key[0] = '[';
+		host[hostlen] = ']';
+		host[hostlen + 1] = ':';
+		port = host + hostlen + 2;
 		break;
 	default:
 		assert(0 && "unsupported address family, could that be IPv7?!");
 	}
 
+	n = snprintf(port, portlen, "%u", ntohs(r->id.idiag_sport));
+	if (n <= 0) {
+		bug_warn_nogvl("BUG: snprintf port: %d\n", n);
+		*key = '\0';
+	}
+
 	if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
 		return stats;
 
 	old_key = key;
 
 	if (r->idiag_state == TCP_ESTABLISHED) {
-		int n = snprintf(key, alloca_len, "%s:%u",
-				 addr_any(sa.ss.ss_family),
+		n = snprintf(key, alloca_len, "%s:%u",
+				 addr_any(r->idiag_family),
 				 ntohs(r->id.idiag_sport));
 		if (n <= 0) {
-			fprintf(stderr, "BUG: snprintf: %d\n", n);
-			bug_warn();
+			bug_warn_nogvl("BUG: snprintf: %d\n", n);
+			*key = '\0';
 		}
 		if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
 			return stats;
@@ -310,8 +287,9 @@ static struct listen_stats *stats_for(st_table *table, struct inet_diag_msg *r)
 			memcpy(key, old_key, n + 1);
 		}
 	} else {
-		key = xmalloc(keylen + 1 + portlen + 1);
-		memcpy(key, old_key, keylen + 1 + portlen + 1);
+		size_t old_len = strlen(old_key) + 1;
+		key = xmalloc(old_len);
+		memcpy(key, old_key, old_len);
 	}
 	stats = xcalloc(1, sizeof(struct listen_stats));
 	st_insert(table, (st_data_t)key, (st_data_t)stats);
@@ -391,8 +369,8 @@ static void prep_diag_args(
 
 	nladdr->nl_family = AF_NETLINK;
 
-	req->nlh.nlmsg_len = sizeof(struct diag_req) +
-	                    RTA_LENGTH(args->iov[2].iov_len);
+	req->nlh.nlmsg_len = (unsigned int)(sizeof(struct diag_req) +
+	                    RTA_LENGTH(args->iov[2].iov_len));
 	req->nlh.nlmsg_type = TCPDIAG_GETSOCK;
 	req->nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 	req->nlh.nlmsg_pid = getpid();
@@ -465,12 +443,12 @@ static VALUE diag(void *ptr)
 		}
 	}
 out:
-	{
+	/* prepare to raise, free memory before reacquiring GVL */
+	if (err && args->table) {
 		int save_errno = errno;
-		if (err && args->table) {
-			st_foreach(args->table, st_free_data, 0);
-			st_free_table(args->table);
-		}
+
+		st_foreach(args->table, st_free_data, 0);
+		st_free_table(args->table);
 		errno = save_errno;
 	}
 	return (VALUE)err;
@@ -584,6 +562,10 @@ static void gen_bytecode(struct iovec *iov, union any_addr *inet)
 	}
 }
 
+/*
+ * n.b. we may safely raise here because an error will cause diag()
+ * to free args->table
+ */
 static void nl_errcheck(VALUE r)
 {
 	const char *err = (const char *)r;
@@ -604,11 +586,18 @@ static VALUE tcp_stats(struct nogvl_args *args, VALUE addr)
 	gen_bytecode(&args->iov[2], &query_addr);
 
 	memset(&args->stats, 0, sizeof(struct listen_stats));
-	nl_errcheck(rb_thread_io_blocking_region(diag, args, args->fd));
+	nl_errcheck(rd_fd_region(diag, args, args->fd));
 
 	return rb_listen_stats(&args->stats);
 }
 
+static int drop_placeholders(st_data_t k, st_data_t v, st_data_t ign)
+{
+	if ((VALUE)v == Qtrue)
+		return ST_DELETE;
+	return ST_CONTINUE;
+}
+
 /*
  * call-seq:
  *      Raindrops::Linux.tcp_listener_stats([addrs[, sock]]) => hash
@@ -649,10 +638,9 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 	case T_ARRAY: {
 		long i;
 		long len = RARRAY_LEN(addrs);
-		VALUE cur;
 
 		if (len == 1) {
-			cur = rb_ary_entry(addrs, 0);
+			VALUE cur = rb_ary_entry(addrs, 0);
 
 			rb_hash_aset(rv, cur, tcp_stats(&args, cur));
 			return rv;
@@ -662,7 +650,7 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 			VALUE cur = rb_ary_entry(addrs, i);
 
 			parse_addr(&check, cur);
-			rb_hash_aset(rv, cur, Qtrue);
+			rb_hash_aset(rv, cur, Qtrue /* placeholder */);
 		}
 		/* fall through */
 	}
@@ -675,11 +663,14 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 		         "addr must be an array of strings, a string, or nil");
 	}
 
-	nl_errcheck(rb_thread_io_blocking_region(diag, &args, args.fd));
+	nl_errcheck(rd_fd_region(diag, &args, args.fd));
 
 	st_foreach(args.table, NIL_P(addrs) ? st_to_hash : st_AND_hash, rv);
 	st_free_table(args.table);
 
+	if (RHASH_SIZE(rv) > 1)
+		rb_hash_foreach(rv, drop_placeholders, Qfalse);
+
 	/* let GC deal with corner cases */
 	if (argc < 2) rb_io_close(sock);
 	return rv;
@@ -687,11 +678,12 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 
 void Init_raindrops_linux_inet_diag(void)
 {
-	VALUE cRaindrops = rb_const_get(rb_cObject, rb_intern("Raindrops"));
+	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
 	VALUE mLinux = rb_define_module_under(cRaindrops, "Linux");
+	VALUE Socket;
 
 	rb_require("socket");
-	cIDSock = rb_const_get(rb_cObject, rb_intern("Socket"));
+	Socket = rb_const_get(rb_cObject, rb_intern("Socket"));
 	id_new = rb_intern("new");
 
 	/*
@@ -700,10 +692,11 @@ void Init_raindrops_linux_inet_diag(void)
 	 * This is a subclass of +Socket+ specifically for talking
 	 * to the inet_diag facility of Netlink.
 	 */
-	cIDSock = rb_define_class_under(cRaindrops, "InetDiagSocket", cIDSock);
+	cIDSock = rb_define_class_under(cRaindrops, "InetDiagSocket", Socket);
 	rb_define_singleton_method(cIDSock, "new", ids_s_new, 0);
 
 	cListenStats = rb_const_get(cRaindrops, rb_intern("ListenStats"));
+	rb_gc_register_mark_object(cListenStats); /* pin */
 
 	rb_define_module_function(mLinux, "tcp_listener_stats",
 	                          tcp_listener_stats, -1);

data/ext/raindrops/raindrops.c

@@ -4,6 +4,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <stddef.h>
+#include <string.h>
 #include "raindrops_atomic.h"
 
 #ifndef SIZET2NUM
@@ -34,11 +35,19 @@ struct raindrops {
 	size_t size;
 	size_t capa;
 	pid_t pid;
+	VALUE io;
 	struct raindrop *drops;
 };
 
 /* called by GC */
-static void gcfree(void *ptr)
+static void rd_mark(void *ptr)
+{
+	struct raindrops *r = ptr;
+	rb_gc_mark(r->io);
+}
+
+/* called by GC */
+static void rd_free(void *ptr)
 {
 	struct raindrops *r = ptr;
 
@@ -51,11 +60,24 @@ static void gcfree(void *ptr)
 	xfree(ptr);
 }
 
+static size_t rd_memsize(const void *ptr)
+{
+	const struct raindrops *r = ptr;
+
+	return r->drops == MAP_FAILED ? 0 : raindrop_size * r->capa;
+}
+
+static const rb_data_type_t rd_type = {
+	"raindrops",
+	{ rd_mark, rd_free, rd_memsize, /* reserved */ },
+	/* parent, data, [ flags ] */
+};
+
 /* automatically called at creation (before initialize) */
 static VALUE alloc(VALUE klass)
 {
 	struct raindrops *r;
-	VALUE rv = Data_Make_Struct(klass, struct raindrops, NULL, gcfree, r);
+	VALUE rv = TypedData_Make_Struct(klass, struct raindrops, &rd_type, r);
 
 	r->drops = MAP_FAILED;
 	return rv;
@@ -65,7 +87,7 @@ static struct raindrops *get(VALUE self)
 {
 	struct raindrops *r;
 
-	Data_Get_Struct(self, struct raindrops, r);
+	TypedData_Get_Struct(self, struct raindrops, &rd_type, r);
 
 	if (r->drops == MAP_FAILED)
 		rb_raise(rb_eStandardError, "invalid or freed Raindrops");
@@ -74,16 +96,10 @@ static struct raindrops *get(VALUE self)
 }
 
 /*
- * call-seq:
- *	Raindrops.new(size)	-> raindrops object
- *
- * Initializes a Raindrops object to hold +size+ counters.  +size+ is
- * only a hint and the actual number of counters the object has is
- * dependent on the CPU model, number of cores, and page size of
- * the machine.  The actual size of the object will always be equal
- * or greater than the specified +size+.
+ * This is the _actual_ implementation of #initialize - the Ruby wrapper
+ * handles keyword-argument handling then calls this method.
  */
-static VALUE init(VALUE self, VALUE size)
+static VALUE init_cimpl(VALUE self, VALUE size, VALUE io, VALUE zero)
 {
 	struct raindrops *r = DATA_PTR(self);
 	int tries = 1;
@@ -100,11 +116,23 @@ static VALUE init(VALUE self, VALUE size)
 	r->capa = tmp / raindrop_size;
 	assert(PAGE_ALIGN(raindrop_size * r->capa) == tmp && "not aligned");
 
+	r->io = io;
+
 retry:
-	r->drops = mmap(NULL, tmp,
-	                PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
+	if (RTEST(r->io)) {
+		int fd = NUM2INT(rb_funcall(r->io, rb_intern("fileno"), 0));
+		rb_funcall(r->io, rb_intern("truncate"), 1, SIZET2NUM(tmp));
+		r->drops = mmap(NULL, tmp,
+				PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+	} else {
+		r->drops = mmap(NULL, tmp,
+				PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
+				-1, 0);
+	}
 	if (r->drops == MAP_FAILED) {
-		if ((errno == EAGAIN || errno == ENOMEM) && tries-- > 0) {
+		int err = errno;
+
+		if ((err == EAGAIN || err == ENOMEM) && tries-- > 0) {
 			rb_gc();
 			goto retry;
 		}
@@ -112,6 +140,9 @@ retry:
 	}
 	r->pid = getpid();
 
+	if (RTEST(zero))
+		memset(r->drops, 0, tmp);
+
 	return self;
 }
 
@@ -140,7 +171,9 @@ static void resize(struct raindrops *r, size_t new_rd_size)
 
 	rv = mremap(old_address, old_size, new_size, MREMAP_MAYMOVE);
 	if (rv == MAP_FAILED) {
-		if (errno == EAGAIN || errno == ENOMEM) {
+		int err = errno;
+
+		if (err == EAGAIN || err == ENOMEM) {
 			rb_gc();
 			rv = mremap(old_address, old_size, new_size, 0);
 		}
@@ -200,14 +233,16 @@ static VALUE capa(VALUE self)
  * call-seq:
  *	rd.dup		-> rd_copy
  *
- * Duplicates and snapshots the current state of a Raindrops object.
+ * Duplicates and snapshots the current state of a Raindrops object. Even
+ * if the given Raindrops object is backed by a file, the copy will be backed
+ * by independent, anonymously mapped memory.
  */
 static VALUE init_copy(VALUE dest, VALUE source)
 {
 	struct raindrops *dst = DATA_PTR(dest);
 	struct raindrops *src = get(source);
 
-	init(dest, SIZET2NUM(src->size));
+	init_cimpl(dest, SIZET2NUM(src->size), Qnil, Qfalse);
 	memcpy(dst->drops, src->drops, raindrop_size * src->size);
 
 	return dest;
@@ -323,7 +358,9 @@ static VALUE aref(VALUE self, VALUE index)
 
 #ifdef __linux__
 void Init_raindrops_linux_inet_diag(void);
-void Init_raindrops_linux_tcp_info(void);
+#endif
+#ifdef HAVE_TYPE_STRUCT_TCP_INFO
+void Init_raindrops_tcp_info(void);
 #endif
 
 #ifndef _SC_NPROCESSORS_CONF
@@ -356,6 +393,20 @@ static VALUE evaporate_bang(VALUE self)
 	return Qnil;
 }
 
+/*
+ * call-seq:
+ * 	to_io	-> IO
+ *
+ * Returns the IO object backing the memory for this raindrop, if
+ * one was specified when constructing this Raindrop. If this
+ * Raindrop is backed by anonymous memory, this method returns nil.
+ */
+static VALUE to_io(VALUE self)
+{
+	struct raindrops *r = get(self);
+	return r->io;
+}
+
 void Init_raindrops_ext(void)
 {
 	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
@@ -414,7 +465,7 @@ void Init_raindrops_ext(void)
 
 	rb_define_alloc_func(cRaindrops, alloc);
 
-	rb_define_method(cRaindrops, "initialize", init, 1);
+	rb_define_private_method(cRaindrops, "initialize_cimpl", init_cimpl, 3);
 	rb_define_method(cRaindrops, "incr", incr, -1);
 	rb_define_method(cRaindrops, "decr", decr, -1);
 	rb_define_method(cRaindrops, "to_ary", to_ary, 0);
@@ -425,9 +476,12 @@ void Init_raindrops_ext(void)
 	rb_define_method(cRaindrops, "capa", capa, 0);
 	rb_define_method(cRaindrops, "initialize_copy", init_copy, 1);
 	rb_define_method(cRaindrops, "evaporate!", evaporate_bang, 0);
+	rb_define_method(cRaindrops, "to_io", to_io, 0);
 
 #ifdef __linux__
 	Init_raindrops_linux_inet_diag();
-	Init_raindrops_linux_tcp_info();
+#endif
+#ifdef HAVE_TYPE_STRUCT_TCP_INFO
+	Init_raindrops_tcp_info();
 #endif
 }