实验报告

实 验（四）

题     目      TinyShell         

     微壳          　 

专       业                     

学　　   号                     

班　　   级                   

学       生              　　　

指 导 教 师                  　　

实 验 地 点         　　　

实 验 日 期                　　　

计算学部

目  录

第1章 实验基本信息... - 4 -

1.1 实验目的... - 4 -

1.2 实验环境与工具... - 4 -

1.2.1 硬件环境... - 4 -

1.2.2 软件环境... - 4 -

1.2.3 开发工具... - 4 -

1.3 实验预习... - 4 -

第2章 实验预习... - 6 -

2.1 进程的概念、创建和回收方法（5分）... - 6 -

2.2信号的机制、种类（5分）... - 6 -

2.3 信号的发送方法、阻塞方法、处理程序的设置方法（5分）... - 6 -

2.4 什么是shell，功能和处理流程（5分）... - 6 -

第3章 TinyShell的设计与实现... - 7 -

3.1.1 void eval(char *cmdline)函数（10分）... - 7 -

3. 1.2 int builtin_cmd(char **argv)函数（5分）... - 7 -

3. 1.3 void do_bgfg(char **argv) 函数（5分）... - 7 -

3. 1.4 void waitfg(pid_t pid) 函数（5分）... - 7 -

3. 1.5 void sigchld_handler(int sig) 函数（10分）... - 8 -

第4章 TinyShell测试... - 9 -

4.1 测试方法... - 9 -

4.2 测试结果评价... - 9 -

4.3 自测试结果... - 9 -

4.3.1测试用例trace01.txt的输出截图（1分）... - 9 -

4.3.2测试用例trace02.txt的输出截图（1分）... - 9 -

4.3.3测试用例trace03.txt的输出截图（1分）... - 10 -

4.3.4测试用例trace04.txt的输出截图（1分）... - 10 -

4.3.5测试用例trace05.txt的输出截图（1分）... - 10 -

4.3.6测试用例trace06.txt的输出截图（1分）... - 11 -

4.3.7测试用例trace07.txt的输出截图（1分）... - 11 -

4.3.8测试用例trace08.txt的输出截图（1分）... - 11 -

4.3.9测试用例trace09.txt的输出截图（1分）... - 12 -

4.3.10测试用例trace10.txt的输出截图（1分）... - 12 -

4.3.11测试用例trace11.txt的输出截图（1分）... - 12 -

4.3.12测试用例trace12.txt的输出截图（1分）... - 13 -

4.3.13测试用例trace13.txt的输出截图（1分）... - 13 -

4.3.14测试用例trace14.txt的输出截图（1分）... - 13 -

4.3.15测试用例trace15.txt的输出截图（1分）... - 14 -

4.4 自测试评分... - 14 -

第4章 总结... - 15 -

4.1 请总结本次实验的收获... - 15 -

4.2 请给出对本次实验内容的建议... - 15 -

参考文献... - 16 -

第1章 实验基本信息

1.1 实验目的

理解现代计算机系统进程与并发的基本知识

掌握linux 异常控制流和信号机制的基本原理和相关系统函数

掌握shell的基本原理和实现方法

深入理解Linux信号响应可能导致的并发冲突及解决方法

培养Linux下的软件系统开发与测试能力

1.2 实验环境与工具

1.2.1 硬件环境

X64 CPU；2GHz；2G RAM；256GHD Disk 以上

1.2.2 软件环境

Windows7/10 64位以上；VirtualBox/Vmware 11以上；Ubuntu 16.04 LTS 64位/优麒麟 64位 以上；

1.2.3 开发工具

Visual Studio 2010 64位以上；CodeBlocks 64位；vi/vim/gedit+gcc

1.3 实验预习

上实验课前，必须认真预习实验指导书（PPT或PDF）

了解实验的目的、实验环境与软硬件工具、实验操作步骤，复习与实验有关的理论知识。

了解进程、作业、信号的基本概念和原理

