ardxwe

struct job_t {              /* The job struct */
    pid_t pid;              /* job PID */
    int jid;                /* job ID [1, 2, ...] */
    int state;              /* UNDEF, BG, FG, or ST */
    char cmdline[MAXLINE];  /* command line */
};

struct job_t jobs[MAXJOBS]; /* The job list */

addjob(jobs, pid, runbg ? BG : FG, cmdline);

void sigtstp_handler(int sig) 
{

#if DEBUG
    printf("sig: %d\n", sig);
    fflush(stdout);
    printf("sigstophandle\n");
    fflush(stdout);
#endif

    sigprocmask(SIG_BLOCK, &mask, NULL);
    pid_t pid = fgpid(jobs);
    struct job_t* job = getjobpid(jobs, pid);
    if (job) {
        job->state = ST;
        fflush(stdout);
        kill(-pid, SIGTSTP);
        printf("Job [%d] (%d) stoped by signal %d\n", pid2jid(pid), pid, SIGTSTP);
        fflush(stdout);
    }
    sigprocmask(SIG_SETMASK, &prev, NULL);
    fflush(stdout);
    return;
}

if ((pid = fork()) < 0){
        unix_error("fork error");
    }
    else if (pid == 0){
        /*child process */
        setpgid(0, 0);
        sigprocmask(SIG_SETMASK, &prev, NULL);
        Signal(SIGINT, SIG_DFL);
        Signal(SIGTSTP, SIG_DFL);
        Signal(SIGCHLD, SIG_DFL);
        Signal(SIGQUIT, SIG_DFL);

#if DEBUG
        printf("\n");
        fflush(stdout);
        printf("child process\npid: (%d)", getpid());
        fflush(stdout);
        printf("cmdline: %s", cmdline);
        fflush(stdout);
#endif

        execv(argv[0], argv);
        /* error */
        printf("%s: Command not found\n", argv[0]);
        fflush(stdout);
        exit(0);
    }
    else {
        /* father process */
        prevpid = pid;

while(prevpid != 0) {
    sigsuspend(&emptyset);
}

while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0){
    if(pid == prevpid) {
        prevpid = 0;
    }
    if (WIFSTOPPED(status)) {

        struct job_t* job = getjobpid(jobs, pid);
        if (job->state == ST);
        else {
            job->state = ST;
            printf("Job [%d] (%d) stoped by signal %d\n", pid2jid(pid), pid, SIGTSTP);
            fflush(stdout);
        } 
    }
    else if(WIFSIGNALED(status)) {
        if (WTERMSIG(status) == SIGINT) {
            if (getjobpid(jobs, pid) != NULL) {
                printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, SIGINT);
                fflush(stdout);
            }
        }
        deletejob(jobs, pid);
    }
    else if(WIFEXITED(status)){

#if DEBUG
        printf("退出值为 %d\n", WEXITSTATUS(status));
        fflush(stdout);
#endif

        deletejob(jobs, pid);
    }
    else if (WIFCONTINUED(status)) {
        printf("continued\n");
        fflush(stdout);
    }

#if DEBUG
    printf("childhandle pid: %d\n", pid);
    fflush(stdout);
#endif

}

void ioredirection(char** argv) {
    int endcmd = 0x7FFFFFFF;
    for (int i = 0; argv[i] != NULL; i++) {
        if (strcmp(argv[i], "<") == 0) {
            isredirect = true;
            if(freopen(argv[i+1], "r", stdin) == NULL) {
                return unix_error("io redirection error.\n");
            }
            if(endcmd > i) {
                endcmd = i;
            }
        }
        else if (strcmp(argv[i], ">") == 0) {
            isredirect = true;
            if (freopen(argv[i+1],"a",stdout) == NULL) {
                return unix_error("io redirection error.\n");
            }
            if (endcmd > i) {
                endcmd = i;
            }
        }
    }
    if(endcmd != 0x7FFFFFFF) {
        argv[endcmd] = NULL;
    }
}

if (isredirect) {
    if (freopen("/dev/tty", "r", stdin) == NULL) {
        unix_error("io redirection error.");
    }
    if (freopen("/dev/tty", "w", stdout) == NULL) {
        unix_error("io redirection error.");
    }
    isredirect = false;
}

void sigint_handler(int sig) 
{

#if DEBUG
    printf("sigint handle call\n");
    fflush(stdout);
#endif

    sigprocmask(SIG_BLOCK, &mask, NULL);
    pid_t pid = fgpid(jobs);
    struct job_t* job = getjobpid(jobs, pid);
    if (job != NULL) {
        printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, SIGINT);
        fflush(stdout);
        deletejob(jobs, pid);
    }
    sigprocmask(SIG_SETMASK, &prev, NULL);

    if (pid) {
        kill(-pid, SIGINT);
    }
    else {
        exit(0);
    }
    return;
}

