posix_mq 0.5.1 → 0.6.0

data/GNUmakefile

@@ -2,7 +2,7 @@
 all::
 RUBY = ruby
 RAKE = rake
-GIT_URL = git://git.bogomips.org/ruby_posix_mq.git
+RSYNC = rsync
 
 GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
 	@./GIT-VERSION-GEN
@@ -39,10 +39,10 @@ clean:
 	-$(MAKE) -C ext/posix_mq clean
 	$(RM) $(setup_rb_files) ext/posix_mq/Makefile
 
-man:
-	$(MAKE) -C Documentation install-man
+man html:
+	$(MAKE) -C Documentation install-$@
 
-pkg_extra := GIT-VERSION-FILE NEWS ChangeLog
+pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
 manifest: $(pkg_extra) man
 	$(RM) .manifest
 	$(MAKE) .manifest
@@ -54,48 +54,16 @@ manifest: $(pkg_extra) man
 	cmp $@+ $@ || mv $@+ $@
 	$(RM) $@+
 
-NEWS: GIT-VERSION-FILE
-	$(RAKE) -s news_rdoc > $@+
-	mv $@+ $@
-
-SINCE = 0.4.0
-ChangeLog: LOG_VERSION = \
-  $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
-          echo $(GIT_VERSION) || git describe)
-ifneq ($(SINCE),)
-ChangeLog: log_range = v$(SINCE)..$(LOG_VERSION)
-endif
 ChangeLog: GIT-VERSION-FILE
-	@echo "ChangeLog from $(GIT_URL) ($(log_range))" > $@+
-	@echo >> $@+
-	git log $(log_range) | sed -e 's/^/    /' >> $@+
-	mv $@+ $@
-
-news_atom := http://bogomips.org/ruby_posix_mq/NEWS.atom.xml
-cgit_atom := http://git.bogomips.org/cgit/ruby_posix_mq.git/atom/?h=master
-atom = <link rel="alternate" title="Atom feed" href="$(1)" \
-             type="application/atom+xml"/>
+	wrongdoc prepare
 
-# using rdoc 2.5.x+
-doc: .document NEWS ChangeLog
+doc: .document NEWS ChangeLog man html
 	for i in $(man1_rdoc); do > $$i; done
-	rdoc -a -t "$(shell sed -ne '1s/^= //p' README)"
+	$(RM) -r doc
+	wrongdoc all
 	install -m644 COPYING doc/COPYING
-	install -m644 $(shell grep '^[A-Z]' .document)  doc/
-	$(MAKE) -C Documentation install-html install-man
+	install -m644 $(shell grep '^[A-Z]' .document) doc/
 	install -m644 $(man1_paths) doc/
-	cd doc && for i in $(base_bins); do \
-	  html=$$(echo $$i | sed 's/\.rb/_rb/')_1.html; \
-	  sed -e '/"documentation">/r man1/'$$i'.1.html' \
-		< $$html > tmp && mv tmp $$html; done
-	$(RUBY) -i -p -e \
-	  '$$_.gsub!("</title>",%q{\&$(call atom,$(cgit_atom))})' \
-	  doc/ChangeLog.html
-	$(RUBY) -i -p -e \
-	  '$$_.gsub!("</title>",%q{\&$(call atom,$(news_atom))})' \
-	  doc/NEWS.html doc/README.html
-	$(RAKE) -s news_atom > doc/NEWS.atom.xml
-	cd doc && ln README.html tmp && mv tmp index.html
 	$(RM) $(man1_rdoc)
 
 ifneq ($(VERSION),)
@@ -109,10 +77,10 @@ release_changes := release_changes-$(VERSION)
 release-notes: $(release_notes)
 release-changes: $(release_changes)
 $(release_changes):
-	$(RAKE) -s release_changes > $@+
+	wrongdoc release_changes > $@+
 	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
 $(release_notes):
-	GIT_URL=$(GIT_URL) $(RAKE) -s release_notes > $@+
+	wrongdoc release_notes > $@+
 	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
 
 # ensures we're actually on the tagged $(VERSION), only used for release
