linux用户栈

㈠ linux用户态栈空间的大小有没有限制

当然有限制，你可以使用命令 ulimit -s 查看大小。
因为物理空间存在着大小限制，因此栈空间肯定也是有大小限制的，不然程序还不崩了。
甚至，你可以测试一下，分配一个超大的栈空间（方法是，在函数中，定义一个超大空间的数组），然后看是否可以运行，当达到一个限制的时候，程序是无法正常运行的

㈡ linux进程为什么有用户栈和内核栈，

linux下的cpu有两个状态：内核态和用户态，内核态的cpu的权限高于用户态下的cpu。
linux下的内存分为用户态内存和内核态内存，一般4个G内存，3个G的分给用户态，1个G分给内核态。
linux进程有时需要调用内核资源时，如读写文件，io读写等，这时候是通过系统调用实现对内核资源的访问的，在访问内核资源前是用户栈，经过系统调用进入到内核态时，cpu的状态也由用户态变为内核态，访问的内存就是内核态下管理的内存了-内核栈，对内核里的资源访问完返回，内存又回到了用户栈，cpu也回到用户态。

㈢ 进程内核栈，用户栈及 Linux 进程栈和线程栈的区别

内核栈、用户栈

32位Linux系统上，进程的地址空间为4G，包括1G的内核地址空间-----内核栈，和3G的用户地址空间-----用户栈。

内核栈，是各个进程在刚开始建立的时候通过内存映射共享的，但是每个进程拥有独立的4G的虚拟内存空间从这一点看又是独立的，互不干扰的（只是刚开始大家都是映射的同一份内存拷贝）
用户栈就是大家所熟悉的内存四区，包括：代码区、全局数据区、堆区、栈区
用户栈中的堆区、栈区即为进程堆、进程栈

进程堆、进程栈与线程栈

1.线程栈的空间开辟在所属进程的堆区与共享内存区之间，线程与其所属的进程共享进程的用户空间，所以线程栈之间可以互访。线程栈的起始地址和大小存放在pthread_attr_t 中，栈的大小并不是用来判断栈是否越界，而是用来初始化避免栈溢出的缓冲区的大小（或者说安全间隙的大小）

2.进程初始化的时候，系统会在进程的地址空间中创建一个堆，叫进程默认堆。进程中所有的线程共用这一个堆。当然，可以增加1个或几个堆，给不同的线程共同使用或单独使用。----一个进程可以多个堆
3、创建线程的时候，系统会在进程的地址空间中分配1块内存给线程栈，通常是1MB或4MB或8MB。线程栈是独立的，但是还是可以互访，因为线程共享内存空间

4.堆的分配：从操作系统角度来看，进程分配内存有两种方式，分别由两个系统调用完成：brk（）和mmap（），glibc中malloc封装了
5.线程栈位置-内存分布测试代码

[cpp] view plain
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <malloc.h>
#include <sys/syscall.h>

void* func(void* arg)
{
long int tid = (long int)syscall(SYS_gettid);
printf("The ID of this thread is: %ld\n", tid );
static int a=10;
int b=11;
int* c=(int *)malloc(sizeof(int));
printf("in thread id:%u a:%p b:%p c:%p\n",tid,&a,&b,c);
printf("leave thread id:%ld\n",tid);
sleep(20);
free((void *)c);
}

void main()
{
pthread_t th1,th2;
printf("pid=%u\n",(int)getpid());
func(NULL);
int ret=pthread_create(&th1,NULL,func,NULL);
if(ret!=0)
{
printf("thread1[%d]:%s\n",th1,strerror(errno));
}
ret=pthread_create(&th2,NULL,func,NULL);
if(ret!=0)
{
printf("thread2[%d]:%s\n",th2,strerror(errno));
}
pthread_join(th1,NULL);
pthread_join(th2,NULL);
}
输出：

