Class: CrashWatch::GdbController

Inherits:
Object
  • Object
show all
Defined in:
lib/crash_watch/gdb_controller.rb

Defined Under Namespace

Classes: ExitInfo

Constant Summary collapse

END_OF_RESPONSE_MARKER = 
'--------END_OF_RESPONSE--------'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ GdbController

Returns a new instance of GdbController.



35
36
37
38
 
# File 'lib/crash_watch/gdb_controller.rb', line 35

def initialize
  @pid, @in, @out = popen_command(find_gdb, "-n", "-q")
  execute("set prompt ")
end

Instance Attribute Details

#debug ⇒ Object

Returns the value of attribute debug.



33
34
35
 
# File 'lib/crash_watch/gdb_controller.rb', line 33

def debug
  @debug
end

Instance Method Details

#all_threads_backtraces ⇒ Object 



125
126
127
 
# File 'lib/crash_watch/gdb_controller.rb', line 125

def all_threads_backtraces
  return execute("thread apply all bt full").strip
end

#attach(pid) ⇒ Object

Raises:

  • (ArgumentError) 


99
100
101
102
103
104
 
# File 'lib/crash_watch/gdb_controller.rb', line 99

def attach(pid)
  pid = pid.to_s.strip
  raise ArgumentError if pid.empty?
  result = execute("attach #{pid}")
  return result !~ /(No such process|Unable to access task|Operation not permitted)/
end

#call(code) ⇒ Object 



106
107
108
109
110
 
# File 'lib/crash_watch/gdb_controller.rb', line 106

def call(code)
  result = execute("call #{code}")
  result =~ /= (.*)$/
  return $1
end

#close ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/crash_watch/gdb_controller.rb', line 73

def close
  if !closed?
    begin
      execute("detach", 5)
      execute("quit", 5) if !closed?
    rescue Errno::EPIPE
    end
    if !closed?
      @in.close
      @out.close
      Process.waitpid(@pid)
      @pid = nil
    end
  end
end

#close! ⇒ Object 



89
90
91
92
93
94
95
96
97
 
# File 'lib/crash_watch/gdb_controller.rb', line 89

def close!
  if !closed?
    @in.close
    @out.close
    Process.kill('KILL', @pid)
    Process.waitpid(@pid)
    @pid = nil
  end
end

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/crash_watch/gdb_controller.rb', line 69

def closed?
  return !@pid
end

#current_thread ⇒ Object 



116
117
118
119
 
# File 'lib/crash_watch/gdb_controller.rb', line 116

def current_thread
  execute("thread") =~ /Current thread is (.+?) /
  return $1
end

#current_thread_backtrace ⇒ Object 



121
122
123
 
# File 'lib/crash_watch/gdb_controller.rb', line 121

def current_thread_backtrace
  return execute("bt full").strip
end

#execute(command_string, timeout = nil) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/crash_watch/gdb_controller.rb', line 40

def execute(command_string, timeout = nil)
  raise "GDB session is already closed" if !@pid
  puts "gdb write #{command_string.inspect}" if @debug
  @in.puts(command_string)
  @in.puts("echo \\n#{END_OF_RESPONSE_MARKER}\\n")
  done = false
  result = ""
  while !done
    begin
      if select([@out], nil, nil, timeout)
        line = @out.readline
        puts "gdb read #{line.inspect}" if @debug
        if line == "#{END_OF_RESPONSE_MARKER}\n"
          done = true
        else
          result << line
        end
      else
        close!
        done = true
        result = nil
      end
    rescue EOFError
      done = true
    end
  end
  return result
end

#program_counter ⇒ Object 



112
113
114
 
# File 'lib/crash_watch/gdb_controller.rb', line 112

def program_counter
  return execute("p/x $pc").gsub(/.* = /, '')
end

#ruby_backtrace ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/crash_watch/gdb_controller.rb', line 129

