Question

我想在Linux中的Java程序中运行我的C插件系统，我已经编写了绑定，并且我的Java程序中的库加载正常。

插件系统提供了一个加载插件的命令，该命令被包装到Java中，所以我可以在我的Java shell中调用i，它可以工作。

当插件尝试从插件系统运行命令时出现问题，我得到一个未定义的符号错误。但是，我已经仔细地将插件使用的所有函数链接到库，系统使用-fPIC和-shared进行编译。我还查看了objdump -T的符号表，并列出了函数。

我认为这个过程有点疯狂，我加载了用Java加载C代码的C代码......有可能吗？

如果有人遇到过这个问题，或者想分享有关可能解决方案的想法，我会非常感激。

谢谢。

编辑：我试图在此示例中尽可能地模仿我的程序。我也得到一个错误，但它是完全不同的。

// plugin_system.c
#include <dlfcn.h>
#include <stdio.h>

int load_and_run_plugin() {
  void *lib = dlopen("/home/kowa/code/c/test_dir/jni/plug/plugin.so", RTLD_LAZY);
  if (lib == NULL) {
    fprintf(stderr, "Cannot open library.\n");
    return -1;
  }
  void (*plug_func)(void) = dlsym(lib, "plug_function");
  if (plug_func == NULL) {
    dlclose(lib);
    fprintf(stderr, "Cannot find plugin function.\n");
    return -1;
  }
  plug_func();
  return 0;
}

// PluginSystem.c
#include "PluginSystem.h"
#include "plugin_system.h"

