首页 技术问答 正文
什么会导致Java本机函数(在C中)进入进入时Segfault?

 2023-01-19    419  

问题描述

项目

我正在使用Java本机接口编写一个内部网络和网络测试工具的C库的Java命令行界面. C代码(我没有编写)很复杂且低级别，通常会在位级别操纵内存，并专门使用原始插座.该应用程序是从C端(在后台运行的PTHREADS)以及Java端(ScheduleDthRe​​adPoolExeCutors运行的线程来调用本机代码)的多线程.也就是说，C库应该大部分是稳定的.事实证明，Java和JNI接口代码正在引起问题.

问题(S)

进入本机C函数时，应用程序会崩溃，并带有分割故障.仅当程序处于特定状态时(即成功运行特定的本机函数会导致下一个呼叫到SegFault的另一个特定本机函数).此外，当发出quit命令时，该应用程序会用相似的segfault崩溃，但仅在成功运行相同的特定本机函数之后，再次出现.

什么会导致Java本机函数(在C中)进入进入时Segfault?

我是一个没有经验的C开发人员和经验丰富的Java开发人员 – 我曾经崩溃，给我一个特定的原因和一个特定的行号.在这种情况下，我要工作的只是hs_err_pid*.log输出和核心转储.我在这个问题的结尾包括了我能做的.

到目前为止我的工作

  1. 自然，我想找到崩溃发生的特定代码行.我将A System.out.println()直接放在Java侧，将A printf()作为本机函数的第一行，该程序崩溃肯定会在之后直接使用fflush(stdout). System.out呼叫运行，printf呼叫没有.这告诉我，Segfault在进入该功能时发生了 – 我从未见过的事情.
  2. 我三重检查了该功能的参数，以确保它们不会行动.但是，我只传递一个(类型jint)的参数.另外两个(JNIEnv *env, jobject j_object)是JNI构造，并且无法控制.
  3. 我评论了该功能中的每一行，最后仅留下return 0;. Segfault仍然发生了.这使我相信问题不在此功能中.
  4. 我以不同的顺序运行命令(有效地运行本机函数不同的订单). SegFaults仅在崩溃函数调用之前运行一个特定的本机函数才会发生.该特定功能在运行时似乎表现正常.
  5. 我打印了env指针的值和附近&j_object的值，以确保我没有以某种方式损坏它们.我不知道我是否破坏了它们，但是退出功能时都具有非零值.
  6. 编辑1:通常，相同的函数在许多线程中运行(通常不同时，但应该是线程安全的).我从主线程中运行了该功能，而没有任何其他线程活动，以确保Java侧的多线程不会引起问题.不是，我得到了相同的segfault.

所有这些使我感到困惑.除了返回语句外，如果我评论整个函数，为什么还要发表整个函数?如果问题出在其他功能中，为什么不在那里失败?如果第一个函数弄乱了内存，而第二个函数非法访问损坏内存，为什么如果不使用非法访问在线而不是输入函数时不会失败?

如果您看到了一篇互联网文章，有人解释了与我的类似问题，请对此发表评论. Segfault文章太多了，似乎没有任何特定问题.同上问题.问题也可能是我的经验不足以将抽象解决方案应用于此问题.

我的问题

什么会导致Java本机函数(在C中)在这样的条目时进行segfault?我可以寻找什么具体的东西可以帮助我压缩这个错误?将来如何编写代码，以帮助我避免此问题?

有用的信息

对于记录，我实际上无法发布代码.如果您认为代码的描述会有所帮助，请发表评论，然后将其编辑.

错误消息

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00002aaaaaf6d9c3, pid=2185, tid=1086892352
#
# JRE version: 6.0_21-b06
# Java VM: Java HotSpot(TM) 64-Bit Server VM (17.0-b16 mixed mode linux-amd64 )
# Problematic frame:
# j  path.to.my.Object.native_function_name(I)I+0
#
# An error report file with more information is saved as:
# /path/to/hs_err_pid2185.log
#
# If you would like to submit a bug report, please visit:
#   http://java.sun.com/webapps/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#

