GitBucket
Newer
from __future__ import (absolute_import, division, print_function)
from threading import Thread
from Queue import Queue, Empty, Full
import lldb
from .vim_buffers import VimBuffers
from .session import Session
__metaclass__ = type # pylint: disable=invalid-name
class EventLoopError(Exception):
pass
class Controller(Thread): # pylint: disable=too-many-instance-attributes
""" Thread object that handles LLDB events and commands. """
CTRL_VOICE = 238 # doesn't matter what this is
TARG_NEW = 1
TARG_DEL = 1 << 1
PROC_NEW = 1 << 2
PROC_DEL = 1 << 3
BP_CHANGED = 1 << 4
BAD_STATE = 1 << 5 # multiple targets
def __init__(self, vimx):
""" Creates the LLDB SBDebugger object and more! """
import logging
self.logger = logging.getLogger(__name__)
self._sink = open('/dev/null')
self._dbg = lldb.SBDebugger.Create()
self._dbg.SetOutputFileHandle(self._sink, False)
self._ipreter = self._dbg.GetCommandInterpreter()
self._rcx = lldb.SBListener("the_ear") # receiver
self._trx = lldb.SBBroadcaster("the_mouth") # transmitter for user events
self._trx.AddListener(self._rcx, self.CTRL_VOICE)
self.target = None
self._process = None
self._proc_cur_line_len = 0
self._proc_lines_count = 0
self._proc_sigstop_count = 0
self._num_bps = 0
self.in_queue = Queue(maxsize=2)
self.out_queue = Queue(maxsize=1)
self.vimx = vimx
self.busy_stack = 0 # when > 0, buffers are not updated
self.buffers = VimBuffers(self, vimx)
self.session = Session(self, vimx)
super(Controller, self).__init__() # start the thread
def is_busy(self):
return self.busy_stack > 0
def busy_more(self):
self.busy_stack += 1
def busy_less(self):
self.busy_stack -= 1
if self.busy_stack < 0:
self.logger.critical("busy_stack < 0")
self.busy_stack = 0
def safe_call(self, method, args=None, sync=False, timeout=None):
""" (thread-safe) Call `method` with `args`. If `sync` is True, wait for
`method` to complete and return its value. If timeout is set and non-
negative, and the `method` did not complete within `timeout` seconds,
an EventLoopError is raised!
"""
if self._dbg is None:
self.logger.critical("Debugger not found!")
raise EventLoopError("Dead debugger!")
if self.out_queue.full(): # garbage
self.out_queue.get() # clean
try:
self.in_queue.put((method, args if args else [], sync), block=False)
interrupt = lldb.SBEvent(self.CTRL_VOICE, "the_sound")
self._trx.BroadcastEvent(interrupt)
if sync:
return self.out_queue.get(block=True, timeout=timeout)
except Empty:
raise EventLoopError("Timed out!")
except Full:
self.logger.critical("Event loop thread is probably dead!")
raise EventLoopError("Dead event loop!")
def safe_execute(self, tokens):
""" (thread-safe) Executes an lldb command defined by a list of tokens.
If a token contains white-spaces, they are escaped using backslash.
"""
cmd = ' '.join([t.replace(' ', '\\ ') for t in tokens])
self.safe_call(self.exec_command, [cmd])
def safe_exit(self):
""" Exit from the event-loop, and wait for the thread to join.
Should be called from outside this thread.
"""
self.safe_call(None)
self.join()
def complete_command(self, arg, line, pos):
""" Returns a list of viable completions for line, and cursor at pos. """
pos = int(pos)
result = lldb.SBStringList()
if arg == line and line != '':
# provide all possible completions when completing 't', 'b', 'di' etc.
self._ipreter.HandleCompletion('', 0, 1, -1, result)
cands = ['']
for x in result:
if x == line:
cands.insert(1, x)
elif x.startswith(line):
cands.append(x)
else:
self._ipreter.HandleCompletion(line, pos, 1, -1, result)
cands = [x for x in result]
if len(cands) > 1:
if cands[0] == '' and arg != '':
if not cands[1].startswith(arg) or not cands[-1].startswith(arg):
return []
return cands[1:]
else:
return []
def update_buffers(self, buf=None):
""" Update lldb buffers and signs placed in source files.
@param buf
If None, all buffers and signs would be updated.
Otherwise, update only the specified buffer.
"""
if self.is_busy():
return
if buf is None:
self.buffers.update(self.target)
else:
self.buffers.update_buffer(buf, self.target)
def get_state_changes(self): # pylint: disable=too-many-branches
""" Get a value denoting how target, process, and/or breakpoint have changed.
If a new process found, add our listener to its broadcaster.
"""
changes = 0
if self._dbg.GetNumTargets() > 1:
return self.BAD_STATE
if self.target is None or not self.target.IsValid():
target = self._dbg.GetSelectedTarget()
if target.IsValid():
changes = self.TARG_NEW
self.target = target
elif self.target is not None:
changes = self.TARG_DEL
self.target = None
if self.target is None:
if self._process is not None:
changes |= self.PROC_DEL
self._process = None
if self._num_bps > 0:
changes |= self.BP_CHANGED
self._num_bps = 0
return changes
if self._process is None or not self._process.IsValid():
process = self.target.process
if process.IsValid():
changes |= self.PROC_NEW
self._process = process
process.broadcaster.AddListener(
self._rcx,
lldb.SBProcess.eBroadcastBitStateChanged |
lldb.SBProcess.eBroadcastBitSTDOUT |
lldb.SBProcess.eBroadcastBitSTDERR
)
self._proc_cur_line_len = 0
self._proc_lines_count = 0
self._proc_sigstop_count = 0
elif self._process is not None:
changes |= self.PROC_DEL
self._process = None
num_bps = self.target.GetNumBreakpoints()
if self._num_bps != num_bps:
# TODO what if one was added and another deleted?
changes |= self.BP_CHANGED
self._num_bps = num_bps
# TODO Watchpoints
return changes
def change_buffer_cmd(self, buf, cmd):
""" Change a buffer command and update it. """
self.buffers.content_map[buf] = cmd
self.update_buffers(buf=buf)
if self.target is not None:
self.vimx.command('drop [lldb]%s' % buf)
def do_btswitch(self):
""" Switch backtrace command to show all threads. """
cmd = self.buffers.content_map['backtrace']
if cmd != 'bt all':
cmd = 'bt all'
else:
cmd = 'bt'
self.change_buffer_cmd('backtrace', cmd)
def bp_set_line(self, spath, line):
from os.path import abspath
fpath = abspath(spath).encode('ascii', 'ignore')
bp = self.target.BreakpointCreateByLocation(fpath, line)
self.buffers.logs_append(u'\u2192(lldb-bp) %s:%d\n' % (spath, line))
self.session.bp_map_auto(bp, (spath, line))
self.update_buffers(buf='breakpoints')
def do_breakswitch(self, bufnr, line):
""" Switch breakpoint at the specified line in the buffer. """
key = (bufnr, line)
if key in self.buffers.bp_list:
bps = self.buffers.bp_list[key]
args = "delete %s" % " ".join([str(b.GetID()) for b in bps])
self.exec_command("breakpoint " + args)
else:
self.bp_set_line(self.vimx.get_buffer_name(bufnr), line)
def do_breakdelete(self, bp_id):
""" Delete a breakpoint by id """
if bp_id:
self.exec_command("breakpoint delete {}".format(bp_id))
def put_stdin(self, instr):
""" Call PutSTDIN() of process with instr. """
if self._process is not None:
self._process.PutSTDIN(instr)
else:
self.vimx.log('No active process!')
def get_command_result(self, command, add2hist=False):
""" Runs command in the interpreter and returns (success, output)
Not to be called directly for commands which changes debugger state;
use exec_command instead.
"""
result = lldb.SBCommandReturnObject()
cmd = command.encode('ascii', 'ignore')
self._ipreter.HandleCommand(cmd, result, add2hist)
self.logger.debug('(lldb) %s\n%s', cmd, result)
return (result.Succeeded(),
result.GetOutput() if result.Succeeded() else result.GetError())
def exec_command(self, command):
""" Runs command in the interpreter, calls update_buffers, and display the
result in the logs buffer. Returns True if succeeded.
"""
self.buffers.logs_append(u'\u2192(lldb) %s\n' % command)
(success, output) = self.get_command_result(command, True)
if not success:
self.buffers.logs_append(output, u'\u2717')
elif len(output) > 0:
self.buffers.logs_append(output, u'\u2713')
state_changes = self.get_state_changes()
if state_changes & self.TARG_NEW != 0:
self.session.new_target(self.target)
elif state_changes & self.BP_CHANGED != 0 and self.target is not None:
self.session.bp_changed(command, self.target.breakpoint_iter())
self.update_buffers()
return success
def run(self): # pylint: disable=too-many-branches,too-many-statements
""" This thread's event loop. """
import traceback
to_count = 0
while True:
event = lldb.SBEvent()
if self._rcx.WaitForEvent(30, event): # 30 second timeout
def event_matches(broadcaster, skip=True):
if event.BroadcasterMatchesRef(broadcaster):
if skip:
while self._rcx.GetNextEventForBroadcaster(broadcaster, event):
pass
return True
return False
if event_matches(self._trx, skip=False):
try:
method, args, sync = self.in_queue.get(block=False)
if method is None:
break
self.logger.info('Calling %s with %s', method.func_name, repr(args))
ret = method(*args)
if sync:
self.out_queue.put(ret, block=False)
except Exception: # pylint: disable=broad-except
self.logger.critical(traceback.format_exc())
elif event_matches(self._process.broadcaster):
# Dump stdout and stderr to logs buffer
while True:
out = ''
stdout = self._process.GetSTDOUT(256)
if stdout is not None:
out += stdout
stderr = self._process.GetSTDERR(256)
if stderr is not None:
out += stderr
if len(out) == 0:
break
n_lines = self.buffers.logs_append(out)
if n_lines == 0:
self._proc_cur_line_len += len(out)
else:
self._proc_cur_line_len = 0
self._proc_lines_count += n_lines
if self._proc_cur_line_len > 8192 or self._proc_lines_count > 2048:
# detect and stop/kill insane process
if self._process.state == lldb.eStateStopped:
pass
elif self._proc_sigstop_count > 7:
self._process.Kill()
self.buffers.logs_append(
u'\u2717SIGSTOP limit exceeded! Sent SIGKILL!\n')
else:
self._process.SendAsyncInterrupt()
self._proc_sigstop_count += 1
self.buffers.logs_append(
u'\u2717Output limits exceeded! Sent SIGSTOP!\n')
break
# end of dump while
self.update_buffers()
else: # Timed out
to_count += 1
if to_count > 172800: # in case WaitForEvent() does not wait!
self.logger.critical('Broke the loop barrier!')
break
# end of event-loop while
self._dbg.Terminate()
self._dbg = None
self._sink.close()
self.logger.info('Terminated!')