linux-exit.c

最新推荐文章于 2023-05-28 09:24:23 发布
最新推荐文章于 2023-05-28 09:24:23 发布
阅读量2k 收藏
点赞数
分类专栏： linux-0.12 文章标签： struct kill jobs 任务 signal tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangsc1984/article/details/4238913
版权
/*
*  linux/kernel/exit.c
*         //－－任务终止和退出的有关处理事宜,包括释放,会话,终止和程序退出处理函数以及杀死进程
*  (C) 1991  Linus Torvalds
*/
#define DEBUG_PROC_TREE
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/tty.h>
#include <asm/segment.h>
int sys_pause(void);
int sys_close(int fd);
void release(struct task_struct * p)    //－－根据进程的任务数据结构指针，
{                                    //－－在任务数组中删除指定的进程指针，释放相关内存页
    int i;                            //－－并立刻让内核重新调度任务的运行。
    if (!p)
        return;
    if (p == current) {
        printk("task releasing itself/n/r");
        return;
    }
    for (i=1 ; i<NR_TASKS ; i++)
        if (task[i]==p) {
            task[i]=NULL;
            /* Update links */
            if (p->p_osptr)
                p->p_osptr->p_ysptr = p->p_ysptr;
            if (p->p_ysptr)
                p->p_ysptr->p_osptr = p->p_osptr;
            else
                p->p_pptr->p_cptr = p->p_osptr;
            free_page((long)p);                    //－－释放内存页
            schedule();                            //－－重新调度任务
            return;
        }
    panic("trying to release non-existent task");
}
#ifdef DEBUG_PROC_TREE
/*
* Check to see if a task_struct pointer is present in the task[] array
* Return 0 if found, and 1 if not found.
*/
int bad_task_ptr(struct task_struct *p)            //－－检查任务结构指针p
{
    int     i;
    if (!p)
        return 0;
    for (i=0 ; i<NR_TASKS ; i++)
        if (task[i] == p)
            return 0;
    return 1;
}
    
