标签：内部命令 att 办公 nice 计算机系统 意思 记录 理解 unlikely
Linux系统一般有4个主要部分：内核、shell、文件系统和应用程序。内核、shell和文件系统一起形成了基本的操作系统结构，它们使得用户可以运行程序、管理文件并使用系统。
内核是系统的核心，是运行程序和管理诸如磁盘和打印机等硬件设备的核心程序。操作系统是一个用来和硬件打交道并为用户程序提供有限服务集的低级支撑软件。一个计算机系统是一个硬件和软件的共生体，它们相互依赖、不可分割。外围设备、处理器、内存、硬盘和其他的电子塞河北组成了计算机的发动机，但是如果没有软件来操作和控制它，硬件自身是不能工作的。完成这个控制工作的软件就称为操作系统。在Linux的术语中“内核”也称为“核心”。
Linux内核的主要模块分以下几个部分：存储管理、CPU和进程管理、文件系统、设备管理和驱动、网络通信，以及系统的初始化（引导）、系统调用等。内核最重要的部分就是内存管理和进程管理。
Shell是系统的用户界面，提供了用户与内核进行交互操作的一种接口。它接收用户输入的命令并把它送入内核。不仅如此，Shell有自己的编程语言用于对命令的编辑，它允许用户编写由Shell命令组成的程序。Shell编程语言具有普通编程语言的很多特点，比如它也有循环结构和分支控制结构等，用这种编程语言编写的Shell程序与其他应用程序具有同样的效果。
Shell中命令分为内部命令和外部命令，前者包含在Shell之中，如cd,exit等，查看内部命令可用help命令.后者存于文件系统某个目录下的具体可操作程序，如cp等。查看外部命令的路径可用which
Linux文件系统是文件存放在磁盘等存储设备上的组织方法。Linux能支持多种目前流行的文件系统。如EXT2、EXT3、FAT、VFAT、ISO9660、NFS、SMB等。
文件系统是Linux操作系统的重要组成部分，Linux文件具有强大的功能。文件系统中的文件是数据的集合，文件系统不仅包含着重要组成部分，所有Linux用户和程序看到的文件、目录、软连接及文件保护信息等都存储在其中。一个文件系统的好坏主要体现在对文件和目录的组织上。目录提供了管理文件的一个方便而有效的途径。使用Linux，用户可以设置目录和文件的权限，以便允许或拒绝其他人对其进行访问。Linux目录采用多级树形结构，用户可以浏览整个系统，可以进入任何一个已授权进入的目录，访问那里的文件。文件结构的相互关联性使共享数据变得容易，几个用户可以访问同一个文件。Linux是一个多用户系统，操作系统本身的驻留程序存放在从根目录开始的专用目录中，有时被指定为系统目录。
标准的Linux系统都有一整套称为应用程序的程序集，包括文本编辑器、编程语言、X-Window、办公套件、Internet工具、数据库等。
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体；进程是处于执行期的程序以及它所包含的所有资源的总称，包括虚拟处理器，虚拟空间，寄存器，堆栈，全局数据段等。
在Linux中，每个进程在创建时都会被分配一个数据结构，称为进程控制（Process Control Block，简称PCB）。PCB中包含了很多重要的信息，供系统调度和进程本身执行使用。所有进程的PCB都存放在内核空间中。PCB中最重要的信息就是进程PID，内核通过这个PID来唯一标识一个进程。PID可以循环使用，最大值是32768。init进程的pid为1，其他进程都是init进程的后代。
除了进程控制块（PCB）以外，每个进程都有独立的内核堆栈（8k），一个进程描述符结构，这些数据都作为进程的控制信息储存在内核空间中；而进程的用户空间主要存储代码和数据。
进程控制块PCB（Process Control Block）是进程存在和运行的唯一标志，在Linux中用task_struct这个结构体来表示。这个结构体中有很多数据项，查看源代码时没必要理解全部的数据项，只需要在以后使用时再理解。
1 struct task_struct 2 { 3 .... 4 };
下面重点介绍几个基本的数据项：
task_struct中用一个长整形state表示进程的状态。
1 volatile long state；
linux用一个32位无符号整形pid来简单的标识一个进程，用uid和gid分别来标识进程所属的用户和组。
1 pid_t pid; 2 uid_t uid; 3 gid_t gid;
pid的上限是由pid_max决定的。编译内核时会让选择0x1000和0x8000两种数值，即pid_max=4096和pid_max=32768两种。
1 struct list_head children; //子进程链表 2 struct list_head sibling; //兄弟进程链表 3 struct task_struct *real_parent; //真正创建当前进程的进程 4 struct task_struct *parent; //养父进程
当进程从用户态进入内核态时要使用位于内核数据段上的内核栈。
1 union thread_union 2 { 3 struct thread_info thread_info; 4 unsigned long stack[THERAD_SIZE/sizeof(long)];//内核栈，一般为8KB 5 };
内核中将task_struct的指针放在thread_info结构体中，而这个结构体又与内核栈一块被放在8KB的内核空间thread_union中。
1 struct thread_info{ 2 struct task_struct *task; 3 struct exec_domain *exec_domain; 4 ..... 5 };
每个task_struct中都有一个tasks的域来连接到进程链表上去。
1 struct task_struct{ 2 ... 3 struct list_head tasks; 4 ... 5 char comm[TASK_COMM_LEN];//可执行程序名 6 ... 7 };
而这个链表的头是init_task.它是0号进程的PCB，0号进程永远不会被撤销，它被静态的分配到内核数据段上。也就是Init_task的PCB是由编译器预先分配的，在程序运行的过程中一直存在，直到程序结束。
1 struct task_struct init_task = INIT_TASK(init_task);
可以编写以下内核模块，得到所有进程的pid和进程名，并统计出进程总数。
1 #include<linux/kernel.h> 2 #include<linux/init.h> 3 #include<linux/module.h> 4 #include<linux/sched.h> 5 6 MODULE_LICENSE("GPL"); 7 8 static int __init print_pid_init(void) 9 { 10 struct task_struct *task,*p; 11 struct list_head *pos; 12 int count = 0; 13 printk("Begin to print process :\n"); 14 task = &init_task; 15 list_for_each(pos,&task->tasks) 16 { 17 p = list_entry(pos,struct task_struct,tasks); 18 count++; 19 printk("%d ======> %s\n",p->pid,p->comm); 20 } 21 printk("the number of process is %d\n",count); 22 return 0; 23 } 24 static void __exit print_pid_exit(void) 25 { 26 printk("End to print process.\n"); 27 } 28 module_init(print_pid_init); 29 module_exit(print_pid_exit);
由于进程链表是将所有的进程连接到一个链表上去，所以查找一个进程的时间复杂度是O（N），是相当的低效。为此，使用哈希表来提高查找的效率。
1 static struct hlist_head *pid_hash;
学过数据结构的应该知道，哈希函数对整个查找是至关重要的，它决定了发生冲突的概率。好的哈希函数能够得到减少冲突。
1 #define pid_hashfn(nr, ns) \ 2 hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift)
1 #define hash_long(val, bits) hash_32(val, bits)
1 static inline u32 hash_32(u32 val, unsigned int bits) 2 { 3 /* On some cpus multiply is faster, on others gcc will do shifts */ 4 u32 hash = val * GOLDEN_RATIO_PRIME_32; 5 6 /* High bits are more random, so use them. */ 7 return hash >> (32 - bits); 8 }
1 /* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */ 2 #define GOLDEN_RATIO_PRIME_32 0x9e370001UL
内核并不能直接通过pid找到对应的task_struct，而是先通过pid找到对应的struct pid,在通过struct pid 找到对应的task_struct。
下面是详细介绍这两个的链接：
ii.struct pid 到task_struct的内核函数详解
与进程链表类似，task_struct也定义了一个连接到就绪队列的域run_list。
1 struct sched_rt_entity { 2 struct list_head run_list; 3 .... 4 }; 5 struct task_struct 6 { 7 .... 8 struct sched_rt_entity rt; 9 ...... 10 };
就绪队列头：
同样，内核中有一个就绪队列头runqueue_head。
1 typedef struct __wait_queue wait_queue_t; 2 struct __wait_queue { 3 unsigned int flags; 4 #define WQ_FLAG_EXCLUSIVE 0x01 5 void *private; 6 wait_queue_func_t func; 7 struct list_head task_list; 8 };
task_list链接到等待队列上去。
func是一个函数指针，指向唤醒等待队列中进程的函数。prviate是传递给func的参数，用于指定所要唤醒的进程。
1 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);
flags标志进程是否互斥：flags为WQ_FLAG_EXCLUSIVE 时互斥，否则，非互斥。
1 struct __wait_queue_head { 2 spinlock_t lock; 3 struct list_head task_list; 4 }; 5 typedef struct __wait_queue_head wait_queue_head_t;
因为等待队列是由中断处理程序和主要的内核函数修改的，因此要避免被同时访问。lock自旋锁对其进行同步，避免了双向链表被同时访问。task_list是双向链表的节点。
i. 初始化
首先，使用了下面的宏声明并初始化了一个等待队列头。
1 #define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \ 2 .lock = __SPIN_LOCK_UNLOCKED(name.lock), \ 3 .task_list = { &(name).task_list, &(name).task_list } } 4 5 #define DECLARE_WAIT_QUEUE_HEAD(name) \ 6 wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
如果要对列中一个元素初始化，要使用这个函数：
1 static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p) 2 { 3 q->flags = 0; 4 q->private = p; 5 q->func = default_wake_function;//default_wake_function能够唤醒睡眠的进程p，并将其从等待队列中删除。 6 }
ii.插入/删除
add_wait_queue()将一个非互斥进程插入到等待队列的第一个位置。
1 void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait) 2 { 3 unsigned long flags; 4 5 wait->flags &= ~WQ_FLAG_EXCLUSIVE; 6 spin_lock_irqsave(&q->lock, flags); 7 __add_wait_queue(q, wait); 8 spin_unlock_irqrestore(&q->lock, flags); 9 }
add_wait_queue_exclusive()将一个互斥进程插入到等待队列的最后一个位置 。
1 void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait) 2 { 3 unsigned long flags; 4 5 wait->flags |= WQ_FLAG_EXCLUSIVE; 6 spin_lock_irqsave(&q->lock, flags); 7 __add_wait_queue_tail(q, wait); 8 spin_unlock_irqrestore(&q->lock, flags); 9 }
之所以将非互斥进程放在队首，而将互斥进程放在队尾，大概是因为非互斥进程不需要临界资源，将它唤醒不会影响其它进程的执行，而互斥进程得到临界资源会导致别的进程无法执行。
remove_wait_queue()将一个进程从等待队列中删除。
1 void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait) 2 { 3 unsigned long flags; 4 5 spin_lock_irqsave(&q->lock, flags); 6 __remove_wait_queue(q, wait); 7 spin_unlock_irqrestore(&q->lock, flags); 8 }
iii.检查是否为空队列,直接调用了list.h中的list_empty()
1 static inline int waitqueue_active(wait_queue_head_t *q) 2 { 3 return !list_empty(&q->task_list); 4 }
iv.睡眠
1 sleep_on_common(wait_queue_head_t *q, int state, long timeout) 2 { 3 unsigned long flags; 4 wait_queue_t wait; 5 6 init_waitqueue_entry(&wait, current); 7 8 __set_current_state(state); 9 10 spin_lock_irqsave(&q->lock, flags); 11 __add_wait_queue(q, &wait); 12 spin_unlock(&q->lock); 13 timeout = schedule_timeout(timeout); 14 spin_lock_irq(&q->lock); 15 __remove_wait_queue(q, &wait); 16 spin_unlock_irqrestore(&q->lock, flags); 17 18 return timeout; 19 }
v.唤醒
1 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode, 2 int nr_exclusive, int wake_flags, void *key) 3 { 4 wait_queue_t *curr, *next; 5 6 list_for_each_entry_safe(curr, next, &q->task_list, task_list) { 7 unsigned flags = curr->flags; 8 9 if (curr->func(curr, mode, wake_flags, key) && 10 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive) 11 break; 12 } 13 }
为了更好地理解进程控制，我们需要知道进程状态这个概念。和其他普通事物一样，进程始终处于一系列的状态中，比如我们至少可以想象出“运行”，“休眠”之类的。
TASK_RUNNING：
可执行状态。这是 “进程正在被CPU执行” 和 “进程正在可执行队列中等待被CPU执行” 统称。也可以将它们拆开成“RUNNING”和“READY”两种状态。
TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE：
可中断的睡眠状态 和 不可中断的睡眠状态。处于睡眠状态的进程不会被调度到CPU进行执行，而是否可中断的意思是指进程是否会响应异步信号，如果是可中断的，当进程收到某个信号时其会重新回到TASK_RUNNING状态。值得注意的是，如果处于不可中断的睡眠状态时，进程将不响应异步信号，比如你无法“kill -9”。
TASK_STOPPED：
暂停状态。这里的STOPPED是指停止运行（暂停），而不是进程终止。向进程发送SIGSTOP信号可以让进程暂停下来，相反，发送SIGCONT可以将其从TASK_STOPPED状态唤醒而重新进入TASK_RUNNING状态。
TASK_TRACED：
被跟踪状态。一个进程被另一个进程“TRACE（跟踪）"最经典的例子是DEBUG，比如使用gdb或任何一款ide的debug功能。TASK_TRACED和TASK_STOPPED非常相近，都是让进程暂停下来，区别是不能通过向TASK_TRACED的进程发送SIGCONT信号让其恢复，只能由跟踪该进程的那个进程发送PTRACE_CONT,PTRACE_DETACH等，也就是说得让跟踪进程来决定是否挂起或继续被跟踪进程，当然，跟踪进程如果退出的话，被跟踪进程也会重新回到TASK_RUNNING状态。
TASK_DEAD：
僵尸状态。很搞笑的名字，之所以是“僵尸”而不是“死亡”是因为进程已不响应任何信号以及大部分相关数据已被清除，但其TASK_STRUCT结构仍存在，这个结构相当于进程的“躯壳”，还保留着一些信息，父进程可以利用这些信息得到进程终止前的一些状态。如果你看到某些文档上描写的ZOMBIE也是指的这个状态。
下图描述了进程各个状态之间的相互转化：
void _exit(int status) 与 void exit(int status)
这两个函数都是让进程退出， 参数status表示进程将以何种状态退出，在<stdlib.h>中预定义了一些状态，比如EXIT_SUCCESS(值为0)表示以成功状态退出，EXIT_FAILURE(值为1)表示以失败状态退出。
调用_exit函数时，其会关闭进程所有的文件描述符，清理内存以及其他一些内核清理函数，但不会刷新流(stdin, stdout, stderr ...). exit函数时在_exit函数之上的一个封装，其会调用_exit，并在调用之前先刷新流。
参考下面这段代码：
1 #include <stdio.h> //for printf(const char *) 2 #include <unistd.h> //for fork() 3 #include <sys/wait.h> //for wait(int *) 4 #include <stdlib.h> //for EXIT_SUCCESS 5 6 7 int main () 8 { 9 printf("app start...\n"); 10 11 if(fork() == 0) 12 { 13 printf("do something in child process ...\n"); 14 15 exit(EXIT_SUCCESS); 16 17 printf("this will not been executed\n"); 18 } 19 20 int status; 21 wait(&status); 22 23 printf("app end\n"); 24 25 return 0; 26 }
上面的代码无论时用exit还是_exit输出结果都如下：
1 app start... 2 do something in child process ... 3 app end
这是因为stdout缓冲区是按行缓冲的，当遇到换行符时会刷新当前缓冲区，所以当进程退出前即便_exit不刷新，"do somethign in child process "这句话仍然被输出到了屏幕上。
现在我们将使用不带换行符的printf, 并且也不调用fflush之类的函数，在使用_exit试试：
1 #include <stdio.h> //for printf(const char *) 2 #include <unistd.h> //for fork() 3 #include <sys/wait.h> //for wait(int *) 4 #include <stdlib.h> //for EXIT_SUCCESS 5 6 7 int main () 8 { 9 printf("app start...\n"); 10 11 if(fork() == 0) 12 { 13 printf("do something in child process ..."); 14 15 _exit(EXIT_SUCCESS); 16 17 printf("this will not been executed\n"); 18 } 19 20 int status; 21 wait(&status); 22 23 printf("app end\n"); 24 25 return 0; 26 }
输出结果为：
1 app start... 2 app end
如果换成exit则输出结果为：
1 app start... 2 do something in child process ...app end
void abort ()
非正常地退出进程。其会产生一个SIGABORT信号(关于信号，会在下一篇“进程间通信”介绍)，然后使进程戛然而止，也就意外着其不会进行清理工作, 但它会刷新缓冲区。
1 #include <stdio.h> //for printf() 2 #include <unistd.h> //for fork() 3 #include <sys/wait.h> //for wait() 4 #include <stdlib.h> //for EXIT_SUCCESS 5 6 int main () 7 { 8 printf("app start...\n"); 9 10 if(fork() == 0) 11 { 12 printf("do something in child process ..."); 13 14 abort(); 15 16 printf("this will not been executed\n"); 17 } 18 19 int status; 20 wait(&status); 21 22 printf("app end\n"); 23 24 return 0; 25 }
输出为：
1 app start... 2 do something in child process ...app end
void atexit( void (*f) () )
如果想在进程正常结束之前干一点自定义的事情，就可以调用这个函数. 其简单地利用你传入的函数指针执行一个函数回调。
值得注意的是：其仅仅在调用exit函数结束进程或进程执行完所有代码后自然结束这两种状态下，回调函数才会被执行，也就是说如果进程是被_exit或abort结束的，则atexit函数无效。
1 #include <stdio.h> //for printf() 2 #include <unistd.h> //for fork() 3 #include <sys/wait.h> //for wait() 4 #include <stdlib.h> //for EXIT_SUCCESS 5 6 void before_exit() 7 { 8 printf("1,2,3 exit!\n"); 9 } 10 11 int main () 12 { 13 printf("app start...\n"); 14 15 if(fork() == 0) 16 { 17 printf("do something in child process ...\n"); 18 19 void (*f)() = before_exit; 20 atexit(f); 21 22 exit(EXIT_SUCCESS); 23 24 printf("this will not been executed\n"); 25 } 26 27 int status; 28 wait(&status); 29 30 printf("app end\n"); 31 32 return 0; 33 }
输出为：
1 app start... 2 do something in child process ... 3 1,2,3 exit! 4 app end
int pause()
暂停进程，可以使用pause函数，其会挂起当前进程直到有信号来唤醒或者进程被结束。
随便提一下，如果你仅仅需要简单地暂停一下（press any key to continue...）, 可以使用 system("pause")这个系统调用，甚至是getch()之类的。
关于pause这个函数的Demo和更详细的理解，由于其会涉及到比较多与“信号”相关的知识，所以我打算放到下一篇“进程间通信”来讲
unsigned sleep(unsigned seconds)
int usleep(useconds_t useconds)
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
sleep系列函数都是让进程挂起一段时间，sleep只能精确到秒，usleep能精确到微妙，而nanosleep传说精度更高。
long ptrace(/*some args*/)
要像debug程序一样去跟踪进程，是一个比较复杂的问题。
大家经常看到的关于waitpid的经典例子是：你下载了某个软件的安装程序A，其在安装即将结束时启动了另外一个流氓软件的安装程序B，当B也安装结束后，其告诉你所有安装成功了。A和B分别在不同的进程中，A如何启动B并知道B安装完成了呢？可以很简单地在A中用fork启动B，然后用waitpid(或wait)来等待B的结束。
pid_t waitpid(pid_t pid, int *stat_loc, int options);
参数pid：
如果大于0，表示父进程所需要等待的子进程的进程号
如果等于0，则表示任意任意group id和父进程相同的子进程
如果等于-1, 则表示等待任意子进程（有多个子进程时，任意进程结束，函数都会返回），此时waitpid和wait相同。
如果小于－1，则取其绝对值作为需要等待的子进程的进程号
参数stat_loc:
表示进程退出时进程状态的存储位置，有一些专门的宏类根据该位置计算状态值，可以参考这里。
参数options:
这个参数控制函数是否立即返回，它有三个值：0，WNOHANG（值为1），WUNTRACED（值为2），这三个值多少让有有些迷惑，有个帖子中是如此说的：options的各个常量不是互斥关系，而是通过按位或运算组合起来的关系。进程的状态数是有限的，所有的进程状态改变可能性，是一个元素个数有限的集合，waitpid中指定的子进程的状态改变，必然是这个集合的子集，记为A。options决定如何取A中的元素，默认时(0)，只有A不是空集的时候，才会返回，否则阻塞。WNOHANG 告诉waitpid，即使A是空集，也不会挂起，而是立即返回。WUNTRACED 告诉waitpid，如果A中含有进程STOPED状态，也立即返回。如果是被trace的子进程，那么即使不提供WUNTRACED参数，也会理解返回。
另外，关于waitpid和wait的关系： wait(&status) 等于 waitpid(-1, &status, 0)
1 #include <stdio.h> //for printf() 2 #include <unistd.h> //for fork() 3 #include <sys/wait.h> //for wait() 4 #include <stdlib.h> //for EXIT_SUCCESS 5 6 7 int main () 8 { 9 printf("app start...\n"); 10 11 printf("do something in main process\n"); 12 13 sleep(5); 14 15 if(fork() == 0) 16 { 17 printf("do something in child process ...\n"); 18 19 sleep(5); 20 21 exit(EXIT_SUCCESS); 22 23 printf("this will not been executed\n"); 24 } 25 26 int status; 27 wait(&status); 28 29 printf("app end\n"); 30 31 return 0; 32 }
wait的另外一个用途是替子进程“收尸”，这有点难听，但是一个恰当的比喻。我们知道，当进程结束后，进程的大部分资源会被回收，比如释放内存，关闭描述符等，但表示进程的那个结构体STRUCT_TASK却还存在，此时的进程相当于“灵魂已亡，尸体犹在”，所以称之为ZOMBIE状态，这个结构体存在是有它的意义的，因为进程在退出前会讲一些信息保存在其中，父进程可以在wait或waitpid中得到这个结构体并取得相关信息，最后在讲结构体销毁，子进程彻底地消失了。 关于僵尸进程，更多地可以看这里。
很多书中将进程分为CPU密集型和I/O密集型，另外还有一种分法：
Linux中调度算法可以明确所有实时程序的身份，但没法区分交互式程序和批处理程序。Linux实现了基于进程过去行为的启发式算法以确定进程应被当作交互式进程还是批处理进程，相比批处理进程，调度程序偏爱调度交互式进程。
Linux2.6实现了一个O(1)的调度程序，本博文主要就是要介绍这个算法，Linux将进程分为下面三种：
不同的进程对应的调度算法有很大的区别。
每个普通进程都有自己的静态优先级，内核用从100（最高优先级）到139（最低优先级）的数来表示普通进程的静态优先级。新进程总是继承父进程的静态优先级，用户可以改变自己拥有进程的静态优先级，通过nice()和setpriority()。
静态优先级的本质上决定了进程的基本时间片，静态优先级和基本时间片的关系用下面的公式确定：
基本时间片(ms) = (140 – 静态优先级) X 20 若静态优先级<120
基本时间片(ms) = (140 – 静态优先级) X 5 若静态优先级>=120
普通进程除了静态优先级还有动态优先级，其值范围是100~139，动态优先级是调度程序在选择新进程来运行时使用的数，它与静态优先级的关系如下：
动态优先级=max(100, min(静态优先级 – bonus + 5, 139))
bonus是范围从0~10的值，值小于5表示降低优先级以示惩罚，值大于5表示增加优先级以示奖赏。bonus的值依赖于进程的平均睡眠时间。
Linux使用平均睡眠时间来确定进程时交互式进程还是批处理进程，如果满足下面的公式则被看做是交互式进程，否则为批处理进程。
动态优先级<= 3 X 静态优先级 / 4 + 28
即 bonus – 5 >= 静态优先级/4 – 28
另外，表达式 静态优先级/4 – 28 被称为交互式的δ。基本上可以理解成将睡眠时间较长的进程可以看做交互式进程（因为一直在等待I/O）。
为了使低优先级的进程也能够被CPU调度，以免总被高优先级的进程饿死，当一个进程用完它的时间片后，应该被还没用完时间片的低优先级进程取代，为了实现这这种机制，调度程序维护两个不想交的可运行进程的集合。
不过因为调度程序试图提升交互式进程（并不一定是优先级高，而是睡眠时间相对较多的进程）的性能，用完其时间片的活动批处理进程进入过期进程，而交互式进程仍然是活动进程，调度程序会重新装填它的时间片。但是如果最老的过期进程已经等待了很长的时间，或者过期进程中比交互式进程的静态优先级高，调度程序就把用完时间片的交互式进程移到过期进程集合中。最终活动进程变为空，过期进程将有机会运行。
每个实时进程都与一个实时优先级相关，实时优先级是一个范围从1（最高优先级）到99（最低优先级）的值。调度程序总是让优先级高的进程运行，与普通进程不同，实时进程总是被当做活动进程（不考虑低优先级的进程饥饿问题）。只有发生下面是事件之一时实时进程才会被另一个进程取代：
基于时间片轮转的实时进程的时间片长度与实时进程的优先级无关，只与进程的静态优先级有关，关系见4.2的公式。
既然是从源码深入了解调度程序，那一定要从数据结构开始分析，然后再看Linux如何实现/优化调度。
运行队列runqueue
runqueue是2.6调度最重要的数据结构，系统中每个CPU拥有自己的运行队列，定义如下：
1 struct runqueue { 2 spinlock_t lock; 3 4 /* 5 * nr_running and cpu_load should be in the same cacheline because 6 * remote CPUs use both these fields when doing load calculation. 7 */ 8 unsigned long nr_running; 9 unsigned long cpu_load; 10 unsigned long long nr_switches; 11 12 /* 13 * This is part of a global counter where only the total sum 14 * over all CPUs matters. A task can increase this counter on 15 * one CPU and if it got migrated afterwards it may decrease 16 * it on another CPU. Always updated under the runqueue lock: 17 */ 18 unsigned long nr_uninterruptible; 19 20 unsigned long expired_timestamp; 21 unsigned long long timestamp_last_tick; 22 task_t *curr, *idle; 23 struct mm_struct *prev_mm; 24 prio_array_t *active, *expired, arrays[2]; 25 int best_expired_prio; 26 atomic_t nr_iowait; 27 28 struct sched_domain *sd; 29 30 /* For active balancing */ 31 int active_balance; 32 int push_cpu; 33 34 task_t *migration_thread; 35 struct list_head migration_queue; 36 };
系统中每个可运行进程属于且只属于一个运行队列，所以每个进程只能运行在拥有该运行队列的CPU上，但是linux可以将进程从一个运行队列迁移到另一个运行队列。
简单解释一下每个字段：
稍微解释一下活动进程和过期进程的设计，arrays声明了一个prio_array_t结构数组，active指向其中一个作为运行进程队列链表，expired就指向另一个作为过期进程队列链表，如此反复切换只有修改指针值的开销，拥有很高的效率。
运行队列链表prio_array_t
1 struct prio_array { 2 unsigned int nr_active; 3 unsigned long bitmap[BITMAP_SIZE]; 4 struct list_head queue[MAX_PRIO]; 5 }; 6 typedef struct prio_array prio_array_t; 7 8 /* 进程描述符中的prio_array_t */ 9 struct task_t{ 10 .... 11 prio_array_t *array; 12 .... 13 };
进程描述符task_t
这个结构包含了进城相关的所有数据结构，去掉一些调试用的仍然有一百多项，因此只说明和调度程序有关的一些字段。
1 struct task_struct { 2 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */ 3 struct thread_info *thread_info; 4 int prio, static_prio; 5 struct list_head run_list; 6 prio_array_t *array; 7 unsigned long sleep_avg; 8 unsigned long long timestamp, last_ran; 9 int activated; 10 unsigned long policy; 11 cpumask_t cpus_allowed; 12 unsigned int time_slice, first_time_slice; 13 unsigned long rt_priority; 14 ...... 15 }; 16 typedef struct task_struct task_t;
挑一些和调度相关的字段注释一下：
在每次硬件时钟节拍到来时，中断处理函数中会调用本函数，本函数更新当前进程的时间片，如果需要重新调度会设置标志位，函数如下（注释直接放在代码中）
1 void scheduler_tick(void) 2 { 3 /* 获得CPU编号 */ 4 int cpu = smp_processor_id(); 5 /* 获得当前CPU的运行队列 */ 6 runqueue_t *rq = this_rq(); 7 /* 获得当前正在运行的进程 */ 8 task_t *p = current; 9 10 /* sched_clock()返回被转化为纳秒的64寄存器TSC 11 * 更新timestampt_last_tick，此字段即为最后一次定时器中断的时间戳 12 */ 13 rq->timestamp_last_tick = sched_clock(); 14 15 /* 如果当前进程是当前CPU的swapper进程 */ 16 if (p == rq->idle) { 17 /* 18 * 如果有其他进程，则设置TIF_NEED_RESCHED字段 19 * 如果没有待运行进程，标志为空闲状态退出 20 */ 21 if (wake_priority_sleeper(rq)) 22 goto out; 23 /* 这个函数在后面介绍，维持多处理器中运行队列的平衡 */ 24 rebalance_tick(cpu, rq, SCHED_IDLE); 25 return; 26 } 27 28 /* 29 * 如果当前进程所在运行队列链表(prio_array_t类型)不等于运行队列的运行队列， 30 * 则说明当前进程应该停止运行，强制重新调度。 31 */ 32 if (p->array != rq->active) { 33 set_tsk_need_resched(p); 34 goto out; 35 } 36 spin_lock(&rq->lock); 37 38 /* 是否为实时进程 */ 39 if (rt_task(p)) { 40 /* 如果时间片轮转实时进程时间片用完 */ 41 if ((p->policy == SCHED_RR) && !--p->time_slice) { 42 /* 使用前面的公式计算时间片长度 */ 43 p->time_slice = task_timeslice(p); 44 /* 时间片用完，将标志位去除 */ 45 p->first_time_slice = 0; 46 /* 设置TIF_NEED_RESCHED标志 */ 47 set_tsk_need_resched(p); 48 49 /* 将进程加入活动进程队列队尾，使其他同优先级的实时进程得以运行 */ 50 requeue_task(p, rq->active); 51 } 52 goto out_unlock; 53 } 54 /* 普通进程执行 */ 55 if (!--p->time_slice) { 56 /* 如果时间片用完，则将进程从活动进程队列中移除 */ 57 dequeue_task(p, rq->active); 58 /* 设置需要重新调度 */ 59 set_tsk_need_resched(p); 60 /* 重新计算动态优先级 */ 61 p->prio = effective_prio(p); 62 /* 重新分配时间片 */ 63 p->time_slice = task_timeslice(p); 64 /* 将第一次时间片标志位置0 */ 65 p->first_time_slice = 0; 66 67 /* 如果过期进程队列为空，则将最老被插入的进程的插入时间更新 */ 68 if (!rq->expired_timestamp) 69 rq->expired_timestamp = jiffies; 70 /* 71 * 将当前进程插入活动进程或者过期进程， 72 * TASK_INTERACTIVE判断是否是交互式进程， 73 * EXPIRED_STARVING判断过期进程是否等待太久或者有优先级更高的进程 74 * 75 * 那么这个判断就是如果当前进程是批处理进程或者过期进程已经等待太长时间 76 * 或者等待进程中有优先级更高的进程时， 77 * 将当前进程加入过期进程； 78 * 否则将当前进程重新加入活动进程 */ 79 if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) { 80 /* 插入过期进程 */ 81 enqueue_task(p, rq->expired); 82 /* 更新过期进程的最高优先级 */ 83 if (p->static_prio < rq->best_expired_prio) 84 rq->best_expired_prio = p->static_prio; 85 } else 86 /* 插入活动进程 */ 87 enqueue_task(p, rq->active); 88 } else { 89 /* 时间片未用完，检查剩余时间片是否过长，如果是则将当前进程置到队列队尾， 90 * 然后设置重新调度标志位。 */ 91 if (TASK_INTERACTIVE(p) && !((task_timeslice(p) - 92 p->time_slice) % TIMESLICE_GRANULARITY(p)) && 93 (p->time_slice >= TIMESLICE_GRANULARITY(p)) && 94 (p->array == rq->active)) { 95 96 requeue_task(p, rq->active); 97 set_tsk_need_resched(p); 98 } 99 } 100 out_unlock: 101 spin_unlock(&rq->lock); 102 out: 103 rebalance_tick(cpu, rq, NOT_IDLE); 104 }
将进程设置为TASK_RUNNING，并把进程插入某个CPU的运行队列来唤醒睡眠或停止的进程，代码和注释如下。
1 /*** 2 * try_to_wake_up - 唤醒一个进程 3 * @p: 带唤醒进程 4 * @state: 可以被唤醒的进程状态 5 * @sync: 同步唤醒标志 6 * 7 * 如果进程已经是激活状态则返回0 8 */ 9 static int try_to_wake_up(task_t * p, unsigned int state, int sync) 10 { 11 int cpu, this_cpu, success = 0; 12 unsigned long flags; 13 long old_state; 14 runqueue_t *rq; 15 unsigned long load, this_load; 16 struct sched_domain *sd; 17 int new_cpu; 18 19 /* task_rq_lock函数会禁用本地中断， 20 * 并根据进程最后在哪个CPU上运行，获取该CPU运行队列 */ 21 rq = task_rq_lock(p, &flags); 22 /* 保存进程旧状态 */ 23 old_state = p->state; 24 /* 如果旧状态不属于允许唤醒进程的状态掩码，则无法唤醒 */ 25 if (!(old_state & state)) 26 goto out; 27 28 /* 如果进程已经属于某个运行队列，则设置state为TASK_RUNNING后结束 */ 29 if (p->array) 30 goto out_running; 31 32 /* 获取之前运行p的CPU和当前CPU编号 */ 33 cpu = task_cpu(p); 34 this_cpu = smp_processor_id(); 35 36 /* 如果p进程正在运行, rq->curr == p */ 37 if (unlikely(task_running(rq, p))) 38 goto out_activate; 39 40 new_cpu = cpu; 41 42 /* 如果当前CPU和进程之前运行所在的CPU相同或者进程p不允许运行在当前CPU上 43 * 那么直接将p放在p原来运行的CPU上。*/ 44 if (cpu == this_cpu || unlikely(!cpu_isset(this_cpu, p->cpus_allowed))) 45 goto out_set_cpu; 46 47 /* 进入这里则表示当前CPU和之前运行p的CPU不是同一个CPU，且p可以在当前CPU上运行 */ 48 49 /* 获取运行p进程原CPU的负载猜测，两种算法取较小值 */ 50 load = source_load(cpu); 51 /* 获取当前CPU的负载猜测，两种算法取较大值 */ 52 this_load = target_load(this_cpu); 53 54 /* 如果设置同步标志则当前cpu负载降低 */ 55 if (sync) 56 this_load -= SCHED_LOAD_SCALE; 57 58 /* 如果先前执行进程的CPU工作量远小于当前CPU，则运行在原CPU上 */ 59 if (load < SCHED_LOAD_SCALE/2 && this_load > SCHED_LOAD_SCALE/2) 60 goto out_set_cpu; 61 62 new_cpu = this_cpu; 63 64 for_each_domain(this_cpu, sd) { 65 unsigned int imbalance; 66 /* 当到达imbalance_pct限制时，开始被动平衡 */ 67 imbalance = sd->imbalance_pct + (sd->imbalance_pct - 100) / 2; 68 69 if ((sd->flags & SD_WAKE_AFFINE) && 70 !task_hot(p, rq->timestamp_last_tick, sd)) { 71 /* 72 * 这个域有SD_WAKE_AFFINE标志，并且p进程的缓存可能可以用 */ 73 if (cpu_isset(cpu, sd->span)) { 74 goto out_set_cpu; 75 } 76 } else if ((sd->flags & SD_WAKE_BALANCE) && 77 imbalance*this_load <= 100*load) { 78 /* 这个域有SD_WAKE_BALANCE标志并且有不平衡发生 */ 79 if (cpu_isset(cpu, sd->span)) { 80 goto out_set_cpu; 81 } 82 } 83 } 84 85 new_cpu = cpu; /* 没找到合适的CPU，那么使用原CPU */ 86 87 /* 将进程放进new_cpu对应的运行队列 */ 88 out_set_cpu: 89 /* 检查是否有空闲CPU，如果有空闲CPU直接让p运行在空闲CPU上 */ 90 new_cpu = wake_idle(new_cpu, p); 91 if (new_cpu != cpu) { 92 set_task_cpu(p, new_cpu); 93 task_rq_unlock(rq, &flags); 94 /* might preempt at this point */ 95 rq = task_rq_lock(p, &flags); 96 old_state = p->state; 97 if (!(old_state & state)) 98 goto out; 99 if (p->array) 100 goto out_running; 101 102 this_cpu = smp_processor_id(); 103 cpu = task_cpu(p); 104 } 105 106 /* 处理进程激活的标志位 */ 107 out_activate: 108 if (old_state == TASK_UNINTERRUPTIBLE) { 109 /* 进程已经不处于TASK_UNINTERRUPTIBLE状态，更新原运行队列的状态 */ 110 rq->nr_uninterruptible--; 111 p->activated = -1; 112 } 113 114 /* 115 * activate_task函数的作用： 116 * 1、获取以纳秒为单位的当前时间戳，如果CPU不是本地CPU会补偿偏差 117 * 2、调用recalc_task_prio重新计算出动态描述符，见下一个函数 118 * 3、设置p->activated字段的值 119 * 4、把当前进程描述符插入活动进程集合 120 * */ 121 activate_task(p, rq, cpu == this_cpu); 122 /* 123 * 如果没有设置sync标志或者目标CPU不是本地CPU，检查新进程的动态优先级是否高于 124 * rq运行队列当前正在运行的进程，则强制调度。 */ 125 if (!sync || cpu != this_cpu) { 126 if (TASK_PREEMPTS_CURR(p, rq)) 127 resched_task(rq->curr); 128 } 129 success = 1; 130 131 out_running: 132 p->state = TASK_RUNNING; 133 out: 134 task_rq_unlock(rq, &flags); 135 136 return success; 137 }
更新进程的平均睡眠时间和动态优先级，它接受进程描述符p和由函数sched_clock()计算出来的当前时间戳now作为参数。
1 static void recalc_task_prio(task_t *p, unsigned long long now) 2 { 3 unsigned long long __sleep_time = now - p->timestamp; 4 unsigned long sleep_time; 5 6 /* 计算上次睡眠时间 */ 7 if (__sleep_time > NS_MAX_SLEEP_AVG) 8 sleep_time = NS_MAX_SLEEP_AVG; 9 else 10 sleep_time = (unsigned long)__sleep_time; 11 12 if (likely(sleep_time > 0)) { 13 if (p->mm && p->activated != -1 && 14 sleep_time > INTERACTIVE_SLEEP(p)) { 15 /* 进程不是从uninterruptible状态被唤醒，并且睡眠时间大于交互式进程的睡眠时间 16 * 更新睡眠时间为最大睡眠时间减去一个标准进程的基本睡眠时间片长度，这是一个经验值 */ 17 p->sleep_avg = JIFFIES_TO_NS(MAX_SLEEP_AVG - 18 DEF_TIMESLICE); 19 } else { 20 /* 如果平均睡眠时间越短，sleep_time则越大 */ 21 sleep_time *= (MAX_BONUS - CURRENT_BONUS(p)) ? : 1; 22 23 if (p->activated == -1 && p->mm) { 24 if (p->sleep_avg >= INTERACTIVE_SLEEP(p)) 25 /* 如果进程原来处于TASK_UNINTERRUPTIBLE状态，且是交互式进程，则睡眠时间置为0 */ 26 sleep_time = 0; 27 else if (p->sleep_avg + sleep_time >= 28 INTERACTIVE_SLEEP(p)) { 29 /* 如果进程原来处于TASK_UNINTERRUPTIBLE状态，且是批处理进程，将平均睡眠时间设为极限值 */ 30 p->sleep_avg = INTERACTIVE_SLEEP(p); 31 sleep_time = 0; 32 } 33 } 34 35 /* 加上睡眠时间 */ 36 p->sleep_avg += sleep_time; 37 38 if (p->sleep_avg > NS_MAX_SLEEP_AVG) 39 p->sleep_avg = NS_MAX_SLEEP_AVG; 40 } 41 } 42 43 /* 使用前文介绍的公式计算动态优先级 */ 44 p->prio = effective_prio(p); 45 }
实现调度程序，它的任务是从运行队列的链表中找到一个进程，并将CPU分配给这个进程。schedule()可以由几个内核控制路径调用。
直接调用
如果current进程因不能获得必要的资源而要立刻被阻塞，就直接调用调度程序。在这种情况下，要阻塞进程的内核路径按以下步骤执行：
延迟调用
把当前进程的TIF_NEED_RESCHED标志置为1，而以延迟方式调用调度程序。由于用户总是在恢复用户态进程的执行之前检查这个标志的值，所以schedule()将在不久之后某个时间被明确地调用。以下是典型的例子：
1 asmlinkage void __sched schedule(void) 2 { 3 long *switch_count; 4 task_t *prev, *next; 5 runqueue_t *rq; 6 prio_array_t *array; 7 struct list_head *queue; 8 unsigned long long now; 9 unsigned long run_time; 10 int cpu, idx; 11 12 /* 13 * Test if we are atomic. Since do_exit() needs to call into 14 * schedule() atomically, we ignore that path for now. 15 * Otherwise, whine if we are scheduling when we should not be. 16 */ 17 if (likely(!current->exit_state)) { 18 if (unlikely(in_atomic())) { 19 printk(KERN_ERR "scheduling while atomic: " 20 "%s/0x%08x/%d\n", 21 current->comm, preempt_count(), current->pid); 22 dump_stack(); 23 } 24 } 25 profile_hit(SCHED_PROFILING, __builtin_return_address(0)); 26 27 need_resched: 28 /* 关闭本地中断，当前current赋值给prev，释放内核锁 */ 29 preempt_disable(); 30 prev = current; 31 release_kernel_lock(prev); 32 need_resched_nonpreemptible: 33 rq = this_rq(); 34 35 now = sched_clock(); 36 if (likely(now - prev->timestamp < NS_MAX_SLEEP_AVG)) 37 run_time = now - prev->timestamp; 38 else 39 run_time = NS_MAX_SLEEP_AVG; 40 run_time /= (CURRENT_BONUS(prev) ? : 1); 41 42 spin_lock_irq(&rq->lock); 43 44 if (unlikely(prev->flags & PF_DEAD)) 45 prev->state = EXIT_DEAD; 46 47 switch_count = &prev->nivcsw; 48 if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) { 49 switch_count = &prev->nvcsw; 50 if (unlikely((prev->state & TASK_INTERRUPTIBLE) && 51 unlikely(signal_pending(prev)))) 52 /* 如果是可打断的状态且有信号到达，则进入重新修改为可运行状态 */ 53 prev->state = TASK_RUNNING; 54 else { 55 if (prev->state == TASK_UNINTERRUPTIBLE) 56 rq->nr_uninterruptible++; 57 /* 如果prev是不可打断地状态则将其从运行队列中删除 58 * 函数让rq进程数减一，删除prev，使prev->array=NULL */ 59 deactivate_task(prev, rq); 60 } 61 } 62 63 cpu = smp_processor_id(); 64 if (unlikely(!rq->nr_running)) { 65 go_idle: 66 /* 无可运行进程，从其他运行队列迁移一些可运行进程到本地 */ 67 idle_balance(cpu, rq); 68 if (!rq->nr_running) { 69 /* 如果依然没有进程，则运行swapper进程 */ 70 next = rq->idle; 71 rq->expired_timestamp = 0; 72 wake_sleeping_dependent(cpu, rq); 73 74 /* swapper进程结束后也许有新的进程 */ 75 if (!rq->nr_running) 76 goto switch_tasks; 77 } 78 } else { 79 if (dependent_sleeper(cpu, rq)) { 80 /* 检查本CPU最高优先级的进程是否比其他CPU上正在运行的进程优先级低 81 * 如果是则运行swapper进程。 82 */ 83 next = rq->idle; 84 goto switch_tasks; 85 } 86 if (unlikely(!rq->nr_running)) 87 goto go_idle; 88 } 89 90 /* 已经有可运行进程 */ 91 array = rq->active; 92 if (unlikely(!array->nr_active)) { 93 /* 如果活动进程中没有进程，则将过期进程和活动进程交换 */ 94 rq->active = rq->expired; 95 rq->expired = array; 96 array = rq->active; 97 rq->expired_timestamp = 0; 98 rq->best_expired_prio = MAX_PRIO; 99 } 100 101 /* 寻找最高优先级（数字最小）不为空的链表下标 */ 102 idx = sched_find_first_bit(array->bitmap); 103 /* 对应最高优先级的活动进程链表头 */ 104 queue = array->queue + idx; 105 next = list_entry(queue->next, task_t, run_list); 106 107 if (!rt_task(next) && next->activated > 0) { 108 unsigned long long delta = now - next->timestamp; 109 110 /* 进程原来处于TASK_INTERRUPTIBLE，被系统调用或内核线程唤醒的 111 * 增加睡眠时间，间接增加动态优先级 */ 112 if (next->activated == 1) 113 delta = delta * (ON_RUNQUEUE_WEIGHT * 128 / 100) / 128; 114 115 array = next->array; 116 dequeue_task(next, array); 117 recalc_task_prio(next, next->timestamp + delta); 118 enqueue_task(next, array); 119 } 120 next->activated = 0; 121 switch_tasks: 122 /* 准备切换进程 */ 123 124 /* 将next进程描述符装入硬件高速缓存 */ 125 prefetch(next); 126 /* 清除prev的TIF_NEED_RESCHEHD标志 */ 127 clear_tsk_need_resched(prev); 128 /* 记录CPU正在经历静态状态 */ 129 rcu_qsctr_inc(task_cpu(prev)); 130 131 /* 更新prev的平均睡眠时间 */ 132 prev->sleep_avg -= run_time; 133 if ((long)prev->sleep_avg <= 0) 134 prev->sleep_avg = 0; 135 prev->timestamp = prev->last_ran = now; 136 137 if (likely(prev != next)) { 138 /* 两进程不相等 */ 139 next->timestamp = now; 140 rq->nr_switches++; 141 rq->curr = next; 142 ++*switch_count; 143 144 /* 建立next的地址空间，并调用switch_to函数进行进程切换 */ 145 prev = context_switch(rq, prev, next); 146 barrier(); 147 148 /* 恢复地址空间，如果prev进程结束，则还要释放页表相关的描述符 */ 149 finish_task_switch(prev); 150 } else 151 /* 两进程相等，不需要切换进程 */ 152 spin_unlock_irq(&rq->lock); 153 154 prev = current; 155 if (unlikely(reacquire_kernel_lock(prev) < 0)) 156 /* 如果获取了大内核锁，则继续调度，直到本进程主动释放大内核锁？ */ 157 goto need_resched_nonpreemptible; 158 /* 打开内核抢占 */ 159 preempt_enable_no_resched(); 160 if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) 161 /* 如果设置了TTIF_NEED_RESCHED标志，则重新调度 */ 162 goto need_resched; 163 }
①开源，可以让大家对系统进行随意开发，设计出自己所需要的系统。
②安全，提供大量网络管理软件，网络安全软件
③广泛的硬件支持，可以在现如今的主流处理器上完美运行
然而他没有windous那样拥有友好的图形化界面，对于初学者来说需要多多学习操作命令，所以需要有比较长的学习时间才能够熟悉使用。
https://blog.csdn.net/qq_29115063/article/details/53242835
https://blog.csdn.net/fdssdfdsf/article/details/7891748
https://blog.csdn.net/fdssdfdsf/article/details/7894211
http://www.cnblogs.com/zhouyinhui/archive/2010/09/09/1822594.html
http://yylogo.com/archives/519#comments
标签：内部命令 att 办公 nice 计算机系统 意思 记录 理解 unlikely
原文地址：https://www.cnblogs.com/ishlx/p/8977094.html
