6

晚上好，我目前正在开发基于Plux.net模型的 C++/Linux 插件系统。

为了简单起见，我基本上用 extern C 声明了一个符号（我们称之为 pluginInformation）（以解开），我的插件管理器在预配置的导入 (.so) 中查找该符号。

问题是主应用程序声明了相同的符号，不仅如此，它所具有的任何依赖项也可能具有该符号。（因为在这个插件信息中，模块可以发布插件和/或插槽）。

因此，当我的 PluginManager 启动时，它首先尝试在主程序中查找符号（将 NULL 传递给dlopen），然后尝试在其任何依赖项中查找符号（使用dl_iterate_phdr）。最后它将dlopen一组配置导入（它将读取 .so 的路径，以便用户配置，dlopen它们，最后dlsym插件信息符号）。

然后使用在所有模块中找到的 pluginInformation 集合来构建扩展 3。

如果我在主程序中声明符号并使用dlopen加载导入，它就可以工作（只要我在 dlopen 导入时传递标志 RTLD_DEEPBIND ）。

但是对于应用程序依赖项，我没有传递标志的选项（我可以但它不做任何事情），因为这个 .sos 是在应用程序启动时加载的。

现在，当我尝试使用从依赖项（启动时加载的那些）中获得的任何符号时，我会遇到分段错误。我认为问题是我在符号表中有几个同名的符号，奇怪的是它似乎正确地识别出有几个符号，它甚至给了我正确的 .so 路径，符号在哪里声明，但是一旦我访问该符号，就会发生分段错误。如果我只在主程序或依赖项之一中声明该符号，则一切正常。

如何使用 dlsym 管理主程序和strat up 导入之间的重复符号？

我一直在考虑保持修改然后只是尝试找到我的符号来解析符号表，但我不确定这是否可能（以编程方式列出模块中的所有符号）。

PD：对不起，我没有发布任何代码，但我现在不在家，我希望对我尝试做的事情的描述足够清楚，如果没有，我明天可以发布一些代码。

4

1 回答 1

5

这是另一种方法。

应用程序本身导出一个或多个插件项注册功能。例如：

int register_plugin_item(const char *const text,
                         const char *const icon,
                         void (*enter)(void *),
                         void (*click)(void *),
                         void (*leave)(void *),
                         void *data);

每个注册项有两个字符串槽（text和icon）、三个函数槽（enter、、click和leave），以及在调用时作为参数提供给函数的不透明引用。

（请注意，在编译主应用程序（实现上述功能的目标文件）时，您需要使用-rdynamic编译器选项，以确保链接器将register_plugin_item符号添加到动态符号表中。）

每个插件register_plugin_item()在构造函数中调用它想要的每个项目的函数（在库加载时自动运行）。函数可以首先检查它运行的环境，以确定要注册哪些功能，或者要为每个插件项使用哪些优化的函数变体，这是可能的，而且通常很有用。

这是一个简单的示例插件。注意所有符号是如何的static，这样插件就不会污染动态符号表，或者导致任何符号冲突。

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

extern int register_plugin_item(const char *const,
                                const char *const,
                                void (*enter)(void *),
                                void (*click)(void *),
                                void (*leave)(void *),
                                void *);

static void enter(void *msg)
{
    fprintf(stderr, "Plugin: Enter '%s'\n", (char *)msg);
}

static void leave(void *msg)
{
    fprintf(stderr, "Plugin: Leave '%s'\n", (char *)msg);
}

static void click(void *msg)
{
    fprintf(stderr, "Plugin: Click '%s'\n", (char *)msg);
}

static void init(void) __attribute__((constructor));
static void init(void)
{
    register_plugin_item("one", "icon-one.gif",
                         enter, leave, click,
                         "1");

    register_plugin_item("two", "icon-two.gif",
                         enter, leave, click,
                         "2");
}

上面的插件导出了两个项目。为了测试，至少创建上述的几个变体；即使插件使用相同的（静态）变量和函数名，您也会看到没有符号冲突。

这是一个加载指定插件并测试每个注册项目的示例应用程序：

#include <stdlib.h>
#include <dlfcn.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>

struct item {
    struct item *next;
    const char  *text;
    const char  *icon;
    void        *data;
    void       (*enter)(void *);
    void       (*leave)(void *);
    void       (*click)(void *);
};

static struct item *list = NULL;

int register_plugin_item(const char *const text,
                         const char *const icon,
                         void (*enter)(void *),
                         void (*click)(void *),
                         void (*leave)(void *),
                         void *data)
{
    struct item *curr;

    curr = malloc(sizeof *curr);
    if (!curr)
        return ENOMEM;

    curr->text = text;
    curr->icon = icon;
    curr->data = data;
    curr->enter = enter;
    curr->leave = leave;
    curr->click = click;

    /* Prepend to list */
    curr->next = list;
    list = curr;

    return 0;
}

