source: tools/gdb/utils-gdb.py @ 9dad5b3

pthread-emulationqualifiedEnum
Last change on this file since 9dad5b3 was 9dad5b3, checked in by Thierry Delisle <tdelisle@…>, 6 months ago

Fixed gdb printing of processors which was broken for a while now.

  • Property mode set to 100644
File size: 18.3 KB
Line 
1#
2# Copyright (C) Lynn Tran, Jiachen Zhang 2018
3#
4# utils-gdb.py --
5#
6# Author           : Lynn Tran
7# Created On       : Mon Oct 1 22:06:09 2018
8# Last Modified By : Peter A. Buhr
9# Last Modified On : Sat Jan 19 14:16:10 2019
10# Update Count     : 11
11#
12
13"""
14To run this extension, the python name has to be as same as one of the loaded library
15Additionally, the file must exist in a folder which is in gdb's safe path
16"""
17import collections
18import gdb
19import re
20
21# set these signal handlers with some settings (nostop, noprint, pass)
22gdb.execute('handle SIGALRM nostop noprint pass')
23gdb.execute('handle SIGUSR1 nostop noprint pass')
24
25CfaTypes = collections.namedtuple('CfaTypes', 'cluster_ptr processor_ptr thread_ptr int_ptr thread_state yield_state')
26
27class ThreadInfo:
28        tid = 0
29        cluster = None
30        value = None
31
32        def __init__(self, cluster, value):
33                self.cluster = cluster
34                self.value = value
35
36        def is_system(self):
37                return False
38
39# A named tuple representing information about a stack
40StackInfo = collections.namedtuple('StackInfo', 'sp fp pc')
41
42# A global variable to keep track of stack information as one switches from one
43# task to another task
44STACK = []
45
46not_supported_error_msg = "Not a supported command for this language"
47
48def is_cforall():
49        return True
50
51def get_cfa_types():
52        # GDB types for various structures/types in CFA
53        return CfaTypes(cluster_ptr = gdb.lookup_type('struct cluster').pointer(),
54                processor_ptr = gdb.lookup_type('struct processor').pointer(),
55                thread_ptr = gdb.lookup_type('struct thread$').pointer(),
56                int_ptr = gdb.lookup_type('int').pointer(),
57                thread_state = gdb.lookup_type('enum __Coroutine_State'),
58                yield_state = gdb.lookup_type('enum __Preemption_Reason'))
59
60def get_addr(addr):
61        """
62        NOTE: sketchy solution to retrieve address. There is a better solution...
63        @addr: str of an address that can be in a format 0xfffff <type of the object
64        at this address>
65        Return: str of just the address
66        """
67        str_addr = str(addr)
68        ending_addr_index = str_addr.find('<')
69        if ending_addr_index == -1:
70                return str(addr)
71        return str_addr[:ending_addr_index].strip()
72
73def print_usage(obj):
74        print(obj.__doc__)
75
76def parse(args):
77        """
78        Split the argument list in string format, where each argument is separated
79        by whitespace delimiter, to a list of arguments like argv
80        @args: str of arguments
81        Return:
82                [] if args is an empty string
83                list if args is not empty
84        """
85        # parse the string format of arguments and return a list of arguments
86        argv = args.split(' ')
87        if len(argv) == 1 and argv[0] == '':
88                return []
89        return argv
90
91class ClusterIter:
92        def __init__(self, root):
93                self.curr = None
94                self.root = root
95
96        def __iter__(self):
97                return self
98
99        def __next__(self):
100                # Clusters form a cycle
101                # If we haven't seen the root yet, then the root is the first
102                if not self.curr:
103                        self.curr = self.root
104                        return self.curr
105
106                # if we already saw the root, then go forward
107                self.curr = self.curr['_X4nodeS26__cluster____dbg_node_cltr_1']['_X4nextPS7cluster_1']
108
109                # if we reached the root again, then we are done
110                if self.curr == self.root:
111                        raise StopIteration
112
113                # otherwise return the next
114                return self.curr
115
116def all_clusters():
117        """
118        Return: a list of all the clusters as an iterator.
119        obtained from gdb.Value of globalClusters.root (is an address)
120        """
121        if not is_cforall():
122                return []
123
124        cluster_root = gdb.parse_and_eval('_X11mainClusterPS7cluster_1')
125        if cluster_root.address == 0x0:
126                print('No clusters, program terminated')
127                return []
128
129        return ClusterIter(cluster_root)
130
131class ProcIter:
132        def __init__(self, root):
133                self.curr = None
134                self.root = root
135
136        def __iter__(self):
137                return self
138
139        def check(self):
140                # check if this is the last value
141                addr = int(self.curr)
142                mask = 1 << ((8 * int(gdb.parse_and_eval('sizeof(void*)'))) - 1)
143                if 0 != (mask & addr):
144                        raise StopIteration
145
146        def __next__(self):
147                cfa_t = get_cfa_types()
148
149                # Processors form a cycle
150                # If we haven't seen the root yet, then the root is the first
151                if not self.curr:
152                        my_next = self.root
153                        self.curr = my_next.cast(cfa_t.processor_ptr)
154
155                        #check if this is an empty list
156                        self.check()
157
158                        return self.curr
159
160                # if we already saw the root, then go forward
161                my_next = self.curr['__anonymous_object2225']['_X4nextPY13__tE_generic__1']
162                self.curr = my_next.cast(cfa_t.processor_ptr)
163
164                #check if we reached the end
165                self.check()
166
167                # otherwise return the next
168                return self.curr
169
170def proc_list(cluster):
171        """
172        Return: for a given processor, return the active and idle processors, as 2 iterators
173        """
174        cfa_t = get_cfa_types()
175        proclist = cluster['_X5procsS19__cluster_proc_list_1']
176        idle = proclist['_X5idlesS5dlist_S9processorS5dlink_S9processor___1']['__anonymous_object2167']['_X4nextPY13__tE_generic__1']
177        active = proclist['_X7activesS5dlist_S9processorS5dlink_S9processor___1']['__anonymous_object2167']['_X4nextPY13__tE_generic__1']
178        return ProcIter(active.cast(cfa_t.processor_ptr)), ProcIter(idle.cast(cfa_t.processor_ptr))
179
180def all_processors():
181        procs = []
182        for c in all_clusters():
183                active, idle = proc_list(c)
184                for p in active:
185                        procs.append(p)
186
187                for p in idle:
188                        procs.append(p)
189
190        print(procs)
191        return procs
192
193def tls_for_pthread(pthrd):
194        prev = gdb.selected_thread()
195        inf = gdb.selected_inferior()
196
197        thrd = inf.thread_from_thread_handle( pthrd )
198        thrd.switch()
199        tls = gdb.parse_and_eval('&_X9kernelTLSS16KernelThreadData_1')
200
201        prev.switch()
202        return tls
203
204def tls_for_proc(proc):
205        return proc['_X10local_dataPS16KernelThreadData_1']
206
207def thread_for_pthread(pthrd):
208        return tls_for_pthread(pthrd)['_X11this_threadVPS7thread$_1']
209
210def thread_for_proc(proc):
211        return tls_for_proc(proc)['_X11this_threadVPS7thread$_1']
212
213
214
215def find_curr_thread():
216        # btstr = gdb.execute('bt', to_string = True).splitlines()
217        # if len(btstr) == 0:
218        #     print('error')
219        #     return None
220        # return btstr[0].split('this=',1)[1].split(',')[0].split(')')[0]
221        return None
222
223def lookup_cluster(name = None):
224        """
225        Look up one or more cluster given a name
226        @name: str
227        Return: gdb.Value
228        """
229        if not is_cforall():
230                return None
231
232        clusters = all_clusters()
233        if not clusters:
234                return None
235
236        if not name:
237                return clusters.root
238
239        # lookup for the task associated with the id
240        found = [c for c in clusters if c['_X4namePKc_1'].string() == name]
241
242        if not found:
243                print("Cannot find a cluster with the name: {}.".format(name))
244                return None
245
246        return found
247
248
249def lookup_threads_by_cluster(cluster):
250                # Iterate through a circular linked list of threads and accumulate them in an array
251                threads = []
252
253                cfa_t = get_cfa_types()
254                root = cluster['_X7threadsS8__dllist_S7thread$__1']['_X4headPY15__TYPE_generic__1'].cast(cfa_t.thread_ptr)
255
256                if root == 0x0 or root.address == 0x0:
257                        print('There are no tasks for cluster: {}'.format(cluster))
258                        return threads
259
260                curr = root
261                tid = 0
262                sid = -1
263
264                while True:
265                        t = ThreadInfo(cluster, curr)
266                        if t.is_system():
267                                t.tid = sid
268                                sid -= 1
269                        else:
270                                t.tid = tid
271                                tid += 1
272
273                        threads.append(t)
274
275                        curr = curr['node']['next']
276                        if curr == root or curr == 0x0:
277                                break
278
279                return threads
280
281def system_thread(thread):
282        return False
283
284def adjust_stack(pc, fp, sp):
285        # pop sp, fp, pc from global stack
286        gdb.execute('set $pc = {}'.format(pc))
287        gdb.execute('set $rbp = {}'.format(fp))
288        gdb.execute('set $sp = {}'.format(sp))
289
290############################ COMMAND IMPLEMENTATION #########################
291
292class Clusters(gdb.Command):
293        """Cforall: Display currently known clusters
294Usage:
295        info clusters                 : print out all the clusters
296"""
297
298        def __init__(self):
299                super(Clusters, self).__init__('info clusters', gdb.COMMAND_USER)
300
301        def print_cluster(self, cluster_name, cluster_address):
302                print('{:>20}  {:>20}'.format(cluster_name, cluster_address))
303
304        #entry point from gdb
305        def invoke(self, arg, from_tty):
306                if not is_cforall():
307                        return
308
309                if arg:
310                        print("info clusters does not take arguments")
311                        print_usage(self)
312                        return
313
314                self.print_cluster('Name', 'Address')
315
316                for c in all_clusters():
317                        self.print_cluster(c['_X4namePKc_1'].string(), str(c))
318
319                print("")
320
321############
322class Processors(gdb.Command):
323        """Cforall: Display currently known processors
324Usage:
325        info processors                 : print out all the processors
326        info processors <cluster_name>  : print out all processors in a given cluster
327"""
328
329        def __init__(self):
330                super(Processors, self).__init__('info processors', gdb.COMMAND_USER)
331
332        def print_processor(self, processor, in_stats):
333                should_stop = processor['_X12do_terminateVb_1']
334                if not should_stop:
335                        status = in_stats
336                else:
337                        stop_count  = processor['_X10terminatedS9semaphore_1']['_X5counti_1']
338                        status_str  = 'Last Thread' if stop_count >= 0 else 'Terminating'
339                        status      = '{}({},{})'.format(status_str, should_stop, stop_count)
340
341                print('{:>20}  {:>11}  {:<7}  {:<}'.format(
342                        processor['_X4namePKc_1'].string(),
343                        status,
344                        str(processor['_X18pending_preemptionb_1']),
345                        str(processor)
346                ))
347                tls = tls_for_proc( processor )
348                thrd = tls['_X11this_threadVPS7thread$_1']
349                if thrd != 0x0:
350                        tname = '{} {}'.format(thrd['self_cor']['name'].string(), str(thrd))
351                else:
352                        tname = None
353
354                print('{:>20}  {}'.format('Thread', tname))
355                print('{:>20}  {}'.format('TLS', tls))
356
357        #entry point from gdb
358        def invoke(self, arg, from_tty):
359                if not is_cforall():
360                        return
361
362                if not arg:
363                        clusters = all_clusters()
364                else:
365                        clusters = [lookup_cluster(arg)]
366
367                if not clusters:
368                        print("No Cluster matching arguments found")
369                        return
370
371                print('{:>20}  {:>11}  {:<7}  {}'.format('Processor', '', 'Pending', 'Object'))
372                print('{:>20}  {:>11}  {:<7}  {}'.format('Name', 'Status', 'Yield', 'Address'))
373                for c in clusters:
374                        print('Cluster {}'.format(c['_X4namePKc_1'].string()))
375
376                        active, idle = proc_list(c)
377                        # print the processor information
378                        for p in active:
379                                self.print_processor(p, 'Active')
380
381                        for p in idle:
382                                self.print_processor(p, 'Idle')
383
384                        print()
385
386                print()
387
388############
389class Threads(gdb.Command):
390        """Cforall: Display currently known threads
391Usage:
392        cfathreads                           : print Main Cluster threads, application threads only
393        cfathreads all                       : print all clusters, all threads
394        cfathreads <clusterName>             : print cluster threads, application threads only
395        """
396        def __init__(self):
397                # The first parameter of the line below is the name of the command. You
398                # can call it 'uc++ task'
399                super(Threads, self).__init__('info cfathreads', gdb.COMMAND_USER)
400
401        def print_formatted(self, marked, tid, name, state, address):
402                print('{:>1}  {:>4}  {:>20}  {:>10}  {:>20}'.format('*' if marked else ' ', tid, name, state, address))
403
404        def print_thread(self, thread, tid, marked):
405                cfa_t = get_cfa_types()
406                ys = str(thread['preempted'].cast(cfa_t.yield_state))
407                if ys == '_X15__NO_PREEMPTIONKM19__Preemption_Reason_1':
408                        state = str(thread['state'].cast(cfa_t.thread_state))
409                elif ys == '_X18__ALARM_PREEMPTIONKM19__Preemption_Reason_1':
410                        state = 'preempted'
411                elif ys == '_X19__MANUAL_PREEMPTIONKM19__Preemption_Reason_1':
412                        state = 'yield'
413                elif ys == '_X17__POLL_PREEMPTIONKM19__Preemption_Reason_1':
414                        state = 'poll'
415                else:
416                        print("error: thread {} in undefined preemption state {}".format(thread, ys))
417                        state = 'error'
418                self.print_formatted(marked, tid, thread['self_cor']['name'].string(), state, str(thread))
419
420        def print_threads_by_cluster(self, cluster, print_system = False):
421                # Iterate through a circular linked list of tasks and print out its
422                # name along with address associated to each cluster
423                threads = lookup_threads_by_cluster(cluster)
424                if not threads:
425                        return
426
427                running_thread = find_curr_thread()
428                if running_thread is None:
429                        print('Could not identify current thread')
430
431                self.print_formatted(False, '', 'Name', 'State', 'Address')
432
433                for t in threads:
434                        if not t.is_system() or print_system:
435                                self.print_thread(t.value, t.tid, t.value == running_thread if running_thread else False)
436
437                print()
438
439        def print_all_threads(self):
440                for c in all_clusters():
441                        self.print_threads_by_cluster(c, False)
442
443        def invoke(self, arg, from_tty):
444                """
445                @arg: str
446                @from_tty: bool
447                """
448                if not is_cforall():
449                        return
450
451                if not arg:
452                        cluster = lookup_cluster()
453                        if not cluster:
454                                print("Could not find Main Cluster")
455                                return
456
457                        # only tasks and main
458                        self.print_threads_by_cluster(cluster, False)
459
460                elif arg == 'all':
461                        # all threads, all clusters
462                        self.print_all_threads()
463
464                else:
465                        cluster = lookup_cluster(arg)
466                        if not cluster:
467                                print("No matching cluster")
468                                return
469
470                        # all tasks, specified cluster
471                        self.print_threads_by_cluster(cluster, True)
472
473
474############
475class Thread(gdb.Command):
476        """Cforall: Switch to specified user threads
477Usage:
478        cfathread <id>                       : switch stack to thread id on main cluster
479        cfathread 0x<address>                : switch stack to thread on any cluster
480        cfathread <id> <clusterName>         : switch stack to thread on specified cluster
481        """
482        def __init__(self):
483                # The first parameter of the line below is the name of the command. You
484                # can call it 'uc++ task'
485                super(Thread, self).__init__('cfathread', gdb.COMMAND_USER)
486
487        ############################ AUXILIARY FUNCTIONS #########################
488
489        def switchto(self, thread):
490                """Change to a new task by switching to a different stack and manually
491                adjusting sp, fp and pc
492                @task_address: str
493                        2 supported format:
494                                in hex format
495                                        <hex_address>: literal hexadecimal address
496                                        Ex: 0xffffff
497                                in name of the pointer to the task
498                                        "task_name": pointer of the variable name of the cluster
499                                                Ex: T* s -> task_name = s
500                        Return: gdb.value of the cluster's address
501                """
502                try:
503                        if not gdb.lookup_symbol('__cfactx_switch'):
504                                print('__cfactx_switch symbol is unavailable')
505                                return
506                except:
507                        print('here 3')
508
509                cfa_t = get_cfa_types()
510
511                state = thread['state'].cast(cfa_t.thread_state)
512                try:
513                        if state == gdb.parse_and_eval('Halted'):
514                                print('Cannot switch to a terminated thread')
515                                return
516
517                        if state == gdb.parse_and_eval('Start'):
518                                print('Cannjot switch to a thread not yet run')
519                                return
520                except:
521                        print("here 2")
522                        return
523
524
525                context = thread['context']
526
527
528
529                # must be at frame 0 to set pc register
530                gdb.execute('select-frame 0')
531                if gdb.selected_frame().architecture().name() != 'i386:x86-64':
532                        print('gdb debugging only supported for i386:x86-64 for now')
533                        return
534
535                # gdb seems to handle things much better if we pretend we just entered the context switch
536                # pretend the pc is __cfactx_switch and adjust the sp, base pointer doesn't need to change
537                # lookup for sp,fp and uSwitch
538                xsp = context['SP'] + 40 # 40 = 5 64bit registers : %r15, %r14, %r13, %r12, %rbx WARNING: x64 specific
539                xfp = context['FP']
540
541                # convert string so we can strip out the address
542                try:
543                        xpc = get_addr(gdb.parse_and_eval('__cfactx_switch').address)
544                except:
545                        print("here")
546                        return
547
548                # push sp, fp, pc into a global stack
549                global STACK
550                sp = gdb.parse_and_eval('$sp')
551                fp = gdb.parse_and_eval('$fp')
552                pc = gdb.parse_and_eval('$pc')
553                stack_info = StackInfo(sp = sp, fp = fp, pc = pc)
554                STACK.append(stack_info)
555
556                # update registers for new task
557                # print('switching to {} ({}) : [{}, {}, {}]'.format(thread['self_cor']['name'].string(), str(thread), str(xsp), str(xfp), str(xpc)))
558                print('switching to thread {} ({})'.format(str(thread), thread['self_cor']['name'].string()))
559                gdb.execute('set $rsp={}'.format(xsp))
560                gdb.execute('set $rbp={}'.format(xfp))
561                gdb.execute('set $pc={}'.format(xpc))
562
563        def find_matching_gdb_thread_id():
564                """
565                Parse the str from info thread to get the number
566                """
567                info_thread_str = gdb.execute('info thread', to_string=True).splitlines()
568                for thread_str in info_thread_str:
569                        if thread_str.find('this={}'.format(task)) != -1:
570                                thread_id_pattern = r'^\*?\s+(\d+)\s+Thread'
571                                # retrive gdb thread id
572                                return re.match(thread_id_pattern, thread_str).group(1)
573
574                        # check if the task is running or not
575                        if task_state == gdb.parse_and_eval('uBaseTask::Running'):
576                                # find the equivalent thread from info thread
577                                gdb_thread_id = find_matching_gdb_thread_id()
578                                if gdb_thread_id is None:
579                                        print('cannot find the thread id to switch to')
580                                        return
581                                # switch to that thread based using thread command
582                                gdb.execute('thread {}'.format(gdb_thread_id))
583
584        def switchto_id(self, tid, cluster):
585                """
586                @cluster: cluster object
587                @tid: int
588                """
589                threads = lookup_threads_by_cluster( cluster )
590
591                for t in threads:
592                        if t.tid == tid:
593                                self.switchto(t.value)
594                                return
595
596                print("Cound not find thread by id '{}'".format(tid))
597
598        def invoke(self, arg, from_tty):
599                """
600                @arg: str
601                @from_tty: bool
602                """
603                if not is_cforall():
604                        return
605
606                argv = parse(arg)
607                if argv[0].isdigit():
608                        cname = " ".join(argv[1:]) if len(argv) > 1 else None
609                        cluster = lookup_cluster(cname)
610                        if not cluster:
611                                print("Could not find cluster '{}'".format(cname if cname else "Main Cluster"))
612                                return
613
614                        try:
615                                tid = int(argv[0])
616                        except:
617                                print("'{}' not a valid thread id".format(argv[0]))
618                                print_usage(self)
619                                return
620
621                                # by id, userCluster
622                        self.switchto_id(tid, cluster)
623
624                elif argv[0].startswith('0x') or argv[0].startswith('0X'):
625                        self.switchto(argv[0]) # by address, any cluster
626
627############
628class PrevThread(gdb.Command):
629        """Switch back to previous task on the stack"""
630        usage_msg = 'prevtask'
631
632        def __init__(self):
633                super(PrevThread, self).__init__('prevtask', gdb.COMMAND_USER)
634
635        def invoke(self, arg, from_tty):
636                """
637                @arg: str
638                @from_tty: bool
639                """
640                global STACK
641                if len(STACK) != 0:
642                        # must be at frame 0 to set pc register
643                        gdb.execute('select-frame 0')
644
645                        # pop stack
646                        stack_info = STACK.pop()
647                        pc = get_addr(stack_info.pc)
648                        sp = stack_info.sp
649                        fp = stack_info.fp
650
651                        # pop sp, fp, pc from global stack
652                        adjust_stack(pc, fp, sp)
653
654                        # must be at C++ frame to access C++ vars
655                        gdb.execute('frame 1')
656                else:
657                        print('empty stack')
658
659class ResetOriginFrame(gdb.Command):
660        """Reset to the origin frame prior to continue execution again"""
661        usage_msg = 'resetOriginFrame'
662        def __init__(self):
663                super(ResetOriginFrame, self).__init__('reset', gdb.COMMAND_USER)
664
665        def invoke(self, arg, from_tty):
666                """
667                @arg: str
668                @from_tty: bool
669                """
670                global STACK
671                if len(STACK) != 0:
672                        stack_info = STACK.pop(0)
673                        STACK.clear()
674                        pc = get_addr(stack_info.pc)
675                        sp = stack_info.sp
676                        fp = stack_info.fp
677
678                        # pop sp, fp, pc from global stack
679                        adjust_stack(pc, fp, sp)
680
681                        # must be at C++ frame to access C++ vars
682                        gdb.execute('frame 1')
683                #else:
684                        #print('reset: empty stack') #probably does not have to print msg
685
686Clusters()
687Processors()
688ResetOriginFrame()
689PrevThread()
690Threads()
691Thread()
692
693# Local Variables: #
694# mode: Python #
695# End: #
Note: See TracBrowser for help on using the repository browser.