了解shell的基本原理

熟知进程创建、回收的方法和相关系统函数

熟知信号机制和信号处理相关的系统函数

第2章 实验预习

总分20分

2.1 进程的概念、创建和回收方法（5分）

进程：一个执行中程序的1实例

进程的创建：通过fork()创建进程

进程的回收：pid_t waitpid(pid_t pid,int *status,int cptains),pid为指定回收进程的pid

> 0:待回收的子进程pid

> -1：任意子进程。

=0：同组的子进程

<-1:进程组号为pid绝对值的任何子进程。

2.2信号的机制、种类（5分）

机制：1）发送信号。发送信号的程序用系统调用kill( )实现；

2）预置对信号的处理方式。接收信号的程序用signal( )来实现对处理方式的预置；

3）收受信号的进程按事先的规定完成对相应事件的处理。     

种类：

1. 与进程终止相关的信号。当进程退出，或者子进程终止时，发出这类信号。
2. 与进程例外事件相关的信号。如进程越界。
3. 与在系统调用期间遇到不可恢复条件相关的信号。如执行系统调用exec时，原有资源已经释放，而目前系统资源又已经耗尽。
4. 与执行系统调用时遇到非预测错误条件相关的信号。如执行一个并不存在的系统调用。
5. 在用户态下的进程发出的信号。如进程调用系统调用kill向其他进程发送信号。
6. 与终端交互相关的信号。如用户关闭一个终端，或按下break键等情况。
7. 跟踪进程执行的信号。

2.3 信号的发送方法、阻塞方法、处理程序的设置方法（5分）

信号的发送方法：

1. 用 /bin/kill 程序发送信号

2. 从键盘发送信号

3. 用 kill 函数发送信号

信号的阻塞方法：

1.隐式阻塞机制：内核默认阻塞与当前正在处理信号类型相同的待处理信号

2. 显示阻塞和解除阻塞机制：

sigprocmask 函数及其辅助函数可以明确地阻塞/解除阻塞

选定的信号：SIG_   BLOCK/UNBLOCK/SET_MASK

辅助函数：sigemptyset – 初始化set为空集合

sigfillset – 把每个信号都添加到set中

sigaddset – 把指定的信号signum添加到set

sigdelset – 从set中删除指定的信号signum

2.4 什么是shell，简述其功能和处理流程（5分）

功能：shell是一个交互型应用级程序，代表用户运行其他程序

处理流程：

1.通过读步骤来读取用户的命令行

2.求值步骤来解析命令

3.代表用户运行

第3章 TinyShell的设计与实现

总分45分

3.1 设计

3.1.1 void eval(char *cmdline)函数（10分）

函数功能：解析和解释命令行的主例程

参    数：char *cmdline即输入的命令行字符串

处理流程：

1.解析命令行，如果argv[0]=NULL,即全路径名为空，直接返回，忽略空的命令行。

2.设置信号掩码，将SIGCHLD, SIGINT, SIGTSTP信号进行阻塞，直到将作业添加到作业列表，如果设置失败则报错。

3.创建子进程，创建失败时报错。

4.运行子进程，先更新信号掩码，将SIGCHLD, SIGINT, SIGTSTP解除阻塞，然后用进程本身的pid来命名进程组pid，在新的作业中运行程序，如果运行失败输出Command not found。

5.根据bg将作业添加到对应的作业列表，如果是前台作业则等待结束，对于后台作业直接打印信息

要点分析：

1.通过信号掩码先添加SIGCHLD, SIGINT, SIGTSTP来消除添加作业到信号列表和SIGCHLD, SIGINT, SIGTSTP的到达之间的冲突。

2.对应每步出错都有报错。

3. 1.2 int builtin_cmd(char **argv)函数（5分）

函数功能：识别并解释内置命令: quit, fg, bg, 和 jobs。

参    数：char **argv[] 表示传入函数的参数序列

处理流程：

1.比较是否输入quit，若是则直接退出。