@@ -177,4 +145,22 @@ test: test-unit
 test-unit: build
 	$(RUBY) -I lib:ext/posix_mq test/test_posix_mq.rb
 
-.PHONY: .FORCE-GIT-VERSION-FILE doc manifest man test
+# publishes docs to http://bogomips.org/ruby_posix_mq/
+publish_doc:
+	-git set-file-times
+	$(RM) -r doc
+	$(MAKE) doc
+	find doc/images -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:03' doc/rdoc.css
+	$(MAKE) doc_gz
+	$(RSYNC) -av doc/ bogomips.org:/srv/bogomips/ruby_posix_mq/
+	git ls-files | xargs touch
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
+.PHONY: .FORCE-GIT-VERSION-FILE doc manifest man test html

data/LATEST

@@ -0,0 +1,6 @@
+=== posix_mq 0.6.0 - Rubinius support / 
+
+  Rubinius 1.2 as well as Ruby 1.9.  Ruby 1.8 works except it will
+  block the entire interpreter for blocking operations.  Spurious
+  errors during GC for POSIX_MQ#to_io users are now avoided.
+

data/NEWS

@@ -1,9 +1,15 @@
-=== 0.5.1 / 2010-05-09 08:10 UTC
+=== posix_mq 0.6.0 - Rubinius support / 2010-12-25 08:28 UTC
+
+  Rubinius 1.2 as well as Ruby 1.9.  Ruby 1.8 works except it will
+  block the entire interpreter for blocking operations.  Spurious
+  errors during GC for POSIX_MQ#to_io users are now avoided.
+
+=== posix_mq 0.5.1 / 2010-05-09 08:10 UTC
 
   Fix POSIX_MQ#notify(&block) usage, this regression was
   introduced in 0.4.0 and our tests for it were broken, as well.
 
-=== 0.5.0 / 2010-05-05 02:54 UTC
+=== posix_mq 0.5.0 / 2010-05-05 02:54 UTC
 
   Uncommonly raised exceptions due to programmer error are now
   raised more safely with respect to the MRI garbage collector.
@@ -15,7 +21,7 @@
 
   Minor cleanups and documentation now uses RDoc 2.5.x
 
-=== 0.4.0 / 2010-03-13 09:44 UTC
+=== posix_mq 0.4.0 / 2010-03-13 09:44 UTC
 
   Small bugfixes and small API changes to avoid potential
   issues/misuse are the focus of this release.
@@ -38,7 +44,7 @@
   * remove non-portable #warning CPP directive
   * ensure POSIX_MQ#name is clobber-proof
 
-=== 0.3.1 / 2010-02-13 12:05 UTC
+=== posix_mq 0.3.1 / 2010-02-13 12:05 UTC
 
   This fixes a misuse of the Ruby API leading to memory leaks in
   cases where message queues are continually opened and closed
@@ -49,7 +55,7 @@
   multi-thread/multi-process-safe in every way imaginable and also
   capable of non-blocking operation.
 
-=== 0.3.0 / 2010-01-09 23:11 UTC
+=== posix_mq 0.3.0 / 2010-01-09 23:11 UTC
 
   This release adds a few new API methods, fixes MRI 1.8.6
   support.  We should now have full feature parity with
@@ -71,7 +77,7 @@
   Linux, FreeBSD and possibly any other platforms where POSIX
   message queues are implemented with a file descriptor.
 
-=== 0.2.0 / 2010-01-03 05:52 UTC
+=== posix_mq 0.2.0 / 2010-01-03 05:52 UTC
 
   This release fixes notification (un)registration and should be
   fully-supported on modern FreeBSD (7.2+) releases.
@@ -81,7 +87,8 @@
   functionality.  Under FreeBSD, using IO.select on POSIX_MQ
   objects is now possible as it has always been under Linux.
 
-=== 0.1.0 / 2010-01-02 11:01 UTC
+=== posix_mq 0.1.0 - initial release
+ / 2010-01-02 11:01 UTC
 
   initial
 

data/README

@@ -26,6 +26,8 @@ network-aware message queue implementations.
 * Thread-safe blocking operations under Ruby 1.9, releases GVL
   before blocking operations.
 
