linux内存堆栈

⑴ 怎么解决 linux 堆栈溢出内存的问题

【缓冲区溢出的处理】
你屋子里的门和窗户越少，入侵者进入的方式就越少……
由于缓冲区溢出是一个编程问题，所以只能通过修复被破坏的程序的代码而解决问题。州隐如果你没有源代码，从上面“堆栈溢出攻击”的原理可以看出，要防止此类攻击，我们可以：
① 开放程序时仔细检查溢出情况，不允许数据溢出缓冲区。由于编程和编程语言的原因，这非常困难，而且不适合大量已经在使用的程序；
② 使用检查堆栈溢出的编译器或者在程序中加入某些记号，以便程序运行时确认禁止黑客有意造成的溢出。问题是无法针对已有程序，对新程序来讲，需要修改编译器；
③ 经常检查你的操作系统和应用程序提供商的站点，一旦发现他们提供的补丁程序，就马上下载并且应用在系统上，这是最好的方法。但是系统管理员总要比攻击者慢 一步，如果这个有问题的软件是可选的，甚团顷至是临时的，把它从你的系统中删除。举另外一个例 子，你屋子里的门和窗户越少，入侵者进入的方式就越少。
----------------------------------------------------------------------------------------------------------------------------------------
char buf[3];
memset(buf,0x55,10);
这个程序就存在溢出

对数据块的访问超出该数据块的地址范围
===================================================================================
【一个检测工具】
Valgrind 是一款 Linux下（支持 x86、x86_64和ppc32）程序的内存调试工具，它可以对编译后的二进制程序进行内存使用监测（C语言中的 malloc 和 free，以及 C++ 中的 new 和 delete），找出内存泄漏问题。

Valgrind 中包含的册或厅 Memcheck 工具可以检查以下的程序错误：

使用未初始化的内存 (Use of uninitialised memory)
使用已经释放了的内存 （Reading/writing memory after it has been free’d）
使用超过 malloc 分配的内存空间（Reading/writing off the end of malloc’d blocks）
对堆栈的非法访问（Reading/writing inappropriate areas on the stack）
申请的空间是否有释放（Memory leaks – where pointers to malloc’d blocks are lost forever）
malloc/free/new/delete 申请和释放内存的匹配（Mismatched use of malloc/new/new [] vs free/delete/delete []）
src 和 dst 的重叠（Overlapping src and dst pointers in memcpy() and related functions）
重复 free

