标签: dynamic-linking

我是linux的新手,在使用动态库进行编译时,我收到了segmentationfault错误.

我有两个文件

ctest1.c

void ctest1(int *i)
{ 
   *i =10;
}

ctest2.c

void ctest2(int *i)
{ 
   *i =20;
}

我已使用以下命令将这两个文件编译到名为libtest.so的共享库中

  gcc -shared -W1,-soname,libtest.so.1 -o libtest.so.1.0.1 ctest1.o ctest2.o -lc

我已经编写了另一个程序prog.c,它使用了这个库导出的函数

prog.c中

#include <stdio.h>

void (*ctest1)(int*);
void (ctest2)(int*);


int main()
{
  int a;

  ctest1(&a);

  printf("%d",a);

  return 0;

}

当我使用以下命令构建可执行文件时

gcc -Wall prog.c -L.-o prog

但是当我运行生成的可执行文件时,我得到了SegmentationFault错误.

当我用ldd检查prog的标题时,它显示出来

linux-vdso.so.1 =>(0x00007f99dff000)libc.so.6 => /lib64/libc.so.6(0x0007feeaa8c1000)/lib64/ld-linux-x86-64.so.2(0x00007feeaac1c000)

有人可以说出问题所在

g++ -o Test Test.cpp -lTest
/usr/bin/ld: cannot find -lTest
collect2: ld returned 1 exit status

如果在运行时按需加载共享/动态库中的符号,为什么在编译时缺少库会导致致命错误？

我在C++中看到了关于动态链接的这篇文章.

我们可以创建一个C++工厂,它将返回我们感兴趣的类的对象.此外,我们应该在工厂的文件范围内创建一个静态对象,以便可以使用它来定位它dlsym().(文章建议静态对象不会受到名称损坏.)

为什么静态对象没有名称损坏？

我正在按照这个答案来覆盖对C库的C函数的调用.

我想我做的一切都正确,但它不起作用:

我想覆盖"DibOpen"功能.这是我在运行应用程序时传递给LD_PRELOAD环境变量的库代码:

DIBSTATUS DibOpen(void **ctx, enum Board b)
{
    printf("look at me, I wrapped\n");

    static DIBSTATUS (*func)(void **, enum Board) = NULL;
    if(!func)
        func = dlsym(RTLD_NEXT, "DibOpen");
    printf("Overridden!\n");
    return func(pContextAddr, BoardType, BoardHdl);
}

nm lib.so | grep DibOpen节目的输出

000000000001d711 T DibOpen

当我像这样运行我的程序时

LD_PRELOAD=libPreload.so ./program

我program用-ldl 链接我,但ldd program没有显示libdl.so的链接

它停止了

 symbol lookup error: libPreload.so: undefined symbol: dlsym

.我该怎么做才能进一步调试？我的错误在哪里？

例如,此代码段错误(请参阅main.cpp中的注释).

hello.h

struct A { virtual ~A() {} };

HELLO.CPP

#include "hello.h"

extern "C" {
    void hello(A*& a) {
        a = new A;
    }
}

main.cpp中:

#include <cassert>
#include <dlfcn.h>

#include "hello.h"

int main() {

    void* handle = dlopen("./hello.so", RTLD_LAZY);
    assert(handle);

    typedef void (*hello_t)(A*& a);
    hello_t hello = (hello_t) dlsym(handle, "hello");
    assert(hello);

    A* a = nullptr;
    hello(a);
    dlclose(handle);

    delete a; // -> segfault
}

编

g++ -Wall -std=c++11 -g main.cpp -ldl -o main
g++ -Wall -std=c++11 -g -shared -fpic hello.cpp …

在低内存Linux系统上,我有一个由单个可执行文件和许多共享库组成的项目.这些库不与其他可执行文件共享,并且只有一个可执行文件实例随时运行.有人告诉我,这个设置允许共享库在不处于活动状态时从内存中卸载.它是否正确？

在我看来,简单地将整个项目构建为单个静态二进制文件(当然不包括系统共享库)更有意义,因为每个函数只有一个副本在内存中是活动的.

这两种方法有区别吗？

参考以下代码

#include <cassert>
#include <vector>
#include <dlfcn.h>
#include <limits>
#include <map>
#include <algorithm>
#include <iostream>
using std::cout;
using std::endl;
using std::vector;

/*
 * Overload the malloc call
 */
int max_heap_usage = 0;
std::map<uintptr_t, int>& heap_memory_map;
void track_max_usage(std::map<uintptr_t, int> heap_memory_map, 
        int& max_heap_usage);

void* malloc(size_t size) {

    // get the original malloc function call
    static auto original_malloc = (decltype(&malloc)) dlsym(RTLD_NEXT, "malloc");

    // Get the pointer from malloc
    void* pointer = original_malloc(size);
    uintptr_t pointer_handle = reinterpret_cast<uintptr_t>(pointer);

    // assert that the pointer does not …

我最近读了这个问题如何静态链接到TBB？我仍然不明白使用tbb作为静态链接库的问题(如果你这样做,可以使用它们的makefile make extra_inc=big_iron.inc tbb)

答案似乎是说问题在于单个程序中可能存在多个单例,单个子的所有(大多数？)实现都不会让这种情况发生.我不明白这背后的原因.

问题在于,当您进行fork()另一个处理时,单例会在两个单独的进程中成为两个独立的单例吗？那是"程序"的意思吗？如果就是这样,为什么他们不能mmap()共享内存并将其用作通信媒介？

也不动态链接只意味着库本身在内存中共享,即代码段？

谢谢!

Python如何调用C库？例如,Tensorflow我认为主要是用C语言编写的,但可以从Python中使用.我正在考虑在我自己的(解释的)编程语言中实现类似的东西(用Go编写,但我认为它将是一个类似的过程).

Python程序调用C函数时会发生什么？我在想RPC或DLL,但它们似乎都不太可能.

我正在构建一个动态库libfoo.so，该库取决于libcrypto.so。

在我的自动工具Makefile.am文件中，我有这样一行：

libfoo_la_LIBADD += -L${OPENSSL_DIR}/lib -lcrypto

其中$OPENSSL_DIR缺省为/usr，但可以通过使被覆盖--with-openssl-dir=/whatever。

我如何确保（仅）libfoo.so使用一个可执行文件而无需构建或运行该可执行文件的人来使用或摆弄？${OPENSSL_DIR}/lib/libcrypto.sorpathLD_LIBRARY_PATH