hs_err_pid*.log文件的重要位

---------------  T H R E A D  ---------------

Current thread (0x000000004fd13800):  JavaThread "pool-1-thread-1" [_thread_in_native, id=2198, stack(0x0000000040b8a000,0x0000000040c8b000)]

siginfo:si_signo=SIGSEGV: si_errno=0, si_code=128 (), si_addr=0x0000000000000000

Registers:
RAX=0x34372e302e3095e1, RBX=0x00002aaaae39dcd0, RCX=0x0000000000000000, RDX=0x0000000000000000
RSP=0x0000000040c89870, RBP=0x0000000040c898c0, RSI=0x0000000040c898e8, RDI=0x000000004fd139c8
R8 =0x000000004fb631f0, R9 =0x000000004faf5d30, R10=0x00002aaaaaf6d999, R11=0x00002b1243b39580
R12=0x00002aaaae3706d0, R13=0x00002aaaae39dcd0, R14=0x0000000040c898e8, R15=0x000000004fd13800
RIP=0x00002aaaaaf6d9c3, EFL=0x0000000000010202, CSGSFS=0x0000000000000033, ERR=0x0000000000000000
  TRAPNO=0x000000000000000d



Stack: [0x0000000040b8a000,0x0000000040c8b000],  sp=0x0000000040c89870,  free space=3fe0000000000000018k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
j  path.to.my.Object.native_function_name(I)I+0
j  path.to.my.Object$CustomThread.fire()V+18
j  path.to.my.CustomThreadSuperClass.run()V+1
j  java.util.concurrent.Executors$RunnableAdapter.call()Ljava/lang/Object;+4
j  java.util.concurrent.FutureTask$Sync.innerRun()V+30
j  java.util.concurrent.FutureTask.run()V+4
j  java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(Ljava/util/concurrent/ScheduledThreadPoolExecutor$ScheduledFutureTask;)V+1
j  java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run()V+15
j  java.util.concurrent.ThreadPoolExecutor$Worker.runTask(Ljava/lang/Runnable;)V+59
j  java.util.concurrent.ThreadPoolExecutor$Worker.run()V+28
j  java.lang.Thread.run()V+11
v  ~StubRoutines::call_stub
V  [libjvm.so+0x3e756d]
V  [libjvm.so+0x5f6f59]
V  [libjvm.so+0x3e6e39]
V  [libjvm.so+0x3e6eeb]
V  [libjvm.so+0x476387]
V  [libjvm.so+0x6ee452]
V  [libjvm.so+0x5f80df]

Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j  path.to.my.Object.native_function_name(I)I+0
j  path.to.my.Object$CustomThread.fire()V+18
j  path.to.my.CustomThreadSuperClass.run()V+1
j  java.util.concurrent.Executors$RunnableAdapter.call()Ljava/lang/Object;+4
j  java.util.concurrent.FutureTask$Sync.innerRun()V+30
j  java.util.concurrent.FutureTask.run()V+4
j  java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(Ljava/util/concurrent/ScheduledThreadPoolExecutor$ScheduledFutureTask;)V+1
j  java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run()V+15
j  java.util.concurrent.ThreadPoolExecutor$Worker.runTask(Ljava/lang/Runnable;)V+59
j  java.util.concurrent.ThreadPoolExecutor$Worker.run()V+28
j  java.lang.Thread.run()V+11
v  ~StubRoutines::call_stub



---------------  P R O C E S S  ---------------

Java Threads: ( => current thread )
  0x000000004fabc800 JavaThread "pool-1-thread-6" [_thread_new, id=2203, stack(0x0000000000000000,0x0000000000000000)]
  0x000000004fbcb000 JavaThread "pool-1-thread-5" [_thread_blocked, id=2202, stack(0x0000000042c13000,0x0000000042d14000)]
  0x000000004fbc9800 JavaThread "pool-1-thread-4" [_thread_blocked, id=2201, stack(0x0000000042b12000,0x0000000042c13000)]
  0x000000004fbc7800 JavaThread "pool-1-thread-3" [_thread_blocked, id=2200, stack(0x0000000042a11000,0x0000000042b12000)]
  0x000000004fc54800 JavaThread "pool-1-thread-2" [_thread_blocked, id=2199, stack(0x0000000042910000,0x0000000042a11000)]