[le@localhost threadStack]$ ./threadStack_main pid=16433
The ID of this thread is: 16433
in thread id:16433 a:0x60107c b:0x7fffc89ce7ac c:0x1b54010
leave thread id:16433
The ID of this thread is: 16461
The ID of this thread is: 16460
in thread id:16461 a:0x60107c b:0x7f6abb096efc c:0x7f6ab40008c0
leave thread id:16461
in thread id:16460 a:0x60107c b:0x7f6abb897efc c:0x7f6aac0008c0
leave thread id:16460
主线程调用func后
[le@localhost threadStack]$ sudo cat /proc/16433/maps
00400000-00401000 r-xp 00000000 fd:02 11666 /home/le/code/threadStack/threadStack_main
00600000-00601000 r--p 00000000 fd:02 11666 /home/le/code/threadStack/threadStack_main
00601000-00602000 rw-p 00001000 fd:02 11666 /home/le/code/threadStack/threadStack_main
01b54000-01b75000 rw-p 00000000 00:00 0 [heap]
7f6abb899000-7f6abba4f000 r-xp 00000000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abba4f000-7f6abbc4f000 ---p 001b6000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc4f000-7f6abbc53000 r--p 001b6000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc53000-7f6abbc55000 rw-p 001ba000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc55000-7f6abbc5a000 rw-p 00000000 00:00 0
7f6abbc5a000-7f6abbc70000 r-xp 00000000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbc70000-7f6abbe70000 ---p 00016000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe70000-7f6abbe71000 r--p 00016000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe71000-7f6abbe72000 rw-p 00017000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe72000-7f6abbe76000 rw-p 00000000 00:00 0
7f6abbe76000-7f6abbe97000 r-xp 00000000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc073000-7f6abc076000 rw-p 00000000 00:00 0
7f6abc095000-7f6abc097000 rw-p 00000000 00:00 0
7f6abc097000-7f6abc098000 r--p 00021000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc098000-7f6abc099000 rw-p 00022000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc099000-7f6abc09a000 rw-p 00000000 00:00 0
7fffc89b0000-7fffc89d1000 rw-p 00000000 00:00 0 [stack]
7fffc89fe000-7fffc8a00000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]

两个子线程启动后
[le@localhost threadStack]$ sudo cat /proc/16433/maps
00400000-00401000 r-xp 00000000 fd:02 11666 /home/le/code/threadStack/threadStack_main
00600000-00601000 r--p 00000000 fd:02 11666 /home/le/code/threadStack/threadStack_main
00601000-00602000 rw-p 00001000 fd:02 11666 /home/le/code/threadStack/threadStack_main
01b54000-01b75000 rw-p 00000000 00:00 0 [heap]
7f6aac000000-7f6aac021000 rw-p 00000000 00:00 0
7f6aac021000-7f6ab0000000 ---p 00000000 00:00 0
7f6ab4000000-7f6ab4021000 rw-p 00000000 00:00 0
7f6ab4021000-7f6ab8000000 ---p 00000000 00:00 0
7f6aba897000-7f6aba898000 ---p 00000000 00:00 0
7f6aba898000-7f6abb098000 rw-p 00000000 00:00 0 [stack:16461]
7f6abb098000-7f6abb099000 ---p 00000000 00:00 0
7f6abb099000-7f6abb899000 rw-p 00000000 00:00 0 [stack:16460]
7f6abb899000-7f6abba4f000 r-xp 00000000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abba4f000-7f6abbc4f000 ---p 001b6000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc4f000-7f6abbc53000 r--p 001b6000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc53000-7f6abbc55000 rw-p 001ba000 fd:00 100678959 /usr/lib64/libc-2.17.so
7f6abbc55000-7f6abbc5a000 rw-p 00000000 00:00 0
7f6abbc5a000-7f6abbc70000 r-xp 00000000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbc70000-7f6abbe70000 ---p 00016000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe70000-7f6abbe71000 r--p 00016000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe71000-7f6abbe72000 rw-p 00017000 fd:00 105796566 /usr/lib64/libpthread-2.17.so
7f6abbe72000-7f6abbe76000 rw-p 00000000 00:00 0
7f6abbe76000-7f6abbe97000 r-xp 00000000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc073000-7f6abc076000 rw-p 00000000 00:00 0
7f6abc095000-7f6abc097000 rw-p 00000000 00:00 0
7f6abc097000-7f6abc098000 r--p 00021000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc098000-7f6abc099000 rw-p 00022000 fd:00 105796545 /usr/lib64/ld-2.17.so
7f6abc099000-7f6abc09a000 rw-p 00000000 00:00 0
7fffc89b0000-7fffc89d1000 rw-p 00000000 00:00 0 [stack]
7fffc89fe000-7fffc8a00000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]

