• 作者: 雪山肥鱼
• 时间：20210710 22:48
• 目的：封装so调试多线程，gdb

# detect - nojoin
# 利用库去调试
  ## 编译so 与 leak.c
  ## 在liak执行文件中 加载 so
  ## 使用方式

整体思路:

1. 将线程变量作为key， 线程的routine函数 与 参数 作为value形成map。
2. 重新封装 pthread_create 与 pthead_join
3. 只要 pthread_create了，就往map里塞值
4. 只要 pthread_join了，就erase 这一项

重新封装pthread_create 与 pthread_join
关于 dlfcn.h 的 学习地址:
https://langzi989.github.io/2017/10/16/Unix%E4%B8%ADdl%E5%BA%93%E5%AD%A6%E4%B9%A0/
利用 <dlfcn.h> 中的 系列函数进行封装实际效果如下：

dlsym.png
其中 dlysm 的 RTLD_NEXT 应该是找到第一个pthread_create 符号链接。即使有多个，寻找的是第一个。详情看 man dlysm

detect - nojoin

/*leak.c*/
#include <pthread.h>
#include <unistd.h>

void* worker(void* unusued)
{
  // Do nothing
}

int main()
{
  pthread_t thread_id;

  for (int i = 0; i < 10; i++) {
    pthread_create(&thread_id, NULL, &worker, (void*)i);
    if (i != 4 && i != 7) 
        pthread_join(thread_id, NULL);
  }
  sleep(1000);
  return 0;
}

人为的制造内存泄漏

#include <assert.h>
#include <dlfcn.h>
#include <pthread.h>
#include <map>
#include <iostream>

static pthread_mutex_t mtx;
typedef std::pair < void *, void *>elem_t;
typedef std::map < pthread_t, elem_t > map_t;
static map_t thr_map;

extern "C" int pthread_create(pthread_t * tid, const pthread_attr_t * attr,
               void *(*start_routine) (void *), void *arg)
{
    static __decltype(pthread_create) * real
        = reinterpret_cast < __decltype(pthread_create) * >(dlsym(RTLD_NEXT,
                                      "pthread_create"));
    int rc = (*real) (tid, attr, start_routine, arg);
    if (rc == 0) {
        pthread_mutex_lock(&mtx);
        thr_map[*tid] = std::make_pair((void *)start_routine, arg);
        std::cout<<"create"<<std::endl
        pthread_mutex_unlock(&mtx);
    }
    return rc;
}

extern "C" int pthread_join(pthread_t tid, void **arg)
{
    static __decltype(pthread_join) * real
        = reinterpret_cast < __decltype(pthread_join) * >(dlsym(RTLD_NEXT,
                                    "pthread_join"));
    int rc = (*real) (tid, arg);
    if (rc == 0) {
        pthread_mutex_lock(&mtx);
        const auto it = thr_map.find(tid);
        assert(it != thr_map.end());
        thr_map.erase(it);
        pthread_mutex_unlock(&mtx);
    }
    return rc;
}

extern "C" void print_nojoin()
{
    pthread_mutex_lock(&mtx);

        std::cout << "found " << thr_map.size() << " not joined threads" << std::endl;

    for (auto it = thr_map.begin(); it != thr_map.end(); it++)
        std::cout << "tid:" << it->first << " fnc:" << it->second.
            first << " arg:" << it->second.second << std::endl;

    pthread_mutex_unlock(&mtx);
}

上述 函数 知识点

1. extern C 防止 名命倾轧， 让 g++ 按照C语言的方式去编译代码，不会修改函数的名称。做成so后，以免链接出现问题。因为 pthread_create/join 属于C库代码
   关于名命倾轧：
   https://blog.csdn.net/lixiang100824/article/details/7437827
2. __decltype
   理解为c++11 中的decltype就好， 推测变量类型

#include<stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

typedef int(*FuncType)(int&, int);

int add_to(int &dest, int ori) {
        return dest + ori;
}

#if 0

int main(int argc, char ** argv) { int a = 4;
//      FuncType pf = add_to;
        FuncType pf = add_to;
        FuncType *ppf = &pf;// just for fun
        int b = (*ppf)(a, 3);
        //int b = pf(a, 3);
        cout<<b<<endl;
        
        return 0;
}
#endif

int main(int argc, char ** argv) { int a = 4;
        //FuncType pf = add_to;
        //decltype(add_to)  pf = add_to;// incorrect
        decltype(add_to) * pf = add_to;
        int b = pf(a, 3);
        cout<<b<<endl;

        return 0;
}

decltype(func_name)的时候，decltype 会返回对应的函数类型，但不会自动转为函数指针，所以 必须要用 decltype(funcname) * p = funcname

同理代码中的
static __decltype(pthread_create) * real = reinterpret_cast < __decltype(pthread_create) * >(dlsym(RTLD_NEXT, "pthread_create"));

3. reinterpret_cast< > 指针和引用类型的转换
   4种 cast
   statoc_cast
   const_cast
   reinterpret_cast
   dynamic_cast

利用库去调试

编译nojoin-helper.so 与 leak.c

g++ -g -fPIC -shared -o nojoin-helper.so nojoin-helper.cpp -ldl --std=c++11

-fPIC 作用于编译阶段，告诉编译器产生与位置无关代码(Position-Independent Code)，则产生的代码中，没有绝对地址，全部使用相对地址，故而代码可以被加载器加载到内存的任意位置，都可以正确的执行。这正是共享库所要求的，共享库被加载时，在内存的位置不是固定的。

g++ -g leak.cpp -o leak  -std=c++11

在 leak执行文件中加载 nojoin-helper.so

//可自行百度LD_PRELOAD

LD_PRELOAD=./nojoin-helper.so   ./leak

使用

1. 打开另一个终端
   在另一个session终端依旧得

LD_PRELOAD=./nojoin-helper.so
sudo gdb -p 2645

2. 在gdb 中强行调用 call print_nojoin() 查看哪些线程没有join 从而造成泄漏

   
   session2.png

3. 在session1 中 查看结果

   
   leak.png

倒是可以通过传入线程的参数，从而定位到底是什么哪根线程除了问题，比如传入对象，通过对象的某个字段定位