① 编译安装 Valgrind：
# wget http://valgrind.org/downloads/valgrind-3.4.1.tar.bz2
# tar xvf valgrind-3.4.1.tar.bz2
# cd valgrind-3.4.1/
# ./configure
…………
Primary build target: X86_LINUX
Secondary build target:
Default supp files: exp-ptrcheck.supp xfree-3.supp xfree-4.supp glibc-2.X-drd.supp glibc-2.34567-NPTL-helgrind.supp glibc-2.5.supp
# make
# make install
# whereis valgrind
valgrind:
/usr/bin/valgrind
/usr/lib/valgrind
/usr/local/bin/valgrind
/usr/local/lib/valgrind
/usr/include/valgrind
/usr/share/man/man1/valgrind.1.gz
运行程序
使用示例：对“ls”程序进程检查，返回结果中的“definitely lost: 0 bytes in 0 blocks.”表示没有内存泄漏。
# /usr/local/bin/valgrind --tool=memcheck --leak-check=full ls /
==29801== Memcheck, a memory error detector.
==29801== Copyright (C) 2002-2008, and GNU GPL'd, by Julian Seward et al.
==29801== Using LibVEX rev 1884, a library for dynamic binary translation.
==29801== Copyright (C) 2004-2008, and GNU GPL'd, by OpenWorks LLP.
==29801== Using valgrind-3.4.1, a dynamic binary instrumentation framework.
==29801== Copyright (C) 2000-2008, and GNU GPL'd, by Julian Seward et al.
==29801== For more details, rerun with: -v
==29801==
bin etc lost+found mnt proc selinux sys usr
boot home media net root smokeping tftpboot var
dev lib misc opt sbin srv tmp
==29801==
==29801== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 21 from 1)
==29801== malloc/free: in use at exit: 14,744 bytes in 32 blocks.
==29801== malloc/free: 162 allocs, 130 frees, 33,758 bytes allocated.
==29801== For counts of detected errors, rerun with: -v
==29801== searching for pointers to 32 not-freed blocks.
==29801== checked 139,012 bytes.
==29801==
==29801== LEAK SUMMARY:
==29801== definitely lost: 0 bytes in 0 blocks.
==29801== possibly lost: 0 bytes in 0 blocks.
==29801== still reachable: 14,744 bytes in 32 blocks.
==29801== suppressed: 0 bytes in 0 blocks.
==29801== Reachable blocks (those to which a pointer was found) are not shown.
==29801== To see them, rerun with: --leak-check=full --show-reachable=yes
----------------------------------------------------------------------------------------------------------------------------------------
# /usr/local/bin/valgrind --tool=memcheck --leak-check=full ps /
==29898== Memcheck, a memory error detector.
==29898== Copyright (C) 2002-2008, and GNU GPL'd, by Julian Seward et al.
==29898== Using LibVEX rev 1884, a library for dynamic binary translation.
==29898== Copyright (C) 2004-2008, and GNU GPL'd, by OpenWorks LLP.
==29898== Using valgrind-3.4.1, a dynamic binary instrumentation framework.
==29898== Copyright (C) 2000-2008, and GNU GPL'd, by Julian Seward et al.
==29898== For more details, rerun with: -v
==29898==
ERROR: Garbage option.
********* simple selection ********* ********* selection by list *********
-A all processes -C by command name
-N negate selection -G by real group ID (supports names)
-a all w/ tty except session leaders -U by real user ID (supports names)
-d all except session leaders -g by session OR by effective group name
-e all processes -p by process ID
T all processes on this terminal -s processes in the sessions given
a all w/ tty, including other users -t by tty
g OBSOLETE -- DO NOT USE -u by effective user ID (supports names)
r only running processes U processes for specified users
x processes w/o controlling ttys t by tty
*********** output format ********** *********** long options ***********
-o,o user-defined -f full --Group --User --pid --cols --ppid
-j,j job control s signal --group --user --sid --rows --info
-O,O preloaded -o v virtual memory --cumulative --format --deselect
-l,l long u user-oriented --sort --tty --forest --version
-F extra full X registers --heading --no-heading --context
********* misc options *********
-V,V show version L list format codes f ASCII art forest
-m,m,-L,-T,H threads S children in sum -y change -l format
-M,Z security data c true command name -c scheling class
-w,w wide output n numeric WCHAN,UID -H process hierarchy
==29898==
==29898== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 14 from 1)
==29898== malloc/free: in use at exit: 16 bytes in 2 blocks.
==29898== malloc/free: 20 allocs, 18 frees, 2,344 bytes allocated.
==29898== For counts of detected errors, rerun with: -v
==29898== searching for pointers to 2 not-freed blocks.
==29898== checked 263,972 bytes.
==29898==
==29898== 8 bytes in 1 blocks are definitely lost in loss record 2 of 2
==29898== at 0x4005A88: malloc (vg_replace_malloc.c:207)
==29898== by 0xBFF6DF: strp (in /lib/libc-2.5.so)
==29898== by 0x804A464: (within /bin/ps)
==29898== by 0x804A802: (within /bin/ps)
==29898== by 0x804964D: (within /bin/ps)
==29898== by 0xBA5E8B: (below main) (in /lib/libc-2.5.so)
==29898==
==29898== LEAK SUMMARY:
==29898== definitely lost: 8 bytes in 1 blocks.
==29898== possibly lost: 0 bytes in 0 blocks.
==29898== still reachable: 8 bytes in 1 blocks.
==29898== suppressed: 0 bytes in 0 blocks.
==29898== Reachable blocks (those to which a pointer was found) are not shown.
==29898== To see them, rerun with: --leak-check=full --show-reachable=yes

⑵ Linux 怎么查看一个进程的堆栈

方法一：pstack pid
NAME
pstack - print a stack trace of a running process
SYNOPSIS
pstack pid
DESCRIPTION
pstack attaches to the active process named by the pid on the command line, and prints out an execution stack trace. If ELF symbols exist in the binary (usually the case
unless you have run strip(1)), then symbolic addresses are printed as well.
If the process is part of a thread group, then pstack will print out a stack trace for each of the threads in the group.
SEE ALSO
nm(1), ptrace(2), gdb(1)
方法二:gstack pid
NAME
gstack - print a stack trace of a running process
SYNOPSIS
gstack pid
DESCRIPTION
gstack attaches to the active process named by the pid on the command line, and prints out an execution stack trace. If ELF symbols exist in the binary (usually the case
unless you have run strip(1)), then symbolic addresses are printed as well.
If the process is part of a thread group, then gstack will print out a stack trace for each of the threads in the group.
SEE ALSO
nm(1), ptrace(2), gdb(1)
方胡敬升法三：
使用gdb 然后attach 进程ID，然后再使用命令 thread apply all bt。
方法一和裤老方法二一样，方法三可以查看更多稿拿的信息。

⑶ 在linux系统下使用内存技术，检测堆越界错误