2.若不是，比较是否输入jobs，若是则直接执行listjobs(jobs),并返回1

3.若不是，比较是否输入bg或fg，若是则执行do_bgfg，并返回1

4.若均不是则返回0表示未输入内置命令。

要点分析：

1.判断输入命令行是否为内置命令，是则立即执行，不是返回0；

3. 1.3 void do_bgfg(char **argv) 函数（5分）

函数功能：实现内置命令bg 和 fg

参    数：char **argv[] 表示传入函数的参数序列

处理流程：

1.忽略没有参数的指令，如果argv[1]为空则输出提示信息并返回

2.分析需要的PID或者%JID参数，如果没有相对应的PID或JID参数在jobs中，输出提示信息并返回，如果argv[1]不是PID或%JID参数，则输出提示并返回。

3.若输入的是bg指令，则将停止的后台作业转换为运行的后台作业，作业状态赋为BG，并打印信息。若输入的是fg指令，则将运行或停止的后台作业转换为运行的后台作业，将作业状态赋值为FG，并打印信息。

4.如果均不是，打印提示信息并退出

要点分析：

1.第一步是对参数进行检查，如果输入参数不在jobs中或者不符合规范，则直接返回。

2.第二步是对指令进行检查，输入bg或fg成功执行，否则直接退出。

3. 1.4 void waitfg(pid_t pid) 函数（5分）

函数功能：等待一个前台作业结束

参    数：指定前台作业的pid

处理流程：当fg_completed=0时持续休眠直到fg_completed=1时返回

要点分析：使用busy loop实现等待前台作业结束

3. 1.5 void sigchld_handler(int sig) 函数（10分）

函数功能：捕获SIGCHILD信号

参    数：int sig

处理流程：

1.获取当前作业的pid，如果是前台作业，直接让waitpid跳出循环。

2.根据子进程结束状态进行相关操作，若子进程正常结束则删除对应作业，否则若子进程因信号而结束，打印信息并且删除对应作业，否则若子进程处于暂停状态，则打印信息并且修改state

要点分析：

注意信号并不会叠加，所以无法得知有几个SIGCHILD信号，使用while而不是if

3.2 程序实现（tsh.c的全部内容）（10分）

重点检查代码风格：

1. 用较好的代码注释说明——5分
2. 检查每个系统调用的返回值——5分

第4章 TinyShell测试

总分15分

4.1 测试方法

针对tsh和参考shell程序tshref，完成测试项目4.1-4.15的对比测试，并将测试结果截图或者通过重定向保存到文本文件(例如：./sdriver.pl -t trace01.txt -s ./tsh -a "-p" > tshresult01.txt)。

4.2 测试结果评价

tsh与tshref的输出在一下两个方面可以不同：

（1）PID

（2）测试文件trace11.txt, trace12.txt和trace13.txt中的/bin/ps命令，每次运行的输出都会不同，但每个mysplit进程的运行状态应该相同。

除了上述两方面允许的差异，tsh与tshref的输出相同则判为正确，如不同则给出原因分析。

第4章 总结

4.1 请总结本次实验的收获

1.本次实验我复习了进程，作业，信号的基本概念以及原理，加深了对于进程与信号的了解。

2.认识到了shell的基本原理，感觉掌握的更加扎实了

3.熟悉了信号的机制以及信号处理相关的系统函数

4.了解了如何创建进程，回收进程。

4.2 请给出对本次实验内容的建议

希望老师能实现说明一下在泰山服务器上运行需要注意的问题以及相关的操作。

注：本章为酌情加分项。

参考文献

为完成本次实验你翻阅的书籍与网站等

[1]  林来兴. 空间控制技术[M]. 北京：中国宇航出版社，1992：25-42.

[2]  辛希孟. 信息技术与信息服务国际研讨会论文集：A集[C]. 北京：中国科学出版社，1999.

