io-extra 1.2.5 → 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 413914a045cda689f991f043d5b314d6734777094d0f90359e5c10c1062d7648
+  data.tar.gz: beeb120887bf9e7c3af06f0f2a9cc733cce21f21ddf9738ef2830bab0be1931f
+SHA512:
+  metadata.gz: 2ad2db30be150d3837b182e6063f2db69faf0895fde33b5ba552029c1ba988093efdfd96421a155129543ae43b545eca656b2e9243bc6c0c13fd3a4dec37a842
+  data.tar.gz: 3611120e98da21cd73fd3960a6a1df6a05514a5436fbf29de3e9d0f27971ad5c94e2309fcc3399581439dc95735c78bb75303ca772cca8dcd0225631a266a1b3

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+\����}WyN�P:���n���?`>����+�w�t�&�O�ϴb�ľ�W �QX�'���%�Ȏ�w���������,h4�h�"�\�"N@�i՞�x�?���bC7R}����h	��^��%�U��Z�u+��m,|� ���>X]�M�9�L�ZI�X����,Ω=�V=p�&�����M����|r
��BpӃâC��������OLdzb`Y�ݽ��N�Q ,�]y���k��'�z��3�d����.�R4�7������
ש8���K@U�`���ϩ_�0Z�ii��9��+��3��_iҽ�c�"ÐrQ���i��~��t�f����ql
+�u�@��l��|2��v�5X>��!)k�=@`n�҉��͕�ڐJK

data/CHANGES

@@ -1,3 +1,48 @@
+== 1.4.0 - 8-Jul-2020
+* Replaced the C versions of IO.pread and IO.pwrite singleton methods with
+  pure Ruby wrappers since core Ruby has implemented instance method versions
+  since Ruby 2.5. These now require filehandles (rather than fileno) as an
+  argument.
+* Removed the pread_ptr method, I don't think anyone was using it. Might get
+  added back if there are complaints.
+* Removed the DIRECT constant since that is now defined by core Ruby.
+* Moved the VERSION constant into the pure Ruby file.
+* Now requires Ruby 2.5 or later.
+* Added a LICENSE file as required by the Apache-2.0 license.
+* The 'io-extra' file is now the preferred way to require this library.
+
+== 1.3.0 - 19-Oct-2018
+* Now assumes Ruby 2.1 or later. This has no effect on the external API, but
+  it does allow for lots of internal cleanup.
+* License changed to Apache-2.0.
+* The EXTRA_VERSION constant is now frozen.
+* Added the io-extra.rb file for convenience.
+* Updates to the gemspec, including the addition of metadata.
+* The Rakefile now assumes Rubygems 2.0 or later.
+* Added a cert.
+* Removed the .gemtest file.
+
+== 1.2.8 - 29-Dec-2014
+* Updated for compatibility with Ruby 2.2.x.
+
+== 1.2.7 - 10-Aug-2013
+* Direct IO is now supported on Darwin, and some bugs in the directio
+  methods have been fixed. Thanks go to Genki Takiuchi for the patches.
+* Fixed a bug in fdwalk and closefrom when using Ruby 1.9.3 where
+  closing reserved file descriptors would segfault the interpreter.
+  Thanks go to Eric Wong for the patch.
+* Fixed a bug in the fdwalk method where it was not honoring the
+  lowfd argument, and added a test for it.
+* The rb_thread_call_without_gvl function is now used internally in
+  place of rb_thread_blocking_region for Ruby 2.x.
+
+== 1.2.6 - 22-May-2011
+* Fixed a potential memory leak in the pread_ptr method where malloc'ed
+  memory was not freed if the pread function call failed. Thanks go to
+  Eric Wong for the spot.
+* Added the IO#ttyname method.
+* Added the (empty) .gemtest file for test.rubygems.org.
+
 == 1.2.5 - 23-Mar-2011
 * Use rb_thread_blocking_region internally for IO.pread and IO.pwrite. Thanks
   go to Eric Wong for the patch.