/*
 * Class:     PluginSystem
 * Method:    cmdPlug
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_PluginSystem_cmdPlug
  (JNIEnv *env, jclass this)
{
  printf("Calling load_and_run function...\n");
  load_and_run_plugin();
  printf("End of call to load_and_run function\n");
}

// plugin_user_api.c
#include <stdio.h>

static void verbose_stdout(char *str)
{
  printf("%s", str);
}

void (*verbose) (char *str) = verbose_stdout;

// plugin.c
#include "plugin_user_api.h"

int plug_function() {
  verbose("I'm a plugin and I use external functions.\n");
  return 0;
}

// PluginSystem.java
public class PluginSystem
{
  static { 
    System.load("/home/kowa/code/c/test_dir/jni/plug/plugin_system.so");
  }
  public static native void cmdPlug();

  public static void main(String args[]) {
    PluginSystem.cmdPlug();
  }
}

// Makefile
JAVA_HOME      = /usr/lib/jvm/java-8-openjdk
C_INCLUDE_PATH = $(JAVA_HOME)/include $(JAVA_HOME)/include/linux
INCLUDE        = $(foreach i, $(C_INCLUDE_PATH), -I$i)
CFLAGS         = -Wall -O2 -std=gnu99

all:
    gcc $(CFLAGS) -fPIC -c plugin.c
    gcc $(CFLAGS) -Wl,-soname,plugin.so -shared -o plugin.so plugin.o
    gcc $(CFLAGS) $(INCLUDE) -fPIC -c plugin_system.c
    gcc $(CFLAGS) $(INCLUDE) -fPIC -c plugin_user_api.c
    gcc $(CFLAGS) $(INCLUDE) -fPIC -c PluginSystem.c
    gcc $(CFLAGS) -Wl,-soname,plugin_system.so -shared -o plugin_system.so plugin_system.o plugin_user_api.o PluginSystem.o
    sed -i "s:System.load(.*):System.load(\"$(shell echo `pwd`)/plugin_system.so\"):" PluginSystem.java
    javac PluginSystem.java


clean:
    rm *.o *.so *.class

输出：

Calling load_and_run function...
#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x0000000000000000, pid=1653, tid=0x00007f01c76a2700
#
# JRE version: OpenJDK Runtime Environment (8.0_92-b14) (build 1.8.0_92-b14)
# Java VM: OpenJDK 64-Bit Server VM (25.92-b14 mixed mode linux-amd64 compressed oops)
# Problematic frame:
# C  0x0000000000000000
#
# Core dump written. Default location: /home/kowa/code/c/test_dir/jni/plug/core or core.1653
#
# An error report file with more information is saved as:
# /home/kowa/code/c/test_dir/jni/plug/hs_err_pid1653.log
#
# If you would like to submit a bug report, please visit:
#   http://bugreport.java.com/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#
[2]    1653 abort (core dumped)  java PluginSystem

日志文件很长（654行！）所以不要因为没有发布而责备我！

Answer 1

您的示例代码对我有用，但需要注意以下几点：

我运行了javah来制作我自己的PluginSystem.h版本，并且我编写了自己的plugin_system.h，因为这些版本未发布
我将硬编码的共享库路径更改为适合我本地系统的路径。
为方便起见，我将plugin_user_api.c合并到plugin.c并删除了plugin_user_api.h（无论如何都没提供）
我用更惯用的风格重新编写了Makefile

如果我构建本机库，插件和Java类，那么运行它会产生以下结果：

$ /usr/lib/jvm/java-1.8.0/bin/java PluginSystem
Calling load_and_run function...
I'm a plugin and I use external functions.
End of call to load_and_run function

更新

我可以复制您的问题，而不是将plugin_user_api.c合并到plugin.c，而是将其合并到plugin_system.c。在这种情况下，我可以实现C驱动程序能够加载插件的结果，但Java无法这样做。这表明Java正在使用RTLD_LOCAL标志加载库，因此其符号不会暴露给随后加载的库，例如插件。

至少有三种可能的解决方案：

在Java和plugin_system.so之间插入另一个加载器，以便您控制plugin_system.so符号的范围。
将插件所需的所有支持功能从plugin_system.so中移出，并插入一个单独的动态库，任何和所有插件都可以链接到
通过让插件系统使用指向所需功能和数据的指针初始化插件，使插件免于需要动态链接插件系统

其中，第一个需要对现有代码进行最少的修改，但最后一个是最安全的，并且与Java有意识地避免暴露库的动态符号的努力最为一致。实际上，你可以考虑让你的插件系统做同样的事情，以降低插件互相干扰的风险。

以下是原始代码的变体，演示了第三种方法。它添加了一个每插件初始化函数，必须在加载插件后调用它;这样可以避免更改任何现有插件功能的签名。这种变化还避免了将插件的符号暴露给Java（或C）恰好加载的其他库。 Java方面不需要进行任何更改：

<强> plugin_system.h

#ifndef PLUGIN_SYSTEM_H
#define PLUGIN_SYSTEM_H

struct plugin_context {
    void (*verbose) (char *str);
};

#endif

<强> plugin_system.c

#include <dlfcn.h>
#include <stdio.h>
#include "plugin_system.h"

typedef int (*init_function)(struct plugin_context *);

static void verbose_stdout(char *str)
{
  printf("%s", str);
}

static struct plugin_context context = { .verbose = verbose_stdout };

int load_and_run_plugin() {
  void *lib = dlopen("/home/kowa/code/c/test_dir/jni/plug/plugin.so",
      RTLD_LAZY | RTLD_LOCAL);
  if (lib == NULL) {
    fprintf(stderr, "Cannot open library.\n");
    return -1;
  }
  init_function plug_init = dlsym(lib, "plug_init");
  if (plug_init == NULL) {
    dlclose(lib);
    fprintf(stderr, "Cannot find plugin initialization function.\n");
    return -1;
  }
  plug_init(&context);  // error checking omitted

  void (*plug_func)(void) = dlsym(lib, "plug_function");
  if (plug_func == NULL) {
    dlclose(lib);
    fprintf(stderr, "Cannot find plugin function.\n");
    return -1;
  }
  plug_func();         // error checking omitted
  return 0;
}

<强> plugin.c

include <stdio.h>
#include "plugin_system.h"

static void (*verbose) (char *str);

int plug_init(struct plugin_context *context) {
  verbose = context->verbose;
  return 0;
}

int plug_function() {
  if (verbose) {
    verbose("I'm a plugin and I use external functions.\n");
    return 0;
  } else {
    return -1;
  }
}

使用JNI加载C插件系统：未定义的符号

1 个答案:

更新