=>0x000000004fd13800 JavaThread "pool-1-thread-1" [_thread_in_native, id=2198, stack(0x0000000040b8a000,0x0000000040c8b000)]
  0x000000004fb04800 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=2194, stack(0x0000000041d0d000,0x0000000041e0e000)]
  0x000000004fb02000 JavaThread "CompilerThread1" daemon [_thread_blocked, id=2193, stack(0x0000000041c0c000,0x0000000041d0d000)]
  0x000000004fafc800 JavaThread "CompilerThread0" daemon [_thread_blocked, id=2192, stack(0x0000000040572000,0x0000000040673000)]
  0x000000004fafa800 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=2191, stack(0x0000000040471000,0x0000000040572000)]
  0x000000004fad6000 JavaThread "Finalizer" daemon [_thread_blocked, id=2190, stack(0x0000000041119000,0x000000004121a000)]
  0x000000004fad4000 JavaThread "Reference Handler" daemon [_thread_blocked, id=2189, stack(0x0000000041018000,0x0000000041119000)]
  0x000000004fa51000 JavaThread "main" [_thread_in_vm, id=2186, stack(0x00000000418cc000,0x00000000419cd000)]

Other Threads:
  0x000000004facf800 VMThread [stack: 0x0000000040f17000,0x0000000041018000] [id=2188]
  0x000000004fb0f000 WatcherThread [stack: 0x0000000041e0e000,0x0000000041f0f000] [id=2195]

VM state:not at safepoint (normal execution)

VM Mutex/Monitor currently owned by a thread: None

Heap
 PSYoungGen      total 305856K, used 31465K [0x00002aaadded0000, 0x00002aaaf3420000, 0x00002aaaf3420000)
  eden space 262208K, 12% used [0x00002aaadded0000,0x00002aaadfd8a6a8,0x00002aaaedee0000)
  from space 43648K, 0% used [0x00002aaaf0980000,0x00002aaaf0980000,0x00002aaaf3420000)
  to   space 43648K, 0% used [0x00002aaaedee0000,0x00002aaaedee0000,0x00002aaaf0980000)
 PSOldGen        total 699072K, used 0K [0x00002aaab3420000, 0x00002aaadded0000, 0x00002aaadded0000)
  object space 699072K, 0% used [0x00002aaab3420000,0x00002aaab3420000,0x00002aaadded0000)
 PSPermGen       total 21248K, used 3741K [0x00002aaaae020000, 0x00002aaaaf4e0000, 0x00002aaab3420000)
  object space 21248K, 17% used [0x00002aaaae020000,0x00002aaaae3c77c0,0x00002aaaaf4e0000)


VM Arguments:
jvm_args: -Xms1024m -Xmx1024m -XX:+UseParallelGC


---------------  S Y S T E M  ---------------

OS:Red Hat Enterprise Linux Client release 5.5 (Tikanga)

uname:Linux 2.6.18-194.8.1.el5 #1 SMP Wed Jun 23 10:52:51 EDT 2010 x86_64
libc:glibc 2.5 NPTL 2.5
rlimit: STACK 10240k, CORE 102400k, NPROC 10000, NOFILE 1024, AS infinity
load average:0.21 0.08 0.05

CPU:total 1 (1 cores per cpu, 1 threads per core) family 6 model 26 stepping 4, cmov, cx8, fxsr, mmx, sse, sse2, sse3, ssse3, sse4.1, sse4.2, popcnt

Memory: 4k page, physical 3913532k(1537020k free), swap 1494004k(1494004k free)

vm_info: Java HotSpot(TM) 64-Bit Server VM (17.0-b16) for linux-amd64 JRE (1.6.0_21-b06), built on Jun 22 2010 01:10:00 by "java_re" with gcc 3.2.2 (SuSE Linux)

time: Tue Oct 15 15:08:13 2013
elapsed time: 13 seconds

valgrind Output