一般使用c或cpp编程时，堆栈越界访问（read/write）往往会引起很多意想不到的错误，比如延后的进程崩溃等。因此，如果有一种方法，可以让越界访问立即触发系统错误（让进程抛出异常而终止，再生成coremp文件），就可以立即检测出内存越界行为，并将对这种隐藏的错误，及时作出反应，以免在生产环境下造成更大粗唯冲的损失。

我们知道，在windows系统下面，我们可以使用VirtualAlloc系列函数，通过申请2页内存，并设置某页的保护参数（比如，可读，可写等），就可以实现类似的保护机制。这样，当我们对新增加的类（数据结构），就可以重载operator new/delete，将类的边界设置到一页的边缘，再将相邻页设置为不可读不可写。这样就能有效监测堆越界读写问题。而且可以，设置某个编译宏，比如PROTECT_CLASSX。演示代码如下：

在linux下，则需要借助mmap和mprotect来实现这个机制。具体步骤如下，首先用mmap使用PROT_NONE映射一个特殊文件，比如/岩歼dev/zero(或者使用MAP_ANONYMOUS)，然后再用mprotect提交内存。上面的例子，可以继续使用，但是只列出来核心的代码，什么重载操作符就不写了，另外，内存映射文件j句柄最好用内存山族池来hold，最后在close掉。演示代码只说明大致用法，并不能直接拿来用。

下面补充mprotect的用法：

再把mmap函数的用法示例如下：

⑷ Redhat Linux中怎样自动设置线程堆栈大小

不是可以直接用线程属性进行设置吗？

我写了一个小程序。如下：

#include <pthread.h>
#include <limits.h>#define Thread_NUM 5void *MultiThread_soap_serve(){ sleep(5); printf("new pthread!!\n");}//PTHREAD_STACK_MIN 经过计算是16K。//64*16K = 1M，线程堆栈应该是够用的。#define MICHAEL_SET_PTHREAD_STACK_SIZE 64int main(){ pthread_attr_t attr; pthread_attr_init(&attr); size_t stacksize = MICHAEL_SET_PTHREAD_STACK_SIZE*PTHREAD_STACK_MIN; //stacksize =PTHREAD_STACK_MIN; //stackaddr=(void*)malloc((N+1)*PTHREAD_STACK_MIN); //pthread_attr_getstack(&attr,&statckattr,&stacksize); //pthread_attr_setstack(&attr,stackaddr,); pthread_attr_setstacksize(&attr,stacksize); int iThreadNum = 0; pthread_t PSoapThread[Thread_NUM]; for ( ; iThreadNum < Thread_NUM ; iThreadNum++ ) { pthread_create(&PSoapThread[iThreadNum],&attr,MultiThread_soap_serve,(void *)NULL); } pthread_attr_destroy(&attr); while(1) { sleep(10); printf("main!!\n"); }}

⑸ linux16g内存分配多少java堆内存

linux16g内存分配 -Xmxjava堆内存
以WAS为例：
[tmp]$ ps -ef | grep jav
root 9787 1 0 Sep17 ? 00:02:48 /opt/IBM/WebSphere/AppServer/java/bin/java Xms50m -Xmx256m-Xms 和 -Xmx 分别代表分配JVM的最小内存和最大内存。堆栈信息你可以用 kill -3 后斗稿简面跟上java进程的pid，这样就能生成 thread mp 了。
具体如下：
简介C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处空裤理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。尽管C语言提供了许多低级处理的功能，但仍然保持着良好跨平台的特性，以一个标准规格写出的C语言程序可在许多电脑平台上进行编译，甚至包含一敬铅些嵌入式处理器（单片机或称MCU）以及超级电脑等作业平台。

⑹ Linux内核中用户空间栈和内核栈的区别

您好，很高兴为您解答。
1.进程的堆栈

内核在创建进程的时候，在创建task_struct的同事，会为进程创建相应的堆栈。每个进程会有两个栈，一个用户栈，存在于用户空间，一个内核栈，存在于内核空间。当进程在用户空间运行时，cpu堆栈指针寄存器里面的内容是用户堆栈地址，使用用户栈；当进程在内核空间时，cpu堆栈指针寄存器里面的内容是内核栈空间地址，使用内核栈。
2.进程用户栈和内核栈的切换

当进程因为中断或者系统调用而陷入内核态之行时，进程所使用的堆栈也要从用户栈转到内核栈。

进程陷入内核态后，先把用户态堆栈的地址保存在内核栈之中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈向内核栈的转换；当进程从内核态恢复到用户态之行时，在内核态之行的最后将保存在内核栈里面的用户栈的地址恢复到堆栈指针寄存器即可。这样就实现了内核栈和用户栈的互转。