㈣ linux为什么需要内核栈，系统调用时直接使用用户栈不行吗

在空气中喷出

㈤ Linux内核——用户堆栈和内核堆栈

每个进程都有用户堆栈和内核堆栈两个堆栈。进程在用户态时使用用户堆栈，陷入到内核态时便使用内核堆栈。

㈥ linux 管道原理

Linux原理的学习，我打算由浅入深，从上之下，也就是先了解个大概再逐个深入。先了解一下Linux的进程先。

一、Linux进程上下文

Linux进程上下文，我理解就是进程组成元素的集合。包括进程描述符tast_struct，正文段，数据段，栈，寄存器内容，页表等。

1）tast_struct

它是一种数据结构，存储着进程的描述信息，例如pid，uid，状态，信号项，打开文件表等。是进程管理和调度的重要依据。

2）用户栈和核心栈

顾名思义，用户栈是进程运行在用户态使用的栈，含有用户态执行时候函数调用的参数，局部变量等；核心栈是该进程运行在核心态下用的栈，保存调用系统函数所用的参数和调用序列。这两个栈的指针都保存在tast_struct结构中。

3）寄存器

保存程序计数器，状态字，通用寄存器，栈指针。

4）页表

线性地址到物理地址的映射

5）正文段，数据段。

二、Linux进程的状态

Linux中进程共有5个状态：就绪，可中断睡眠，不可中断睡眠，暂停，僵死。也就是说，linux不区分就绪和运行，它们统一叫做就绪态。进程所处的状态记录在tast_struct中。

三、进程的控制

1）进程树的形成

计算机启动后，BIOS从磁盘引导扇区加载系统引导程序，它将Linux系统装入内存，并跳到内核处执行，Linux内核就执行初始化工作：初始化硬件、初始化内部数据结构、建立进程0。进程0创建进程1，进程1是以后所有创建的进程的祖先，它负责初始化所有的用户进程。进程1创建shell进程，shell进程显示提示符，等待命令的输入。

2）进程的创建

任何一个用户进程的创建都是由现有的一个进程完成的，进程的创建要经过fork和exec两个过程。Fork是为新进程分配相应的数据结构，并将父进程的相应上下文信息复制过来。Exec是将可执行文件的正文和数据转入内存覆盖它原来的（从父进程复制过来的），并开始执行正文段。

3）进程的终止

系统调用exit()就可自我终结，exit释放除了tast_struct以外的所有上下文，父进程收到子进程终结的消息后，释放子进程的tast_struct。

4）进程的调度

进程的调度是由schele()完成的，一种情况是，当处理机从核心态向用户态转换之前，它会检查调度标志是否为1，如果是1，则运行schele()，执行进程的调度。另一种情况是进程自动放弃处理机，时候进行进程调度。

进程的调度过程分为两步，首先利用相关策略选择要执行的进程，然后进行上下文的切换。

四、进程的通信

进程的通信策略主要有，消息，管道，消息队列，共享存储区和信号量。

1）信息

消息机制主要是用来传递进程间的软中断信号，通知对方发生了异步事件。发送进程将信号（约定好的符号）发送到目标进程的tast_struct中的信号项，接收进程看到有消息后就调用相应的处理程序，注意，处理程序必须到进程执行时候才能执行，不能立即响应。

2）管道

我理解就是两个进程使用告诉缓冲区中的一个队列（每两个进程一个），发送进程将数据发送到管道入口，接收进程从管道出口读数据。

3） 消息队列

消息队列是操作系统维护的一个个消息链表，发送进程根据消息标识符将消息添加到制定队列中，接收进程从中读取消息。

4）共享存储区

在内存中开辟一个区域，是个进程共享的，也就是说进程可以把它附加到自己的地址空间中，对此区域中的数据进行操作。

5）信号量

控制进程的同步。

㈦ 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~