[3]  赵耀东. 新时代的工业工程师[M/OL]. 台北：天下文化出版社，1998 [1998-09-26]. http://www.ie.nthu.edu.tw/info/ie.newie.htm（Big5）.

[4]  谌颖. 空间交会控制理论与方法研究[D]. 哈尔滨：哈尔滨工业大学，1992：8-13.

[5]  KANAMORI H. Shaking Without Quaking[J]. Science，1998，279（5359）：2063-2064.

[6]  CHRISTINE M. Plant Physiology: Plant Biology in the Genome Era[J/OL]. Science，1998，281：331-332[1998-09-23]. http://www.sciencemag.org/cgi/ collection/anatmorp.

源码如下：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 


#define MAXLINE    1024   
#define MAXARGS     128   
#define MAXJOBS      16   
#define MAXJID    1<<16   


#define UNDEF 0 
#define FG 1    
#define BG 2    
#define ST 3    




extern char **environ;      
char prompt[] = "tsh> ";    
int verbose = 0;            
int nextjid = 1;            
char sbuf[MAXLINE];         
volatile sig_atomic_t fg_completed = 0;//当前台的作业停止或结束时，置为1，否则置为0

struct job_t                
{
    pid_t pid;              
    int jid;                
    int state;              
    char cmdline[MAXLINE];  
};
struct job_t jobs[MAXJOBS]; 






void eval(char *cmdline);
int builtin_cmd(char **argv);
void do_bgfg(char **argv);
void waitfg(pid_t pid);

void sigchld_handler(int sig);
void sigtstp_handler(int sig);
void sigint_handler(int sig);


int parseline(const char *cmdline, char **argv);
void sigquit_handler(int sig);

void clearjob(struct job_t *job);
void initjobs(struct job_t *jobs);
int maxjid(struct job_t *jobs);
int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline);
int deletejob(struct job_t *jobs, pid_t pid);
pid_t fgpid(struct job_t *jobs);
struct job_t *getjobpid(struct job_t *jobs, pid_t pid);
struct job_t *getjobjid(struct job_t *jobs, int jid);
int pid2jid(pid_t pid);
void listjobs(struct job_t *jobs);

void usage(void);
void unix_error(char *msg);
void app_error(char *msg);
typedef void handler_t(int);
handler_t *Signal(int signum, handler_t *handler);


int main(int argc, char **argv)
{
    char c;
    char cmdline[MAXLINE];
    int emit_prompt = 1; 

    
    dup2(1, 2);

    
    while ((c = getopt(argc, argv, "hvp")) != EOF)
    {
        switch (c)
        {
        case 'h':             
            usage();
            break;
        case 'v':             
            verbose = 1;
            break;
        case 'p':             
            emit_prompt = 0;  
            break;
        default:
            usage();
        }
    }

    

    
    Signal(SIGINT,  sigint_handler);   
    Signal(SIGTSTP, sigtstp_handler);  
    Signal(SIGCHLD, sigchld_handler);  

    
    Signal(SIGQUIT, sigquit_handler);

    
    initjobs(jobs);

    
    while (1)
    {

        
        if (emit_prompt)
        {
            printf("%s", prompt);
            fflush(stdout);
        }
        if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin))
            app_error("fgets error");
        if (feof(stdin))   
        {
            fflush(stdout);
            exit(0);
        }

        
        eval(cmdline);
        fflush(stdout);
        fflush(stdout);
    }

    exit(0); 
}