那么，我们知道从内核转到用户态时用户栈的地址是在陷入内核的时候保存在内核栈里面的，但是在陷入内核的时候，我们是如何知道内核栈的地址的呢？

关键在进程从用户态转到内核态的时候，进程的内核栈总是空的。这是因为，当进程在用户态运行时，使用的是用户栈，当进程陷入到内核态时，内核栈保存进程在内核态运行的相关信心，但是一旦进程返回到用户态后，内核栈中保存的信息无效，会全部恢复，因此每次进程从用户态陷入内核的时候得到的内核栈都是空的。所以在进程陷入内核的时候，直接把内核栈的栈顶地址给堆栈指针寄存器就可以了。
3.内核栈的实现

内核栈在kernel-2.4和kernel-2.6里面的实现方式是不一样的。
在kernel-2.4内核里面，内核栈的实现是：
union task_union {
struct task_struct task;
unsigned long stack[init_stack_size/sizeof(long)];
}; 其中，init_stack_size的大小只能是8k。

内核为每个进程分配task_struct结构体的时候，实际上分配两个连续的物理页面，底部用作task_struct结构体，结构上面的用作堆栈。使用current()宏能够访问当前正在运行的进程描述符。
注意：这个时候task_struct结构是在内核栈里面的，内核栈的实际能用大小大概有7k。

内核栈在kernel-2.6里面的实现是（kernel-2.6.32）：

union thread_union {
struct thread_info thread_info；
unsigned long stack[thread_size/sizeof(long)];
}; 其中thread_size的大小可以是4k，也可以是8k，thread_info占52bytes。

当内核栈为8k时，thread_info在这块内存的起始地址，内核栈从堆栈末端向下增长。所以此时，kernel-2.6中的current宏是需要更改的。要通过thread_info结构体中的task_struct域来获得于thread_info相关联的task。更详细的参考相应的current宏的实现。
struct thread_info {
struct task_struct *task；
struct exec_domain *exec_domain；
__u32 flags；
__u32 status;
__u32 cpu;
… ..
}; 注意：此时的task_struct结构体已经不在内核栈空间里面了。
如若满意，请点击右侧【采纳答案】，如若还有问题，请点击【追问】
希望我的回答对您有所帮助，望采纳！

~
o(∩_∩)o~

⑺ linux 设置堆栈大小 为无限制

你好。

执行命令ulimit -a，查看栈大小的限制。

通过使用 ulimit -s 数字 进行设置。

⑻ Linux进程内存如何管理

Linux系统提供了复杂的存储管理系统，使得进程所能访问的内存达到4GB。在Linux系统中，进程的4GB内存空滑物间被分为两个部分—颤让掘—用户空间与内核空间。用户空间的地址一般分布为0~3GB(即PAGE_OFFSET，在Ox86中它等于OxC0000000），这样，剩下的3~4GB为内核空间，用户进程通常只能访问用户空间的虚拟地址，不能访问内核空间的虚拟地址。用户进程只有通过系统调用（代表用户进程在内核态执行）等方式才可以访问到内核空间。每个进程的用户空间都是完全独立、互不相干的，用户进程各自有不同的页表。而内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核空间的虚拟地址到物理地址映射是被所有进程共享的，内核的虚拟空间独立于其他程序。Linux中1GB的内核地址空间又被划分为物理内存映射区、虚拟内存分配区、高端页面映射区、专用页面映射区和系统保留映射区这几个区域。对于x86系统而言，一般情况下，物理内存映射区最大长度为896MB，系统的物理内存被顺序映射在内核空间的这个区域中。当系统物理内存大于896MB时，超过物理内存映射区的那部分内存称为高端内存（而未超过物理内存映射区的内存通常被称为常规内存），内核在存取高端内存时必须将它们映射到高端页面映射区。Linux保留内核空间最顶部FIXADDR_TOP~4GB的区域作为保留区。当系统物理内存超过4GB时，必须使用CPU的扩展分页(PAE）模式所提供的64位页目录项才能存取到4GB以上的物理内存，这需要CPU的支持。加入了PAE功能的Intel Pentium Pro及以后的CPU允许内存最大可配置到64GB，它们茄核具备36位物理地址空间寻址能力。由此可见，对于32位的x86而言，在3~4GB之间的内核空间中，从低地址到高地址依次为:物理内存映射区隔离带vmalloc虚拟内存分配器区隔离带高端内存映射区专用页面映射区保留区。

⑼ linux系统最大堆栈内存

linux系统最大堆栈消搜内存是-Xmx512m。根据查找相关公开资料显敏简示，linux系统堆栈大小拿拿历的配置启动参数，初始堆大小-Xms32m最大堆大小-Xmx512m。