process_tail 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8de878e91fb0d39a77238a19bcb567e6257ed449
-  data.tar.gz: 9b4353b4c9e7cd4ed6ee44cdc9796310448912a3
+  metadata.gz: 85d86bdf54735a348134ab9abceec3610882fe23
+  data.tar.gz: 9f1e65346bd355e4fb1b9f9c83fdf8c45a16a224
 SHA512:
-  metadata.gz: dec2d6a557f9c826234c0fdbc0d4bc19eca4e35c28d303d63a9e7078e3e93c72684ea469eb6ae6581a97e2598602b89380d60b19301139ab6b812fcfa0fdc360
-  data.tar.gz: b71a3dc8ca8bccd242ccfa2148e777c3063b3941a169b50fe09858b25e23df0921f9e42bafc022830d75417cad0e8c51e66996fdc85d6702b50dc74813ac9136
+  metadata.gz: e3da11ae5cece8697449bcea8307bc34e1af5b6cb3a39834e96d56f2b32d6306e4ac9070909c79bab0f2486f319a15de408d13df6982d9d3fa367163920c8387
+  data.tar.gz: 30b6556d39cf4b06169e518a69fe7a8c1b0b03a05e0f0db97bcd6abafee42625622048885fbc7452dfbf48cec4915983c2feb10aa6aae5ea132a7a7b8c770b56

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+script: bundle exec rake

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in process_tail.gemspec
 gemspec
+
+gem 'pry'

data/README.md

@@ -1,4 +1,4 @@
-# ProcessTail
+# ProcessTail [![Build Status](https://travis-ci.org/hibariya/process_tail.svg?branch=master)](https://travis-ci.org/hibariya/process_tail)
 
 https://github.com/hibariya/process_tail
 
@@ -11,6 +11,7 @@ So you can get other process outputs.
 
 * Mac OSX and Windows are not supported at the moment
 * SEGV occures occasionally
+* Multithreaded process support
 
 ## Installation
 

data/bin/process_tail

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'process_tail'
+
+$stdout.sync = true
+
+ProcessTail.open Integer(ARGV[0]) do |io|
+  while c = io.getc
+    print c
+  end
+end

data/ext/process_tail/extconf.rb

@@ -4,10 +4,11 @@ require 'mkmf'
   abort "missing #{h}" unless have_header(h)
 end
 
-abort 'missing ptrace' unless have_func('ptrace', 'sys/ptrace.h')
-
 %w(orig_rax rdi rdx rsi rdx).each do |m|
   abort "missing #{m}" unless have_struct_member('struct user_regs_struct', m, 'sys/user.h')
 end
 
+abort 'missing __WALL'                unless have_const('__WALL', 'sys/wait.h')
+abort 'missing PTRACE_O_TRACESYSGOOD' unless have_const('PTRACE_O_TRACESYSGOOD', 'sys/ptrace.h')
+
 create_makefile 'process_tail/process_tail'

data/ext/process_tail/process_tail.c

@@ -1,5 +1,3 @@
-#include <errno.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ptrace.h>
@@ -10,148 +8,257 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 
-struct
-process_tail_args {
+typedef struct pt_tracee {
   pid_t pid;
+  int activated;
+  int dead;
+  struct pt_tracee *next;
+} pt_tracee_t;
+
+typedef struct pt_wait_args {
   int *status;
-  unsigned int fd;
-  VALUE io;
-};
+  pid_t pid;
+} pt_wait_args_t;
 
-static void *
-process_tail_waitpid(void *argp)
+static pt_tracee_t *
+pt_tracee_add(pt_tracee_t **headpp, pid_t pid)
 {
-  struct process_tail_args *args = argp;
+  pt_tracee_t *tracee = malloc(sizeof(pt_tracee_t));
 
-  waitpid(args->pid, args->status, WUNTRACED | WCONTINUED);
+  if (tracee == NULL) {
+    exit(EXIT_FAILURE);
+  }
 
-  return NULL;
+  tracee->pid       = pid;
+  tracee->activated = 0;
+  tracee->dead      = 0;
+  tracee->next      = (struct pt_tracee *)*headpp;
+
+  (*headpp) = tracee;
+
+  return tracee;
+}
+
+static pt_tracee_t *
+pt_tracee_find_or_add(pt_tracee_t **headpp, pid_t pid)
+{
+  pt_tracee_t *tracee = *headpp;
+
+  while (tracee != NULL) {
+    if (tracee->pid == pid) {
+      return tracee;
+    }
+
+    tracee = tracee->next;
+  }
+
+  return pt_tracee_add(headpp, pid);
 }
 
 static int