void eval(char *cmdline)
{
    
    char *argv[MAXARGS]; 
    int bg;              
    pid_t pid;           
    sigset_t mask;       

    
    bg = parseline(cmdline, argv);
    if (argv[0] == NULL) //全路径名为空
        return;   

    if (!builtin_cmd(argv))
    {

        

        if (sigemptyset(&mask) < 0)//sigemptyset()用来将参数set 信号集初始化并清空.
            unix_error("sigemptyset error");
        if (sigaddset(&mask, SIGCHLD)) //向信号集添加SIGCHLD 终止时向父进程发送
            unix_error("sigaddset error");
        if (sigaddset(&mask, SIGINT))
            unix_error("sigaddset error");
        if (sigaddset(&mask, SIGTSTP))
            unix_error("sigaddset error");
        if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0)//
            unix_error("sigprocmask error");

        
        if ((pid = fork()) < 0)
            unix_error("fork error");

        

        if (pid == 0)
        {
            
            sigprocmask(SIG_UNBLOCK, &mask, NULL);//更新信号掩码

            
            if (setpgid(0, 0) < 0) //用进程本身的pid来命名组pid
                unix_error("setpgid error");

            
            if (execve(argv[0], argv, environ) < 0)
            {
                printf("%s: Command not foundn", argv[0]);
                exit(0);
            }
        }

        

        
        addjob(jobs, pid, (bg == 1 ? BG : FG), cmdline);
        sigprocmask(SIG_UNBLOCK, &mask, NULL);

        if (!bg)
            waitfg(pid);
        else
            printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }
    
    return;
}


int parseline(const char *cmdline, char **argv)
{
    static char array[MAXLINE]; 
    char *buf = array;          
    char *delim;                
    int argc;                   
    int bg;                     

    strcpy(buf, cmdline);
    buf[strlen(buf)-1] = ' ';  
    while (*buf && (*buf == ' ')) 
        buf++;

    
    argc = 0;
    if (*buf == ''')
    {
        buf++;
        delim = strchr(buf, ''');
    }
    else
    {
        delim = strchr(buf, ' ');
    }

    while (delim)
    {
        argv[argc++] = buf;
        *delim = '';
        buf = delim + 1;
        while (*buf && (*buf == ' ')) 
            buf++;

        if (*buf == ''')
        {
            buf++;
            delim = strchr(buf, ''');
        }
        else
        {
            delim = strchr(buf, ' ');
        }
    }
    argv[argc] = NULL;

    if (argc == 0)  
        return 1;

    
    if ((bg = (*argv[argc-1] == '&')) != 0)
    {
        argv[--argc] = NULL;
    }
    return bg;
}