/*
* This routine scans the pid tree and make sure the rep invarient still
* holds.  Used for debugging only, since it's very slow....
*
* It looks a lot scarier than it really is.... we're doing **nothing more
* than verifying the doubly-linked list found**in p_ysptr and p_osptr,
* and checking it corresponds with the process tree defined by p_cptr and
* p_pptr;
*/
void audit_ptree()                        //－－检查进程树，仅用于调试
{
    int    i;
    for (i=1 ; i<NR_TASKS ; i++) {
        if (!task[i])
            continue;
        if (bad_task_ptr(task[i]->p_pptr))
            printk("Warning, pid %d's parent link is bad/n",
                task[i]->pid);
        if (bad_task_ptr(task[i]->p_cptr))
            printk("Warning, pid %d's child link is bad/n",
                task[i]->pid);
        if (bad_task_ptr(task[i]->p_ysptr))
            printk("Warning, pid %d's ys link is bad/n",
                task[i]->pid);
        if (bad_task_ptr(task[i]->p_osptr))
            printk("Warning, pid %d's os link is bad/n",
                task[i]->pid);
        if (task[i]->p_pptr == task[i])
            printk("Warning, pid %d parent link points to self/n");
        if (task[i]->p_cptr == task[i])
            printk("Warning, pid %d child link points to self/n");
        if (task[i]->p_ysptr == task[i])
            printk("Warning, pid %d ys link points to self/n");
        if (task[i]->p_osptr == task[i])
            printk("Warning, pid %d os link points to self/n");
        if (task[i]->p_osptr) {
            if (task[i]->p_pptr != task[i]->p_osptr->p_pptr)
                printk(
            "Warning, pid %d older sibling %d parent is %d/n",
                task[i]->pid, task[i]->p_osptr->pid,
                task[i]->p_osptr->p_pptr->pid);
            if (task[i]->p_osptr->p_ysptr != task[i])
                printk(
        "Warning, pid %d older sibling %d has mismatched ys link/n",
                task[i]->pid, task[i]->p_osptr->pid);
        }
        if (task[i]->p_ysptr) {
            if (task[i]->p_pptr != task[i]->p_ysptr->p_pptr)
                printk(
            "Warning, pid %d younger sibling %d parent is %d/n",
                task[i]->pid, task[i]->p_osptr->pid,
                task[i]->p_osptr->p_pptr->pid);
            if (task[i]->p_ysptr->p_osptr != task[i])
                printk(
        "Warning, pid %d younger sibling %d has mismatched os link/n",
                task[i]->pid, task[i]->p_ysptr->pid);
        }
        if (task[i]->p_cptr) {
            if (task[i]->p_cptr->p_pptr != task[i])
                printk(
            "Warning, pid %d youngest child %d has mismatched parent link/n",
                task[i]->pid, task[i]->p_cptr->pid);
            if (task[i]->p_cptr->p_ysptr)
                printk(
            "Warning, pid %d youngest child %d has non-NULL ys link/n",
                task[i]->pid, task[i]->p_cptr->pid);
        }
    }
}
#endif /* DEBUG_PROC_TREE */
static inline int send_sig(long sig,struct task_struct * p,int priv)
{                                                        //－－向指定任务发送信号sig,权限为priv
    if (!p)
        return -EINVAL;
    if (!priv && (current->euid!=p->euid) && !suser())    //－－检查权限,是否是当前用户,是否是超级用户
        return -EPERM;
    if ((sig == SIGKILL) || (sig == SIGCONT)) {            //－－如果是sigkill和sigcout信号，则...
        if (p->state == TASK_STOPPED)
            p->state = TASK_RUNNING;
        p->exit_code = 0;
        p->signal &= ~( (1<<(SIGSTOP-1)) | (1<<(SIGTSTP-1)) |
                (1<<(SIGTTIN-1)) | (1<<(SIGTTOU-1)) );    //－－去掉可能会导致进程停止的信号
    }
    /* If the signal will be ignored, don't even post it */
    if ((int) p->sigaction[sig-1].sa_handler == 1)        //－－如果信号将被进程p忽略，则不用发送。
        return 0;
    /* Depends on order SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU */
    if ((sig >= SIGSTOP) && (sig <= SIGTTOU))
        p->signal &= ~(1<<(SIGCONT-1));
    /* Actually deliver the signal */
    p->signal |= (1<<(sig-1));                            //－－向p发送信号
    return 0;
}
int session_of_pgrp(int pgrp)                            //－－根据进程组号pgrp取得进程组所属的会话号
{
    struct task_struct **p;
     for (p = &LAST_TASK ; p > &FIRST_TASK ; --p)
        if ((*p)->pgrp == pgrp)
            return((*p)->session);
    return -1;
}
int kill_pg(int pgrp, int sig, int priv)                //－－向进程组发送信号
{
    struct task_struct **p;
    int err,retval = -ESRCH;
    int found = 0;
    if (sig<1 || sig>32 || pgrp<=0)
        return -EINVAL;
     for (p = &LAST_TASK ; p > &FIRST_TASK ; --p)
        if ((*p)->pgrp == pgrp) {
            if (sig && (err = send_sig(sig,*p,priv)))
                retval = err;
            else
                found++;
        }
    return(found ? 0 : retval);
}
int kill_proc(int pid, int sig, int priv)                //－－向进程发送信号
{
     struct task_struct **p;
    if (sig<1 || sig>32)
        return -EINVAL;
    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p)
        if ((*p)->pid == pid)
            return(sig ? send_sig(sig,*p,priv) : 0);
    return(-ESRCH);
}
/*
* POSIX specifies that kill(-1,sig) is unspecified, but what we have
* is probably wrong.  Should make it like BSD or SYSV.
*/
int sys_kill(int pid,int sig)                            //－－用于向任何进程或进程组发送任何信号
{
    struct task_struct **p = NR_TASKS + task;
    int err, retval = 0;
    if (!pid)                                            //－－信号发送给当前进程的进程组中所有的进程
        return(kill_pg(current->pid,sig,0));
    if (pid == -1) {                                    //－－信号发送给除初始进程外的所有进程
        while (--p > &FIRST_TASK)
            if (err = send_sig(sig,*p,0))
                retval = err;
        return(retval);
    }
    if (pid < 0)                                         //－－信号发送给进程组-pid的所有进程
        return(kill_pg(-pid,sig,0));
    /* Normal kill */
    return(kill_proc(pid,sig,0));                        //－－信号发送给指定进程
}
/*
* Determine if a process group is "orphaned", according to the POSIX
* definition in 2.2.2.52.  Orphaned process groups are not to be affected
* by terminal-generated stop signals.  Newly orphaned process groups are
* to receive a SIGHUP and a SIGCONT.
*
* "I ask you, have you ever known what it is to be an orphan?"
*/
int is_orphaned_pgrp(int pgrp)                            //－－判断一个进程是否是孤儿进程
{                                                        //－－如果...如果...否则...我也看不懂什么是孤儿进程了
    struct task_struct **p;
    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
        if (!(*p) ||
            ((*p)->pgrp != pgrp) ||
            ((*p)->state == TASK_ZOMBIE) ||
            ((*p)->p_pptr->pid == 1))
            continue;
        if (((*p)->p_pptr->pgrp != pgrp) &&
            ((*p)->p_pptr->session == (*p)->session))
            return 0;
    }
    return(1);    /* (sighing) "Often!" */                //－－为孤儿进程...
}
static int has_stopped_jobs(int pgrp)                    //－－判断进程组中是否有处于停止状态的作业
{
    struct task_struct ** p;
    for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
        if ((*p)->pgrp != pgrp)
            continue;
        if ((*p)->state == TASK_STOPPED)
            return(1);
    }
    return(0);
}
volatile void do_exit(long code)                        //－－程序退出处理函数
{
    struct task_struct *p;
    int i;
                                                         //－－首先释放当前进程代码段和数据段所占的内存
    free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));
    free_page_tables(get_base(current->ldt[2]),get_limit(0x17));
    for (i=0 ; i<NR_OPEN ; i++)                            //－－关闭当前进程打开着的所有文件
        if (current->filp[i])
            sys_close(i);
    iput(current->pwd);                                    //－－当前目录
    current->pwd = NULL;
    iput(current->root);                                //－－根目录
    current->root = NULL;
    iput(current->executable);                            //－－执行文件
    current->executable = NULL;
    iput(current->library);                                //－－库文件
    current->library = NULL;
    current->state = TASK_ZOMBIE;                        //－－僵死状态
    current->exit_code = code;
    /*
     * Check to see if any process groups have become orphaned
     * as a result of our exiting, and if they have any stopped
     * jobs, send them a SIGUP and then a SIGCONT.  (POSIX 3.2.2.2)
     *
     * Case i: Our father is in a different pgrp than we are
     * and we were the only connection outside, so our pgrp
     * is about to become orphaned.
      */                                                //－－检查当前进程的退出是否会造成进程组变成孤儿进程
    if ((current->p_pptr->pgrp != current->pgrp) &&
        (current->p_pptr->session == current->session) &&
        is_orphaned_pgrp(current->pgrp) &&
        has_stopped_jobs(current->pgrp)) {
        kill_pg(current->pgrp,SIGHUP,1);
        kill_pg(current->pgrp,SIGCONT,1);
    }
    /* Let father know we died */
    current->p_pptr->signal |= (1<<(SIGCHLD-1));    //－－发送信号通知父进程当前进程将终止
    
    /*
     * This loop does two things:
     *
       * A.  Make init inherit all the child processes
     * B.  Check to see if any process groups have become orphaned
     *    as a result of our exiting, and if they have any stopped
     *    jons, send them a SIGUP and then a SIGCONT.  (POSIX 3.2.2.2)
     */
    if (p = current->p_cptr) {                        //－－让init进程成为其所有子进程的父进程
        while (1) {
            p->p_pptr = task[1];
            if (p->state == TASK_ZOMBIE)            //－－若为僵死状态，则向init发送进程已终止信号
                task[1]->signal |= (1<<(SIGCHLD-1));
            /*
             * process group orphan check
             * Case ii: Our child is in a different pgrp
             * than we are, and it was the only connection
             * outside, so the child pgrp is now orphaned.
             */
            if ((p->pgrp != current->pgrp) &&        //－－呃...好复杂
                (p->session == current->session) &&    //－－处理兄弟进程
                is_orphaned_pgrp(p->pgrp) &&
                has_stopped_jobs(p->pgrp)) {
                kill_pg(p->pgrp,SIGHUP,1);
                kill_pg(p->pgrp,SIGCONT,1);
            }
            if (p->p_osptr) {
                p = p->p_osptr;
                continue;
            }
            /*
             * This is it; link everything into init's children
             * and leave
             */
            p->p_osptr = task[1]->p_cptr;            //－－最老与最新子进程的处理
            task[1]->p_cptr->p_ysptr = p;
            task[1]->p_cptr = current->p_cptr;
            current->p_cptr = 0;
            break;
        }
    }
    if (current->leader) {                            //－－如果当前进程为会话头领进程
        struct task_struct **p;
        struct tty_struct *tty;
        if (current->tty >= 0) {
            tty = TTY_TABLE(current->tty);
            if (tty->pgrp>0)
                kill_pg(tty->pgrp, SIGHUP, 1);
            tty->pgrp = 0;
            tty->session = 0;
        }
         for (p = &LAST_TASK ; p > &FIRST_TASK ; --p)
            if ((*p)->session == current->session)
                (*p)->tty = -1;
    }
    if (last_task_used_math == current)                //－－如果当前进程上次使用国协处理器，则...
        last_task_used_math = NULL;
