EXPORT_SYMBOL和其用户态类似的使用方式学习

EXPORT_SYMBOL是什么，主要用于？

EXPORT_SYMBOL是Linux内核中的一个宏定义，用于导出符号（symbols）给其他模块使用。

在Linux内核中，模块是可以在运行时插入和移除的，模块之间需要相互通信，因此需要在模块之间共享符号。符号是指函数、变量或常量等在编译时由编译器生成的名字。

EXPORT_SYMBOL的作用就是将符号导出，使得其他模块可以使用它们。具体来说，当一个模块使用EXPORT_SYMBOL导出符号时，其他模块就可以使用该符号。例如，一个模块可以导出一个函数，供其他模块调用，或者导出一个变量，供其他模块读取或修改。

需要注意的是，EXPORT_SYMBOL导出的符号只能被其他模块使用，而不能被用户空间的程序使用。如果需要在用户空间使用符号，可以使用EXPORT_SYMBOL_GPL宏定义，它会限制符号的使用权限，只允许GPL协议的模块使用。

总的来说，EXPORT_SYMBOL是Linux内核中一个非常重要的机制，它使得模块之间可以相互调用，从而实现了内核的模块化设计。

一个例子来说明EXPORT_SYMBOL

在一个名为 my_module 的内核模块中，定义一个全局变量 my_global_var，并将其导出：

// my_module.c

#include <linux/module.h>

int my_global_var = 42;

EXPORT_SYMBOL(my_global_var);

static int __init my_module_init(void)
{
    printk(KERN_INFO "my_module initialized\n");
    return 0;
}