data/MANIFEST

@@ -1,10 +1,13 @@
+* CHANGES
+* LICENSE
 * MANIFEST
 * README
-* CHANGES
 * Rakefile
 * io-extra.gemspec
+* certs/djberg96_pub.pem
 * doc/io_extra.txt
 * examples/example_io_extra.rb
 * ext/extconf.rb
 * ext/io/extra.c
-* test/test_io_extra.rb
+* lib/io-extra.rb
+* test/test_io_extra.rb

data/README

@@ -5,13 +5,13 @@
 	
   This library is not supported on MS Windows.
 
-  Support for OS X is limited. See the documentation for details.
+  Support for OS X is limited. See below for details.
 
 = Installation
   gem install io-extra
 
 = Synopsis
-  require 'io/extra'
+  require 'io-extra' # Do not use 'io/extra'
 
   # Close all file descriptors from 3 up.
   IO.closefrom(3)
@@ -27,6 +27,10 @@
   IO.writev(fh.fileno, %w[a b c])
 
 = Developer's Notes
+  The "require 'io-extra'" is preferred over 'io/extra' because this is a mix
+  of pure Ruby and C extension. The former require's the latter, so that way
+  you get all the methods and constants that you expect.
+
   You might be wondering what the difference is between my implementation of
   IO.closefrom and a pure Ruby version that looks something like this:
 
@@ -45,9 +49,9 @@
   of IO.fdwalk and a pure Ruby version that looks something like this:
 
    def IO.fdwalk(n)
-      ObjectSpace.each_object(File){ |f|
-         yield f if f.fileno >= n
-      }
+     ObjectSpace.each_object(File){ |f|
+       yield f if f.fileno >= n
+     }
    end
 
   The primary difference is that this only closes Ruby file objects, not
@@ -55,8 +59,8 @@
   opened via system() calls.
 
 = Note to OS X Users
-  The OS X platform does not support closefrom(), fdwalk() or directio(). The
-  hand-crafted IO.closefrom function will not work because the getrlimit()
+  The OS X platform does not support closefrom() or fdwalk(). The hand-
+  crafted IO.closefrom function will not work because the getrlimit()
   function on OS X does not work. Patches welcome.
 
 = Documentation
@@ -64,24 +68,24 @@
   documentation that was generated by RDoc (if you did a gem install).
 
 = Known Issues
-  The IO.writev tests fail on Solaris. We are not sure why yet.
+  The IO.writev tests fail on Solaris. Short test scripts seem to work,
+  however. We're not sure what the issue is yet. Help wanted.
 
-  Please file any bug reports on the project page at
-  http://www.rubyforge.org/projects/shards.
+  Update: As of 2018 Solaris is basically dead, so I'm not going to worry
+  about supporting Solaris unless there's an outcry.
 
-= Future Plans
-  * I may add the File::O_DIRECT open constant on platforms that support it.
-  * Switch from C extension to FFI.
+  Please file any bug reports on the project page at
+  https://github.com/djberg96/io-extra
 
 = Acknowledgements
   Eric Wong for some great work on Linux compatibility and other fixes, as
   well as the code for the IO.writev method.
-   
+
 = License
-  Artistic 2.0
+  Apache-2.0
 
 = Copyright
-  (C) 2003-2010 Daniel J. Berger
+  (C) 2003-2020 Daniel J. Berger
   All Rights Reserved
     
 = Warranty

data/ext/extconf.rb

@@ -10,11 +10,8 @@ have_header('sys/uio.h')
 have_func('closefrom')
 have_func('fdwalk')
 have_func('directio')
-have_func('pread')
-have_func('pwrite')
 have_func('writev')
-have_func('rb_str_set_len', 'ruby.h')
-have_func('rb_thread_blocking_region')
+have_func('ttyname')
 
 case RbConfig::CONFIG['host_os']
 when /darwin/i