ardxwe@ardxwe ~/github/CS15-213labs/shlab-handout$ cat trace15.txt
#
# trace15.txt - Putting it all together
#

/bin/echo tsh> ./bogus
./bogus

/bin/echo tsh> ./myspin 10
./myspin 10

SLEEP 2
INT

/bin/echo -e tsh> ./myspin 3 \046
./myspin 3 &

/bin/echo -e tsh> ./myspin 4 \046
./myspin 4 &

/bin/echo tsh> jobs
jobs

/bin/echo tsh> fg %1
fg %1

SLEEP 2
TSTP

/bin/echo tsh> jobs
jobs

/bin/echo tsh> bg %3
bg %3

/bin/echo tsh> bg %1
bg %1

/bin/echo tsh> jobs
jobs

/bin/echo tsh> fg %1
fg %1

/bin/echo tsh> quit
quit

ardxwe@ardxwe ~/github/CS15-213labs/shlab-handout$ make test15 
./sdriver.pl -t trace15.txt -s ./tsh -a "-p"
#
# trace15.txt - Putting it all together
#
tsh> ./bogus
./bogus: Command not found
tsh> ./myspin 10
Job [1] (18375) terminated by signal 2
tsh> ./myspin 3 &
[1] (18388) ./myspin 3 &
tsh> ./myspin 4 &
[2] (18390) ./myspin 4 &
tsh> jobs
[1] (18388) Running ./myspin 3 &
[2] (18390) Running ./myspin 4 &
tsh> fg %1
Job [1] (18388) stoped by signal 20
tsh> jobs
[1] (18388) Stopped ./myspin 3 &
[2] (18390) Running ./myspin 4 &
tsh> bg %3
No such job
tsh> bg %1
[1] (18388) ./myspin 3 &
tsh> jobs
[1] (18388) Running ./myspin 3 &
[2] (18390) Running ./myspin 4 &
tsh> fg %1
tsh> quit

#include <signal.h>
typedef void(*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

#include <signal.h>
/* 所有信号的对应位清0 */
int sigemptyset(sigset_t *set);

/* 设置所有的信号，包括系统支持的所有信号 */
int sigfillset(sigset_t *set);

/* 在该信号集中添加有效信号 */
int sigaddset(sigset_t *set, int signo);

/* 在该信号集中删除有效信号 */
int sigdelset(sigset_t *set, int signo);

/* 判断一个信号集的有效信号中是否包含某种信号 */
int sigismember(const sigset_t *set, int signo);

/*
 * how:
 * SIG_BLOCK     信号屏蔽字是其当前信号屏蔽字和set指向信号集的并集，set包含了希望阻塞的信号
 * SIG_UNBLOCK   信号屏蔽字是其当前信号屏蔽字和set所指向信号集补集的交集，set包含了希望解除阻塞的信号
 * SIG_SETMASK   信号屏蔽字将被set指向的信号集的值代替
*/
int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);

/*sigpending读取当前进程的未决信号集,通过set参数传出 */
int sigpending(sigset_t *set);

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdbool.h>

void printsigset(const sigset_t *pset)
{
    for (int i = 0; i < 64; i++)
    {
        if (sigismember(pset, i + 1))
            putchar('1');
        else
            putchar('0');
        fflush(stdout);
    }
    printf("\n");
    fflush(stdout);
}

void siginthandle(int sig) {
    printf("sigint handle call\n");
    sleep(1);
    return;
}

int main() {
    signal(SIGINT, siginthandle);

    sigset_t sigint, prev;
    sigemptyset(&sigint);
    sigaddset(&sigint, SIGINT);
    sigprocmask(SIG_BLOCK, &sigint, &prev);

    int count = 1;
    while(true) {
        sigset_t now, pending;

        printf("block   set:");
        fflush(stdout);
        sigprocmask(SIG_BLOCK, NULL, &now);
        printsigset(&now);
        sigpending(&pending);
        printf("pending set:");
        fflush(stdout);
        printsigset(&pending);
        sleep(1);
        count++;
        if (count == 5) {
            sigprocmask(SIG_SETMASK, &prev, NULL);
        }
        else if (count == 10) {
            break;
        }
    }
    return 0;
}

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdbool.h>


void siginthandle(int sig) {
    printf("sigint handle call\n");
    unsigned int rs = sleep(5);
    printf("remain seconds: %d\n", rs);
    return;
}

void sigtstphandle(int sig) {
    printf("sigtstp handle call\n");
    sleep(1);
    return;
}

int main() {
    signal(SIGINT, siginthandle);
    signal(SIGTSTP, sigtstphandle);

    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGTSTP);

    unsigned int rs = sleep(5);
    printf("main routine remain seconds: %d\n", rs);
    return 0;
}