int builtin_cmd(char **argv)
{
    if (!strcmp(argv[0], "quit"))//判断是否为quit
        exit(1);
    else if (!strcmp(argv[0], "jobs"))//判断是否为jobs
    {
        listjobs(jobs);
        return 1;
    }
    else if (!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg"))//判断是否为bg或fg
    {
        do_bgfg(argv);
        return 1;
    }
    return 0;     
}


void do_bgfg(char **argv)
{
    
    struct job_t *jobp=NULL;

    
    if (argv[1] == NULL)
    {
        printf("%s command requires PID or %%jobid argumentn", argv[0]);
        return;
    }

    
    if (isdigit(argv[1][0]))
    {
        pid_t pid = atoi(argv[1]);
        if (!(jobp = getjobpid(jobs, pid)))
        {
            printf("(%d): No such processn", pid);
            return;
        }
    }
    else if (argv[1][0] == '%')
    {
        int jid = atoi(&argv[1][1]);
        if (!(jobp = getjobjid(jobs, jid)))
        {
            printf("%s: No such jobn", argv[1]);
            return;
        }
    }
    else
    {
        printf("%s: argument must be a PID or %%jobidn", argv[0]);
        return;
    }

    
    if (!strcmp(argv[0], "bg"))
    {
        if (kill(-(jobp->pid), SIGCONT) < 0)
            unix_error("kill (bg) error");
        jobp->state = BG;
        printf("[%d] (%d) %s", jobp->jid, jobp->pid, jobp->cmdline);
    }

    
    else if (!strcmp(argv[0], "fg"))
    {
        if (kill(-(jobp->pid), SIGCONT) < 0)
            unix_error("kill (fg) error");
        jobp->state = FG;
        waitfg(jobp->pid);
    }
    else
    {
        printf("do_bgfg: Internal errorn");
        exit(0);
    }
    
    return;
}


void waitfg(pid_t pid)
{

    fg_completed = 0;

    while (!fg_completed)//采用busy loop
    {
        sleep(1);
    }
    return;
}




void sigchld_handler(int sig)
{
    int olderrno = errno;//错误代码
    pid_t pid;
    struct job_t *job_now;
    int sta;
    sigset_t mask_all, mask_prev;


    if (sigfillset(&mask_all) < 0)//检查sigfillset是否正常
            unix_error("sigfillset error");
    //pending signals are not queued！用while而不是if
    while ((pid = waitpid(-1, &sta, WNOHANG | WUNTRACED)) > 0) {
        //在访问全局变量时，不能被信号处理程序中断，所以阻塞所有信号。
         if (sigprocmask(SIG_BLOCK, &mask_all, &mask_prev) < 0)//
            unix_error("sigprocmask error");
        job_now = getjobpid(jobs, pid);
        //如果是前台任务，修改fg_completed，让waitfg跳出循环
        if (job_now->state == FG) fg_completed = 1;
        if (WIFEXITED(sta)) {
            //子进程正常结束，删除对应任务
            deletejob(jobs, pid);
        } else if (WIFSIGNALED(sta)) {
            //子进程因信号而结束，打印相关信息并删除对应任务
            printf("Job [%d] (%d) terminated by signal %dn", job_now->jid, job_now->pid, WTERMSIG(sta));
            deletejob(jobs, pid);
        } else if (WIFSTOPPED(sta)) {
            //子进程处于暂停状态，打印相关信息并修改state
            printf("Job [%d] (%d) stopped by signal %dn", job_now->jid, job_now->pid, WSTOPSIG(sta));
            job_now->state = ST;
        }
        if (sigprocmask(SIG_SETMASK, &mask_prev, NULL) < 0)//
            unix_error("sigprocmask error");

    }
    errno = olderrno;
    return;
}


void sigint_handler(int sig)
{
    int olderrno = errno;
    pid_t pid;
    sigset_t mask_all, mask_prev;

    if (sigfillset(&mask_all) < 0)//检查sigfillset是否正常
            unix_error("sigfillset error");
    //在访问全局变量时，不能被信号处理程序中断，故阻塞所有信号。
     if (sigprocmask(SIG_BLOCK, &mask_all, &mask_prev) < 0)//检查sigprocmask是否正常
            unix_error("sigprocmask error");
    pid = fgpid(jobs);//foreground job pid
    if (sigprocmask(SIG_SETMASK, &mask_prev, NULL) < 0)//检查sigprocmask是否正常
            unix_error("sigprocmask error");
    if (pid != 0) {
        //向前台进程组发送SIGINT，故是-pid（子进程的进程组ID与PID相同）
        kill(-pid, SIGINT);
    }
    errno = olderrno;
    return;
}


void sigtstp_handler(int sig)
{
    int olderrno = errno;
    pid_t pid;
    sigset_t mask_all, mask_prev;

    sigfillset(&mask_all);
    //在访问全局变量时，不能被信号处理程序中断，故阻塞所有信号。
    if (sigprocmask(SIG_BLOCK, &mask_all, &mask_prev) < 0)//检查sigprocmask是否正常
            unix_error("sigprocmask error");
    pid = fgpid(jobs);//foreground job pid
    if (sigprocmask(SIG_SETMASK, &mask_prev, NULL) < 0)//检查sigprocmask是否正常
            unix_error("sigprocmask error");
    if (pid != 0) {
        //向前台进程组发送SIGTSTP，故是-pid（子进程的进程组ID与PID相同）
        kill(-pid, SIGTSTP);
    }
    errno = olderrno;
    return;

}






void clearjob(struct job_t *job)
{
    job->pid = 0;
    job->jid = 0;
    job->state = UNDEF;
    job->cmdline[0] = '';
}


void initjobs(struct job_t *jobs)
{
    int i;

    for (i = 0; i < MAXJOBS; i++)
        clearjob(&jobs[i]);
}


int maxjid(struct job_t *jobs)
{
    int i, max=0;

    for (i = 0; i < MAXJOBS; i++)
        if (jobs[i].jid > max)
            max = jobs[i].jid;
    return max;
}


int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline)
{
    int i;

    if (pid < 1)
        return 0;

    for (i = 0; i < MAXJOBS; i++)
    {
        if (jobs[i].pid == 0)
        {
            jobs[i].pid = pid;
            jobs[i].state = state;
            jobs[i].jid = nextjid++;
            if (nextjid > MAXJOBS)
                nextjid = 1;
            strcpy(jobs[i].cmdline, cmdline);
            if(verbose)
            {
                printf("Added job [%d] %d %sn", jobs[i].jid, jobs[i].pid, jobs[i].cmdline);
            }
            return 1;
        }
    }
    printf("Tried to create too many jobsn");
    return 0;
}