int main(int argc, char *argv[])
{
    int          arg;
    void        *handle;
    struct item *curr;

    if (argc < 2 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "Usage: %s [ -h | --help ]\n", argv[0]);
        fprintf(stderr, "       %s PLUGIN.so ... \n", argv[0]);
        fprintf(stderr, "\n");
        fprintf(stderr, "Please supply full plugin paths, unless\n");
        fprintf(stderr, "the plugins reside in a standard library directory,\n");
        fprintf(stderr, "or in a directory listed in LD_LIBRARY_PATH.\n");
        fprintf(stderr, "\n");
        return 1;
    }

    for (arg = 1; arg < argc; arg++) {

        handle = dlopen(argv[arg], RTLD_NOW);
        if (handle != NULL)
            fprintf(stderr, "%s: Loaded.\n", argv[arg]);
        else
            fprintf(stderr, "%s.\n", dlerror());

        /* Note: We deliberately "leak" the handle,
         *       so that the plugin is not unloaded. */
    }

    for (curr = list; curr != NULL; curr = curr->next) {
        if (curr->text)
            printf("Item '%s':\n", curr->text);
        else
            printf("Unnamed item:\n");

        if (curr->icon)
            printf("\tIcon is '%s'\n", curr->icon);
        else
            printf("\tNo icon\n");

        if (curr->data)
            printf("\tCustom data at %p\n", curr->data);
        else
            printf("\tNo custom data\n");

        if (curr->enter)
            printf("\tEnter handler at %p\n", curr->enter);
        else
            printf("\tNo enter handler\n");

        if (curr->click)
            printf("\tClick handler at %p\n", curr->click);
        else
            printf("\tNo click handler\n");

        if (curr->leave)
            printf("\tLeave handler at %p\n", curr->leave);
        else
            printf("\tNo leave handler\n");

        if (curr->enter || curr->click || curr->leave) {
            printf("\tTest calls:\n");
            if (curr->enter)
                curr->enter(curr->data);
            if (curr->click)
                curr->click(curr->data);
            if (curr->leave)
                curr->leave(curr->data);
            printf("\tTest calls done.\n");
        }
    }

    return 0;
}

如果应用程序是app.c，并且您有插件plugin-foo.c，plugin-bar.c您可以使用例如编译它们

gcc -W -Wall -rdynamic app.c -ldl -o app

gcc -W -Wall -fpic -c plugin-foo.c
gcc -shared -Wl,-soname,plugin-foo.so plugin-foo.o -o plugin-foo.so

gcc -W -Wall -fpic -c plugin-bar.c
gcc -shared -Wl,-soname,plugin-bar.so plugin-bar.o -o plugin-bar.so

并使用例如运行

./app --help

./app ./plugin-foo.so

./app ./plugin-foo.so ./plugin-bar.so

请注意，如果多次定义同一个插件，则该库的构造函数只会执行一次。不会有重复注册。

插件和应用程序之间的接口完全取决于您。在这个例子中，只有一个函数。一个真正的应用程序可能会有更多。应用程序还可以导出其他功能，例如插件查询应用程序配置。

设计一个好的界面是一个完全不同的话题，绝对值得你在实现中投入同样多的思考。

Plux.NET 插件平台也允许插件导出自己的插槽。这种替代方法在许多方面都允许这样做。其中之一是导出一个插件注册函数——也就是说，用于注册插件 而不是单个项目——它需要一个函数指针：

int register_plugin(const char *const name,
                    int (*extend)(const char *const, ...));

如果插件提供slots，它提供自己的注册函数作为extend函数指针。该应用程序还导出一个函数，例如

int plugin_extend(const char *const name, ...);

插件可以用来调用其他插件的注册功能。（plugin_extend()主应用程序中的实现涉及搜索extend已注册的合适函数，然后调用它/它们。）

在实现方面，允许插件导出插槽会使实现变得相当复杂。特别是，插件导出的插槽何时以及以何种顺序可用？是否有必须加载插件的特定顺序，以确保导出所有可能的插槽？如果存在循环依赖会发生什么？插件是否应该在注册开始之前指定它们依赖的其他插件？

如果每个插件都是一个单独的实体，不导出任何自己的插槽，只插入主应用程序插槽，您可以避免实现中的大部分复杂性。

不过，检查注册项目的顺序是您可能需要考虑的细节。上面的示例程序使用了一个链表，其中项目的结束顺序与注册顺序相反，注册顺序与命令行中首先指定插件文件名的顺序相同。如果您有一个自动扫描的插件目录（使用例如 ///循环opendir()），那么插件注册顺序是半随机的（取决于文件系统；通常仅在添加或删除插件时更改）。readdir()dlopen()closedir()

更正？问题？注释？

于 2013-09-14T13:37:57.723 回答