精华内容
下载资源
问答
  • 本篇文章介绍了,对JavaCore文件的深入分析。需要的朋友参考下
  • 本文档详细描述了在实际工程调试过程中如何使用gdb来分析core文件。结合实际中出现的一些问题,配图描述了如何通过gdb工具从堆栈,回溯等信息判断出来问题所在。对实际工程调试起到一定指导作用
  • 下面小编就为大家分享一篇ASP.NET Core文件上传与下载实例(多种上传方式),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • .net core文件上传代码

    2019-05-05 17:18:57
    .net core上传代码示例,文件上传代码!前后端上传代码
  • 利用core文件排查系统崩溃的信息详细步骤,希望对你快速排除Bug有用................
  • 怎样分析core文件

    2013-06-02 13:20:27
    详细描述怎样分析Unix core文件.coredump
  • 本文讲述了实现core文件自动生成的配置方法,具体执行步骤如下: 1.编辑环境配置文件,让shell启动时自动设置ulimit   vi /etc/profile ulimit -c unlimited > /dev/null 2>&1 2.更改core文件生成路径   vi /...
  • Linux生成core文件core文件路径设置

    千次阅读 2019-01-05 17:57:09
    core dump的概念: A core dump is the recorded state of the working memory of a computer program at a specific time, generally when the program has terminated abnormally (crashed). In practice, ...

    core dump的概念:

    core dump is the recorded state of the working memory of a computer program at a specific time, generally when the program has terminated abnormally (crashed). In practice, other key pieces of program state are usually dumped at the same time, including the processor registers, which may include the program counter and stack pointer, memory management information, and other processor and operating system flags and information. The name comes from the once-standard memory technology core memory. Core dumps are often used to diagnose or debug errors in computer programs.

    On many operating systems, a fatal error in a program automatically triggers a core dump, and by extension the phrase "to dump core" has come to mean, in many cases, any fatal error, regardless of whether a record of the program memory is created.


    在linux平台下,设置core dump文件生成的方法:
     

    linux coredump调试

     

    1 )如何生成 coredump 文件 ?

    登陆 LINUX 服务器,任意位置键入

           echo "ulimit -c 1024" >> /etc/profile

    退出 LINUX 重新登陆 LINUX

    键入 ulimit -c

    如果显示 1024 那么说明 coredump 已经被开启。

    1024 限制产生的 core 文件的大小不能超过 1024kb,可以使用参数unlimited,取消该限制

    ulimit -c unlimited

    2 ) . core 文件的简单介绍

    在一个程序崩溃时,它一般会在指定目录下生成一个 core 文件,一般在/tmp目录下。 core 文件仅仅是一个内存映象 ( 同时加上调试信息 ) ,主要是用来调试的

    3 ) . 开启或关闭 core 文件的生成

    用以下命令来阻止系统生成 core 文件 :

    ulimit -c 0

    下面的命令可以检查生成 core 文件的选项是否打开 :

    ulimit -a

    该命令将显示所有的用户定制,其中选项 -a 代表“ all ”。

    也可以修改系统文件来调整 core 选项

    在 /etc/profile 通常会有这样一句话来禁止产生 core 文件,通常这种设置是合理的 :

    # No core files by default

    ulimit -S -c 0 > /dev/null 2>&1

    但是在开发过程中有时为了调试问题,还是需要在特定的用户环境下打开 core 文件产生的设置。

    在用户的 ~/.bash_profile 里加上 ulimit -c unlimited 来让特定的用户可以产生 core 文件。

    如果 ulimit -c 0 则也是禁止产生 core 文件,而 ulimit -c 1024 则限制产生的 core 文件的大小不能超过 1024kb

    4 ) . 设置 Core Dump 的核心转储文件目录和命名规则

    /proc/sys/kernel/core_uses_pid 可以控制产生的 core 文件的文件名中是否添加 pid 作为扩展 ,如果添加则文件内容为 1 ,否则为 0

    proc/sys/kernel/core_pattern 可以设置格式化的 core 文件保存位置或文件名 ,比如原来文件内容是 core-%e

    可以这样修改 :

    echo "/corefile/core-%e-%p-%t" > core_pattern

    将会控制所产生的 core 文件会存放到 /corefile 目录下,产生的文件名为 core- 命令名 -pid- 时间戳

    以下是参数列表 :

        %p - insert pid into filename 添加 pid

        %u - insert current uid into filename 添加当前 uid

        %g - insert current gid into filename 添加当前 gid

        %s - insert signal that caused the coredump into the filename 添加导致产生 core 的信号

        %t - insert UNIX time that the coredump occurred into filename 添加 core 文件生成时的 unix 时间

        %h - insert hostname where the coredump happened into filename 添加主机名

        %e - insert coredumping executable name into filename 添加命令名

    6 ) . 一个小方法来测试产生 core 文件

    直接输入指令 :

    kill -s SIGSEGV $$

    如何产生Core Dump

    发生doredump一般都是在进程收到某个信号的时候,Linux上现在大概有60多个信号,可以使用 kill -l 命令全部列出来。

    sagi@sagi-laptop:~$ kill -l
         1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
          6) SIGABRT     7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1
          11) SIGSEGV   12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
          16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
          21) SIGTTIN   22) SIGTTOU 23) SIGURG  24) SIGXCPU 25) SIGXFSZ
          26) SIGVTALRM 27) SIGPROF 28) SIGWINCH    29) SIGIO   30) SIGPWR
          31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
          38) SIGRTMIN+4    39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
          43) SIGRTMIN+9    44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
          48) SIGRTMIN+14   49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
          53) SIGRTMAX-11   54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
          58) SIGRTMAX-6    59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
          63) SIGRTMAX-1    64) SIGRTMAX

    针对特定的信号,应用程序可以写对应的信号处理函数。如果不指定,则采取默认的处理方式, 默认处理是coredump的信号如下:

    3)SIGQUIT   4)SIGILL    6)SIGABRT   8)SIGFPE    11)SIGSEGV    7)SIGBUS    31)SIGSYS
    5)SIGTRAP   24)SIGXCPU  25)SIGXFSZ  29)SIGIOT

    我们看到SIGSEGV在其中,一般数组越界或是访问空指针都会产生这个信号。另外虽然默认是这样的,但是你也可以写自己的信号处理函数改变默认行为,更多信号相关可以看参考链接33。

    上述内容只是产生coredump的必要条件,而非充分条件。要产生core文件还依赖于程序运行的shell,可以通过ulimit -a命令查看,输出内容大致如下:

    sagi@sagi-laptop:~$ ulimit -a
        core file size          (blocks, -c) 0
        data seg size           (kbytes, -d) unlimited
        scheduling priority             (-e) 20
        file size               (blocks, -f) unlimited
        pending signals                 (-i) 16382
        max locked memory       (kbytes, -l) 64
        max memory size         (kbytes, -m) unlimited
        open files                      (-n) 1024
        pipe size            (512 bytes, -p) 8
        POSIX message queues     (bytes, -q) 819200
        real-time priority              (-r) 0
        stack size              (kbytes, -s) 8192
        cpu time               (seconds, -t) unlimited
        max user processes              (-u) unlimited
        virtual memory          (kbytes, -v) unlimited
        file locks                      (-x) unlimited

    看到第一行了吧,core file size,这个值用来限制产生的core文件大小,超过这个值就不会保存了。我这里输出是0,也就是不会保存core文件,即使产生了,也保存不下来==! 要改变这个设置,可以使用ulimit -c unlimited。

    OK, 现在万事具备,只缺一个能产生Core的程序了,介个对C程序员来说太容易了。

    #include <stdio.h>;
    #include <stdlib.h>;
     
        int crash()
        {
                char *xxx = "crash!!";
                xxx[1] = 'D'; // 写只读存储区!
                return 2;
        }
     
        int foo()
        {
                return crash();
        }
     
        int main()
        {
                return foo();
        }

    上手调试

    测试如下代码

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    #include <stdio.h>

     

    int func(int *p)

    {

            *p = 0;

    }

     

    int main()

    {

            func(NULL);

            return 0;

    }

     

    生成可执行文件并运行

    gcc -o main a.c

    root@ubuntu:~# ./main
    Segmentation fault (core dumped) 

    <-----这里出现段错误并生成core文件了。

    在/tmp目录下发现文件core-main-10815 

     

    如何查看进程挂在哪里了?

    我们可以用

    gdb main /tmp/core-main-10815 

    查看信息,发现能定位到函数了

    Program terminated with signal 11, Segmentation fault.
    #0  0x080483ba in func ()

     

    如何定位到行?

    在编译的时候开启-g调试开关就可以了

    gcc -o main -g a.c

    gdb main /tmp/core-main-10815 

    最终看到的结果如下,好棒。

    Program terminated with signal 11, Segmentation fault.
    #0  0x080483ba in func (p=0x0) at a.c:5
    5          *p = 0;

     

    总结一下,需要定位进程挂在哪一行我们只需要4个操作,

    ulimit -c unlimited

    echo "/tmp/core-%e-%p" > /proc/sys/kernel/core_pattern

    gcc -o main -g a.c

    gdb main /tmp/core-main-10815 

    就可以啦。

     

    上边的程序编译的时候有一点需要注意,需要带上参数-g, 这样生成的可执行程序中会带上足够的调试信息。编译运行之后你就应该能看见期待已久的“Segment Fault(core dumped)”或是“段错误 (核心已转储)”之类的字眼了。看看当前目录下是不是有个core或是core.xxx的文件。祭出linux下经典的调试器GDB,首先带着core文件载入程序:gdb exefile core,这里需要注意的这个core文件必须是exefile产生的,否则符号表会对不上。载入之后大概是这个样子的:

    sagi@sagi-laptop:~$ gdb coredump core
    Core was generated by ./coredump'.
        Program terminated with signal 11, Segmentation fault.
    #0  0x080483a7 in crash () at coredump.c:8
        8       xxx[1] = 'D';
    (gdb)

    我们看到已经能直接定位到出core的地方了,在第8行写了一个只读的内存区域导致触发Segment Fault信号。在载入core的时候有个小技巧,如果你事先不知道这个core文件是由哪个程序产生的,你可以先随便找个代替一下,比如/usr/bin/w就是不错的选择。比如我们采用这种方法载入上边产生的core,gdb会有类似的输出:

    sagi@sagi-laptop:~$ gdb /usr/bin/w core
    Core was generated by ./coredump'.
        Program terminated with signal 11, Segmentation fault.
    #0  0x080483a7 in ?? ()
        (gdb)

    可以看到GDB已经提示你了,这个core是由哪个程序产生的。

    GDB 常用操作

    上边的程序比较简单,不需要另外的操作就能直接找到问题所在。现实却不是这样的,常常需要进行单步跟踪,设置断点之类的操作才能顺利定位问题。下边列出了GDB一些常用的操作。

    • 启动程序:run

       

    • 设置断点:b 行号|函数名

       

    • 删除断点:delete 断点编号

       

    • 禁用断点:disable 断点编号

       

    • 启用断点:enable 断点编号

       

    • 单步跟踪:next 也可以简写 n

       

    • 单步跟踪:step 也可以简写 s

       

    • 打印变量:print 变量名字

       

    • 设置变量:set var=value

       

    • 查看变量类型:ptype var

       

    • 顺序执行到结束:cont

       

    • 顺序执行到某一行: util lineno

       

    • 打印堆栈信息:bt
    展开全文
  • Linux之core文件分析

    千次阅读 2019-11-21 01:03:03
    当程序在运行的过程中异常终止或崩溃,操作系统会将程序当时的内存状态记录下来,保存在一个文件中,这种行为就叫做core dump。我们可以认为 core dump 是“内存快照”,但实际上,除了内存信息之外,还有些关键的...

    一、概述:

            当程序在运行的过程中异常终止或崩溃,操作系统会将程序当时的内存状态记录下来,保存在一个文件中,这种行为就叫做core dump。我们可以认为 core dump 是“内存快照”,但实际上,除了内存信息之外,还有些关键的程序运行状态也会同时 dump 下来,例如寄存器信息(包括程序指针、栈指针等)、内存管理信息、其他处理器和操作系统状态和信息,主要格式是ELF格式。core dump 对于编程人员诊断和调试程序是非常有帮助的,因为对于有些程序错误是很难重现的,例如指针异常,而 core 文件可以再现程序出错时的情景。

            core 文件一般都很大,如果core文件很多占用硬盘空间太大,最终可能导致死机。

    二、配置:

           1、查看是否开启core dump:

    ulimit -c

    如果输出:0,说明是关闭的,如果输出:unlimited,说明是开启的。

           2、开启core dump,并且不限制core文件大小,只限当前会话有效:

    ulimit -c unlimited

           3、开启core dump,限制core文件大小,单位是KB,只限当前会话有效:

    ulimit -c 30000000

           4、关闭core dump,只限当前会话有效:

    ulimit -c 0

           5、如果需要长久有效,有两种方式:

                  ①在/etc/profile中,将0改为unlimited,然后source /etc/profile生效;

                  ②在/etc/security/limits.conf设置:

           6、core文件默认保存的位置是程序被执行的可执行文件的目录,修改/proc/sys/kernel/core_pattern内容则可以改变目录和文件名,默认是:core,可以改为:

    /tmp/corefile/core-%e-%p-%t

           常用格式有:

                  1>%%:单个%字符

                  2>%p:所dump进程的进程ID

                  3>%u:所dump进程的实际用户ID

                  4>%g:所dump进程的实际组ID

                  5>%s:导致本次core dump的信号

                  6>%t:core dump的时间 (由1970年1月1日计起的秒数)

                  7>%h:主机名

                  8>%e:程序文件名

           7、默认文件名是core,修改/proc/sys/kernel/core_uses_pid,内容改为1,则文件名变为core.xxx,其中 xxx为进程pid。

    三、查看:

           一般使用gdb进行查看,gdb中常用命令有:

           1、l(list):显示源代码,并且可以看到对应的行号;

           2、b(break)x:x是行号,表示在对应的行号位置设置断点;

           3、p(print)x:x是变量名,表示打印变量x的值;

           4、r(run):表示继续执行到断点的位置;

           5、n(next):表示执行下一步;

           6、c(continue):表示继续执行;

           7、q(quit):表示退出gdb;

           8、info share:查看已加载的动态库;

           9、bt:查看程序堆栈信息;

    四、Singal含义:

           1、SIGABRT:调用abort函数时产生此信号。进程异常终止。

           2、SIGBUS:指示一个实现定义的硬件故障。

           3、SIGEMT:指示一个实现定义的硬件故障。EMT这一名字来自PDP-11的emulator trap 指令。

           4、SIGFPE:此信号表示一个算术运算异常,例如除以0,浮点溢出等。

           5、SIGILL:此信号指示进程已执行一条非法硬件指令。4.3BSD由abort函数产生此信号。SIGABRT现在被用于此。

           6、SIGIOT:这指示一个实现定义的硬件故障。IOT这个名字来自于PDP-11对于输入/输出TRAP(input/outputTRAP)指令的缩写。系统V的早期版本,由abort函数产生此信号。SIGABRT现在被用于此。

           7、SIGQUIT:当用户在终端上按退出键(一般采用Ctrl-/)时,产生此信号,并送至前台进程组中的所有进程。此信号不仅终止前台进程组(如SIGINT所做的那样),同时产生一个core文件。

           8、SIGSEGV:指示进程进行了一次无效的存储访问。名字SEGV表示“段违例(segmentationviolation)”。

           9、SIGSYS:指示一个无效的系统调用。由于某种未知原因,进程执行了一条系统调用指令,但其指示系统调用类型的参数却是无效的。

           10、SIGTRAP:指示一个实现定义的硬件故障。此信号名来自于PDP-11的TRAP指令。

           11、SIGXCPUSVR4和4.3+BSD支持资源限制的概念。如果进程超过了其软CPU时间限制,则产生此信号。

           12、SIGXFSZ:如果进程超过了其软文件长度限制,则SVR4和4.3+BSD产生此信号。

     

    推荐博客:https://www.jianshu.com/p/414a1bde76a2

    展开全文
  • javacore文件及heapdump文件分析
  • 通常在 Linux 下遇到程序异常退出或者中止,我们都会使用 core 文件进行分析,其中包含了程序运行时的内存,寄存器,堆栈指针等信息,格式为 ELF ,可以理解是程序工作当前状态转储成一个文件,通过工具分析这个文件...
  • core文件分析

    千次阅读 2019-02-15 11:24:01
    core文件分析
                   

    内容提要:
    主要包含两部分内容:
    1,core文件描述
    2,core文件分析

    说明:


    一,Core 文件描述
    Coredump 在unix 平台是非常容易出现的一种错误形式,直接表现形式为core 文件, core 文件产生于当前目录下,
    通常,象内存地址错误、非法指令、总线错误等会引起coredump ,core 文件的内容包含进程出现异常时的错误影
    像。如果错误进程为多线程并且core 文件的大小受限于ulimit 的系统限制,则系统只将数据区中错误线程的堆栈区
    复制到core 文件中。
    应当注意,从AIX 5L 版本5.1 开始core 文件的命名格式可以通过环境变量CORE_NAMING 设置,其格式为:
    core.pid.ddhhmmss ,分别代表为:
    pid :进程标示符
    dd :当前日期
    hh :当前小时
    mm :当前的分钟
    ss :当前的秒
    core 文件的缺省格式为老版本的格式,coredump 文件的内容按照以下的顺序组织:
    1 ) core 文件的头部信息

    • 定义
    coredump 的基本信息,及其他信息的地址偏移量

    2 ) ldinfo 结构信息

    • 定义
    loader 区的信息

    3 ) mstsave 结构信息

    • 定义核心线程的状态信息,错误线程的
    mstsave 结构信息直接存储在 core 文件的头部区,此区域只对多线程的
    程序有效,除错误线程外的其他线程的 mstsave 结构信息存与此区域。

    4 ) 缺省的用户堆栈数据

    • 存储
    coredump 时的用户堆栈数据

    5 ) 缺省的数据区域

    • 存储用户数据区域信息

    6 ) 内存映射数据

    • 存储匿名的内存映射数据

    7 ) vm_info 结构信息

    • 存储内存映射区域的地址偏移量和大小信息

    缺省情况下,用户数据、匿名的内存区域和vm_info 结构信息并不包含在core 文件中,core 文件值包含当前的进
    程堆栈、线程堆栈、线程mstsave 结构、用户结构和错误时的寄存器信息,这些信息足够跟踪错误的产生。Core
    文件的大小也可以通过setrlimit 函数设定。

    二,Core 文件分析
    首先分析coredump 的结构组成,core 文件的头信息是由结构core_dump 结构定义的,结构成员定义如下:

    成员类型描述
    c_signo char 引起错误的信号量
    C_entries ushort Coredump 的模块数
    *c_tab Struct ld_info Core 数据的地址偏移量
    成员类型描述
    c_flag char 描述coredump 的类型,类型为:
    FULL_CORECore 包含数据区域
    CORE_VERSION_1 生成 core 文件的AIX 的版本
    MSTS_VALID 包含mstsave 的结构
    CORE_BIGDATACore 文件包含大数据
    UBLOCK_VALIDCore 文件包含u_block 结构
    USTACK_VALIDCore 文件包含用户堆栈数据
    LE_VALIDCore 文件至少包含一个模块
    CORE_TRUNCCore 文件被截短
    c_stack Caddr_t 用户堆栈的起始地址偏移量
    C_size int 用户堆栈的大小
    C_mst Struct mstsave 错误mst 的拷贝
    C_u Struct user 用户结构的拷贝
    C_nmsts int Mstsave 结构的数量
    C_msts Struct mstsvae * 线程的mstsave 结构的地址偏移量
    C_datasize int 数据区域的大小
    C_data Caddr_t 用户数据的地址偏移量
    C_vmregions int 匿名地址映射的数量
    C_vmm Struct vm_info * Vm_info 数据表的起始地址偏移量


    借助于下面提供的程序可以分析core 文件的部分信息:
    #include <stdio.h>
    #include <sys/core.h>

    void main(int argc, char *argv[])
    {
    FILE *corefile;
    struct core_dumpx c_file;
    char command[256];

    if (argc != 2) {
    fprintf(stderr, "Usage: %s <corefile>/n", *argv);
    exit(1);
    }

    if ((corefile = fopen(argv[1], "r")) == NULL) {
    perror(argv[1]);
    exit(1);
    }

    fread(&c_file, sizeof(c_file), 1, corefile);
    fclose(corefile);

    sprintf(command, "lquerypv -h %s 6E0 64 | head -1 | awk '{print $6}'", argv[1]);

    printf("Core created by: /n");

    system(command);

    printf("Signal number and cause of error number: %i/n", c_file.c_signo);
    printf("Core file type: %i/n", c_file.c_flag);
    printf("Number of core dump modules: %i/n", c_file.c_entries);
    printf("Core file format number: %i/n", c_file.c_version);
    printf("Thread identifier: %i/n", c_file.c_flt.th.ti_tid);
    printf("Process identifier: %i/n", c_file.c_flt.th.ti_pid);
    printf("Current effective priority: %i/n", c_file.c_flt.th.ti_pri);
    printf("Processor Usage: %i/n", c_file.c_flt.th.ti_cpu);
    printf("Processor bound to: cpu%i/n", c_file.c_flt.th.ti_cpuid);

    /* if (c_file.c_flt.th.ti_cpu > 1) printf("Last Processor: cpu%i/n", c_file.c_flt.th.ti_affinity);
    */
    exit(0);
    }
    假定以上程序的可执行程序名称为anacore ,按照以下步骤察看其运行结果:
    1 ) 通过下面的程序生成core 文件

    •   main() {
      char *testadd;

      strcpy(testadd, 搣Just a testing攠);
      }
      程序命名为core.c

    2 ) 编译程序core.c

    •   xlc –o pcore core.c

    3 ) 运行pcore 产生core 文件
    4 ) 运行anacore 察看结果

    •   anacore core

    5 ) 结果如下 [root@F80_1#]acore core
    Core created by:
    |pcore...........|
    Signal number and cause of error number: 11
    Core file type: 114
    Number of core dump modules: 0
    Core file format number: 267312561
    Thread identifier: 40827
    Process identifier: 9520
    Current effective priority: 60
    Processor Usage: 0
    Processor bound to: cpu-1

    从上面的结果,我们可以简单的分析产生core 文件的应用、信号量及进程等信息,如果要求一
    些更详细的信息,可以借助于dbx 等调试工具进一步分析。

               

    再分享一下我老师大神的人工智能教程吧。零基础!通俗易懂!风趣幽默!还带黄段子!希望你也加入到我们人工智能的队伍中来!https://blog.csdn.net/jiangjunshow

    展开全文
  • ulimit -c unlimited生成core文件

    千次阅读 2020-02-04 11:46:10
    core_pattern接受的是core文件名称的pattern,它包含任何字符串,并且用%作为转移符号生成一些标示符,为core文件名称加入特殊含义。已定义的标示符有如下这些: %%:相当于% %p:相当于 %u:相当于 %g:...

    ulimint -a 用来显示当前的各种用户进程限制
    Linux对于每个用户,系统限制其最大进程数,为提高性能,可以根据设备资源情况,
    设置个Linux用户的最大进程数,一些需要设置为无限制:
    数据段长度:ulimit -d unlimited
    最大内存大小:ulimit -m unlimited
    堆栈大小:ulimit -s unlimited

    我们在用这个命令的时候主要是为了产生core文件,就是程序运行发行段错误时的文件:

    ulimit -c unlimited   

    生成core文件,

    #######################################################
    以下来自;http://hi.baidu.com/jrckkyy/blog/item/2562320a5bdbc534b1351d95.html

    查看限制情况 ulimit -a

    可以看到如下信息

    core file size          (blocks, -c) 0
    data seg size           (kbytes, -d) unlimited
    file size               (blocks, -f) unlimited
    pending signals                 (-i) 1024
    max locked memory       (kbytes, -l) 32
    max memory size         (kbytes, -m) unlimited
    open files                      (-n) 1024
    pipe size            (512 bytes, -p) 8
    POSIX message queues     (bytes, -q) 819200
    stack size              (kbytes, -s) 10240
    cpu time               (seconds, -t) unlimited
    max user processes              (-u) 4096
    virtual memory          (kbytes, -v) unlimited
    file locks                      (-x) unlimited

    而我们需要修改的是open files (-n) 1024的值

    于是命令就是limit -n 2048(随各自需要设置)

    -----------------------------------------------------------------------------------

     

    功能说明:控制shell程序的资源。

    语  法:ulimit [-aHS][-c <core文件上限>][-d <数据节区大小>][-f <文件大小>][-m <内存大小>][-n <文件数目>][-p <缓冲区大小>][-s <堆叠大小>][-t <CPU时间>][-u <程序数目>][-v <虚拟内存大小>]

    补充说明:ulimit为shell内建指令,可用来控制shell执行程序的资源。

    参  数:
       -a  显示目前资源限制的设定。 
       -c <core文件上限>  设定core文件的最大值,单位为区块。 
       -d <数据节区大小>  程序数据节区的最大值,单位为KB。 
       -f <文件大小>  shell所能建立的最大文件,单位为区块。 
       -H  设定资源的硬性限制,也就是管理员所设下的限制。 
       -m <内存大小>  指定可使用内存的上限,单位为KB。 
       -n <文件数目>  指定同一时间最多可开启的文件数。 
       -p <缓冲区大小>  指定管道缓冲区的大小,单位512字节。 
       -s <堆叠大小>  指定堆叠的上限,单位为KB。 
       -S  设定资源的弹性限制。 
       -t <CPU时间>  指定CPU使用时间的上限,单位为秒。 
       -u <程序数目>  用户最多可开启的程序数目。 
       -v <虚拟内存大小>  指定可使用的虚拟内存上限,单位为KB。

    ------------------

     

    1,说明:
    ulimit用于shell启动进程所占用的资源.

    2,类别:
    shell内建命令

    3,语法格式:
    ulimit [-acdfHlmnpsStvw] [size]

    4,参数介绍:

    QUOTE:
    -H 设置硬件资源限制.
    -S 设置软件资源限制.
    -a 显示当前所有的资源限制.
    -c size:设置core文件的最大值.单位:blocks
    -d size:设置数据段的最大值.单位:kbytes
    -f size:设置创建文件的最大值.单位:blocks
    -l size:设置在内存中锁定进程的最大值.单位:kbytes
    -m size:设置可以使用的常驻内存的最大值.单位:kbytes
    -n size:设置内核可以同时打开的文件描述符的最大值.单位:n
    -p size:设置管道缓冲区的最大值.单位:kbytes
    -s size:设置堆栈的最大值.单位:kbytes
    -t size:设置CPU使用时间的最大上限.单位:seconds
    -v size:设置虚拟内存的最大值.单位:kbytes


    5,简单实例:

    1]在RH8的环境文件/etc/profile中,我们可以看到系统是如何配置ulimit的:

    CODE:
    #grep ulimit /etc/profile
    ulimit -S -c 0 > /dev/null 2>&1


    这条语句设置了对软件资源和对core文件大小的设置

    2]如果我们想要对由shell创建的文件大小作些限制,如:

    CODE:
    #ll h
    -rw-r--r-- 1 lee lee 150062 7月 22 02:39 h
    #ulimit -f 100 #设置创建文件的最大块(一块=512字节)
    #cat h>newh
    File size limit exceeded
    #ll newh
    -rw-r--r-- 1 lee lee 51200 11月 8 11:47 newh


    文件h的大小是150062字节,而我们设定的创建文件的大小是512字节x100块=51200字节
    当然系统就会根据你的设置生成了51200字节的newh文件.

    3]可以像实例1]一样,把你要设置的ulimit放在/etc/profile这个环境文件中.

     

    ------------------------------------------------------------------------------------------------------------------

    当系统中的一些程序在遇到一些错误以及crash时,系统会自动产生core文件记录crash时刻系统信息,包括内存和寄存器信息,用以程序员日 后debug时可以使用。这些错误包括段错误、非法指令、总线错误或用户自己生成的退出信息等等,一般地,core文件在当前文件夹中存放。

    core文件有时可能在你发生错误时,并没有出现在你当前的文件夹中,发生这种情况的原因有两个:一个是当前终端被设置为不能弹出core文件;另一种则是core文件被指定了路径。

    对于前者,我们可以使用ulimit命令对core文件的大小进行设定。一般默认情况下,core文件的大小被设置为0,这样系统就不dump出core文件了。这时,使用命令:ulimit -c unlimited进行设置,就可以把core文件的大小设置为无限大,同时也可以使用数字来替代unlimited,对core文件的上限制做更精确的设定。

    除了可以设置core文件的大小之外,还可以对core文件的名称进行一些规定。这种设置是对/proc/sys/kernel/core_pattern和/proc/sys/kernel/core_uses_pid这两个文件进行修改。改动这两个文件的方法如下:

    echo <pattern> > /proc/sys/kernel/core_pattern

    echo <"0"/"1"> /proc/sys/kernel/core_uses_pid

    并且注意,只有超级用户才可以修改这两个表。

    core_pattern接受的是core文件名称的pattern,它包含任何字符串,并且用%作为转移符号生成一些标示符,为core文件名称加入特殊含义。已定义的标示符有如下这些:

    %%:相当于%

    %p:相当于<pid>

    %u:相当于<uid>

    %g:相当于<gid>

    %s:相当于导致dump的信号的数字

    %t:相当于dump的时间

    %e:相当于执行文件的名称

    %h:相当于hostname

    除以上这些标志位外,还规定:

    1、末尾的单个%可以直接去除;

    2、%加上除上述以外的任何字符,%和该字符都会被去除;

    3、所有其他字符都作为一般字符加入名称中;

    4、core文件的名称最大值为64个字节(包括'\0');

    5、core_pattern中默认的pattern为core;

    6、为了保持兼容性,通过设置core_uses_pid,可以在core文件的末尾加上%p;

    7、pattern中可以包含路径信息。

    ------------------------------------------------------------------------------------------------------------------

    下面的资料是从互联网上整理的来的,参考文献如下:

    http://blog.csdn.net/hanchaoman/archive/2009/08/03/4405655.aspx

    http://www.mysys-admin.org/category/general/

     

     

    1. 可以用ulimit -a 查看一下栈的大小。
    在内核2.6.20下, stack size 为8192 kbytes
    如果这里没有限制,就栈的大小就只受内存的限制。2G是上限。

    2. core 文件
        * 开启或关闭core文件的生成
    ulimit -c 可以查看是否打开此选项,若为0则为关闭;
    ulimit -c 0可手动关闭
    ulimit -c 1000 为设置core文件大小最大为1000k

    ulimit -c unlimited 设置core文件大小为不限制大小

     

    很多系统在默认的情况下是关闭生成core文件的,这个命令可以加到你的profile中去

    3.设置Core Dump的核心转储文件目录和命名规则

     

    在默认的情况下,很多系统的core文件是生成在你运行程序的目录下,或者你在程序中chdir后的那个目录,然后在core文件的后面加了一个 pid。在实际工作中,这样可能会造成很多目录下产生core文件,不便于管理,实际上,在2.6下,core文件的生成位置和文件名的命名都是可以配置 的。

     

    /proc/sys/kernel/core_uses_pid可以控制产生的core文件的文件名中是否添加pid作为扩展,如果添加则文件内容为1,否则为0
    proc/sys/kernel/core_pattern可以设置格式化的core文件保存位置或文件名,比如原来文件内容是core-%e
    可以这样修改:
    echo "/tmp/core-%e-%p" > core_pattern
    将会控制所产生的core文件会存放到/corefile目录下,产生的文件名为core-命令名-pid-时间戳
    以下是参数列表:
        %p - insert pid into filename 添加pid
        %u - insert current uid into filename 添加当前uid
        %g - insert current gid into filename 添加当前gid
        %s - insert signal that caused the coredump into the filename 添加导致产生core的信号
        %t - insert UNIX time that the coredump occurred into filename 添加core文件生成时的unix时间
        %h - insert hostname where the coredump happened into filename 添加主机名
        %e - insert coredumping executable name into filename 添加命令名

    当然,你可以用下列方式来完成
    sysctl -w kernel.core_pattern=/tmp/core-%e-%p

     

    这些操作一旦计算机重启,则会丢失,如果你想持久化这些操作,可以在 /etc/sysctl.conf文件中增加:
    kernel.core_pattern=/tmp/core%p

     

    加好后,如果你想不重启看看效果的话,则用下面的命令:
    sysctl -p /etc/sysctl.conf

    ------------------------------------------------------------------------------------------------------------------

    高手指教:

        解决的问题:
             现有一程序P 长期在服务器上运行,目前经常是每1天死掉一次(段错误)。

        目前解决方法:
             用SecureCRT开一个终端,并在服务其上设置ulimit -c nulimited,然后启动程序P。用ulimite -a 命令查询结果如下:

             core file size       (blocks, -c) unlimited
             data seg size           (kbytes, -d) unlimited
             file size             (blocks, -f) unlimited
             pending signals                 (-i) 1024
             max locked memory    (kbytes, -l) 32
              ............
             表明core文件可以生成。

             并测试利用kill -6 pid能够core文件。

       目前的困难:

             当运行ulimit -c nulimited终端 (并且该终端将程序P启动到后台了 ./P &)关闭,程序P死掉后并没有生成 core文件。
             经试验后发现ulimit 命令与终端有关。

       高手指教:
              如何设置能够生成core 文件,与终端无关
              即,程序启动,关闭终端,当程序死掉(段错误)后能够生成core文件。


    /etc/security/limits.conf (中设置 redhat衍生系linux)

    /etc/profile中的:
    # No core files by default
    ulimit -S -c 0 > /dev/null 2>&1

    注释掉上面一行。

    还有其他UNIX类操作系统也有自己的配置文件可以设置。

    ------------------------------------------------------------------------------------------------------------------

    gdb core 多线程
    在linux环境下调试多线程,总觉得不像.NET那么方便。这几天就为找一个死锁的bug折腾好久,介绍一下用过的方法吧。

    多线程如果dump,多为段错误,一般都涉及内存非法读写。可以这样处理,使用下面的命令打开系统开关,让其可以在死掉的时候生成core文件。   
    ulimit -c unlimited
    这样的话死掉的时候就可以在当前目录看到core.pid(pid为进程号)的文件。接着使用gdb:
    gdb ./bin ./core.pid 
    进去后,使用bt查看死掉时栈的情况,在使用frame命令。

    还有就是里面某个线程停住,也没死,这种情况一般就是死锁或者涉及消息接受的超时问题(听人说的,没有遇到过)。遇到这种情况,可以使用:
    gcore pid (调试进程的pid号)
    手动生成core文件,在使用pstack(linux下好像不好使)查看堆栈的情况。如果都看不出来,就仔细查看代码,看看是不是在 if,return,break,continue这种语句操作是忘记解锁,还有嵌套锁的问题,都需要分析清楚了。

    最后,说一句,静心看代码,捶胸顿足是没有用的。

    -------------------------------------

    1,说明:
    ulimit用于shell启动进程所占用的资源.
    2,类别:
    shell内建命令
    3,语法格式:
    ulimit [-acdfHlmnpsStvw] [size]
    4,参数介绍:
    -H 设置硬件资源限制.
    -S 设置软件资源限制.
    -a 显示当前所有的资源限制.
    -c size:设置core文件的最大值.单位:blocks
    -d size:设置数据段的最大值.单位:kbytes
    -f size:设置创建文件的最大值.单位:blocks
    -l size:设置在内存中锁定进程的最大值.单位:kbytes
    -m size:设置可以使用的常驻内存的最大值.单位:kbytes
    -n size:设置内核可以同时打开的文件描述符的最大值.单位:n
    -p size:设置管道缓冲区的最大值.单位:kbytes
    -s size:设置堆栈的最大值.单位:kbytes
    -t size:设置CPU使用时间的最大上限.单位:seconds
    -v size:设置虚拟内存的最大值.单位:kbytes 5,简单实例: 
    5.举例
    在Linux下写程序的时候,如果程序比较大,经常会遇到“段错误”(segmentation fault)这样的问题,这主要就是由于Linux系统初始的堆栈大小(stack size)太小的缘故,一般为10M。我一般把stack size设置成256M,这样就没有段错误了!命令为:
    ulimit   -s 262140 
    如果要系统自动记住这个配置,就编辑/etc/profile文件,在 “ulimit -S -c 0 > /dev/null 2>&1”行下,添加“ulimit   -s 262140”,保存重启系统就可以了! 
    1]在RH8的环境文件/etc/profile中,我们可以看到系统是如何配置ulimit的:
    #grep ulimit /etc/profile
    ulimit -S -c 0 > /dev/null 2>&1
    这条语句设置了对软件资源和对core文件大小的设置
    2]如果我们想要对由shell创建的文件大小作些限制,如:
    #ll h
    -rw-r--r-- 1 lee lee 150062 7月 22 02:39 h
    #ulimit -f 100 #设置创建文件的最大块(一块=512字节)
    #cat h>newh
    File size limit exceeded
    #ll newh
    -rw-r--r-- 1 lee lee 51200 11月 8 11:47 newh
    文件h的大小是150062字节,而我们设定的创建文件的大小是512字节x100块=51200字节
    当然系统就会根据你的设置生成了51200字节的newh文件.
    3]可以像实例1]一样,把你要设置的ulimit放在/etc/profile这个环境文件中.
    用途 
    设置或报告用户资源极限。
    语法 
    ulimit [ -H ] [ -S ] [ -a ] [ -c ] [ -d ] [ -f ] [ -m ] [ -n ] [ -s ] [ -t ] [ Limit ]
    描述 
    ulimit 命令设置或报告用户进程资源极限,如 /etc/security/limits 文件所定义。文件包含以下缺省值极限: 
    fsize = 2097151
    core = 2097151
    cpu = -1
    data = 262144
    rss = 65536
    stack = 65536
    nofiles = 2000 
    当新用户添加到系统中时,这些值被作为缺省值使用。当向系统中添加用户时,以上值通过 mkuser 命令设置,或通过 chuser 命令更改。 
    极限分为软性或硬性。通过 ulimit 命令,用户可将软极限更改到硬极限的最大设置值。要更改资源硬极限,必须拥有 root 用户权限。 
    很多系统不包括以上一种或数种极限。 特定资源的极限在指定 Limit 参数时设定。Limit 参数的值可以是每个资源中指定单元中的数字,或者为值 unlimited。要将特定的 ulimit 设置为 unlimited,可使用词 unlimited。 
        注:在 /etc/security/limits 文件中设置缺省极限就是设置了系统宽度极限, 而不仅仅是创建用户时用户所需的极限。 
    省略 Limit 参数时,将会打印出当前资源极限。除非用户指定 -H 标志,否则打印出软极限。当用户指定一个以上资源时,极限名称和单元在值之前打印。如果未给予选项,则假定带有了 -f 标志。 
    由于 ulimit 命令影响当前 shell 环境,所以它将作为 shell 常规内置命令提供。如果在独立的命令执行环境中调用该命令,则不影响调用者环境的文件大小极限。以下示例中正是这种情况: 
    nohup ulimit -f 10000
    env ulimit 10000 
    一旦通过进程减少了硬极限,若无 root 特权则无法增加,即使返回到原值也不可能。 
    关于用户和系统资源极限的更多信息,请参见 AIX 5L Version 5.3 Technical Reference: Base Operating System and Extensions Volume 1 中的 getrlimit、setrlimit 或 vlimit 子例程。
    标志
    -a     列出所有当前资源极限。
    -c     以 512 字节块为单位,指定核心转储的大小。
    -d     以 K 字节为单位指定数据区域的大小。
    -f     使用 Limit 参数时设定文件大小极限(以块计),或者在未指定参数时报告文件大小极限。缺省值为 -f 标志。
    -H     指定设置某个给定资源的硬极限。如果用户拥有 root 用户权限,可以增大硬极限。任何用户均可减少硬极限。
    -m     以 K 字节为单位指定物理存储器的大小。
    -n     指定一个进程可以拥有的文件描述符的数量的极限。
    -s     以 K 字节为单位指定堆栈的大小。
    -S     指定为给定的资源设置软极限。软极限可增大到硬极限的值。如果 -H 和 -S 标志均未指定,极限适用于以上二者。
    -t     指定每个进程所使用的秒数。
    退出状态 
    返回以下退出值:
    0     成功完成。
    >0     拒绝对更高的极限的请求,或发生错误。
    示例 
    要将文件大小极限设置为 51,200 字节,输入: 
    ulimit -f 100
    展开全文
  • Linux下gdb调试生成core文件并调试core文件

    万次阅读 多人点赞 2018-03-30 16:11:20
    1.什么是core文件?有问题的程序运行后,产生“段错误 (核心已转储)”时生成的具有堆栈信息和调试信息的文件。编译时需要加 -g 选项使程序生成调试信息: gcc -g core_test.c -o core_test2.怎样配置生成 core 文件(1...
  • 上网找了好多都不行,就自己研究写了一个!此示例需要在命令行里用dotnet run 启动,不能用vs里的IIS Express启动。cmd 进入到应用目录,然后用dotnet run 启动。在浏览器里 用https://localhost:5001/ 访问既可
  • linux下根据core文件定位崩溃

    千次阅读 2019-07-08 10:09:01
    linux下根据core文件定位崩溃 根据core文件定位问题
  • core文件如何查看和调试

    千次阅读 2019-06-27 17:51:36
    调试Linux程序的时候,出现Segmentation Fault是最郁闷的事情了,程序代码量很大的时候,可能花很多时间都找不到...这种方法需要用到Linux提供的core dump机制:当程序中出现内存操作错误时,会发生崩溃并产生核心文...
  • Gdb 调试core文件详解

    万次阅读 2018-06-08 11:02:41
    一,什么是coredump &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp; 我们经常听到大家说到程序core掉了,需要定位解决,这里...
  • 如何在让docker中运行的进程生成core dump文件
  • Core文件作用、设置及用法

    千次阅读 2018-04-14 11:56:07
    原文:...当程序崩溃时便会产生core文件,其实准确的应该说是core dump 文件,默认生成位置与可执行程序位于同一目录下,文件名为core.***,其中***是某一数字。2.开启或...
  • Linux下,产生core文件,和不产生core文件的条件: 当我们的程序崩溃时,内核有可能把该程序当前内存映射到core文件里,方便程序员找到程序出现问题的地方。最常出现的,几乎所有C程序员都出现过的错误就是...
  • 主要为大家详细介绍了.Net Core实现图片文件上传下载功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Linux环境下如何生成core文件

    千次阅读 2020-07-05 21:45:50
    但是生成core文件需要设置开关,具体步骤如下: 1、查看生成core文件的开关是否开启,输入命令# ulimit -a 我们看到,第一行core文件大小为0,没有开启。 2、使用#ulimit -c [kbytes]可以设置系统允许生成的core...
  • .net core 文件上传

    千次阅读 2019-05-21 12:14:40
    .net文件上传 1.前端代码 <form id="uploadForm"> <input type="file" name="file" multiple /> <input type="button" value="上传" onclick="doUpload()" /> </form> <script>...
  • 不知道为什么我的~/Desktop/linux学习/linux/code下无法产生core文件 我已经确定 ulimit 显示的值是 unlimited code 文件夹的权限是 drwxrwxrwx 3 rookie rookie 4096 Jun 8 04:40 code 我是用rookie这个用户...
  • Core文件生成的两种方法

    千次阅读 2019-10-24 19:30:31
     当程序运行的过程中异常终止或崩溃,操作系统会将程序当时的内存状态记录下来,保存在一个文件中,这种行为就叫做Core Dump(中文有的翻译成“核心转储”)。我们可以认为 core dump 是“内存快照”,但实际上,...
  • linux下core文件设置与查看

    千次阅读 2018-07-18 18:05:31
    1、查看系统中core文件生成的开关是否打开  1)使用ulimit -c命令可查看core文件的生成开关,若结果为0,则便是关闭了此功能,不会生成core文件。 2、设置core文件生成  1)使用命令ulimit -c filesize命令  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 920,247
精华内容 368,098
关键字:

core文件