int deletejob(struct job_t *jobs, pid_t pid)
{
    int i;

    if (pid < 1)
        return 0;

    for (i = 0; i < MAXJOBS; i++)
    {
        if (jobs[i].pid == pid)
        {
            clearjob(&jobs[i]);
            nextjid = maxjid(jobs)+1;
            return 1;
        }
    }
    return 0;
}


pid_t fgpid(struct job_t *jobs)
{
    int i;

    for (i = 0; i < MAXJOBS; i++)
        if (jobs[i].state == FG)
            return jobs[i].pid;
    return 0;
}


struct job_t *getjobpid(struct job_t *jobs, pid_t pid)
{
    int i;

    if (pid < 1)
        return NULL;
    for (i = 0; i < MAXJOBS; i++)
        if (jobs[i].pid == pid)
            return &jobs[i];
    return NULL;
}


struct job_t *getjobjid(struct job_t *jobs, int jid)
{
    int i;

    if (jid < 1)
        return NULL;
    for (i = 0; i < MAXJOBS; i++)
        if (jobs[i].jid == jid)
            return &jobs[i];
    return NULL;
}


int pid2jid(pid_t pid)
{
    int i;

    if (pid < 1)
        return 0;
    for (i = 0; i < MAXJOBS; i++)
        if (jobs[i].pid == pid)
        {
            return jobs[i].jid;
        }
    return 0;
}


void listjobs(struct job_t *jobs)
{
    int i;

    for (i = 0; i < MAXJOBS; i++)
    {
        if (jobs[i].pid != 0)
        {
            printf("[%d] (%d) ", jobs[i].jid, jobs[i].pid);
            switch (jobs[i].state)
            {
            case BG:
                printf("Running ");
                break;
            case FG:
                printf("Foreground ");
                break;
            case ST:
                printf("Stopped ");
                break;
            default:
                printf("listjobs: Internal error: job[%d].state=%d ",
                       i, jobs[i].state);
            }
            printf("%s", jobs[i].cmdline);
        }
    }
}






void usage(void)
{
    printf("Usage: shell [-hvp]n");
    printf("   -h   print this messagen");
    printf("   -v   print additional diagnostic informationn");
    printf("   -p   do not emit a command promptn");
    exit(1);
}


void unix_error(char *msg)
{
    fprintf(stdout, "%s: %sn", msg, strerror(errno));
    exit(1);
}


void app_error(char *msg)
{
    fprintf(stdout, "%sn", msg);
    exit(1);
}


handler_t *Signal(int signum, handler_t *handler)
{
    struct sigaction action, old_action;

    action.sa_handler = handler;
    sigemptyset(&action.sa_mask); 
    action.sa_flags = SA_RESTART; 

    if (sigaction(signum, &action, &old_action) < 0)
        unix_error("Signal error");
    return (old_action.sa_handler);
}


void sigquit_handler(int sig)
{
    printf("Terminating after receipt of SIGQUIT signaln");
    exit(1);
}