Python in GDB

try:
	import gdb
except ImportError as e:
	raise ImportError("This script must be run in GDB: ", str(e))

logFileName = "./multithread_log.txt"
flag = 0
def stop_handler (event):
	global flag
	print("thread %s" %(event.inferior_thread))
	if isinstance(event,gdb.SignalEvent):
		print("event stop signal %s" %(event.stop_signal))
		if event.stop_signal == 'SIGINT':
			print("process got interrupted")
			resp = raw_input("continue logging ? (y/n)")
			if resp == 'n':
				flag = 0
			else:
				set_breakpoints()
				gdb.execute("c")

gdb.events.stop.connect (stop_handler)

class ConsoleColorCodes:
	RED = '\033[91m'
	BLUE = '\033[94m'
	YELLOW = '\033[93m'
	END = '\033[0m'

class Utility:
	@staticmethod
	def writeColorMessage(message, colorCode):
		print(colorCode + message + ConsoleColorCodes.END)

	@staticmethod
	def writeMessage(message):
		Utility.writeColorMessage(message, ConsoleColorCodes.BLUE)

	@staticmethod
	def writeErrorMessage(message):
		Utility.writeColorMessage(message, ConsoleColorCodes.RED)

	@staticmethod
	def logInfoMessage(message):
		global logFileName
		with open(str(logFileName), 'a') as logFile:
			logFile.write(str(message))

	@staticmethod
	def writeInfoMessage(message):
		Utility.logInfoMessage(message)
		Utility.writeColorMessage(message, ConsoleColorCodes.RED)

	@staticmethod
	def convertToHexString(val):
		return hex(int(val))

Functions = ["thread_echo"]
thread_echo_Args = ["thread number"]

max_callstack_depth = 16

def get_callstack():
	ret = []
	depth = 1
	frame = gdb.selected_frame()
	while True:
		if (frame) and ( depth <= max_callstack_depth ):
			current_frame_name = str(frame.name())
			ret.append(current_frame_name)
			frame = frame.older()
			depth += 1
		else:
			gdb.Frame.select ( gdb.newest_frame() )
			return ret

def get_return_value():
	ret = ""
	gdb.execute("finish")
	ret = str(gdb.parse_and_eval("$r0"))
	return ret

def get_argument (counter):
	index = counter - 1
	return str(gdb.parse_and_eval("$r" + str(index)))

def append_callstack(target, callstack):
	ret = str(target) + "\ncallstack : "
	for callstack_frame in callstack:
		ret += "\n\t"
		ret += str(callstack_frame)
	return ret

def set_breakpoints():
	global flag
	gdb.execute("info threads")
	print("choose thread to log")
	thread_num = raw_input()
	if thread_num == 'q':
		print("stop log")
		flag = 0
		return
	# Remove breakpoints
	gdb.execute("delete breakpoints")

	# Setup breakpoints for memory functions
	for Function in Functions:
		gdb.execute("b " + Function + " thread " + thread_num )
		print("breakpoints set")

gdb.execute("set confirm off")
gdb.execute("set pagination off")
gdb.execute("set breakpoint pending on")
backtrace_limit_command = "set backtrace limit " + str(max_callstack_depth)
gdb.execute(backtrace_limit_command)
flag = 1
gdb.execute("b main")
gdb.execute("r")
set_breakpoints()
gdb.execute("i b")
gdb.execute("c")

while flag == 1:
	print("entered while loop")
	try:
		frame = gdb.selected_frame()
	except:
		set_breakpoints()
		gdb.execute("c")
	print("current frame: " + str(frame.name()))
	current_frame_name = str(frame.name())

	##########################################################################
	#MAIN
	if "main" in current_frame_name:
		gdb.execute("cont")
	##########################################################################
	#EXIT
	if "exit" in current_frame_name:
		Utility.writeInfoMessage("\n")
		break
	##########################################################################

	if "thread_echo" in current_frame_name:
		message = "\ntype : thread_echo ,"

		counter = 1
		for arg in thread_echo_Args:
			message += " arg" + str(counter) + "  : "
			message += get_argument(counter)
			message += ","
			counter += 1

		callstack = get_callstack()

		address = Utility.convertToHexString(get_return_value())
		message += " return value : " + address
		message += ","
		# append callstack at the end
		message = append_callstack(message, callstack)
		# Continue
		Utility.writeInfoMessage(message)
		gdb.execute("cont")
Utility.writeMessage('DEBUGEE EXITING')