def ruby_backtrace
  filename = "/tmp/gdb-capture.#{@pid}.txt"
  
  orig_stdout_fd_copy = call("(int) dup(1)")
  new_stdout = call(%Q{(void *) fopen("#{filename}", "w")})
  new_stdout_fd = call("(int) fileno(#{new_stdout})")
  call("(int) dup2(#{new_stdout_fd}, 1)")
  
  # Let's hope stdout is set to line buffered or unbuffered mode...
  call("(void) rb_backtrace()")
  
  call("(int) dup2(#{orig_stdout_fd_copy}, 1)")
  call("(int) fclose(#{new_stdout})")
  call("(int) close(#{orig_stdout_fd_copy})")
  
  if File.exist?(filename)
    result = File.read(filename)
    result.strip!
    if result.empty?
      return nil
    else
      return result
    end
  else
    return nil
  end
ensure
  if filename
    File.unlink(filename) rescue nil
  end
end

#wait_until_exit ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/crash_watch/gdb_controller.rb', line 161

def wait_until_exit
  execute("break _exit")
  
  signal = nil
  backtraces = nil
  snapshot = nil
  
  while true
    result = execute("continue")
    if result =~ /^Program received signal (.+?),/
      signal = $1
      backtraces = execute("thread apply all bt full").strip
      if backtraces.empty?
        backtraces = execute("bt full").strip
      end
      snapshot = yield(self) if block_given?
      
      # This signal may or may not be immediately fatal; the
      # signal might be ignored by the process, or the process
      # has some clever signal handler that fixes the state,
      # or maybe the signal handler must run some cleanup code
      # before killing the process. Let's find out by running
      # the next machine instruction.
      old_program_counter = program_counter
      result = execute("stepi")
      if result =~ /^Program received signal .+?,/
        # Yes, it was fatal. Here we don't care whether the
        # instruction caused a different signal. The last
        # one is probably what we're interested in.
        return ExitInfo.new(nil, signal, backtraces, snapshot)
      elsif result =~ /^Program (terminated|exited)/ || result =~ /^Breakpoint .*? _exit/
        # Running the next instruction causes the program to terminate.
        # Not sure what's going on but the previous signal and
        # backtrace is probably what we're interested in.
        return ExitInfo.new(nil, signal, backtraces, snapshot)
      elsif old_program_counter == program_counter
        # The process cannot continue but we're not sure what GDB
        # is telling us.
        raise "Unexpected GDB output: #{result}"
      end
      # else:
      # The signal doesn't isn't immediately fatal, so save current
      # status, continue, and check whether the process exits later.
    elsif result =~ /^Program terminated with signal (.+?),/
      if $1 == signal
        # Looks like the signal we trapped earlier
        # caused an exit.
        return ExitInfo.new(nil, signal, backtraces, snapshot)
      else
        return ExitInfo.new(nil, signal, nil, snapshot)
      end
    elsif result =~ /^Breakpoint .*? _exit /
      backtraces = execute("thread apply all bt full").strip
      if backtraces.empty?
        backtraces = execute("bt full").strip
      end
      snapshot = yield(self) if block_given?
      # On OS X, gdb may fail to return from the 'continue' command
      # even though the process exited. Kernel bug? In any case,
      # we put a timeout here so that we don't wait indefinitely.
      result = execute("continue", 10)
      if result =~ /^Program exited with code (\d+)\.$/
        return ExitInfo.new($1.to_i, nil, backtraces, snapshot)
      elsif result =~ /^Program exited normally/
        return ExitInfo.new(0, nil, backtraces, snapshot)
      else
        return ExitInfo.new(nil, nil, backtraces, snapshot)
      end
    elsif result =~ /^Program exited with code (\d+)\.$/
      return ExitInfo.new($1.to_i, nil, nil, nil)
    elsif result =~ /^Program exited normally/
      return ExitInfo.new(0, nil, nil, nil)
    else
      return ExitInfo.new(nil, nil, nil, nil)
    end
  end
end