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 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 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 模块就不能使用它，会出现符号未定义的错误。

用户态实现类似的效果

用户态无法使用EXPORT_SYMBOL.

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

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

libbar.c

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

libfoo.c:

#include 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 
#include 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;
}

打印结果：

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要先加载，不然怎么改都不可能找到。

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

但是内核态呢?

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

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

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

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

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