• gdb调试多进程和多线程命令


    转自: gdb调试多进程和多线程命令

    1. 默认设置下,在调试多进程程序时GDB只会调试主进程。但是GDB(>V7.0)支持多进程的分别以及同时调试,换句话说,GDB可以同时调试多个程序。只需要设置follow-fork-mode(默认值:parent)和detach-on-fork(默认值:on)即可。

          follow-fork-mode  detach-on-fork   说明
    parent                   on               只调试主进程(GDB默认)
    child                     on               只调试子进程
    parent                   off              同时调试两个进程,gdb跟主进程,子进程block在fork位置
    child                     off              同时调试两个进程,gdb跟子进程,主进程block在fork位置

       设置方法:set follow-fork-mode [parent|child]   set detach-on-fork [on|off]

       查询正在调试的进程:info inferiors
       切换调试的进程: inferior <infer number>
       添加新的调试进程: add-inferior [-copies n] [-exec executable] ,可以用file executable来分配给inferior可执行文件。
       其他:remove-inferiors infno, detach inferior

    2. GDB默认支持调试多线程,跟主线程,子线程block在create thread。
       查询线程:info threads
       切换调试线程:thread <thread number>

    例程:

    #include <stdio.h>
    #include <pthread.h>

    void processA();
    void processB();
    void * processAworker(void *arg);

    int main(int argc, const char *argv[])
      {
      int pid;

      pid = fork();

      if(pid != 0)
        processA();
      else
        processB();

      return 0;
      }

    void processA()
      {
      pid_t pid = getpid();
      char prefix[] = "ProcessA: ";
      char tprefix[] = "thread ";
      int tstatus;
      pthread_t pt;

      printf("%s%lu %s ", prefix, pid, "step1");

      tstatus = pthread_create(&pt, NULL, processAworker, NULL);
      if( tstatus != 0 )
        {
        printf("ProcessA: Can not create new thread.");
        }
     
      processAworker(NULL);
      sleep(1);
      }

    void * processAworker(void *arg)
      {
      pid_t pid = getpid();
      pthread_t tid = pthread_self();
      char prefix[] = "ProcessA: ";
      char tprefix[] = "thread ";

      printf("%s%lu %s%lu %s ", prefix, pid, tprefix, tid, "step2");
      printf("%s%lu %s%lu %s ", prefix, pid, tprefix, tid, "step3");

      return NULL;
      }

    void processB()
      {
      pid_t pid = getpid();
      char prefix[] = "ProcessB: ";
      printf("%s%lu %s ", prefix, pid, "step1");
      printf("%s%lu %s ", prefix, pid, "step2");
      printf("%s%lu %s ", prefix, pid, "step3");

      }

    输出:

    [cnwuwil@centos c-lab]$ ./test
    ProcessA: 802 step1
    ProcessB: 803 step1
    ProcessB: 803 step2
    ProcessB: 803 step3
    ProcessA: 802 thread 3077555904 step2
    ProcessA: 802 thread 3077555904 step3
    ProcessA: 802 thread 3077553008 step2
    ProcessA: 802 thread 3077553008 step3


    调试:
    1. 调试主进程,block子进程。

    (gdb) set detach-on-fork off
    (gdb) show detach-on-fork
    Whether gdb will detach the child of a fork is off.
    (gdb) catch fork
    Catchpoint 1 (fork)
    (gdb) r
    [Thread debugging using libthread_db enabled]

    Catchpoint 1 (forked process 3475), 0x00110424 in __kernel_vsyscall ()
    Missing separate debuginfos, use: debuginfo-install glibc-2.12-1.47.el6.i686
    (gdb) break test.c:14
    Breakpoint 2 at 0x8048546: file test.c, line 14.
    (gdb) cont
    [New process 3475]
    [Thread debugging using libthread_db enabled]

    Breakpoint 2, main (argc=1, argv=0xbffff364) at test.c:14
    Missing separate debuginfos, use: debuginfo-install glibc-2.12-1.47.el6.i686
    (gdb) info inferiors
      Num  Description       Executable       
      2    process 3475      /home/cnwuwil/labs/c-lab/test
    * 1    process 3472      /home/cnwuwil/labs/c-lab/test

    2. 切换到子进程:

    (gdb) inferior 2
    [Switching to inferior 2 [process 3475] (/home/cnwuwil/labs/c-lab/test)]
    [Switching to thread 2 (Thread 0xb7fe86c0 (LWP 3475))]
    #0  0x00110424 in ?? ()
    (gdb) info inferiors
      Num  Description       Executable       
    * 2    process 3475      /home/cnwuwil/labs/c-lab/test
      1    process 3472      /home/cnwuwil/labs/c-lab/test
    (gdb) inferior 1
    [Switching to inferior 1 [process 3472] (/home/cnwuwil/labs/c-lab/test)]
    [Switching to thread 1 (Thread 0xb7fe86c0 (LWP 3472))]
    #0  main (argc=1, argv=0xbffff364) at test.c:14
    (gdb) info inferiors
      Num  Description       Executable       
      2    process 3475      /home/cnwuwil/labs/c-lab/test
    * 1    process 3472      /home/cnwuwil/labs/c-lab/test

    3. 设断点继续调试主进程,主进程产生两个子线程:

    (gdb) break test.c:50
    Breakpoint 3 at 0x804867d: file test.c, line 50. (2 locations)
    (gdb) cont
    ProcessA: 3472 step1
    [New Thread 0xb7fe7b70 (LWP 3562)]
    ProcessA: 3472 thread 3086911168 step2

    Breakpoint 3, processAworker (arg=0x0) at test.c:50
    (gdb) info inferiors
      Num  Description       Executable       
      2    process 3475      /home/cnwuwil/labs/c-lab/test
    * 1    process 3472      /home/cnwuwil/labs/c-lab/test
    (gdb) info threads
      3 Thread 0xb7fe7b70 (LWP 3562)  0x00110424 in __kernel_vsyscall ()
      2 Thread 0xb7fe86c0 (LWP 3475)  0x00110424 in ?? ()
    * 1 Thread 0xb7fe86c0 (LWP 3472)  processAworker (arg=0x0) at test.c:50

    4. 切换到主进程中的子线程,注意:线程2为前面产生的子进程

    (gdb) thread 3
    [Switching to thread 3 (Thread 0xb7fe7b70 (LWP 3562))]#0  0x00110424 in __kernel_vsyscall ()
    (gdb) cont
    ProcessA: 3472 thread 3086911168 step3
    ProcessA: 3472 thread 3086908272 step2
    [Switching to Thread 0xb7fe7b70 (LWP 3562)]

    Breakpoint 3, processAworker (arg=0x0) at test.c:50
    (gdb) info threads
    * 3 Thread 0xb7fe7b70 (LWP 3562)  processAworker (arg=0x0) at test.c:50
      2 Thread 0xb7fe86c0 (LWP 3475)  0x00110424 in ?? ()
      1 Thread 0xb7fe86c0 (LWP 3472)  0x00110424 in __kernel_vsyscall ()
    (gdb) thread 1
     
     
     
    -------------------多线程调试
    转自:http://blog.csdn.net/lhl_blog/article/details/8888010
     

    inux下应用程序的调试工具主要就是gdb,可能你已经习惯了IDE形式的调试工具。也许刚开始使用gdb作为调试工具,会有诸多的不变,但是一旦你学会了如何使用gdb你就会被其富有魔力的功能所吸引的,下面开始逐步的学习linux下gdb的使用方式。

    一直以来对于gdb在多线程调试方面的应用好奇,最近,由于项目需要,学习了linux下的gdb在多线程下的调试方法。下面就结合一个简单的案例介绍一下gdb的多线程调试方法。其中,本例子还介绍了如何调试链接有静态库的多线程应用程序。

    1.理论介绍

    gdb支持的用于多线程调试的工具如下:

    1. 能够自动的提醒新线程的创建。
    2. ‘thred threadno’,实现在不同线程间切换。
    3. ‘info thead’,可以查看存在的线程信息。
    4. ‘thread applay [threadno[all] args’  ,在指定的线程上执行特定的命令args。
    5. 可以在线程中设置特定的断点。
    6. ‘set print thread-events’,用于设定是否提示线程启动或停止时的信息。
    7. ‘set libthread-db-search-path path’,用于是用户可以自己制定libthread-db 的路径信息
    8.  'set scheduler-locking mode',在某些操作系统中,你可以通过锁住OS的调度行为,这样可以就可以改变GDB默认的行为,达到同一时间只有一个线程在运行的目的。
      • off:没有锁定,所有线程可以在任何时间运行。
      • on:锁定线程,只有当前线程在运行。
      • step:该模式是对single-stepping模式的优化。此模式会阻止其他线程在当前线程单步调试时,抢占当前线。因此调试的焦点不会被以外的改变。其他线程不可能抢占当前的调试线程。其他线程只有下列情况下会重新获得运行的机会:
        • 当你‘next’一个函数调用的时候。
        • 当你使用诸如‘continue’、‘until‘、’finish‘命令的时候。
        • 其他线程遇到设置好的断点的时候。

    1.1线程创建提醒

    当应用程序创建线程的时候,如果你设置了’set print thread-events‘,那么他会自动提示新创建线程的信息,GNU/linux 下的提示信息如下:

    [cpp] view plaincopy
     
    1. [New Thread 0x41e02940 (LWP 25582)]  


    1.2显示线程信息

    info thread用于显示系统中正在运行的所有线程的信息。信息主要包括如下几项:

    1. GDB分配的id号。
    2. 目标系统定义的线程id(systag)。
    3. 线程的名字,如果存在的话,会被显示出来。用户可以自定义线程的名字,或者由程序自己指定。
    4. 线程相关的栈的信息。

    其中,*表示当前正在运行的线程,下面是一个多线程的相关信息。

    [cpp] view plaincopy
     
    1. (gdb) info threads  
    2. Id Target Id Frame  
    3. 3 process 35 thread 27 0x34e5 in sigpause ()  
    4. 2 process 35 thread 23 0x34e5 in sigpause ()  
    5. * 1 process 35 thread 13 main (argc=1, argv=0x7ffffff8)  
    6. at threadtest.c:68  

    1.3切换线程

    thread threadno用于在同步线程之间实现切换。threadno即上面显示的GDB自定义的线程的id号。线程切换成功后,会打印该线程的相关信息,比如栈信息。

    [cpp] view plaincopy
     
    1. (gdb) thread 2  
    2. [Switching to thread 2 (Thread 0xb7fdab70 (LWP 12747))]  
    3. #0 some_function (ignore=0x0) at example.c:8  
    4. 8 printf ("hello ");  

    变量$_thread 记录了当前线程的id号。你或许在设置断点条件或脚本的时候会用到该变量。

    1.4执行命令

    thread apply[threadid|all] command,该工具用于在一个或多个线程执行指定的命令command。threadid可以是一个或多个线程id,或是一个范围值,例如,1-3

    1.5定义/find线程名

    thread name,可以通过该工具实现线程名的重新定义。一般,系统会为每一个线程定义一个名字,例如GNU/linux,使用该命令后会将系统定义的线程名称覆盖掉。

    thread find [regexp],其中regexp可以是线程的systag,例如,LWP 25582中的25582,或线程名(系统定义的或用户自定义的)

    2.实例调试

    下面通过一个实例,具体演示一下gdb  thread调试。

    2.1静态库编译

    下面为一个简单的函数用于打印不同的字符串。

    [cpp] view plaincopy
     
    1. #include<iostream>                                                                                                                      
    2. #include<string>  
    3. #include"print.h"  
    4.   
    5. using namespace std;  
    6.   
    7. void print(string words)  
    8. {  
    9.         std::cout << words << std::endl;  
    10. }  

    将其编译成静态库

    [cpp] view plaincopy
     
    1. g++ -c print.cpp   
    [cpp] view plaincopy
     
    1. ar crs libprint.a print.o  


    2.2 链接静态库

    下面为一个多线程程序的打印程序,很简单

    [cpp] view plaincopy
     
    1. #include<iostream>  
    2. #include<pthread.h>  
    3. #include"print.h"  
    4.   
    5. void* threadPrintHello(void* arg)  
    6. {  
    7.     while(1)  
    8.     {  
    9.         sleep(5);  
    10.         print(string("Hello"));  
    11.     }  
    12. }  
    13.   
    14. void* threadPrintWorld(void* arg)  
    15. {  
    16.     while(1)  
    17.     {  
    18.         sleep(5);  
    19.         print(string("World"));  
    20.     }  
    21. }  
    22.   
    23. int main( int argc , char* argv[])  
    24. {  
    25.     pthread_t pid_hello , pid_world;  
    26.       
    27.     int ret = 0;  
    28.   
    29.     ret = pthread_create(&pid_hello , NULL , threadPrintHello , NULL);  
    30.   
    31.     if( ret != 0 )  
    32.     {  
    33.         std::cout << "Create threadHello error" << std::endl;  
    34.         return -1;  
    35.     }  
    36.   
    37.     ret = pthread_create(&pid_world , NULL , threadPrintWorld , NULL);  
    38.   
    39.     if( ret != 0 )  
    40.     {  
    41.         std::cout << "Create threadWorld error" << std::endl;  
    42.         return -1;  
    43.     }  
    44.   
    45.     while(1)  
    46.     {  
    47.         sleep(10);  
    48.         std::cout << "In main thread"  << std::endl;  
    49.     }     
    50.       
    51.     pthread_join(pid_hello , NULL);  
    52.     pthread_join(pid_world , NULL);  
    53.   
    54.     return 0;  
    55. }  


    编译程序

    [cpp] view plaincopy
     
    1. g++ -o thread thread.cpp -lpthread -lprint  


    2.3调试程序

    启动程序

    [cpp] view plaincopy
     
    1. $./thread   


    进程id

    [cpp] view plaincopy
     
    1. $ps aux |grep thred  
    [cpp] view plaincopy
     
    1. 1000     24931  0.0  0.0  21892   912 pts/0    tl+  03:04   0:00 src/thread  

    attach该进程

    [cpp] view plaincopy
     
    1. $sudo gdb thread 24931  


    显示线程信息

    [cpp] view plaincopy
     
    1. (gdb) info thread  
    2.   Id   Target Id         Frame   
    3. * 3    Thread 0xb7471b40 (LWP 24932) "threadPrintHello" threadPrintHello (arg=0x0) at thread.cpp:10  
    4.   2    Thread 0xb6c70b40 (LWP 24933) "thread" 0xb7779424 in __kernel_vsyscall ()  
    5.   1    Thread 0xb7473700 (LWP 24931) "thread" 0xb7779424 in __kernel_vsyscall ()  
  • 相关阅读:
    2019-2020-1学期 20192419 《网络空间安全专业导论》第一周学习总结 (读书心得)
    2019-2020-1学期 20192419 《网络空间安全专业导论》第一周学习总结 (读书笔记)
    DFA最小化,语法分析初步
    作业8非确定的自动机NFA确定化为DFA
    作业7 正规式、正规文法与自动机
    作业6 正规文法与正规式
    作业5 词法分析程序的设计与实现
    作业4 文法和语言总结与梳理
    作业3 语法树,短语,直接短语,句柄
    作业2理解文法和语文
  • 原文地址:https://www.cnblogs.com/wliangde/p/3737040.html
Copyright © 2020-2023  润新知