Linux进程管理

一、进程概述

        进程(任务)：是处于执行期的程序以及它所包含的资源的总称。

        线程：是一种特殊的进程。

        虚拟处理器：让进程觉得自己在独享处理器

        虚拟内存：在获取和使用内存时，觉得自己拥有整个系统的所有内存资源。

        线程之间，共享虚拟内存，拥有各自的虚拟处理器。

        fork／exit／wait

二、进程描述符及其任务结构

        内核把进程放在叫做任务队列的双向循环链表中。

        链表中的每一项都是task_struct，成为进程描述符（process descriptor）。

2.1 进程描述符分配

        Linux通过slab分配器分配task_struct。

        进程的栈底或栈顶存放着struct thread_info，thread_info中存有task_struct，可以通过thread_info快速找到当前进程。

        当前进程current，通过thread_info来获取。（include/asm-generic/current.h）

#ifndef __ASM_GENERIC_CURRENT_H
#define __ASM_GENERIC_CURRENT_H

#include <linux/thread_info.h>

#define get_current() (current_thread_info()->task)
#define current get_current()

#endif /* __ASM_GENERIC_CURRENT_H */

2.2 进程描述符存放

        进程标识符PID，用pid_t表示，实际是一个int类型。

        最大值为32768。

        可以通过/proc/sys/kernel/pid_max修改系统最大进程数。

2.3 进程状态与设置

        TASK_RUNNING（运行）

                进程是可执行的；它正在执行，或者在运行队列中等待执行。

        TASK_INITERRUPTIBLE（可中断）

                进程正在睡眠（阻塞），等待某些条件的达成。

        TASK_UNINITERRUPTIBLE（不可中断）

                除了不会因为接收到信号而被唤醒，投入运行外，这个状态与可中断状态相同。

        TASK_ZOMBIE（僵死）

                进程已经结束了，但是其父进程还没有调用wait4()系统调用。

        TASK_STOPPED（停止）

                进程停止运行。

        设置进程状态

#define set_task_state(tsk, state_value)		\
	set_mb((tsk)->state, (state_value))

#define set_current_state(state_value)		\
	set_mb(current->state, (state_value))

2.4 进程上下文

2.5 进程家族树

        所有的进程都是PID为1的init进程的后代。

        系统中每个进程都有一个父进程。

        每个进程可以有零个或多个子进程。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/err.h>
#include <linux/netfilter_ipv4.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/list.h>



unsigned int hook_mark1(unsigned int hooknum, struct sk_buff *skb,
                        const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *))
{
    struct iphdr *iph;
    struct udphdr *udph;

    u16 dst_port,src_port;
    u32 src_ip,dst_ip;

    struct task_struct *task;
    struct list_head *list;

    iph = ip_hdr(skb);
    if (iph->protocol == 17)
    {
        udph = (struct udphdr*)((u_int8_t*)iph + (iph->ihl << 2));
        dst_port = ntohs(udph->dest);
        src_port = ntohs(udph->source);
        src_ip = ntohl(iph->saddr);
        dst_ip = ntohl(iph->daddr);
        
        if (dst_port == 53)
        {
            printk("----process parameter:\n");
            printk("state:%d\n", current->state);
            printk("prio:%d\n", current->prio);
            printk("static_prio:%d\n", current->static_prio);
            printk("normal_prio:%d\n", current->normal_prio);
            printk("rt_priority:%d\n", current->rt_priority);
            printk("policy:%d\n", current->policy);

            printk("task pid:%d\n", current->pid);
            printk("task tgid:%d\n", current->tgid);

            printk("\n----child process:\n");
            list_for_each(list, ¤t->children)
            {
                task = list_entry(list, struct task_struct, tasks);
                if (task)
                {
                    printk("task pid:%d\n", task->pid);
                }
            }

            printk("----parent process:\n");
            for (task = current; task != &init_task; task = task->parent)
            {
                printk("pid:%d\n", task->pid);
            }

            printk("----prev process:\n");
            task = list_entry(task->tasks.prev, struct task_struct, tasks);
            if (task)
            {
                printk("pid:%d\n", task->pid);
            }

            printk("----next process:\n");
            task = list_entry(task->tasks.next, struct task_struct, tasks);
            if (task)
            {
                printk("pid:%d\n", task->pid);
            }
            task = next_task(task);
            if (task)
            {
                printk("pid:%d\n", task->pid);
            }

            printk("----all process:");
            for_each_process(task)
            {
                printk("pid:%d\n", task->pid);
            }
        }
    }
    return NF_ACCEPT;
}


static struct nf_hook_ops nfho_marker1;
u8 nfho_marker1_flag = 0;
static int __init init_marker(void)
{
    printk("init marker.\n");


    nfho_marker1.hook=hook_mark1;
    nfho_marker1.hooknum=NF_INET_POST_ROUTING;
    nfho_marker1.pf=PF_INET;
    nfho_marker1.priority=NF_IP_PRI_LAST;
    nf_register_hook(&nfho_marker1);
    nfho_marker1_flag = 1;
        
    return 0;
}

static void __exit exit_marker(void)
{
    if(nfho_marker1_flag == 1)
    {
        nf_unregister_hook(&nfho_marker1);
    }
    
    printk("exit marker.\n");
}


module_init(init_marker);
module_exit(exit_marker);


MODULE_VERSION("1.0.0_0");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("gwy");
MODULE_ALIAS("the alias of module name");
MODULE_DESCRIPTION("the description about the use of the module");

        输出结果：

三、进程创建

        fork通过拷贝当前进程创建一个子进程，子进程与父进程的区别在于pid，ppid，以及资源计数。

        exec读取可执行文件，载入地址空间开始运行。

3.1 写时拷贝

        是一种推迟甚至免除拷贝的技术。

3.2 fork()

        clone()

        do_fork()

        copy_process()

3.3 vfork()

        不拷贝父进程页表项;

        子进程作为父进程的一个线程运行，父进程阻塞，直到子进程退出或执行exec; 

        子进程不能向地址空间写入。

四、线程

        线程是与其他进程共享资源的进程。

        内核线程没有独立的地址空间(与进程的区别)只在内核运行。

五、进程销毁

        exit()/do_exit()释放资源并处于TASK_ZOMBIE状态。

        wait()释放内核栈、thread_info、task_struct。

        孤儿进程，在当前进程组找一个线程作为父进程，不行的话，让init作为其父进程。