内存管理器（九）内核内存管理–进程相关数据结构

ゝ一世哀愁。 2022-08-09 18:54 203阅读 0赞

## 内存管理器（九）内核内存管理–进程相关数据结构 ##

### 前言 ###

前面的几篇博文都是在学习用户态内存管理，malloc与free 也研究了Glibc 的内存管理函数的实现，本来想点到位置，但是觉得还是太浅了，不够深入，遂决定，继续挖掘下去（读破万卷始见金嘛）。所以再次修改学习路线,希望最后能做出来一切实可用的东西。  
毕竟本科学习阶段主要还是在于掌握原理上的东西，真的很难做出什么有实际价值的东西，但是持续的造轮子也有助于我们学习和锻炼。  
基本上下来就按照两步走的策略。  
第一步：  
学习目标与目的：以学习kernel内存管理的思想为核心，主要是学习其数据结构设计和算法思想。  
实践方式：主要就是写内核模块看看在程序运行时，内存到底发生了什么。  
第二步：  
主要以实践为主，准备做一个内存的监控与调整程序。但是细节与需求还没有具体设计。先完成第一步，在这个过程中总结思考吧。

基本定于这个月内能完成第一步最好，但是最好能够完成吧，然而22号还有出去金工实习，，，，

### \_\_start ###

废话不多说，开始说正事。  
既然说到进程，就必须的说task\_struct .但是我想先说下pid\_t 这个类型，就先说下它吧，之前对它我还是有点疑惑的。本来还以为这是个什么结构体类型，今天正好看到源码就先说它吧。  
< typedef int \_\_kernel\_pid\_t; typedef \_\_kernel\_pid\_t pid\_t; 由此看出，pid\_t 就是整形。其实书上都写了，但是如果不是我亲眼看到，怎么都不放心，强迫症没办法。。 >

现在正式来说task\_struct  
在我的4.0.4 内核源码中仅仅task\_struct 这个进程描述符就有435行，所以我就部全部列举了，下面简要说几个重要的  
`struct task_struct{`

volatile long state; /\* -1 unrunnable, 0 runnable, >0 stopped \*/  
//进程的状态，-1：不可运行 0：可运行 >0 ：停止  
void \*stack; //栈  
atomic\_t usage;  
unsigned int flags; /\* per process flags, defined below \*/  
//每进程标志  
unsigned int ptrace;  
unsigned lock\_depth; /\*大内核锁深度\*/  
int on\_rq;

int prio, static\_prio, normal\_prio; //进程动态优先级，静态优先级，普通优先级  
unsigned int rt\_priority;  
const struct sched\_class \*sched\_class; //进程所有调用函数的集合  
struct sched\_entity se; //保存这进程的权重  
struct sched\_rt\_entity rt;

pid\_t pid; //进程ID  
pid\_t tgid;

struct task\_struct \_\_rcu \*real\_parent; /\* real parent process \*/（在被调试情况下）  
struct task\_struct \_\_rcu \*parent; /\* recipient of SIGCHLD, wait4() reports \*/

/\*  
\* children/sibling forms the list of my natural children  
\*/  
struct list\_head children; /\* list of my children \*///子进程链表  
struct list\_head sibling; /\* linkage in my parent’s children list \*/  
//兄弟进程链表  
struct task\_struct \*group\_leader; /\* threadgroup leader \*/

/\*  
\* ptraced is the list of tasks this task is using ptrace on.  
\* This includes both natural children and PTRACE\_ATTACH targets.  
\* p->ptrace\_entry is p’s link on the p->parent->ptraced list.  
\*/  
struct list\_head ptraced; //调试使用  
struct list\_head ptrace\_entry;

/\* PID/PID hash table linkage. \*/ //进程描述符和哈希表存储  
struct pid\_link pids\[PIDTYPE\_MAX\];  
struct list\_head thread\_group;  
struct list\_head thread\_node;

struct completion \*vfork\_done; /\* for vfork() \*/  
int \_\_user \*set\_child\_tid; /\* CLONE\_CHILD\_SETTID \*/  
int \_\_user \*clear\_child\_tid; /\* CLONE\_CHILD\_CLEARTID \*/

cputime\_t utime, stime, utimescaled, stimescaled; //和CPU时间相关的变量  
cputime\_t gtime;

struct rcu\_head rcu;

unsigned long nvcsw, nivcsw; /\* context switch counts \*/ //上下文切换次数  
u64 start\_time; /\* monotonic time in nsec \*/  
u64 real\_start\_time; /\* boot based time in nsec \*/ //记录启动时间  
/\* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific \*/  
unsigned long min\_flt, maj\_flt;

struct task\_cputime cputime\_expires;  
struct list\_head cpu\_timers\[3\];  
/\* process credentials \*/  
const struct cred \_\_rcu \*real\_cred; /\* objective and real subjective task  
\* credentials (COW) \*/  
const struct cred \_\_rcu \*cred; /\* effective (overridable) subjective task  
\* credentials (COW) \*/  
char comm\[TASK\_COMM\_LEN\]; /\* executable name excluding path 进程的名字  
– access with \[gs\]et\_task\_comm (which lock  
it with task\_lock())  
– initialized normally by setup\_new\_exec \*/  
/\* file system info \*/  
int link\_count, total\_link\_count;  
/\* ipc stuff \*/  
struct sysv\_sem sysvsem;  
struct sysv\_shm sysvshm;  
/\* filesystem information 文件系统信息\*/  
struct fs\_struct \*fs;  
/\* open file information \*/  
struct files\_struct \*files;  
/\* namespaces 命名空间\*/  
struct nsproxy \*nsproxy;  
/\* signal handlers 信号处理\*/  
struct signal\_struct \*signal;  
struct sighand\_struct \*sighand;

sigset\_t blocked, real\_blocked;  
sigset\_t saved\_sigmask; /\* restored if set\_restore\_sigmask() was used \*/  
struct sigpending pending;

unsigned long sas\_ss\_sp;  
size\_t sas\_ss\_size;  
int (\*notifier)(void \*priv);  
void \*notifier\_data;  
sigset\_t \*notifier\_mask;  
struct callback\_head \*task\_works;

struct audit\_context \*audit\_context;

/\*  
\* cache last used pipe for splice  
\*/  
struct pipe\_inode\_info \*splice\_pipe; //管道相关

struct page\_frag task\_frag;

以上就是进程描述符的基本内容。

当然这些都是静态的内核代码，我们可以从/proc 中看到更多关于进程相关信息的东西，比如每一个进程都有资源限制，且限制是动态的，此时我们就去看/proc/self/limits .就可以看到进程的限制

[![2015-11-03 23:00:22 的屏幕截图][2015-11-03 23_00_22]][2015-11-03 23_00_22 _2015-11-03 23_00_22]

这就是进程的限制参数了。

### 进程的类型 ###

进程一般就两个类型：

1.fork 产生的子进程

2.exec 从一个可执行二进制文件加载另一个应用程序。

两者区别就不多说了 ，很简单。

[2015-11-03 23_00_22]: http://zmr.lezifang.cn/wp-content/uploads/2015/11/2015-11-03-230022-%E7%9A%84%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE-300x128.png
[2015-11-03 23_00_22 _2015-11-03 23_00_22]: http://zmr.lezifang.cn/wp-content/uploads/2015/11/2015-11-03-230022-%E7%9A%84%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE.png