@@ -35,4 +32,8 @@ if have_macro("O_DIRECT", %w(sys/types.h fcntl.h))
   $CPPFLAGS += " -DHAVE_O_DIRECT_MACRO"
 end
 
+if have_macro("F_NOCACHE", %w(fcntl.h))
+  $CPPFLAGS += " -DHAVE_F_NOCACHE_MACRO"
+end
+
 create_makefile('io/extra', 'io')

data/ext/io/extra.c

@@ -1,10 +1,7 @@
 /* Extra methods for the IO class */
 #include "ruby.h"
-#ifdef HAVE_RUBY_IO_H
 #include "ruby/io.h"
-#else
-#include "rubyio.h"
-#endif
+#include "ruby/thread.h"
 
 #include <unistd.h>
 #include <stdlib.h>
@@ -26,53 +23,11 @@
 #if defined(_SC_IOV_MAX)
 #define IOV_MAX (sysconf(_SC_IOV_MAX))
 #else
-/* assume infinity, or let the syscall return with error ... */
+// Assume infinity, or let the syscall return with error
 #define IOV_MAX INT_MAX
 #endif
 #endif
 
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
-/*
- * partial emulation of the 1.9 rb_thread_blocking_region under 1.8,
- * this is enough to ensure signals are processed safely when doing I/O
- * to a slow device, but doesn't actually ensure threads can be
- * scheduled fairly in 1.8
- */
-#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 *fn, void *data1,
-   rb_unblock_function_t *ubf, void *data2)
-{
-   VALUE rv;
-
-   TRAP_BEG;
-   rv = fn(data1);
-   TRAP_END;
-
-   return rv;
-}
-#endif
-
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(v) (RSTRING(v)->ptr)
-#define RSTRING_LEN(v) (RSTRING(v)->len)
-#endif
-
-#ifndef HAVE_RB_STR_SET_LEN
-/* this is taken from Ruby 1.8.7, 1.8.6 may not have it */
-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
-
-
 #ifdef PROC_SELF_FD_DIR
 #include <dirent.h>
 #endif