+* Works under Ruby 1.8, Ruby 1.9 and Rubinius 1.2
+
 * Documented library API
 
 * Includes a generic "posix-mq-rb" command-line tool with manpage.

data/Rakefile

@@ -1,108 +1,6 @@
 # -*- encoding: binary -*-
-
-# most tasks are in the GNUmakefile which offers better parallelism
-
-def tags
-  timefmt = '%Y-%m-%dT%H:%M:%SZ'
-  @tags ||= `git tag -l`.split(/\n/).map do |tag|
-    if %r{\Av[\d\.]+\z} =~ tag
-      header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
-      header = header.split(/\n/)
-      tagger = header.grep(/\Atagger /).first
-      body ||= "initial"
-      {
-        :time => Time.at(tagger.split(/ /)[-2].to_i).utc.strftime(timefmt),
-        :tagger_name => %r{^tagger ([^<]+)}.match(tagger)[1].strip,
-        :tagger_email => %r{<([^>]+)>}.match(tagger)[1].strip,
-        :id => `git rev-parse refs/tags/#{tag}`.chomp!,
-        :tag => tag,
-        :subject => subject,
-        :body => body,
-      }
-    end
-  end.compact.sort { |a,b| b[:time] <=> a[:time] }
-end
-
 cgit_url = "http://git.bogomips.org/cgit/ruby_posix_mq.git"
-git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/ruby_posix_mq.git'
-web_url = "http://bogomips.org/ruby_posix_mq/"
-
-desc 'prints news as an Atom feed'
-task :news_atom do
-  require 'nokogiri'
-  new_tags = tags[0,10]
-  puts(Nokogiri::XML::Builder.new do
-    feed :xmlns => "http://www.w3.org/2005/Atom" do
-      id! "#{web_url}NEWS.atom.xml"
-      title "Ruby posix_mq news"
-      subtitle "POSIX Message Queues for Ruby"
-      link! :rel => "alternate", :type => "text/html",
-            :href => "#{web_url}NEWS.html"
-      updated(new_tags.empty? ? "1970-01-01T00:00:00Z" : new_tags.first[:time])
-      new_tags.each do |tag|
-        entry do
-          title tag[:subject]
-          updated tag[:time]
-          published tag[:time]
-          author {
-            name tag[:tagger_name]
-            email tag[:tagger_email]
-          }
-          url = "#{cgit_url}/tag/?id=#{tag[:tag]}"
-          link! :rel => "alternate", :type => "text/html", :href =>url
-          id! url
-          message_only = tag[:body].split(/\n.+\(\d+\):\n {6}/s).first.strip
-          content({:type =>:text}, message_only)
-          content(:type =>:xhtml) { pre tag[:body] }
-        end
-      end
-    end
-  end.to_xml)
-end
-
-desc 'prints RDoc-formatted news'
-task :news_rdoc do
-  tags.each do |tag|
-    time = tag[:time].tr!('T', ' ').gsub!(/:\d\dZ/, ' UTC')
-    puts "=== #{tag[:tag].sub(/^v/, '')} / #{time}"
-    puts ""
-
-    body = tag[:body]
-    puts tag[:body].gsub(/^/sm, "  ").gsub(/[ \t]+$/sm, "")
-    puts ""
-  end
-end
-
-desc "print release changelog for Rubyforge"
-task :release_changes do
-  version = ENV['VERSION'] or abort "VERSION= needed"
-  version = "v#{version}"
-  vtags = tags.map { |tag| tag[:tag] =~ /\Av/ and tag[:tag] }.sort
-  prev = vtags[vtags.index(version) - 1]
-  if prev
-    system('git', 'diff', '--stat', prev, version) or abort $?
-    puts ""
-    system('git', 'log', "#{prev}..#{version}") or abort $?
-  else
-    system('git', 'log', version) or abort $?
-  end
-end
-
-desc "print release notes for Rubyforge"
-task :release_notes do
-  require 'rubygems'
-
-  spec = Gem::Specification.load('posix_mq.gemspec')
-  puts spec.description.strip
-  puts ""
-  puts "* #{spec.homepage}"
-  puts "* #{spec.email}"
-  puts "* #{git_url}"
-
-  _, _, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
-  print "\nChanges:\n\n"
-  puts body
-end
+git_url = 'git://git.bogomips.org/ruby_posix_mq.git'
 
 desc "read news article from STDIN and post to rubyforge"
 task :publish_news do