我真的不知道如何正确使用Valgrind.这是运行valgrind app arg1

时出现的原因

==2184== 
==2184== HEAP SUMMARY:
==2184==     in use at exit: 16,914 bytes in 444 blocks
==2184==   total heap usage: 673 allocs, 229 frees, 32,931 bytes allocated
==2184== 
==2184== LEAK SUMMARY:
==2184==    definitely lost: 0 bytes in 0 blocks
==2184==    indirectly lost: 0 bytes in 0 blocks
==2184==      possibly lost: 0 bytes in 0 blocks
==2184==    still reachable: 16,914 bytes in 444 blocks
==2184==         suppressed: 0 bytes in 0 blocks
==2184== Rerun with --leak-check=full to see details of leaked memory
==2184== 
==2184== For counts of detected and suppressed errors, rerun with: -v
==2184== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 7 from 7)

编辑2:

GDB输出和回溯

我用GDB运行了它.我确保用-g标志编译了C库.

$ gdb `which java`
GNU gdb (GDB) Red Hat Enterprise Linux (7.0.1-23.el5)
Copyright (C) 2009 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /usr/bin/java...(no debugging symbols found)...done.
(gdb) run -jar /opt/scts/scts.jar test.config
Starting program: /usr/bin/java -jar /opt/scts/scts.jar test.config
[Thread debugging using libthread_db enabled]
Executing new program: /usr/lib/jvm/java-1.6.0-sun-1.6.0.21.x86_64/jre/bin/java
[Thread debugging using libthread_db enabled]
[New Thread 0x4022c940 (LWP 3241)]
[New Thread 0x4032d940 (LWP 3242)]
[New Thread 0x4042e940 (LWP 3243)]
[New Thread 0x4052f940 (LWP 3244)]
[New Thread 0x40630940 (LWP 3245)]
[New Thread 0x40731940 (LWP 3246)]
[New Thread 0x40832940 (LWP 3247)]
[New Thread 0x40933940 (LWP 3248)]
[New Thread 0x40a34940 (LWP 3249)]

…我的程序做了一些工作，并启动了一个背景线程… 

[New Thread 0x41435940 (LWP 3250)]

…我键入似乎在下一个命令上引起segfault的命令；期望新线程… 

[New Thread 0x41536940 (LWP 3252)]
[New Thread 0x41637940 (LWP 3253)]
[New Thread 0x41738940 (LWP 3254)]
[New Thread 0x41839940 (LWP 3255)]
[New Thread 0x4193a940 (LWP 3256)]

…我键入实际触发segfault的命令.由于该函数在其自己的线程中运行，因此可以预期新线程.如果它没有segfault，它将创建与上一个命令的线程数量相同的线程… 

[New Thread 0x41a3b940 (LWP 3257)]

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x41839940 (LWP 3255)]
0x00002aaaabcaec45 in ?? ()

…我疯狂地阅读了GDB帮助，然后运行回溯… 

(gdb) bt
#0  0x00002aaaabcaec45 in ?? ()
#1  0x00002aaaf3ad7800 in ?? ()
#2  0x00002aaaf3ad81e8 in ?? ()
#3  0x0000000041838600 in ?? ()
#4  0x00002aaaeacddcd0 in ?? ()
#5  0x0000000041838668 in ?? ()
#6  0x00002aaaeace23f0 in ?? ()
#7  0x0000000000000000 in ?? ()

…如果我用-g编译，那不应该有符号吗?我做了，根据make的输出的行:

gcc -g -Wall -fPIC -c -I ...
gcc -g -shared -W1,soname, ...

推荐答案

看起来我已经解决了这个问题，我将在这里概述其他问题.

发生了什么

分割故障的原因是我使用sprintf()将值分配给未分配值的指针.这是不良代码:

char* ip_to_string(uint32_t ip)
{
    unsigned char bytes[4];
    bytes[0] = ip & 0xFF;
    bytes[1] = (ip >> 8) & 0xFF;
    bytes[2] = (ip >> 16) & 0xFF;
    bytes[3] = (ip >> 24) & 0xFF;

    char *ip_string;
    sprintf(ip_string, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
    return ip_string;
}

指针ip_string在这里没有值，这意味着它没有指向.除了，这不是完全正确的.指出的是不确定的.它可以指向任何地方.因此，在用sprintf()为其分配一个值时，我无意中覆盖了随机的存储器.我相信这种奇怪行为的原因(尽管我从未证实这一点)是未定义的指针指向堆栈上的某个地方.当调用某些功能时，这导致计算机混淆.

解决此问题的一种方法是分配内存，然后将指针指向该内存，可以使用malloc()完成.该解决方案看起来与此相似:

char* ip_to_string(uint32_t ip)
{
    unsigned char bytes[4];
    bytes[0] = ip & 0xFF;
    bytes[1] = (ip >> 8) & 0xFF;
    bytes[2] = (ip >> 16) & 0xFF;
    bytes[3] = (ip >> 24) & 0xFF;

    char *ip_string = malloc(16);
    sprintf(ip_string, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
    return ip_string;
}

问题在于，每个malloc()都需要通过调用free()匹配，或者您有内存泄漏.如果我在此功能中调用free(ip_string)，则返回的指针将是没有用的，如果我不这样做，那么我必须依靠调用此功能的代码来释放内存，这很危险.

据我所知，对此的”正确”解决方案是将已分配的指针传递给该功能，因此填充指向内存的函数的责任.这样，可以在代码块中调用malloc()和free().更安全.这是新功能:

char* ip_to_string(uint32_t ip, char *ip_string)
{
    unsigned char bytes[4];
    bytes[0] = ip & 0xFF;
    bytes[1] = (ip >> 8) & 0xFF;
    bytes[2] = (ip >> 16) & 0xFF;
    bytes[3] = (ip >> 24) & 0xFF;

    sprintf(ip_string, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
    return ip_string;
}

问题的答案

什么会导致Java本机函数(在C中)在这样的条目时进行segfault?

如果将值分配给尚未分配内存的指针，则可能会意外地覆盖堆栈上的内存.这可能不会导致立即失败，但稍后调用其他功能时可能会引起问题.

我可以寻找什么特定的东西可以帮助我挤压此错误?

像其他任何人一样寻找细分故障.诸如将值分配给未分配的内存或删除空指针之类的东西.我不是这个专家，但我愿意敢打赌，有许多Web资源

将来如何编写代码，以帮助我避免此问题?

请小心指针，尤其是当您负责创建它们时.如果您看到了看起来像这样的代码行:

type *variable;

…然后寻找看起来像…

的行

variable = ...;

…并确保这条线在写入指向内存之前是出现的.

其他推荐答案

您是否尝试过将GDB挂在JVM上?

这样做:

  1. 对JVM的二进制运行GDB. (/usr/bin/java，或您正在使用的任何JVM)
  2. 将gdb中的args设置为您传递到JVM

    3. 的args

  3. 重新创建segfault.听起来这是可以重复的.

您应该能够运行该应用程序并将其处于破碎状态.一旦到达那里，GDB应该在其发现故障的位置中断，您也许可以获得堆栈跟踪.确保库是使用调试符号编译的，以便您可以看到方法调用和行号.

其他推荐答案

将来如何编写代码，以帮助我避免此问题?

您可以针对NULL初始化/验证，这是c.

中的最佳实践

顺便说一句，您的IP是否以:47.0.0结尾?这就是其中包含十六进制中RAX寄存器的一部分:

rax = 0x34372E302E3095E1

尽管Sprintf应该在最后一个数字之后添加一个空字符.

以上所述是小编给大家介绍的什么会导致Java本机函数(在C中)进入进入时Segfault?,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对77isp云服务器技术网的支持！

发表评论：

原文链接：https://77isp.com/post/25803.html

=========================================

https://77isp.com/ 为 “云服务器技术网” 唯一官方服务平台，请勿相信其他任何渠道。

热门文章
热门标签
最新留言
友情链接

首页 IT运维空间 网云互联 1818IP网

本站资源均来自原创及互联网，仅供学习与参考，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。

苏ICP备2022008373号-1