@@ -131,17 +86,16 @@ static int open_max(void){
  * The manual approach was copied from the closefrom() man page on Solaris 9.
  */
 static VALUE io_closefrom(VALUE klass, VALUE v_low_fd){
-#ifdef HAVE_CLOSEFROM
-   closefrom(NUM2INT(v_low_fd));
-#else
-   int i, lowfd;
-   int maxfd = open_max();
-   lowfd = NUM2INT(v_low_fd);
+  int i, lowfd;
+  int maxfd = open_max();
+  lowfd = NUM2INT(v_low_fd);
 
-   for(i = lowfd; i < maxfd; i++)
+  for(i = lowfd; i < maxfd; i++) {
+    if(!RB_RESERVED_FD_P(i))
       close(i);
-#endif
-   return klass;
+  }
+
+  return klass;
 }
 
 #ifndef HAVE_FDWALK
@@ -202,11 +156,17 @@ static int fdwalk(int (*func)(void *data, int fd), void *data){
  * It's up to the user to close it.
  */
 static int close_func(void* lowfd, int fd){
-   VALUE v_args[1];
+  VALUE v_args[1];
 
-   v_args[0] = UINT2NUM(fd);
-   rb_yield(rb_class_new_instance(1, v_args, rb_cFile));
-   return 0;
+  if(fd >= *(int*)lowfd){
+    if (RB_RESERVED_FD_P(fd))
+      return 0;
+
+    v_args[0] = UINT2NUM(fd);
+    rb_yield(rb_class_new_instance(1, v_args, rb_cFile));
+  }
+
+  return 0;
 }
 
 /*
@@ -218,19 +178,19 @@ static int close_func(void* lowfd, int fd){
  * Not supported on all platforms.
  */
 static VALUE io_fdwalk(int argc, VALUE* argv, VALUE klass){
-   VALUE v_low_fd, v_block;
-   int lowfd;
+  VALUE v_low_fd, v_block;
+  int lowfd;
 
-   rb_scan_args(argc, argv, "1&", &v_low_fd, &v_block);
-   lowfd = NUM2INT(v_low_fd);
+  rb_scan_args(argc, argv, "1&", &v_low_fd, &v_block);
+  lowfd = NUM2INT(v_low_fd);
 
-   fdwalk(close_func, &lowfd);
+  fdwalk(close_func, &lowfd);
 
-   return klass;
+  return klass;
 }
 #endif
 
-#if defined(HAVE_DIRECTIO) || defined(O_DIRECT)
+#if defined(HAVE_DIRECTIO) || defined(O_DIRECT) || defined(F_NOCACHE)
 /*
  * call-seq:
  *    IO#directio?
@@ -239,24 +199,21 @@ static VALUE io_fdwalk(int argc, VALUE* argv, VALUE klass){
  * current handle. The default is false.
  */
 static VALUE io_get_directio(VALUE self){
-#if defined(HAVE_DIRECTIO)
-   VALUE v_advice = Qnil;
+#if defined(HAVE_DIRECTIO) || defined(F_NOCACHE)
+  VALUE v_advice = rb_iv_get(self, "@directio");
 
-   if(rb_ivar_defined(rb_cIO, rb_intern("@directio")))
-      v_advice = rb_iv_get(self, "directio");
+  if(NIL_P(v_advice))
+    v_advice = Qfalse;
 
-   if(NIL_P(v_advice))
-      v_advice = Qfalse;
-
-   return v_advice;
+  return v_advice;
 #elif defined(O_DIRECT)
-   int fd = NUM2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
-   int flags = fcntl(fd, F_GETFL);
+  int fd = NUM2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
+  int flags = fcntl(fd, F_GETFL);
 
-   if(flags < 0)
-      rb_sys_fail("fcntl");
+  if(flags < 0)
+    rb_sys_fail("fcntl");
 
-   return (flags & O_DIRECT) ? Qtrue : Qfalse;
+  return (flags & O_DIRECT) ? Qtrue : Qfalse;
 #endif /* O_DIRECT */
 }
 
@@ -287,9 +244,12 @@ static VALUE io_set_directio(VALUE self, VALUE v_advice){
       rb_raise(rb_eStandardError, "The directio() call failed");
 
    if(advice == DIRECTIO_ON)
-      rb_iv_set(self, "directio", Qtrue);
+      rb_iv_set(self, "@directio", Qtrue);
+   else
+      rb_iv_set(self, "@directio", Qfalse);
 #else
    {
+#if defined(O_DIRECT)
       int flags = fcntl(fd, F_GETFL);
 
       if(flags < 0)
@@ -306,6 +266,17 @@ static VALUE io_set_directio(VALUE self, VALUE v_advice){
                rb_sys_fail("fcntl");
          }
       }
+#elif defined(F_NOCACHE)
+      if(advice == DIRECTIO_OFF){
+         if(fcntl(fd, F_NOCACHE, 0) < 0)
+            rb_sys_fail("fcntl");
+         rb_iv_set(self, "@directio", Qfalse);
+      } else { /* DIRECTIO_ON*/
+         if(fcntl(fd, F_NOCACHE, 1) < 0)
+            rb_sys_fail("fcntl");
+         rb_iv_set(self, "@directio", Qtrue);
+      }
+#endif
    }
 #endif
 
@@ -313,116 +284,6 @@ static VALUE io_set_directio(VALUE self, VALUE v_advice){
 }
 #endif
 
-#ifdef HAVE_PREAD
-struct pread_args {
-   int fd;
-   void *buf;
-   size_t nbyte;
-   off_t offset;
-};
-
-static VALUE nogvl_pread(void *ptr)
-{
-   struct pread_args *args = ptr;
-
-   return (VALUE)pread(args->fd, args->buf, args->nbyte, args->offset);
-}
-
-/*
- * IO.pread(fd, length, offset)
- *
- * This is similar to the IO.read method, except that it reads from a given
- * position in the file without changing the file pointer. And unlike IO.read,
- * the +fd+, +length+ and +offset+ arguments are all mandatory.
- */
-static VALUE s_io_pread(VALUE klass, VALUE fd, VALUE nbyte, VALUE offset){
-   struct pread_args args;
-   VALUE str;
-   ssize_t nread;
-
-   args.fd = NUM2INT(fd);
-   args.nbyte = NUM2ULONG(nbyte);
-   args.offset = NUM2OFFT(offset);
-   str = rb_str_new(NULL, args.nbyte);
-   args.buf = RSTRING_PTR(str);
-
-   nread = (ssize_t)rb_thread_blocking_region(nogvl_pread, &args, RUBY_UBF_IO, 0);
-
-   if (nread == -1)
-      rb_sys_fail("pread");
-   if ((size_t)nread != args.nbyte)
-      rb_str_set_len(str, nread);
-
-   return str;
-}
-
-/*
- * IO.pread_ptr(fd, length, offset)
- *
- * This is identical to IO.pread, except that it returns the pointer address
- * of the string, instead of the actual buffer.
- *--
- * This was added because, in some cases, the IO.pread buffer might return
- * an empty string. In such situations we are unable to get the actual pointer
- * address with pure Ruby.
- */
-static VALUE s_io_pread_ptr(VALUE klass, VALUE v_fd, VALUE v_nbyte, VALUE v_offset){
-   int fd = NUM2INT(v_fd);
-   size_t nbyte = NUM2ULONG(v_nbyte);
-   off_t offset = NUM2OFFT(v_offset);
-   uintptr_t* vector = malloc(nbyte + 1);
-
-   if(pread(fd, vector, nbyte, offset) == -1)
-      rb_sys_fail("pread");
-
-   return ULL2NUM(vector[0]);
-}
-#endif
-
-#ifdef HAVE_PWRITE
-struct pwrite_args {
-   int fd;
-   const void *buf;
-   size_t nbyte;
-   off_t offset;
-};
-
-static VALUE nogvl_pwrite(void *ptr)
-{
-   struct pwrite_args *args = ptr;
-
-   return (VALUE)pwrite(args->fd, args->buf, args->nbyte, args->offset);
-}
-
-/*
- * IO.pwrite(fd, buf, offset)
- *
- * This method writes the +buf+, starting at +offset+, to the given +fd+,
- * which must be opened with write permissions.
- *
- * This is similar to a seek & write in standard Ruby but the difference,
- * beyond being a singleton method, is that the file pointer is never moved.
- *
- * Returns the number of bytes written.
- */
-static VALUE s_io_pwrite(VALUE klass, VALUE fd, VALUE buf, VALUE offset){
-   ssize_t result;
-   struct pwrite_args args;
-
-   args.fd = NUM2INT(fd);
-   args.buf = RSTRING_PTR(buf);
-   args.nbyte = RSTRING_LEN(buf);
-   args.offset = NUM2OFFT(offset);
-
-   result = (ssize_t)rb_thread_blocking_region(nogvl_pwrite, &args, RUBY_UBF_IO, 0);
-
-   if(result == -1)
-      rb_sys_fail("pwrite");
-
-   return ULL2NUM(result);
-}
-#endif
-
 /* this can't be a function since we use alloca() */
 #define ARY2IOVEC(iov,iovcnt,expect,ary) \
    do { \
@@ -449,16 +310,15 @@ static VALUE s_io_pwrite(VALUE klass, VALUE fd, VALUE buf, VALUE offset){
 
 #if defined(HAVE_WRITEV)
 struct writev_args {
-   int fd;
-   struct iovec *iov;
-   int iovcnt;
+  int fd;
+  struct iovec *iov;
+  int iovcnt;
 };
 
 static VALUE nogvl_writev(void *ptr)
 {
-   struct writev_args *args = ptr;
-
-   return (VALUE)writev(args->fd, args->iov, args->iovcnt);
+  struct writev_args *args = ptr;
+  return (VALUE)writev(args->fd, args->iov, args->iovcnt);
 }
 
 /*
@@ -473,68 +333,95 @@ static VALUE nogvl_writev(void *ptr)
  * Returns the number of bytes written.
  */
 static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
-   ssize_t result = 0;
-   ssize_t left;
-   struct writev_args args;
+  ssize_t result = 0;
+  ssize_t left;
+  struct writev_args args;
 
-   args.fd = NUM2INT(fd);
-   ARY2IOVEC(args.iov, args.iovcnt, left, ary);
+  // Allow a fileno or filehandle
+  if(rb_respond_to(fd, rb_intern("fileno")))
+    fd = rb_funcall(fd, rb_intern("fileno"), 0, 0);
 
-   for(;;) {
-      ssize_t w = (ssize_t)rb_thread_blocking_region(nogvl_writev, &args,
-                                                     RUBY_UBF_IO, 0);
+  args.fd = NUM2INT(fd);
+  ARY2IOVEC(args.iov, args.iovcnt, left, ary);
 
-      if(w == -1) {
-         if (rb_io_wait_writable(args.fd)) {
-            continue;
-         } else {
-            if (result > 0) {
-               /*
-                * unlikely to hit this case, return the already written bytes,
-                * we'll let the next write (or close) fail instead
-                */
-               break;
-            }
-            rb_sys_fail("writev");
-         }
+  for(;;) {
+    ssize_t w = (ssize_t)rb_thread_call_without_gvl(
+      (void*)nogvl_writev, &args, RUBY_UBF_IO, 0
+    );
+
+    if(w == -1){
+      if(rb_io_wait_writable(args.fd)){
+        continue;
+      }
+      else{
+        if(result > 0){
+          /* unlikely to hit this case, return the already written bytes,
+           * we'll let the next write (or close) fail instead */
+          break;
+        }
+        rb_sys_fail("writev");
       }
+    }
 
-      result += w;
-      if(w == left) {
-         break;
-      } else { /* partial write, this can get tricky */
-         int i;
-         struct iovec *new_iov = args.iov;
-
-         left -= w;
-
-         /* skip over iovecs we've already written completely */
-         for (i = 0; i < args.iovcnt; i++, new_iov++) {
-            if (w == 0)
-               break;
-
-            /*
-             * partially written iov,
-             * modify and retry with current iovec in front
-             */
-            if (new_iov->iov_len > (size_t)w) {
-               VALUE base = (VALUE)new_iov->iov_base;
-
-               new_iov->iov_len -= w;
-               new_iov->iov_base = (void *)(base + w);
-               break;
-            }
-
-            w -= new_iov->iov_len;
-         }
+    result += w;
+
+    if(w == left){
+      break;
+    }
+    else{
+      // Partial write, this can get tricky
+      int i;
+      struct iovec *new_iov = args.iov;
+
+      left -= w;
+
+      // Skip over iovecs we've already written completely
+      for(i = 0; i < args.iovcnt; i++, new_iov++){
+        if (w == 0)
+          break;
 
-         /* retry without the already-written iovecs */
-         args.iovcnt -= i;
-         args.iov = new_iov;
+        // Partially written iov, modify and retry with current iovec in front
+        if(new_iov->iov_len > (size_t)w){
+          VALUE base = (VALUE)new_iov->iov_base;
+
+          new_iov->iov_len -= w;
+          new_iov->iov_base = (void *)(base + w);
+          break;
+        }
+
+        w -= new_iov->iov_len;
       }
-   }
 
-   return LONG2NUM(result);
+      // Retry without the already-written iovecs
+      args.iovcnt -= i;
+      args.iov = new_iov;
+    }
+  }
+
+  return LONG2NUM(result);
+}
+#endif
+
+#ifdef HAVE_TTYNAME
+/*
+ * io.ttyname
+ *
+ * Returns the ttyname associated with the IO object, or nil if the IO
+ * object isn't associated with a tty.
+ *
+ * Example:
+ *
+ *  STDOUT.ttyname # => '/dev/ttyp1'
+ */
+static VALUE io_get_ttyname(VALUE self){
+  VALUE v_return = Qnil;
+
+  int fd = NUM2INT(rb_funcall(self, rb_intern("fileno"), 0, 0));
+
+  if(isatty(fd))
+    v_return = rb_str_new2(ttyname(fd));
+
+  return v_return;
 }
 #endif
 
@@ -542,43 +429,30 @@ static VALUE s_io_writev(VALUE klass, VALUE fd, VALUE ary) {
  * and IO#directio? instance methods (if supported on your platform).
  */
 void Init_extra(){
-   rb_define_singleton_method(rb_cIO, "closefrom", io_closefrom, 1);
+  rb_define_singleton_method(rb_cIO, "closefrom", io_closefrom, 1);
 
 #ifdef HAVE_FDWALK
-   rb_define_singleton_method(rb_cIO, "fdwalk", io_fdwalk, -1);
+  rb_define_singleton_method(rb_cIO, "fdwalk", io_fdwalk, -1);
 #endif
 
-#if defined(HAVE_DIRECTIO) || defined(O_DIRECT)
-   rb_define_method(rb_cIO, "directio?", io_get_directio, 0);
-   rb_define_method(rb_cIO, "directio=", io_set_directio, 1);
+#if defined(HAVE_DIRECTIO) || defined(O_DIRECT) || defined(F_NOCACHE)
+  rb_define_method(rb_cIO, "directio?", io_get_directio, 0);
+  rb_define_method(rb_cIO, "directio=", io_set_directio, 1);
 
-   /* 0: Applications get the default system behavior when accessing file data. */
-   rb_define_const(rb_cIO, "DIRECTIO_OFF", UINT2NUM(DIRECTIO_OFF));
+  /* 0: Applications get the default system behavior when accessing file data. */
+  rb_define_const(rb_cIO, "DIRECTIO_OFF", UINT2NUM(DIRECTIO_OFF));
 
-   /* 1: File data is not cached in the system's memory pages. */
-   rb_define_const(rb_cIO, "DIRECTIO_ON", UINT2NUM(DIRECTIO_ON));
+  /* 1: File data is not cached in the system's memory pages. */
+  rb_define_const(rb_cIO, "DIRECTIO_ON", UINT2NUM(DIRECTIO_ON));
 #endif
 
-#ifdef O_DIRECT
-   /* 040000: direct disk access (in Linux) */
-   rb_define_const(rb_cIO, "DIRECT", UINT2NUM(O_DIRECT));
-#endif
-
-   rb_define_const(rb_cIO, "IOV_MAX", LONG2NUM(IOV_MAX));
-
-#ifdef HAVE_PREAD
-   rb_define_singleton_method(rb_cIO, "pread", s_io_pread, 3);
-   rb_define_singleton_method(rb_cIO, "pread_ptr", s_io_pread_ptr, 3);
-#endif
-
-#ifdef HAVE_PWRITE
-   rb_define_singleton_method(rb_cIO, "pwrite", s_io_pwrite, 3);
-#endif
+  rb_define_const(rb_cIO, "IOV_MAX", LONG2NUM(IOV_MAX));
 
 #ifdef HAVE_WRITEV
-   rb_define_singleton_method(rb_cIO, "writev", s_io_writev, 2);
+  rb_define_singleton_method(rb_cIO, "writev", s_io_writev, 2);
 #endif
 
-   /* 1.2.5: The version of this library. This a string. */
-   rb_define_const(rb_cIO, "EXTRA_VERSION", rb_str_new2("1.2.5"));
+#ifdef HAVE_TTYNAME
+  rb_define_method(rb_cIO, "ttyname", io_get_ttyname, 0);
+#endif
 }