linux线程栈的若干思考

        线程包含了表示其行环境必需的信息，其中包括进程中标示线程的线程ID，一组寄存器值，栈，调度优先级和策略， 信号屏蔽字，errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本，程序的全局内存和堆内存，栈以及文件描述符，所以线程的mm_struct *mm指针变量和所属进程的mm指针变量相同。我们知道在linux系统中，线程栈的默认大小为8M，这可以通过ulimit -s 命令查看，这个线程的大小也是可以更改的。下图的8192B就是8M.

下面让我们来在<<unix环境高级编程>>中涉及的几个关于线程栈的函数：

样例１：

#include <limits.h>  #include <string.h>  #include <pthread.h>  #include <stdlib.h>  #include <stdio.h>#include<iostream> #include <unistd.h>using namespace std;void *thread_fun(void* args){size_t stacksize;void *addr;int *p=(int *)args; pthread_attr_t thread_attr;pthread_attr_getstacksize(&thread_attr,&stacksize);cout<<"the size of stack is: "<<stacksize<<endl;return (void*)0;}int main(){pthread_t pid[3];int i=0;int a[3]={1,2,3};for(i=0;i<3;i++){pthread_create(&pid[i],NULL,thread_fun,(void *)&a[i]);cout<<"pthread id is: "<<pid[i]<<endl;}for(i=0;i<3;i++){pthread_join(pid[i],NULL);}return 0;}

输出结果：

我们可以看到其中有一个线程的堆栈大小为4001536字节约等于３.8Ｍ的大小，而其它两个大小为默认值8M，为什么会出现不想等的情况？？？？？

样例２：

#include <limits.h>  #include <string.h>  #include <pthread.h>  #include <stdlib.h>  #include <stdio.h>#include<iostream>#include <unistd.h>using namespace std;int main(){   pthread_t thread;   size_t stacksize;   pthread_attr_t thread_attr;   int ret;   void *addr;   pthread_attr_init(&thread_attr);   int new_size = 20480;   ret =  pthread_attr_getstack(&thread_attr,&addr,&stacksize);   if(ret != 0){       cout << "emError" << endl;       return -1;   }   cout << "stacksize=" << stacksize << endl<<"addr is: "<<addr<<endl;   cout << PTHREAD_STACK_MIN << endl;   ret = pthread_attr_setstacksize(&thread_attr,new_size);   if(ret != 0)return -1;   ret =  pthread_attr_getstack(&thread_attr,&addr,&stacksize);   if(ret != 0){       cout << "emError" << endl;       return -1;   }   cout << "after set stacksize=" << stacksize << endl;   cout<<"the address is: "<<addr<<endl;   ret = pthread_attr_destroy(&thread_attr);   if(ret != 0)return -1;   return 0;}

测试结果：

从上面的例子可以看出，当我们使用pthread_attr_getstack的时候获得的线程栈的大小为0，且地址也为0，不明白？？？

当我们做如下修改的时候(也就是将pthread_attr_getstack变成pthread_attr_getsize)：

int main(){   pthread_t thread;   size_t stacksize;   pthread_attr_t thread_attr;   int ret;   void *addr=NULL;   pthread_attr_init(&thread_attr);   int new_size = 20480;   ret =  pthread_attr_getstacksize(&thread_attr,&stacksize);   if(ret != 0){       cout << "emError" << endl;       return -1;   }   cout << "stacksize=" << stacksize << endl<<"addr is: "<<addr<<endl;   cout << PTHREAD_STACK_MIN << endl;   ret = pthread_attr_setstacksize(&thread_attr,new_size);   if(ret != 0)return -1;   ret =  pthread_attr_getstack(&thread_attr,&addr,&stacksize);   if(ret != 0){       cout << "emError" << endl;       return -1;   }   cout << "after set stacksize=" << stacksize << endl;   cout<<"the address is: "<<addr<<endl;   ret = pthread_attr_destroy(&thread_attr);   if(ret != 0)return -1;   return 0;}

当我们更改函数的时候就可以得到线程栈的大小。当我们修改线程栈的大小之后再调用pthread_attr_getstack时，就可以获得线程栈的地址，但是我们可以看到，此时线程栈的地址在内核空间，这是为什么？？？？？

样例３：

#include <limits.h>  #include <string.h>  #include <pthread.h>  #include <stdlib.h>  #include <stdio.h>#include <iostream>#include <unistd.h>#include <errno.h>using namespace std;int main(void){void *stackaddr;unsigned int stacksize;unsigned int guardsize;pthread_attr_t attr;if (pthread_attr_init(&attr) != 0){    printf("init attr failed.\n");    return -1;    }if (pthread_attr_getstacksize(&attr,&stacksize) == 0){    printf("default stacksize:0x%x\n",stacksize);    }if (pthread_attr_getstack(&attr,&stackaddr,&stacksize) == 0){    printf("default stacksize:0x%x,stack addr:%p\n",stacksize,stackaddr);    }    stacksize = 16*1024;if (pthread_attr_setstacksize(&attr,stacksize) != 0){    printf("set thread stack size failed,error:%s\n",strerror(errno));    return -1;    }if (pthread_attr_getstack(&attr,&stackaddr,&stacksize) == 0){    printf("after set stacksize,stacksize:0x%x,stack addr:%p\n",stacksize,stackaddr);    }if (pthread_attr_setstack(&attr,(void *)0x80000,stacksize) !=  0){    printf("set stack error:%s\n",strerror(errno));    }if (pthread_attr_getstack(&attr,&stackaddr,&stacksize) == 0){    printf("after setstack,stacksize:0x%x,stack addr:%p\n",stacksize,stackaddr);    }return 0;}