data/ext/posix_mq/extconf.rb

@@ -6,8 +6,8 @@ have_header("mqueue.h") or abort "mqueue.h header missing"
 have_func("__mq_oshandle")
 have_header("pthread.h")
 have_func("rb_str_set_len")
-have_func("rb_struct_alloc_noinit")
 have_func('rb_thread_blocking_region')
+have_library("m")
 have_library("rt")
 have_library("pthread")
 dir_config("posix_mq")

data/ext/posix_mq/posix_mq.c

@@ -10,8 +10,8 @@
 #endif
 #include <ruby.h>
 
-#ifndef RB_GC_GUARD
-#  define RB_GC_GUARD(v) (*(volatile VALUE *)&(v))
+#ifndef NUM2TIMET
+#  define NUM2TIMET NUM2INT
 #endif
 
 #include <time.h>
@@ -21,6 +21,8 @@
 #include <errno.h>
 #include <assert.h>
 #include <unistd.h>
+#include <float.h>
+#include <math.h>
 
 #if defined(__linux__)
 #  define MQD_TO_FD(mqd) (int)(mqd)
@@ -29,11 +31,8 @@
 #else
 #  define MQ_IO_MARK(mq) ((void)(0))
 #  define MQ_IO_SET(mq,val) ((void)(0))
-#endif
-
-#ifdef MQD_TO_FD
-#  define MQ_IO_MARK(mq) rb_gc_mark((mq)->io)
-#  define MQ_IO_SET(mq,val) do { (mq)->io = (val); } while (0)
+#  define MQ_IO_CLOSE(mq) ((void)(0))
+#  define MQ_IO_NILP(mq) ((void)(1))
 #endif
 
 struct posix_mq {
@@ -46,8 +45,26 @@ struct posix_mq {
 #endif
 };
 
+#ifdef MQD_TO_FD
+#  define MQ_IO_MARK(mq) rb_gc_mark((mq)->io)
+#  define MQ_IO_SET(mq,val) do { (mq)->io = (val); } while (0)
+#  define MQ_IO_NIL_P(mq) NIL_P((mq)->io)
+static int MQ_IO_CLOSE(struct posix_mq *mq)
+{
+	if (NIL_P(mq->io))
+		return 0;
+
+	/* not safe during GC */
+	rb_io_close(mq->io);
+	mq->io = Qnil;
+
+	return 1;
+}
+#endif
+
 static VALUE cPOSIX_MQ, cAttr;
-static ID id_new, id_kill, id_fileno;
+static ID id_new, id_kill, id_fileno, id_mul, id_divmod;
+static ID id_flags, id_maxmsg, id_msgsize, id_curmsgs;
 static ID sym_r, sym_w, sym_rw;
 static const mqd_t MQD_INVALID = (mqd_t)-1;
 
@@ -58,34 +75,22 @@ static const mqd_t MQD_INVALID = (mqd_t)-1;
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s) (RSTRING(s)->len)
 #endif
-#ifndef RSTRUCT_PTR
-#  define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
-#endif
-#ifndef RSTRUCT_LEN
-#  define RSTRUCT_LEN(s) (RSTRUCT(s)->len)
+#ifndef RFLOAT_VALUE
+#  define RFLOAT_VALUE(f) (RFLOAT(f)->value)
 #endif
 
 #ifndef HAVE_RB_STR_SET_LEN
-#  ifdef RUBINIUS
-#    define rb_str_set_len(str,len) rb_str_resize(str,len)
-#  else /* 1.8.6 optimized version */
 /* this is taken from Ruby 1.8.7, 1.8.6 may not have it */