#ifdef DEBUG_PROC_TREE
    audit_ptree();                                    //－－调用进程树检测显示函数
#endif
    schedule();                                        //－－重新调度
}
int sys_exit(int error_code)                        //－－终止进程
{
    do_exit((error_code&0xff)<<8);
}
int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
{                                                    //－－系统调用，挂起当前进程，直到pid指定的子进程退出
    int flag;
    struct task_struct *p;
    unsigned long oldblocked;
    verify_area(stat_addr,4);                        //－－检测内存空间是否足够
repeat:
    flag=0;                                            //－－从当前进程的最年轻子进程开始扫描子进程兄弟链表
    for (p = current->p_cptr ; p ; p = p->p_osptr) {
        if (pid>0) {
            if (p->pid != pid)
                continue;
        } else if (!pid) {
            if (p->pgrp != current->pgrp)
                continue;
        } else if (pid != -1) {
            if (p->pgrp != -pid)
                continue;
        }
        switch (p->state) {                            //－－如果...如果...处理...
            case TASK_STOPPED:
                if (!(options & WUNTRACED) ||
                    !p->exit_code)
                    continue;
                put_fs_long((p->exit_code << 8) | 0x7f,
                    stat_addr);
                p->exit_code = 0;
                return p->pid;
            case TASK_ZOMBIE:
                current->cutime += p->utime;
                current->cstime += p->stime;
                flag = p->pid;
                put_fs_long(p->exit_code, stat_addr);
                release(p);
#ifdef DEBUG_PROC_TREE
                audit_ptree();
#endif
                return flag;
            default:
                flag=1;
                continue;
        }
    }
    if (flag) {
        if (options & WNOHANG)
            return 0;
        current->state=TASK_INTERRUPTIBLE;
        oldblocked = current->blocked;
        current->blocked &= ~(1<<(SIGCHLD-1));
        schedule();
        current->blocked = oldblocked;
        if (current->signal & ~(current->blocked | (1<<(SIGCHLD-1))))
            return -ERESTARTSYS;
        else
            goto repeat;
    }
    return -ECHILD;
}
|xGv00|fcc8d4de8197f69fde70263fb4d52380
linux0.11源码研究---exit.c
Move_now的博客
03-07 984
exit.c程序中实现的大致实现的是进程终止和退出等方面如何处理的相关函数，包含kill()函数系统调用的内部实现、exit()函数系统调用的内部实现、waitpid()函数的系统调用的实现，以及一些更底层的函数的实现。要想看懂这些函数,需要对会话以及进程、进程组有一定的了解,并且对pcb里面的一些成员的了解。主要包括有这八个函数：void release(struct task_struct *
Centos8安装mysql-8.0.19-linux-glibc2.12-x86_64.tar.xz 安装步骤与注意事项
xxh_1229的博客
03-15 3210
# tar -xvf mysql-8.0.19-linux-glibc2.12-i686.tar.xz
linux内核分析之exit.c
缘分天空
09-25 2147
#include #include #include #include #include #include #include int sys_pause(void);int sys_close(int fd);释放当前进程，对进程进行清理void release(struct task_struct * p){ int i;    如果待释放的进程指针为空，立即返回 if (!p)  
linux0.11内核完全剖析- exit.c
RunInProgram的博客
12-04 1312
该程序主要描述了进程（任务）终止和退出的处理事宜。主要包含进程释放、会话（进程组）终止和程序退出处理函数以及杀死进程、终止进程、挂起进程等系统调用函数。还包括进程信号发送函数send_sig()和通知父进程子进程终止的函数 tell_father()。 释放进程的函数 release()主要根据指定的任务数据结构（任务描述符）指针，在任务数组中删除指定的进程指针、释放相关内存页并立刻让内核重新调
linux0.12-8-8-eixt.c
fitpolo
05-12 479
学习记录，打卡。卷起来！(-:
Linux-0.11 kernel目录exit.c详解
小x的博客
05-28 852
Linux-0.11 kernel目录exit.c详解
test-on-exit.rar_SOC
09-14
"test-on-exit.c"可能是一个测试程序，用于在退出或完成特定任务时检查某些功能或者性能。在Linux环境中，这种测试程序通常用来验证驱动程序的功能正确性和系统稳定性，特别是在硬件中断处理、资源管理等方面。 "ar...
linux-c-api-ref.zip_linux api_linux-c-api-ref
09-24
在Linux操作系统中，C语言API（Application Programming Interface）是开发者与操作系统进行交互的主要方式。Linux-C-API-ref资源提供了一个详细的学习指南，涵盖了Linux系统调用和C库函数的使用，对于想要深入理解...
linux-deamon-programming.zip_linux deamon
09-19
在"linux deamon programming.txt"这个文本文件中，可能会包含具体的C语言代码示例，演示如何按照上述步骤实现一个简单的守护进程。通常，代码会包含初始化阶段的各个步骤，然后进入一个无限循环，直到接收到停止...
电子-exti.c
09-05
电子-exti.c,单片机/嵌入式STM32-F0/F1/F2
stm32f4xx_hal_exti.c
西红柿炒鸡蛋
06-13 2070
需要预备的知识 >> >> EXIT流程框图提供查阅 Functions HAL_EXTI_SetConfigLine 对EXITx线路寄存器进行配置 HAL_EXTI_GetConfigLine 读取EXITx线路的寄存器配置 HAL_EXTI_ClearConfigLine 重置EXITx线路寄存器的值 HAL_EXTI_RegisterCallback 注册回调函数 HAL_EXTI_GetHandle 获取EXTI句柄信息 HAL_EXTI
野火学习笔记(10) —— EXTI ——外部中断/事件控制器
没霖好叫咩的博客
07-17 2550
文章目录1. EXTI 简介2. EXTI 功能框图3. 中断/事件线4. EXTI 初始化结构体详解5. 外部中断控制实验5.1 硬件设计5.2 软件设计5.2.1 编程要点5.2.2 软件分析 1. EXTI 简介 EXTI（External interrupt/event controller） —— 外部中断/事件控制器， 管理了控制器的 20 个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置
linux内核杂记(5)-进程终结
The research on computer technolog
12-02 256
1、进程的析构是由自身引起的，发生在进程调用exit()系统调用时，既可能显式地调用 这个系统调用，也可能隐匿地从某个程序的主函数 返回。 当进程接受到它既不能处理也不能忽略的信号或异常时，它还可能被动地终结，进程终结上do_exit()（kernel/exit.c）完成. 2 、进程 终结后，所有与进程相关联的所有资源都被释放，处于EXIT_ZOMBIE退出状态，占用的所有内存是内核栈、thread_info结构、tast_struct结构。 3、进程 描述符的删除在最后一个阶段完成，当父进程获得已终结的
linux-011之库函数_exit.c文件解析
行善之人必有余庆
05-03 796
/* ::"a"(_NR_exit)*程序调用内核的退出系统调用函数 */ #define _LIBRARY_ #include /* *内核使用的程序终止函数. *直接调用系统中断int 0x80，功能号_NR_exit. *参数exit_code--退出码 */ volatile void _exit(int exit_code) { /* * %0-ea
窥探 kernel，just for fun --- 浅析do_exit
test_touch的专栏
04-23 248
  本系列文章由张同浩编写，转载请注明出处：http://blog.csdn.net/muge0913/article/details/7483054 邮箱：muge0913@sina.com 进程在退出时，必须释放它所拥有的资源，并通过某种方式告诉父进程。进程的退出一般是显示或隐式地调用了eixt(),或者接受了某种信号。不过什么原因退出，最终都调用了do_exit。  ...
Linux进程退出详解(do_exit)--Linux进程的管理与调度(十四)）
热门推荐
OSKernelLAB(gatieme)
06-11 2万+
日期 内核版本 架构 作者 GitHub CSDN 2016-05-12 Linux-4.6 X86 & arm gatieme LinuxDeviceDrivers Linux进程管理与调度 Linux进程的退出linux下进程退出的方式正常退出 从main函数返回return 调用exit 调用_exit 异常退出 调用abort 由信号终止 _exit
python 创建并开启进程的两种方法
weixin_42272357的博客
09-20 548
python 创建并开启进程的两种方法 #方法一 直接调用 import time import random from multiprocessing import Process def run(name): print('%s runing' %name) time.sleep(random.randrange(1,5))#进程挂起 print('%s running end' %name) if __name__ == '__main__': p1=Proces
linux进程exit系统调用
focus on security
04-28 998
用户态的进程退出时，通过exit系统调用进入到内核，cpu产生系统调用中断，处理该中断时查表sys_call_table找到系统调用号找到sys_exit，sys_exit找到do_exit函数执行。 用户态exit()-->内核态中断处理el0_sync--->内核态el0_svc查找sys_call_table得到sys_execve函数地址执行--->内核态sys_exit--->内核态do_exit。
SMT32笔记之外部中断EXIT
图个吉利儿的博客
03-04 321
关于STM32学习分享 第三章 EXIT外部中断 文章目录前言二、代码1.key.c2.key.h3.stm32f10x_it.c4.main.c总结 前言 开始！开始！单片机的按键配置为输入模式获取控制信号，触发EXIT外部中断。 # 一、按键GPIO输入模式类型 GPIO_Mode_IN_FLOATING = 0x04, // 浮空输入 说明：通常配置按键为浮空输入。 二、代码 1.key.c 代码如下（示例）： #include "exti.h" //NVIC中断优先级与中断源配置 s
arm-linux-gcc main/main.c -o main -I ./include -L ./lib /usr/local/arm/5.4.0/usr/bin/../lib/gcc/arm-none-linux-gnueabi/5.4.0/../../../../arm-none-linux-gnueabi/bin/ld: cannot open output file main: Is a directory collect2: error: ld returned 1 exit status
最新发布
07-22
arm-linux-gcc main/main.c -o main_executable -I ./include -L ./lib ``` 如果你仍然遇到问题，请检查当前目录下是否存在同名的目录，并确保你具有写入权限。如果你想将可执行文件输出到特定的目录，你可以提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值