① linux 内核堆栈总大小 怎么决定
Linux内核栈溢出（stack overflow）问题
最近一段时间在设计和开发一个Linux内核模块，进入到最后的正确性测试与稳定性测试阶段。在这个阶段发现了一个非常有意思的问题，堆栈溢出（stack overflow）。Linux内核堆栈溢出之后直接导致了系统kernel Panic。由于导致stack overflow的原因是递归调用导致的，所以，最后通过调试串口导出的kernel panic信息很快就定位问题所在了，否则这样的问题还真是很难调试和发现。通过这次bug，我们应该记住的是：Linux内核stack资源是有限的，而递归调用将大量消耗stack资源，因此在内核编程中尽量少用递归算法，否则将会导致出乎意料的一些问题。依次类推，为了减少stack资源的消耗，程序的局部变量定义的不要太大，否则也将会消耗大量stack资源，从而导致内核程序的不稳定。
为了解决递归调用导致的问题，我将递归算法改写成了非递归算法，解决了stack overflow的问题。在此介绍一下递归算法改写成非递归算法的一些思想。在项目实现过程中，需要对IO请求进行按顺序排队，因此采用了效率较高并且实现简单的快速排序算法，该算法是一种分治算法，即将排序队列进行切分，分解成一系列的小问题进行求解，针对这种问题，很容易采用递归的办法进行实现，伪代码描述如下：
/* qs_sort实现从小到大的排序 */
Struct bio qs_sort(struct bio_list *list_head, struct bio *bio_tail) {
Struct bio_list *less_list, *large_list;
Struct bio *middle_bio;
/* 递归调用结束点，小问题求解完毕，直接返回最后一个元素 */
If (!list_head) {
Return bio_tail;
}
/* 对队列进行切分，选择一个middle_bio，并且按照middle_bio将其切分成less_list队列和large_list队列 */
Split_list(list_head, less_list, large_list, &middle_bio);
/* 采用递归的方法实现大队列的排序操作 */
Middle_bio->bi_next = qs_sort(large_list, bio_tail);
/* 采用递归的方法实现小队列的排序操作 */
Return qs_sort(less_list, middle_bio);
}
② linux为什么需要内核栈，系统调用时直接使用用户栈不行吗
内核栈和用户栈区别：
intel的cpu分为四个运行级别ring0~ring3
内核创建进程，创建进程的同时创建进程控制块，创建进程自己的堆栈
一个进程有两个堆栈，用户栈和系统栈
用户堆栈的空间指向用户地址空间，内核堆栈的空间指向内核地址空间。
有个CPU堆栈指针寄存器，进程运行的状态有用户态和内核态，当进程运行在用户态时。CPU堆栈指针寄存器指向的是用户堆栈地址，使用的是用户堆栈；当进程运行在内核态时，CPU堆栈指针寄存器指向的是内核堆栈地址，使用的是内核堆栈。
堆栈切换
当系统因为系统调用（软中断）或硬件中断，CPU切换到特权工作模式，进程陷入内核态，进程使用的栈也要从用户栈转向系统栈。
从用户态到内核态要两步骤，首先是将用户堆栈地址保存到内核堆栈中，然后将CPU堆栈指针寄存器指向内核堆栈。
当由内核态转向用户态，步骤首先是将内核堆栈中得用户堆栈地址恢复到CPU堆栈指针寄存器中。
内核栈和用户栈区别
1.
栈是系统运行在内核态的时候使用的栈，用户栈是系统运行在用户态时候使用的栈。
当进程由于中断进入内核态时，系统会把一些用户态的数据信息保存到内核栈中，当返回到用户态时，取出内核栈中得信息恢复出来，返回到程序原来执行的地方。
用户栈就是进程在用户空间时创建的栈，比如一般的函数调用，将会用到用户栈。
2.
内核栈是属于操作系统空间的一块固定区域，可以用于保存中断现场、保存操作系统子程序间相互调用的参数、返回值等。
用户栈是属于用户进程空间的一块区域，用户保存用户进程子程序间的相互调用的参数、返回值等。
3.
每个Windows 都有4g的进程空间，系统栈使用进程空间的地段部分，用户栈是高端部分如果用户要直接访问系统栈部分，需要有特殊的方式。
为何要设置两个不同的栈?
共享原因：
内核的代码和数据是为所有的进程共享的，如果不为每一个进程设置对应的内核栈，那么就不能实现不同的进程执行不同的代码。
安全原因：
如果只有一个栈，那么用户就可以修改栈内容来突破内核安全保护。
③ linux进程为什么有用户栈和内核栈，
linux进程在运行时要调用到系统的功能，这些是靠进程调用系统调用，内核接口实现的，他们具有较高的权限，所以要分开两个栈。
④ linux中断处理程序使用的堆栈是内核的堆栈吗，在哪里
当然是，进程生成时，会被分配一个task_struct 结构（常说的进程控制块），2.4内核中版，在task_struct 结构体上面的7KB空间就权是。加上task_struct结构本身(1KB)，进程内核栈共8KB(两个页面 )，不会动态扩展,所以非常有限（你会见到内核代码用"大块"内存都会kmalloc申请的，就是这个原因）。2.6内核的没注意，不知一样否。详见：《Linux内核源代码情景分析(上)》267页。
为什么会在内核的原因是CPU的保护机制，中断处理需要更高的权限（可能执行硬件相关的操作），故要在0级，不会在用户区的。
⑤ 进程内核栈，用户栈及 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内核是可定制的内核：
1 Linux内核的配置系统
2 Linux内核的模块机制
3 Linux内核的源代码开放
4 经裁减的 Linux内核最小可达到 150KB以下，尤其适合嵌入式领域中资源受限的实际情况。
其次，它的性能优越：Linux 系统内核精简、高效和稳定，能够充分发挥硬件的功能，因此它比其他操作系统的运行效率更高。
再者，它有良好的网络支持：
1 支持 TCP/IP 协议栈
2 提供对包括十兆位、百兆位及千兆位的以太网，还有无线网络、Tokenring（令牌环）和光纤甚至卫星的支持
3 对现在依赖于网络的嵌入式设备来说是很好的选择。
至于网络协议的话，有很多种，就目前主流的3种网络协议是：NetBEUI、IPX/SPX及其兼容协议、TCP/IP，而其他的像Lwip、ZigBee、Sip等很多。
1 NetBEUI的前身是NetBIOS，这一协议是IBM1983年开发完成的，早期的微软OS产品中都选择该协议作为通信协议。它是一套用于实现仅仅在小型局域网上PC见相互通信的标准。该网络最大用户数不能超过30个，1985年，微软对其改进，增加了SMB(Server Message Blocks，服务器消息块)的组成部分，以降低网络的通信阻塞，形成了现在的NetBEUI通信协议。
特点：体积小、效率高、速度快、占用内存少。
2 IPX/SPX及其兼容协议：它的全称是“Internwork Packet Exchange/Sequence Packet Exchange”即网际包交换/顺序包交换。
特点：体积较大、能够连接多种网络、具有强大的路由功能，适合大型网络的使用。windows网络中无法直接使用该协议。
3 TCP/IP是国际互联网Internet采用的协议标准，早期用于ARPANet网络，后来开放用于民间。
特点：灵活性，支持任意规模的网络，可以连接所有的计算机，具有路由功能，且TCP/IP的地址是分级的，容易确定并找到网上的用户，提高了网络代换的利用率。
而其他的像Lwip协议栈的特点：
（1）支持多网络接口的IP转发
（2）支持ICMP协议
（3）包括实验性扩展的UDP
（4）包括阻塞控制，RTT估算和快速恢复和快速转发的TCP
（5）提供专门的内部回调接口用于提高应用程序性能
（6）可选择的Berkeley接口API
（7）在最新的版本中支持ppp
不知道这些是不是你想要的。
⑦ linux 线程间共享内核栈吗
首先，我们知道所有线程共享主线程的虚拟地址空间（current->mm指向同一个地址），且都有自己的用户态堆栈（共享父进程的地址空间，再在里面分配自己的独立栈，默认2M）。这是毫无疑问的，但还有一点我没搞明白，内核栈是共享还是独立的？猜测：独立的。理由：要不然内核栈对应的thread_info中的tast_struct没有办法与每个线程对应起来，因为现在已经有多个task_struct了，但保存内核栈的thread_info（其实是thread_union联合体）中只能保存一个task_struct。所以理论上分析，虽然可以共享地址空间，但每个线程还是需要一个单独的内核栈的。看代码：分析创建线程最终肯定会走到内核函数do_fork()中来的，所以从此函数看起。do_fork()->_process()->p_task_struct()fork.c中p_task_struct()的实现：static struct task_struct *p_task_struct(struct task_struct *orig){struct task_struct *tsk;struct thread_info *ti;unsigned long *stackend;int node = tsk_fork_get_node(orig);int err;tsk = alloc_task_struct_node(node);if (!tsk)return NULL;ti = alloc_thread_info_node(tsk, node);/*就是这里，果然分配内核栈了*/if (!ti)goto free_tsk;err = arch_p_task_struct(tsk, orig);/*这里分配task_struct结构*/if (err)goto free_ti;tsk->stack = ti; ...}