+#  ifdef RUBINIUS
+#    error upgrade Rubinius, rb_str_set_len should be available
+#  endif
 static void rb_18_str_set_len(VALUE str, long len)
 {
 	RSTRING(str)->len = len;
 	RSTRING(str)->ptr[len] = '\0';
 }
-#    define rb_str_set_len(str,len) rb_18_str_set_len(str,len)
-#  endif /* ! RUBINIUS */
 #endif /* !defined(HAVE_RB_STR_SET_LEN) */
 
-#ifndef HAVE_RB_STRUCT_ALLOC_NOINIT
-static VALUE rb_struct_alloc_noinit(VALUE class)
-{
-	return rb_funcall(class, id_new, 0, 0);
-}
-#endif /* !defined(HAVE_RB_STRUCT_ALLOC_NOINIT) */
-
 /* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
 #ifndef HAVE_RB_THREAD_BLOCKING_REGION
 #  include <rubysig.h>
@@ -127,24 +132,63 @@ struct rw_args {
 	struct timespec *timeout;
 };
 
-/* hope it's there..., TODO: a better version that works in rbx */
-struct timeval rb_time_interval(VALUE);
+static void num2timespec(struct timespec *ts, VALUE t)
+{
+	switch (TYPE(t)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		ts->tv_sec = NUM2TIMET(t);
+		ts->tv_nsec = 0;
+		break;
+	case T_FLOAT: {
+		double f, d;
+		double val = RFLOAT_VALUE(t);
+
+		d = modf(val, &f);
+		if (d >= 0) {
+			ts->tv_nsec = (long)(d * 1e9 + 0.5);
+		} else {
+			ts->tv_nsec = (long)(-d * 1e9 + 0.5);
+			if (ts->tv_nsec > 0) {
+				ts->tv_nsec = 1000000000 - ts->tv_nsec;
+				f -= 1;
+			}
+		}
+		ts->tv_sec = (time_t)f;
+		if (f != ts->tv_sec)
+			rb_raise(rb_eRangeError, "%f out of range", val);
+		ts->tv_sec = (time_t)f;
+		}
+		break;
+	default: {
+		VALUE f;
+		VALUE ary = rb_funcall(t, id_divmod, 1, INT2FIX(1));
+
+		Check_Type(ary, T_ARRAY);
+
+		ts->tv_sec = NUM2TIMET(rb_ary_entry(ary, 0));
+		f = rb_ary_entry(ary, 1);
+		f = rb_funcall(f, id_mul, 1, INT2FIX(1000000000));
+		ts->tv_nsec = NUM2LONG(f);
+		}
+	}
+}
 
 static struct timespec *convert_timeout(struct timespec *dest, VALUE t)
 {
-	struct timeval tv, now;
+	struct timespec ts, now;
 
 	if (NIL_P(t))
 		return NULL;
 
-	tv = rb_time_interval(t); /* aggregate return :( */
-	gettimeofday(&now, NULL);
-	dest->tv_sec = now.tv_sec + tv.tv_sec;
-	dest->tv_nsec = (now.tv_usec + tv.tv_usec) * 1000;
+	num2timespec(&ts, t);
+	clock_gettime(CLOCK_REALTIME, &now);
+	dest->tv_sec = now.tv_sec + ts.tv_sec;
+	dest->tv_nsec = now.tv_nsec + ts.tv_nsec;
 
 	if (dest->tv_nsec > 1000000000) {
 		dest->tv_nsec -= 1000000000;
-		dest->tv_sec++;
+		++dest->tv_sec;
 	}
 
 	return dest;
@@ -205,12 +249,10 @@ static void _free(void *ptr)
 {
 	struct posix_mq *mq = ptr;
 
-	if (mq->des != MQD_INVALID) {
+	if (mq->des != MQD_INVALID && MQ_IO_NIL_P(mq)) {
 		/* we ignore errors when gc-ing */
-		int saved_errno = errno;
-
 		mq_close(mq->des);
-		errno = saved_errno;
+		errno = 0;
 	}
 	xfree(ptr);
 }
@@ -246,27 +288,33 @@ static struct posix_mq *get(VALUE self, int need_valid)
 	return mq;
 }
 
-/* converts the POSIX_MQ::Attr astruct into a struct mq_attr attr */
-static void attr_from_struct(struct mq_attr *attr, VALUE astruct, int all)
+static void check_struct_type(VALUE astruct)
 {
-	VALUE *ptr;
+	if (CLASS_OF(astruct) == cAttr)
+		return;
+	astruct = rb_inspect(astruct);
+	rb_raise(rb_eTypeError, "not a POSIX_MQ::Attr: %s",
+		 StringValuePtr(astruct));
+}
 
-	if (CLASS_OF(astruct) != cAttr) {
-		RB_GC_GUARD(astruct) = rb_inspect(astruct);
-		rb_raise(rb_eArgError, "not a POSIX_MQ::Attr: %s",
-		         RSTRING_PTR(astruct));
-	}
+static void rstruct2mqattr(struct mq_attr *attr, VALUE astruct, int all)
+{
+	VALUE tmp;
+
+	check_struct_type(astruct);
+	attr->mq_flags = NUM2LONG(rb_funcall(astruct, id_flags, 0));
 
-	ptr = RSTRUCT_PTR(astruct);
+	tmp = rb_funcall(astruct, id_maxmsg, 0);
+	if (all || !NIL_P(tmp))
+		attr->mq_maxmsg = NUM2LONG(tmp);
 
-	attr->mq_flags = NUM2LONG(ptr[0]);
+	tmp = rb_funcall(astruct, id_msgsize, 0);
+	if (all || !NIL_P(tmp))
+		attr->mq_msgsize = NUM2LONG(tmp);
 
-	if (all || !NIL_P(ptr[1]))
-		attr->mq_maxmsg = NUM2LONG(ptr[1]);
-	if (all || !NIL_P(ptr[2]))
-		attr->mq_msgsize = NUM2LONG(ptr[2]);
-	if (!NIL_P(ptr[3]))
-		attr->mq_curmsgs = NUM2LONG(ptr[3]);
+	tmp = rb_funcall(astruct, id_curmsgs, 0);
+	if (!NIL_P(tmp))
+		attr->mq_curmsgs = NUM2LONG(tmp);
 }
 
 /*
@@ -312,10 +360,10 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 		else if (oflags == sym_rw)
 			x.oflags = O_CREAT|O_RDWR;
 		else {
-			RB_GC_GUARD(oflags) = oflags;
+			oflags = rb_inspect(oflags);
 			rb_raise(rb_eArgError,
 			         "symbol must be :r, :w, or :rw: %s",
-				 RSTRING_PTR(oflags));
+				 StringValuePtr(oflags));
 		}
 		break;
 	case T_BIGNUM:
@@ -347,7 +395,7 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 	switch (TYPE(attr)) {
 	case T_STRUCT:
 		x.argc = 4;
-		attr_from_struct(&x.attr, attr, 1);
+		rstruct2mqattr(&x.attr, attr, 1);
 
 		/* principle of least surprise */
 		if (x.attr.mq_flags & O_NONBLOCK)
@@ -356,14 +404,18 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 	case T_NIL:
 		break;
 	default:
-		RB_GC_GUARD(attr) = rb_inspect(attr);
-		rb_raise(rb_eArgError, "attr must be a POSIX_MQ::Attr: %s",
-		         RSTRING_PTR(attr));
+		check_struct_type(attr);
 	}
 
 	mq->des = (mqd_t)xopen(&x);