-process_tail_attach(void *argp)
+pt_tracee_wipedoutq(pt_tracee_t *headp)
 {
-  struct process_tail_args *args = argp;
+  pt_tracee_t *tracee = headp;
 
-  if (ptrace(PTRACE_ATTACH, args->pid, NULL, NULL) < 0) {
-    rb_sys_fail("PTRACE_ATTACH");
-    return -1;
+  while (tracee != NULL) {
+    if (tracee->dead == 0) {
+      return 0;
+    }
+
+    tracee = tracee->next;
   }
 
-  rb_thread_call_without_gvl(process_tail_waitpid, (void *)argp, RUBY_UBF_PROCESS, NULL);
+  return 1;
+}
+
+static void
+pt_tracee_free(pt_tracee_t **headpp)
+{
+  pt_tracee_t *tracee  = *headpp;
 
-  return 0;
+  if (tracee->next) {
+    pt_tracee_free(&tracee->next);
+  }
+
+  free(tracee);
+  (*headpp) = NULL;
 }
 
-static VALUE
-process_tail_detach(VALUE argp)
+static int
+pt_io_closedq(VALUE io)
 {
-  struct process_tail_args *args = (void *)argp;
+  return rb_funcall(io, rb_intern("closed?"), 0) == Qtrue;
+}
 
-  ptrace(PTRACE_DETACH, args->pid, NULL, NULL);
+static void *
+pt_wait(void *argp)
+{
+  pt_wait_args_t *args = (pt_wait_args_t *)argp;
 
-  return Qnil;
+  args->pid = waitpid(-1, args->status, __WALL);
+
+  return NULL;
 }
 
 static void
-process_tail_get_data(pid_t pid, long addr, char *string, int len)
+pt_get_data(pid_t pid, long addr, char *string, int length)
 {
-  long data;
   int  i;
+  long data;
 
-  for (i = 0; i < len; i += sizeof(long)) {
+  for (i = 0; i < length; i += sizeof(long)) {
     data = ptrace(PTRACE_PEEKDATA, pid, addr + i);
 
     memcpy(string + i, &data, sizeof(long));
   }
 
-  string[len] = '\0';
+  string[length] = '\0';
 }
 
-static VALUE
-process_tail_loop(VALUE argp)
+static void
+pt_ptrace_syscall(pid_t pid, long signal)
 {
-  struct process_tail_args *args = (void *)argp;
-  struct user_regs_struct regs;
-  int in_syscall = 0;
-  int signal     = 0;
+  ptrace(PTRACE_SYSCALL, pid, 0, signal);
+
+  rb_thread_schedule();
+}
+
+static void
+pt_loop(unsigned int fd, VALUE write_io, VALUE read_io, VALUE wait_queue, pt_tracee_t *tracee_headp)
+{
+  char *string = NULL;
+  int syscall  = 0;
   int status;
-  char *string   = NULL;
+  long signal;
+  pid_t pid;
+  pt_tracee_t *tracee;
+  pt_wait_args_t pt_wait_args = {&status};
 
-  args->status = &status;
+  // NOTE: system call: eax, arguments: rdi, rsi, rdx, r10, r8, r9
+  struct user_regs_struct regs;
 
-  while (ptrace(PTRACE_SYSCALL, args->pid, NULL, signal) == 0) {
-    rb_thread_call_without_gvl(process_tail_waitpid, args, RUBY_UBF_PROCESS, NULL);
+  while (1) {
+    rb_thread_call_without_gvl(pt_wait, &pt_wait_args, RUBY_UBF_PROCESS, NULL);
 
     signal = 0;
+    pid    = pt_wait_args.pid;
+    tracee = pt_tracee_find_or_add(&tracee_headp, pid);
+
+    if (pt_io_closedq(read_io)) {
+      pt_tracee_free(&tracee_headp);
 
-    if (WIFEXITED(status)) {
-      return Qnil;
+      return;
     }
 
-    if (!WIFSTOPPED(status)) {
+    if (tracee->activated == 0) {
+      ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD);
+      tracee->activated = 1;
+
+      rb_funcall(wait_queue, rb_intern("enq"), 1, INT2FIX((int)pid));
+      pt_ptrace_syscall(pid, signal);
+
       continue;
     }
 
-    switch (WSTOPSIG(status)) {
-      case SIGTRAP:
-        ptrace(PTRACE_GETREGS, args->pid, 0, &regs);
-
-        if (regs.orig_rax != SYS_write) {
-          continue;
-        }
-
-        in_syscall = 1 - in_syscall;
-        if (in_syscall && (args->fd == 0 || regs.rdi == args->fd)) {
-          string = malloc(regs.rdx + sizeof(long));
-          process_tail_get_data(args->pid, regs.rsi, string, regs.rdx);
-
-          if (rb_funcall(args->io, rb_intern("closed?"), 0) == Qtrue) {
-            return Qnil;
-          }
-
-          rb_io_write(args->io, rb_str_new_cstr(string));
-
-          free(string);
-        }
-      case SIGVTALRM:
-        break;
-      case SIGSTOP:
-        break;
-      default:
-        signal = WSTOPSIG(status);
+    if (WIFEXITED(status) || WIFSIGNALED(status)) {
+      tracee->dead = 1;
+
+      if (pt_tracee_wipedoutq(tracee_headp)) {
+        pt_tracee_free(&tracee_headp);
+
+        return;
+      }
+
+      continue;
     }
 
-    rb_thread_schedule();
-  }
+    if (!(WIFSTOPPED(status) && WSTOPSIG(status) & 0x80)) {
+      signal = WSTOPSIG(status);
+      pt_ptrace_syscall(pid, signal);
 
-  return Qnil;
+      continue;
+    }
+
+    ptrace(PTRACE_GETREGS, pid, 0, &regs);
+
+    if (regs.orig_rax != SYS_write) {
+      pt_ptrace_syscall(pid, signal);
+
+      continue;
+    }
+
+    syscall = 1 - syscall;
+    if (syscall && (fd == 0 || regs.rdi == fd)) {
+      string = malloc(regs.rdx + sizeof(long));
+
+      if (string == NULL) {
+        exit(EXIT_FAILURE);
+      }
+
+      pt_get_data(pid, regs.rsi, string, regs.rdx);
+
+      if (pt_io_closedq(read_io)) {
+        free(string);
+        pt_tracee_free(&tracee_headp);
+
+        return;
+      }
+
+      rb_io_write(write_io, rb_str_new_cstr(string));
+
+      free(string);
+    }
+
+    pt_ptrace_syscall(pid, signal);
+  }
 }
 
 static VALUE
-process_tail_trace(VALUE klass, VALUE pidp, VALUE fdp, VALUE io)
+pt_attach(VALUE klass, VALUE pidv)
 {
-  pid_t pid       = (pid_t)FIX2INT(pidp);
-  unsigned int fd = (unsigned int)FIX2INT(fdp);
+  int pid = (pid_t)FIX2INT(pidv);
 
-  struct process_tail_args args = {pid, NULL, fd, io};
+  Check_Type(pidv, T_FIXNUM);
 
-  Check_Type(pidp, T_FIXNUM);
-  Check_Type(fdp, T_FIXNUM);
-  Check_Type(io, T_FILE);
+  if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
+    rb_sys_fail("PTRACE_ATTACH");
 
-  if (process_tail_attach((void *)&args) == 0) {
-    rb_ensure(process_tail_loop, (VALUE)&args, process_tail_detach, (VALUE)&args);
+    return Qnil;
   }
 
+  return Qtrue;
+}
+
+static VALUE
+pt_detach(VALUE klass, VALUE pidv)
+{
+  Check_Type(pidv, T_FIXNUM);
+
+  ptrace(PTRACE_DETACH, (pid_t)FIX2INT(pidv), NULL, NULL);
+
+  return Qnil;
+}
+
+static VALUE
+pt_trace(VALUE klass, VALUE fdp, VALUE write_io, VALUE read_io, VALUE wait_queue)
+{
+  pt_tracee_t *tracee_headp = NULL;
+
+  Check_Type(fdp,         T_FIXNUM);
+  Check_Type(write_io,    T_FILE);
+  Check_Type(read_io,     T_FILE);
+
+  pt_loop((unsigned int)FIX2INT(fdp), write_io, read_io, wait_queue, tracee_headp);
+
   return Qnil;
 }
 
 void
 Init_process_tail()
 {
-  VALUE ProcessTail;
+  VALUE ProcessTail = rb_define_module("ProcessTail");
 
-  ProcessTail = rb_define_module("ProcessTail");
-  rb_define_singleton_method(ProcessTail, "do_trace", process_tail_trace, 3);
+  rb_define_singleton_method(ProcessTail, "attach",   pt_attach, 1);
+  rb_define_singleton_method(ProcessTail, "do_trace", pt_trace,  4);
+  rb_define_singleton_method(ProcessTail, "detach",   pt_detach, 1);
 }

data/lib/process_tail/version.rb

@@ -1,3 +1,3 @@
 module ProcessTail
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/process_tail.rb

@@ -1,37 +1,68 @@
+require 'thread'
 require 'process_tail/process_tail'
 require 'process_tail/version'
 
 module ProcessTail
+  TRACE_LOCK = Mutex.new # NOTE For now, ProcessTail can't trace multiple processes at the same time
+
   class << self
     def open(pid, fd = :stdout)
-      read_io, thread = trace(pid, fd)
+      io = trace(pid, fd)
 
-      block_given? ? yield(read_io) : read_io
+      block_given? ? yield(io) : io
     ensure
-      finalize = -> {
-        read_io.close unless read_io.closed?
-        thread.kill
-      }
-
-      block_given? ? finalize.call : at_exit(&finalize)
+      io.close if block_given? && !io.closed?
     end
 
     def trace(pid, fd = :stdout)
+      TRACE_LOCK.synchronize {
+        trace_without_lock(pid, fd)
+      }
+    end
+
+    private
+
+    def trace_without_lock(pid, fd)
       read_io, write_io = IO.pipe
+      task_ids   = extract_task_ids(pid)
+      wait_queue = Queue.new
 
       thread = Thread.fork {
         begin
-          do_trace pid, extract_fd(fd), write_io
+          extract_task_ids(pid).each do |tid|
+            attach tid
+          end
+
+          do_trace extract_fd(fd), write_io, read_io, wait_queue
         ensure
-          begin
-            [read_io, write_io].each do |io|
-              io.close unless io.closed?
-            end
-          rescue IOError; end
+          write_io.close unless write_io.closed?
+
+          task_ids.each do |tid|
+            detach tid
+          end
         end
       }
 
-      [read_io, thread]
+      at_exit do
+        thread.kill
+        thread.join
+      end
+
+      wait_all_attach task_ids, wait_queue
+
+      read_io
+    end
+
+    def wait_all_attach(task_ids, waitq)
+      task_ids.size.times do
+        waitq.deq
+      end
+    end
+
+    def extract_task_ids(pid)
+      Dir.open("/proc/#{pid}/task") {|dir|
+        dir.entries.grep(/^\d+$/).map(&:to_i)
+      }
     end
 
     def extract_fd(name)

data/spec/process_tail_spec.rb

@@ -1,24 +1,27 @@
 require 'process_tail'
+require 'timeout'
 
 describe ProcessTail do
   def process_maker(&fn)
      -> {
-      Process.fork {
+      pid = Process.fork {
         trap :USR1 do
-          sleep 0.1 # XXX :(
-
           fn.call if fn
         end
 
         sleep
       }
+
+      $recorded_children << pid
+
+      pid
     }
   end
 
   def expect_same_output_and_no_error(fd, method, string)
-    greeting = process_maker { send(method, string) }
-    pid      = greeting.call
-    io, th   = ProcessTail.trace(pid, fd)
+    greeting    = process_maker { send(method, string) }
+    pid         = greeting.call
+    io          = ProcessTail.trace(pid, fd)
 
     Process.kill :USR1, pid # resume child
 
@@ -26,9 +29,23 @@ describe ProcessTail do
       expect(io.gets).to eq expected
     end
 
-    Process.kill :TERM, pid
+    io.close
+  end
+
+  around do |example|
+    begin
+      $recorded_children = []
+
+      # at least every examples should be finished within 5 seconds
+      timeout 5 do
+        example.run
+      end
 
-    expect { th.join }.to_not raise_error
+    ensure
+      $recorded_children.each do |child|
+        Process.kill :TERM, child
+      end
+    end
   end
 
   describe '.open' do
@@ -46,7 +63,7 @@ describe ProcessTail do
       pid     = process_maker.call
       read_io = nil
 
-      ProcessTail.open pid, :stdout  do |io|
+      ProcessTail.open pid, :stdout do |io|
         read_io = io
 
         expect(read_io).to_not be_closed
@@ -57,9 +74,44 @@ describe ProcessTail do
   end
 
   describe '.trace' do
-    it do
+    specify 'simple stdout'  do
       expect_same_output_and_no_error :stdout, :puts, 'HELLO'
+    end
+
+    specify 'simple stderr' do
       expect_same_output_and_no_error :stderr, :warn, 'HELLO'
+    end
+
+    specify 'multithreaded' do
+      pid = Process.fork {
+        trap :USR1 do
+          puts 'HELLO'
+        end
+
+        Thread.fork do
+          trap :USR2 do
+            puts 'HELLO'
+          end
+
+          sleep
+        end
+
+        sleep
+      }
+
+      $recorded_children << pid
+      io = ProcessTail.trace(pid, :stdout)
+
+      Process.kill :USR1, pid
+      Process.kill :USR2, pid
+
+      expect(io.gets).to eq "HELLO\n"
+      expect(io.gets).to eq "HELLO\n"
+
+      io.close
+    end
+
+    specify 'multiline' do
       expect_same_output_and_no_error :stdout, :puts, "HELLO\nLOVE AND KISSES"
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: process_tail
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Hika Hibariya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,16 +69,19 @@ dependencies:
 description: 
 email:
 - hibariya@gmail.com
-executables: []
+executables:
+- process_tail
 extensions:
 - ext/process_tail/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/process_tail
 - ext/process_tail/extconf.rb
 - ext/process_tail/process_tail.c
 - lib/process_tail.rb