#include <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd);

pid_t pid;

if((pid=fork()) < 0) {
    printf("fork error\n");
    return -1;
}
else if (pid == 0) {
    /* child process */
    ...
}
else {
    /* father process */
    ...
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
#include <unistd.h>

// #define NDEBUG
#define print(x) if (infoflag) printf(x)

#include "cachelab.h"
#include "assert.h"

void getaddrfromline(char* buff, char* result);
long getlownnumber(long addr, long n);

int main(int argc, char* argv[])
{
    // 记录次数
    long hit_count = 0;
    long eviction_count = 0;
    long miss_count = 0;

    // 缓存相关数据
    long tagbits = 0;
    long setsbits = 0;
    long linesperset = 0;
    long blockbits = 0;

    // 文件名
    char* filename = NULL;

    // 是否输出具体信息
    bool infoflag = false;

    // 文件
    FILE* fp = NULL;

    // 实现 LRU 变量
    long max = 1;

    // 解析命令行参数
    for (long i=1; i<argc; i++){
        size_t length = strlen(argv[i]);
        assert(length == 2);
        switch (argv[i][1])
        {
        case 'v':
            infoflag = true;
            break;
        
        case 's':
            setsbits = atoi(argv[++i]);
            break;
        
        case 'E':
            linesperset = atoi(argv[++i]);
            break;
        
        case 'b':
            blockbits = atoi(argv[++i]);
            break;
        
        case 't':
            filename = argv[++i];
            break;

        default:
            fprintf(stderr, "Parameter error, you should use -v -s number -E number -b number -t filename");
            return -1;
        }

    }

    // 地址剩余位数应该为 tag 的位数
    tagbits = sizeof(void*) * 8 - setsbits - blockbits;

    assert(tagbits > 0);

    // cache块数
    long count = (1 << setsbits) * linesperset;

    // tag 和 used 用来模拟 cache
    // calloc: malloc and memset 0
    long* tagptr = calloc(count, sizeof(long));
    long* usedptr = calloc(count, sizeof(long));

    if (usedptr == NULL || tagptr == NULL){
        fprintf(stderr, "calloc error.");
        return -1;
    }

    fp = fopen(filename, "r");

    char buff[1024];
    char number[1024];
    long addr;

    long set;
    long tag;

    while (fgets(buff, 1024, fp) != NULL) {
        memset(number, 0, 1024);

        // 忽略 I 开头的行
        if(*(buff) == 'I')continue;

        // 去掉行尾回车
        if(buff[strlen(buff)-1] == '\n')buff[strlen(buff)-1] = '\0';

        // 去掉行头空格
        if(infoflag && buff[0] == ' ') {
            printf("%s ", buff + 1);
        }
        else if (infoflag) {
            printf("%s ", buff);
        }

        // 得到地址 存于 number
        getaddrfromline(buff, number);
        sscanf(number, "%lx", &addr);

        // 得到地址对应的 tag set
        tag = getlownnumber(addr >> (blockbits + setsbits), tagbits);
        set = getlownnumber(addr >> blockbits, setsbits);

        // cache 行
        long* nowptr = usedptr + set * linesperset;

        long* this = nowptr;

        bool allone = true;
        
        // 试图找到 tag
        for (int i=0; i < linesperset; i++) {
            if (*this != 0) {
                if (*(tagptr + set * linesperset + i) == tag) {
                    if (*(buff+1) == 'M') {
                        print("hit hit \n");
                        hit_count++;
                    }
                    else {
                        print("hit \n");
                    }
                    (*this) = max++;
                    hit_count++;
                    goto ff;
                }
            }
            else allone = false;
            this++;
        }

        long index = 0;

        // 有空余块
        if (allone == false) {
            this = nowptr;
            for (int i=0; i < linesperset; i++) {
                if (*this == 0) {
                    *(tagptr + set * linesperset+i) = tag;
                    break;
                }
                this++;
            }
            *this = max++;
            if (*(buff+1) == 'M') {
                print("miss hit \n");
                hit_count++;
                *this = max++;
            }
            else {
                print("miss \n");
            }
            miss_count++;
        }

        // 驱逐
        else {
            long min = 0x7FFFFFFFFFFFFFFF;
            this = nowptr;
            for (int i=0; i < linesperset; i++) {
                if (*this != 0 && ((*this) < min)) {
                    min = *this;
                    index = i;
                }
                this++;
            }
            *(tagptr + set *linesperset + index) = tag;
            *(nowptr + index) = max++;
            if (*(buff+1) == 'M') {
                print("miss eviction hit \n");
                hit_count++;
            }
            else {
                print("miss eviction \n");
            }
            miss_count++;
            eviction_count++;
        }
        ff:;
    }

    printf("hits:%ld ", hit_count);
    printf("misses:%ld ", miss_count);
    printf("evictions:%ld\n", eviction_count);
    // printSummary(hit_count, miss_count, eviction_count);
    free(tagptr);
    free(usedptr);
    fclose(fp);
    return 0;
}

void getaddrfromline(char* buff, char* result) {
    long start = 0;
    long end = 0;

    for (long i=0; ; i++) {
        if ((buff[i] == ' ') && (i != 0) &&(buff[i+1] != ' ')) {
            start = i + 1;
        }
        else if (buff[i] == ',') {
            end = i;
            break;
        }
    }
    strncpy(result, buff + start, end - start);
}

long getlownnumber(long addr, long n) {
    long x = 1;
    for (long i=1; i<n; i++) x = x | (x << 1);
    return x & addr;
}

/***************************************************************************
 * Dr. Evil's Insidious Bomb, Version 1.1
 * Copyright 2011, Dr. Evil Incorporated. All rights reserved.
 *
 * LICENSE:
 *
 * Dr. Evil Incorporated (the PERPETRATOR) hereby grants you (the
 * VICTIM) explicit permission to use this bomb (the BOMB).  This is a
 * time limited license, which expires on the death of the VICTIM.
 * The PERPETRATOR takes no responsibility for damage, frustration,
 * insanity, bug-eyes, carpal-tunnel syndrome, loss of sleep, or other
 * harm to the VICTIM.  Unless the PERPETRATOR wants to take credit,
 * that is.  The VICTIM may not distribute this bomb source code to
 * any enemies of the PERPETRATOR.  No VICTIM may debug,
 * reverse-engineer, run "strings" on, decompile, decrypt, or use any
 * other technique to gain knowledge of and defuse the BOMB.  BOMB
 * proof clothing may not be worn when handling this program.  The
 * PERPETRATOR will not apologize for the PERPETRATOR's poor sense of
 * humor.  This license is null and void where the BOMB is prohibited
 * by law.
 ***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "support.h"
#include "phases.h"

/* 
 * Note to self: Remember to erase this file so my victims will have no
 * idea what is going on, and so they will all blow up in a
 * spectaculary fiendish explosion. -- Dr. Evil 
 */

FILE *infile;

int main(int argc, char *argv[])
{
    char *input;

    /* Note to self: remember to port this bomb to Windows and put a 
     * fantastic GUI on it. */

    /* When run with no arguments, the bomb reads its input lines 
     * from standard input. */
    if (argc == 1) {  
    infile = stdin;
    } 

    /* When run with one argument <file>, the bomb reads from <file> 
     * until EOF, and then switches to standard input. Thus, as you 
     * defuse each phase, you can add its defusing string to <file> and
     * avoid having to retype it. */
    else if (argc == 2) {
    if (!(infile = fopen(argv[1], "r"))) {
        printf("%s: Error: Couldn't open %s\n", argv[0], argv[1]);
        exit(8);
    }
    }

    /* You can't call the bomb with more than 1 command line argument. */
    else {
    printf("Usage: %s [<input_file>]\n", argv[0]);
    exit(8);
    }

    /* Do all sorts of secret stuff that makes the bomb harder to defuse. */
    initialize_bomb();

    printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
    printf("which to blow yourself up. Have a nice day!\n");

    /* Hmm...  Six phases must be more secure than one phase! */
    input = read_line();             /* Get input                   */
    phase_1(input);                  /* Run the phase               */
    phase_defused();                 /* Drat!  They figured it out!
                      * Let me know how they did it. */
    printf("Phase 1 defused. How about the next one?\n");

    /* The second phase is harder.  No one will ever figure out
     * how to defuse this... */
    input = read_line();
    phase_2(input);
    phase_defused();
    printf("That's number 2.  Keep going!\n");

    /* I guess this is too easy so far.  Some more complex code will
     * confuse people. */
    input = read_line();
    phase_3(input);
    phase_defused();
    printf("Halfway there!\n");

    /* Oh yeah?  Well, how good is your math?  Try on this saucy problem! */
    input = read_line();
    phase_4(input);
    phase_defused();
    printf("So you got that one.  Try this one.\n");
    
    /* Round and 'round in memory we go, where we stop, the bomb blows! */
    input = read_line();
    phase_5(input);
    phase_defused();
    printf("Good work!  On to the next...\n");

    /* This phase will never be used, since no one will get past the
     * earlier ones.  But just in case, make this one extra hard. */
    input = read_line();
    phase_6(input);
    phase_defused();

    /* Wow, they got it!  But isn't something... missing?  Perhaps
     * something they overlooked?  Mua ha ha ha ha! */
    
    return 0;
}