-	if (mq->des == MQD_INVALID)
-		rb_sys_fail("mq_open");
+	if (mq->des == MQD_INVALID) {
+		if (errno == ENOMEM || errno == EMFILE || errno == ENFILE) {
+			rb_gc();
+			mq->des = (mqd_t)xopen(&x);
+		}
+		if (mq->des == MQD_INVALID)
+			rb_sys_fail("mq_open");
+	}
 
 	mq->name = rb_str_dup(name);
 	if (x.oflags & O_NONBLOCK)
@@ -609,19 +661,15 @@ static VALUE getattr(VALUE self)
 {
 	struct posix_mq *mq = get(self, 1);
 	VALUE astruct;
-	VALUE *ptr;
 
 	if (mq_getattr(mq->des, &mq->attr) < 0)
 		rb_sys_fail("mq_getattr");
 
-	astruct = rb_struct_alloc_noinit(cAttr);
-	ptr = RSTRUCT_PTR(astruct);
-	ptr[0] = LONG2NUM(mq->attr.mq_flags);
-	ptr[1] = LONG2NUM(mq->attr.mq_maxmsg);
-	ptr[2] = LONG2NUM(mq->attr.mq_msgsize);
-	ptr[3] = LONG2NUM(mq->attr.mq_curmsgs);
-
-	return astruct;
+	return rb_funcall(cAttr, id_new, 4,
+	                  LONG2NUM(mq->attr.mq_flags),
+	                  LONG2NUM(mq->attr.mq_maxmsg),
+	                  LONG2NUM(mq->attr.mq_msgsize),
+	                  LONG2NUM(mq->attr.mq_curmsgs));
 }
 
 /*
@@ -639,7 +687,7 @@ static VALUE setattr(VALUE self, VALUE astruct)
 	struct posix_mq *mq = get(self, 1);
 	struct mq_attr newattr;
 
-	attr_from_struct(&newattr, astruct, 0);
+	rstruct2mqattr(&newattr, astruct, 0);
 
 	if (mq_setattr(mq->des, &newattr, NULL) < 0)
 		rb_sys_fail("mq_setattr");
@@ -661,11 +709,11 @@ static VALUE _close(VALUE self)
 {
 	struct posix_mq *mq = get(self, 1);
 
-	if (mq_close(mq->des) < 0)
-		rb_sys_fail("mq_close");
-
+	if (! MQ_IO_CLOSE(mq)) {
+		if (mq_close(mq->des) == -1)
+			rb_sys_fail("mq_close");
+	}
 	mq->des = MQD_INVALID;
-	MQ_IO_SET(mq, Qnil);
 
 	return Qnil;
 }
@@ -736,6 +784,20 @@ static void thread_notify_fd(union sigval sv)
 	while ((write(fd, "", 1) < 0) && (errno == EINTR || errno == EAGAIN));
 }
 
+static void my_mq_notify(mqd_t des, struct sigevent *not)
+{
+	mqd_t rv = mq_notify(des, not);
+
+	if (rv == MQD_INVALID) {
+		if (errno == ENOMEM) {
+			rb_gc();
+			rv = mq_notify(des, not);
+		}
+		if (rv == MQD_INVALID)
+			rb_sys_fail("mq_notify");
+	}
+}
+
 /* :nodoc: */
 static VALUE setnotify_exec(VALUE self, VALUE io, VALUE thr)
 {
@@ -763,8 +825,7 @@ static VALUE setnotify_exec(VALUE self, VALUE io, VALUE thr)
 		rb_funcall(mq->thread, id_kill, 0, 0);
 	mq->thread = thr;
 
-	if (mq_notify(mq->des, &not) < 0)
-		rb_sys_fail("mq_notify");
+	my_mq_notify(mq->des, &not);
 
 	return thr;
 }
@@ -834,8 +895,7 @@ static VALUE setnotify(VALUE self, VALUE arg)
 		rb_raise(rb_eArgError, "must be a signal or nil");
 	}
 
-	if (mq_notify(mq->des, notification) < 0)
-		rb_sys_fail("mq_notify");
+	my_mq_notify(mq->des, notification);
 
 	return rv;
 }
@@ -931,6 +991,12 @@ void Init_posix_mq_ext(void)
 	id_new = rb_intern("new");
 	id_kill = rb_intern("kill");
 	id_fileno = rb_intern("fileno");
+	id_mul = rb_intern("*");
+	id_divmod = rb_intern("divmod");
+	id_flags = rb_intern("flags");
+	id_maxmsg = rb_intern("maxmsg");
+	id_msgsize = rb_intern("msgsize");
+	id_curmsgs = rb_intern("curmsgs");
 	sym_r = ID2SYM(rb_intern("r"));
 	sym_w = ID2SYM(rb_intern("w"));
 	sym_rw = ID2SYM(rb_intern("rw"));