static void __exit my_module_exit(void)
{
    printk(KERN_INFO "my_module unloaded\n");
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple example Linux module.");
MODULE_VERSION("0.01");

在另一个模块中，使用 my_global_var 变量：

// another_module.c

#include <linux/module.h>

extern int my_global_var;

static int __init another_module_init(void)
{
    printk(KERN_INFO "another_module initialized with my_global_var = %d\n", my_global_var);
    return 0;
}

static void __exit another_module_exit(void)
{
    printk(KERN_INFO "another_module unloaded\n");
}

module_init(another_module_init);
module_exit(another_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Another example Linux module.");
MODULE_VERSION("0.01");

在上面的代码中，my_module 模块定义了一个全局变量 my_global_var 并导出它，另一个模块 another_module 使用了这个变量。

当这两个模块一起编译并加载到内核中后， another_module 就可以通过 extern int my_global_var 引用 my_global_var 变量了。

需要注意的是，如果没有使用 EXPORT_SYMBOL 导出 my_global_var 变量， another_module 模块就不能使用它，会出现符号未定义的错误。

注意除了提供方要导出符号，使用方要extern声明符号之外，在使用方编译的时候也要添加：
KBUILD_EXTRA_SYMBOLS += /path/to/ModuleA/Module.symvers
这样才能在使用中不会报错找不到符号。

另外需要注意如果是函数符号，调用的时候要确保参数类型一致，不支持隐式转换！尤其是64位隐士转为32位，会出现数据问题

用户态实现类似的效果

用户态无法使用EXPORT_SYMBOL.

只能使用dlopen来读取so信息，然后使用dlsym来获取对应的interface.

如果想要达到内核态使用的一个extern的效果，需要看以下例子：

libbar.c

#include <stdio.h>

extern void foo();

void bar() {
    printf("Hello from bar()\n");
    foo();
}

libfoo.c:

#include <stdio.h>

void foo() {
    printf("Hello from foo()\n");
}

编译：

gcc -Wall -shared -fPIC -o libfoo.so libfoo.c
gcc -Wall -shared -fPIC -o libbar.so libbar.c

这里可以看出一个动态库想要使用另外一个动态库的内容，但是看起来两个是互不相关的。

接着就是主程序：

// file: main.c
#include <dlfcn.h>
#include <stdio.h>

extern int global_var;

int main() {
    void (*foo_ptr)();
    void (*bar_ptr)();

    // 打开动态链接库libfoo.so，同时传入RTLD_NOW和RTLD_GLOBAL标志
    void *handle_foo = dlopen("./libfoo.so", RTLD_NOW | RTLD_GLOBAL);
    if (!handle_foo) {
        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
        return 1;
    }

    // 打开动态链接库libbar.so，同时传入RTLD_NOW标志
    void *handle_bar = dlopen("./libbar.so", RTLD_NOW);
    if (!handle_bar) {
        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
        dlclose(handle_foo);
        return 1;
    }

    // 从动态链接库libfoo.so中获取函数foo的指针，并调用它
    foo_ptr = dlsym(handle_foo, "foo");
    if (!foo_ptr) {
        fprintf(stderr, "Failed to get symbol: %s\n", dlerror());
        dlclose(handle_foo);
        dlclose(handle_bar);
        return 1;
    }
    foo_ptr();

    // 从动态链接库libbar.so中获取函数bar的指针，并调用它
    bar_ptr = dlsym(handle_bar, "bar");
    if (!bar_ptr) {
        fprintf(stderr, "Failed to get symbol: %s\n", dlerror());
        dlclose(handle_foo);
        dlclose(handle_bar);
        return 1;
    }
    bar_ptr();

    // 关闭动态链接库句柄
    dlclose(handle_foo);
    dlclose(handle_bar);
    return 0;
}

gcc main.c -o main -ldl

打印结果：

Hello from foo()
Hello from bar()
Hello from foo()

这里使用dlopen进行动态加载，达到和内核态模块化类似的概念，然后为了dlopen加载避免先后顺序不同导致的找不到符号，所以使用了RTLD_GLOBAL！

RTLD_GLOBAL：动态库中定义的符号可被其后打开的其它库解析。

如果不使用该标志，会导致执行失败：

Failed to load shared library: ./libbar.so: undefined symbol: foo

但是你可能会发现libfoo.so要先加载，不然怎么改都不可能找到。

这就意味着他们调用者和调用者有加载的顺序要求。

该例子可以传递指针数据：

bar:
#include <stdio.h>

extern void foo(int *);

void bar() {
    printf("Hello from bar()\n");
   int i = 6;
         foo(&i);
}

foo:
#include <stdio.h>


void foo(int *sd) {
    *sd = *sd +1;
    printf("Hello from foo():%d\n",*sd);
}

main:
#include <dlfcn.h>
#include <stdio.h>

extern int global_var;

int main() {
    void (*foo_ptr)(int *);
    void (*bar_ptr)();

    void *handle_foo = dlopen("./libfoo.so", RTLD_NOW | RTLD_GLOBAL);
    if (!handle_foo) {
        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
        dlclose(handle_foo);
        return 1;
    }

    // 打开动态链接库libbar.so，同时传入RTLD_NOW标志
    void *handle_bar = dlopen("./libbar.so", RTLD_NOW | RTLD_GLOBAL);
    if (!handle_bar) {
        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
        return 1;
    }
    // 打开动态链接库libfoo.so，同时传入RTLD_NOW和RTLD_GLOBAL标志

    // 从动态链接库libfoo.so中获取函数foo的指针，并调用它
    foo_ptr = dlsym(handle_foo, "foo");
    if (!foo_ptr) {
        fprintf(stderr, "Failed to get symbol: %s\n", dlerror());
        dlclose(handle_foo);
        dlclose(handle_bar);
        return 1;
    }
        int Y = 12;
        foo_ptr(&Y);
        foo_ptr(&Y);

    // 从动态链接库libbar.so中获取函数bar的指针，并调用它
    bar_ptr = dlsym(handle_bar, "bar");
    if (!bar_ptr) {
        fprintf(stderr, "Failed to get symbol: %s\n", dlerror());
        dlclose(handle_foo);
        dlclose(handle_bar);
        return 1;
    }
    bar_ptr();

    // 关闭动态链接库句柄
    dlclose(handle_foo);
    dlclose(handle_bar);
    return 0;
}

结果如下：

但是内核态呢?

EXPORT_SYMBOL的调用者和被调用者有加载顺序要求？

在Linux内核中使用EXPORT_SYMBOL导出符号时，通常不存在加载顺序的要求，因为内核在启动时会将所有模块加载到内存中。当调用者模块使用EXPORT_SYMBOL导出一个符号时，被调用者模块不需要事先加载到内存中，只要在调用时被正确加载即可。

当调用者模块需要使用被调用者模块导出的符号时，内核会在所有已经加载到内存中的模块中搜索该符号。如果找到了符号的定义，调用者模块就可以成功调用该符号。否则，内核会返回一个错误，指示符号未定义。

在某些情况下，可能存在加载顺序的要求。例如，如果被调用者模块使用了调用者模块中定义的一些数据结构或函数，那么调用者模块必须先加载到内存中，以便被调用者模块可以正确地使用这些结构或函数。在这种情况下，您需要在Makefile或modprobe.conf文件中指定正确的模块加载顺序，以确保依赖关系得到正确处理。

总之，虽然在使用EXPORT_SYMBOL导出符号时通常不存在加载顺序的要求，但在某些情况下可能需要考虑模块加载的顺序和依赖关系。