输出结果：

在样例３中我们指定了线程栈的大小和地址，所以输出的结果是0x4000和0x80000；这这个例子中，我们调用pthread_attr_getstack同样获得线程栈的大小为nil，也就是空。

所以总结上面的例子我的疑问有：

(1)为什么一开始调用pthread_attr_getstack不能获得线程栈的大小和线程栈的地址.

(2)在对线程栈进行设置之后(这里的设置仅仅限定栈的大小)，利用pthread_attr_getstack能够输出线程栈的大小和线程栈的地址，但此时线程栈的地址在内核空间？？？？

针对以上问题还希望大牛给出指导！！！！！！！！

补充知识：

用户栈和内核栈的切换：

　　当进程由于中断或系统调用从用户态转换到内核态时，进程所使用的栈也要从用户栈切换到内核栈。系统调用实质就是通过指令产生中断，称为软中断。进程因为中断（软中断或硬件产生中断），使得CPU切换到特权工作模式，此时进程陷入内核态，进程进入内核态后，首先把用户态的堆栈地址保存在内核堆栈中，然后设置堆
栈指针寄存器的地址为内核栈地址，这样就完成了用户栈向内核栈的切换。当进程从内核态切换到用户态时，最后把保存在内核栈中的用户栈地址恢复到CPU栈指针寄存器即可，这样就完成了内核栈向用户栈的切换。这里要理解一下内核堆栈。前面我们讲到，进程从用户态进入内核态时，需要在内核栈中保存用户栈的地址。那么进入内核态时，从哪里获得内核栈的栈指针呢？要解决这个问题，先要理解从用户态刚切换到内核态以后，进程的内核栈总是空的。这点很好理解，当进程在用户空间运行时，使用的是用户 栈；当进程在内核态运行时，内核栈中保存进程在内核态运行的相关信息，但是当进程完成了内核态的运行，重新回到用户态时，此时内核栈中保存的信息全部恢 复，也就是说，进程在内核态中的代码执行完成回到用户态时，内核栈是空的。理解了从用户态刚切换到内核态以后，进程的内核栈总是空的，那刚才这个问题就很好理解了，因为内核栈是空的，那当进程从用户态切换到内核态后，把内核栈的栈顶地址设置给CPU的栈指针寄存器就可以了。
在kernel-2.4内核里面，内核栈的实现是：
 Union task_union {
                   Struct task_struct task;
                   Unsigned long stack[INIT_STACK_SIZE/sizeof(long)];
 };
 其中，INIT_STACK_SIZE的大小只能是8K

在kernel-2.6内核里面，内核栈的实现是：
union thread_union {
 struct thread_info thread_info;
 unsigned long stack[THREAD_SIZE/sizeof(long)];
};
其中，THREAD_SIZE的值取8192时，stack数组的大小为2048；THREAD_SIZE的值取4096时，stack数组的大小为1024。现在我们应该思考，为何要将内核栈和thread_info（其实也就相当于task_struct，只不过使用thread_info结构更节省空间）紧密的放在一起？最主要的原因就是内核可以很容易的通过esp寄存器的值获得当前正在运行进程的thread_info结构的地址，进而获得当前进程描述符的地址;

struct thread_info {           struct task_struct  *task;      /* main task structure */           struct exec_domain  *exec_domain;   /* execution domain */           unsigned long       flags;      /* low level flags */           unsigned long       status;     /* thread-synchronous flags */           __u32           cpu;        /* current CPU */           int         preempt_count;  /* 0 => preemptable, <0 => BUG */              mm_segment_t        addr_limit; // thread address space: 0-0xBFFFFFFF for user-thead 0-0xFFFFFFFF for kernel-　　　　　　//thread*/           void            *sysenter_return;           struct restart_block    restart_block;           unsigned long           previous_esp;   /* ESP of the previous stack in  case of nested (IRQ) stacks */           __u8            supervisor_stack[0];       }; 

获取thread_info的地址(以下是内核栈的内存分配)：

从上面的内存分布来看，我们知道内核栈的大小为两个页面的大小(8KB)，esp指向的是内核堆栈的结尾，由于堆栈是向下增长的，esp和thread_info位于同一个8KB或者4KB的块当中。也就是thread_union的长度了。如果是8KB，屏蔽esp的低13位就可以得到thread_info的地址，也就是8KB块的开始位置。4KB的话，就屏蔽低12位.

下面是linux内核获得thread_info结构体地址的函数：

static inline struct thread_info *current_thread_info(void){  return (struct thread_info *)(current_stack_pointer & ~(THREAD_SIZE - 1));  } 

这个函数直接返回thread_info指针，当前的堆栈指针current_stack_pointer，也就是esp，THREAD_SIZE为块的字节大小8192或者是4096，这里假设值8192，十六进制的表示是0x00002000，二进制的表示是00000000000000000010000000000000~(THREAD_SIZE-1)的结果刚好为1111111111111111111 0000000000000，第十三位是全为零，也就是刚好屏蔽了esp的低十三位，最终得到的是thread_info的地址。