[시스템 프로그래밍] Shall Lab

 

 

 

 

🧐 Trace00

EOF(ctrl + d) 입력을 받으면 프로그램을 종료시켜야 합니다.

 main문을 보면 다음과 같이 이미 구현되어 있는 것을 알 수 있습니다.

while(1)을 통해 쉘을 계속 실행시키다가 ctrl + d가 입력되면 프로그램을 종료합니다.

 

 

 

 

 

 

 

🧐 Trace01

quit 명령어를 built-in command로 등록합니다.
quit이 입력되면 프로그램이 종료되어야 합니다.

void eval(char *cmdline) {

    cahr * argv[MAXARGS];

    parseline(cmdline, argv);

    builtin_cmd(argv);

    return;
}


int builtin_cmd(char **argv) {

    char * cmd = argv[0];

    if (!strcmp(cmd, "quit")) {
        exit(0);
    }

    return 0;
}

 

우선 built-in command로 등록하여야 하기 때문에 builtin_cmd 함수 내부에 작성해 주었습니다.

 

if문을 통해 들어온 입력(cmd)이 "quit"와 동일한 경우 exit(0)을 통해 프로그램을 종료하도록 구현하였습니다.

 

 

 

 

 

 

 

 

 

 

 

 

🧐 Trace02

실행파일을 foreground job으로 실행시킵니다.

이때 실행되는 실행파일의 이름은 ./myenv로써, 환경변수를 출력합니다.

myenv.c 파일은 다음과 같습니다.

int main()
{
    printf("OSTYPE=%s\n", getenv("PATH"));
    fflush(stdout);
    exit(0);
}

 

작성되는 코드는 아래와 같습니다.

void eval(char *cmdline) {
    char * argv[MAXARGS];

    int bg = parseline(cmdline, argv);

    pid_t pid;

    if (builtin_cmd(argv)) {
        return;
    }

    if ((pid = fork()) == 0) { // 자식 프로세스인 경우
        execve(argv[0], argv, environ);
        // 실행파일을 찾지 못한 경우 실행
        printf("%s : Command not found\n", argv[0]); // argvp[0]에는 관습에 의하여 실행파일의 이름 저장
        exit(0); // 종료
    }

    if (bg) {
        return;
    }

    // foregrond job의 경우
    int child_status;

    waitpid(pid, &child_status, 0);

    return;
}

우선 builtin_cmd인 경우 이를 실행시키고 바로 return 하도록 하였습니다.

이후 fork를 통해 자식 프로세스를 생성합니다.

fork()는 2번 return하는 함수이며, 자식 프로세스인 경우 리턴값이 0, 부모 프로세스인 경우 생성되는 자식의 pid 값을 반환합니다.

 

이후 0과 비교하는 조건을 통해 자식 프로세스인지를 판단하고, 자식 프로세스인 경우 execve를 통해 실행파일을 찾아 실행하도록 해주었습니다.

 

execve는 파일 이름을 찾을 수 없어 에러가 발생한 경우에만 -1을 통해 리턴하며, 이외의 경우 절대 return하지 않으므로 따로 조건문을 통해 처리해주지 않았습니다.

 

만약 return되는 경우 '[실행하고자 했던 파일 이름] : Command not found' 가 출력되고

exit(0)를 통해 생성된 자식 프로세스가 종료됩니다.

 

부모 프로세스의 경우에는 fork가 위치한 부분의 조건문에 걸리지 않고 넘어가서 background job인지 foreground job인지를 판단하게 됩니다.

 

parseline의 코드 마지막 부분을 보면 다음 코드가 있는것을 알 수 있습니다.

즉 parseline은 입력된 명령어의 마지막에 &가 있는 경우 1을 반환시킵니다.

eval 함수의 시작 부분에서 int bg = parseline()을 통해, background job으로 실행시켜야 하는지에 대한 여부를 받아옵니다.

trace02에서는 background job의 경우 아무런 처리를 하지 않아도 되므로, 바로 return시켜주도록 코드를 작성하였습니다.

 

foreground job의 경우 fork()로 생성된 자식 프로세스를 waitpid를 통해 제거해 줌으로써 좀비 프로세스를 방지하도록 코드를 작성하였습니다.

 

 

 

 

 

 

 

 

🧐 Trace03

foreground job을 argument 없이 실행시킵니다.

Trace02의 다음 코드를 살펴보겠습니다.

execve(argv[0], argv, environ);

 argv를 두번째 인자로 넘김으로써, 매개변수를 함께 전달하였습니다.

이때 매개변수가 없다면 매개변수 없이 실행되므로, 따로 코드의 수정 없이 Trace03이 통과합니다.

 

 

 

 

🧐 Trace04

foreground job을 argument와 함께실행시킵니다.

Trace02에서 argv를 두번째 인자로 넘김으로써, 매개변수를 함께 전달하였습니다.

이때 매개변수가 있다면 매개변수 있이 실행되므로, 따로 코드의 수정 없이 Trace04가 통과합니다.

 

 

 

 

 

 

 

🧐 Trace05

background job을 실행합니다.

background job은 wait, 혹은 waitpid를 사용할 수 없습니다.(정확히는 사용한다면 그것은 background job이 아니게 됩니다.)

따라서 자식 프로세스의 종료를 처리해 줄 필요가 있는데, 이는 Trace05에서는 요구하지 않으므로 요구하는 Trace로 넘기도록 하겠습니다.

 

우선 Trace05는 myspin1을 실행하였을 때 다음과 같이 출력되어야 함을 tshref를 통해 확인하였습니다.

 

(1)은 JId(Job Id), 3425256은 pid, ./myspin1 & 은 커맨드라인에 입력한 명령어를 의미합니다.

즉 이에 맞추어 코드를 작성하면 다음과 같습니다.

void eval(char *cmdline) {
    char * argv[MAXARGS];

    int bg = parseline(cmdline, argv);

    pid_t pid;

    if (builtin_cmd(argv)) {
        return;
    }

    if ((pid = fork()) == 0) { // 자식 프로세스인 경우
        execve(argv[0], argv, environ);
        // 실행파일을 찾지 못한 경우 실행
        printf("%s : Command not found\n", argv[0]); // argvp[0]에는 관습에 의하여 실행파일의 이름 저장
        exit(0); // 종료
    }

    // 자식 프로세스가 아닌 경우 jobs에 추가합니다.
    addjob(jobs, pid, ((bg == 1) ? BG : FG), cmdline);

    if (bg) {
        printf("(%d) (%d) %s", pid2jid(pid), pid, cmdline);
        return;
    }

    // foregrond job의 경우
    int child_status;

    waitpid(pid, &child_status, 0);
    deletejob(jobs, pid); // jobs에서 제거된 자식을 삭제합니다.

    return;
}

위와 같이 코드를 작성해주면 trace05가 통과하는 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

 

🧐 Trace06

foreground job과 background job을 실행합니다

이전까지의 Trace에서 foreground job과 backgound job을 실행시키는 코드를 모두 작성하였습니다.

따라서 Trace05의 코드와 동일합니다.

 

 

 

 

 

 

🧐 Trace07

jobs 명령어를 built-in command로 등록합니다.
jobs 입력 시 jobs에 등록된 job들의 정보를 모두 출력합니다.

우선 job들의 정보 출력은 listjobs 함수로 이미 정의되어 있습니다.

 

즉 이를 단지 built-in command로 등록하여 사용해주면 Trace07을 통과할 수 있고, 코드는 다음과 같습니다.

int builtin_cmd(char **argv) {
    char *cmd = argv[0];

    // 명령어가 quit인 경우
    if (!strcmp(cmd, "quit")) {
        exit(0);
    }

    // trace07 : jobs 추가
    if (!strcmp(cmd, "jobs")) {
        listjobs(jobs, 1);
        return TRUE;
    }

    return FALSE;
}

eval 함수 부분은 수정되지 않습니다.

 

 

 

 

 

 

 

 

 

 

🧐 Trace08

SIGINT 시그널을 foreground job에게로 보냅니다.
foreground job은 SIGINT를 받으면 해당 시그널을 발생시킨 process를 종료(terminate)시킵니다.

우선 trace08의 설명을 보면 다음과 같이 myintp를 실행시키는 것을 알 수 있습니다.

 

 

이는 다음과 같은 코드로써, SIGINT를 getppid()를 통해 자신의 부모 프로세스에게 송신하는 것을 알 수 있습니다.

 

그리고 tshref를 통해 실행시켜 보면 다음과 같이 출력되는 것을 알 수 있습니다.

[1]은 job id,

(3439063)은 pid,

by signal 2에서 2는 자식프로세스를 종료하도록한 신호의 번호를 의미합니다.

이때 시그널 2번은 SIGINT를 의미합니다.

따라서 자식이 SIGINT 시그널을 받고 종료되었다는 것을 알 수 있습니다.

 

 

 

또한 tsh.c의 main을 보면 다음과 같이 sigint_handler와 sigtstp_handler, sigchld_handler가 미리 등록된 것을 확인할 수 있습니다.

 

 

이제 Trace08의 과정을 살펴보도록 하겠습니다.

 

우선 tsh 쉘에서 myintp 실행파일을 실행합니다.

 

myintp에서는 부모 프로세스의 pid를 알아낸 뒤, 해당 pid로 SIGINT 시그널을 송신합니다.

 

부모 프로세스(tsh 쉘)에서는 이를 sigint_handler를 통해 받아낸 후, jobs에 등록된 job들 중 foreground에서 작동하는 작업, 즉 myintp의 pid를 알아냅니다.

 

이후 해당 pid에 다시 SIGINT를 보내게 됩니다.

 

myintp에서는 SIGINT handler가 정의되어 있지 않으므로(핸들러는 부모로부터 상속되지 않습니다) 기본 동작으로 작동하며, 따라서 프로세스가 종료됩니다.

 

myintp 프로세스가 종료되었으므로 SIGCHLD 시그널이 부모 시그널에게 전달됩니다.

 

부모 프로세스에서는 이를 sigchld_handler를 통해 받아낸 후, waitpid를 통해 종료된 자식 프로세스가 좀비가 되지 않도록 자원을 회수합니다.

 

WIFSIGNALED(child_status)는 자식 프로세스가 어떤 시그널을 통해 종료된 경우 true를 리턴합니다.

 

따라서 WIFSIGNALED를 사용하여 자식 프로세스가 SIGINT를 통해 종료된 경우 WTERMSIG를 통해 자식프로세스를 종료하도록한 시그널의 번호(SIGINT)를 얻어내 이를 통해 정보를 출력합니다.

 

 

이를 위한 코드는 다음과 같습니다.

void eval(char *cmdline) {
    // Block할 시그널
    sigset_t mask;

    // 이전 Block 상태 저장용 시그널
    sigset_t prev;

    sigemptyset(&mask);        // 모든 시그널 0으로 채우기
    sigaddset(&mask, SIGINT);  // SIGINT 1로 Block
    sigaddset(&mask, SIGCHLD); // SIGCHLD 1로 Block

    char *argv[MAXARGS];
    int bg = parseline(cmdline, argv);

    if (builtin_cmd(argv)) {
        return;
    }

    sigprocmask(SIG_BLOCK, &mask, &prev); // Block 추가하기

    pid_t pid;
    if ((pid = fork()) == 0) { // 자식 프로세스인 경우
        // SIGNAL Block 이전 상태로 복원
        // execve 실행 시 blocked는 부모로부터 상속되므로 언블락 해주고 실행해야 함.
        sigprocmask(SIG_SETMASK, &prev, NULL);

        execve(argv[0], argv, environ);
        printf("%s : Command not found\n\n", argv[0]);
        exit(0);
    }

    // 자식 프로세스가 아닌 경우 jobs에 추가합니다.
    addjob(jobs, pid, ((bg == 1) ? BG : FG), cmdline);


    if (bg) {
        printf("(%d) (%d) %s", pid2jid(pid), pid, cmdline);
        // SIGNAL Block 이전 상태로 복원
        sigprocmask(SIG_SETMASK, &prev, NULL);
        return;
    }

    while (1) {  // SIGCHLD signal을 통해 자식 프로세스 제거할때까지 반복
        if (pid != fgpid(jobs)) {
            break;
        }

        sigsuspend(&prev);
    }

    // SIGNAL Block 이전 상태로 복원
    sigprocmask(SIG_SETMASK, &prev, NULL);
    return;
}




void sigchld_handler(int sig) {
    int child_status = 0;
    pid_t pid;
    while ((pid = waitpid(-1, &child_status, WNOHANG)) > 0) {
        //자식프로세스가 어떤 시그널때문에 종료되었다면 참을 반환
        if (WIFSIGNALED(child_status)) {
            printf("Job [%d] (%d) terminated by signal %d\n",
                   pid2jid(pid),
                   pid,
                   WTERMSIG(child_status));
            deletejob(jobs, pid);
        } else {
            deletejob(jobs, pid);
        }
    }
    return;
}


void sigint_handler(int sig) {
    pid_t pid = fgpid(jobs);

    if (pid != 0) {
        kill(pid, sig);
    }
    return;
}

 

 

 

 

 

 

 

 

 

 

🧐 Trace09

SIGTSTP 시그널을 foreground job에게로 보냅니다.
foreground job은 SIGTSTP를 받으면 해당 시그널을 발생시킨 process를 정지 상태로 만듭니다.

Trace09는 Trace08과 비슷하지만 중요한 차이점이 존재합니다.

 

첫번째 차이점은 SIGTSTP를 받으면 foreground job이 종료되는 것이 아닌 정지되어야 합니다.

따라서 deletejob을 수행해주지 않으며, state를 ST로 변경해 주어야 합니다.

 

ST는 다음과 같이 미리 정의되어 있습니다.

 

우선 SIGTSTP를 Block하기 위해 eval 함수를 다음과 같이 수정해 주었습니다.

void eval(char *cmdline) {
    // Block할 시그널
    sigset_t mask;

    // 이전 Block 상태 저장용 시그널
    sigset_t prev;

    sigemptyset(&mask);        // 모든 시그널 0으로 채우기
    sigaddset(&mask, SIGINT);  // SIGINT 1로 Block
    sigaddset(&mask, SIGCHLD); // SIGCHLD 1로 Block
    sigaddset(&mask, SIGTSTP); // SIGTSTP 1로 Block

    char *argv[MAXARGS];
    int bg = parseline(cmdline, argv);

    if (builtin_cmd(argv)) {
        return;
    }

    sigprocmask(SIG_BLOCK, &mask, &prev); // Block 추가하기

    pid_t pid;
    if ((pid = fork()) == 0) { // 자식 프로세스인 경우
        // SIGNAL Block 이전 상태로 복원
        sigprocmask(SIG_SETMASK, &prev, NULL);

        execve(argv[0], argv, environ);
        printf("%s : Command not found\n\n", argv[0]);
        exit(0);
    }

    // 자식 프로세스가 아닌 경우 jobs에 추가합니다.
    addjob(jobs, pid, ((bg == 1) ? BG : FG), cmdline);


    if (bg) {
        printf("(%d) (%d) %s", pid2jid(pid), pid, cmdline);
        // SIGNAL Block 이전 상태로 복원
        sigprocmask(SIG_SETMASK, &prev, NULL);
        return;
    }

    while (1) {  // SIGCHLD signal을 통해 자식 프로세스 제거할때까지 반복
        if (pid != fgpid(jobs)) {
            break;
        }

        sigsuspend(&prev);
    }

    // SIGNAL Block 이전 상태로 복원
    sigprocmask(SIG_SETMASK, &prev, NULL);
    return;
}

 

이후 sigchld_handler는 다음과 같이 수정하였습니다.

 

void sigchld_handler(int sig) {
    int child_status = 0;
    pid_t pid;

    while ((pid = waitpid(-1, &child_status, WNOHANG | UNTRACED)) > 0) {
        if (WIFSIGNALED(child_status)) {
            printf("Job [%d] (%d) terminated by signal %d\n",
                   pid2jid(pid),
                   pid,
                   WTERMSIG(child_status));
            deletejob(jobs, pid);
        }
        if (WIFSTOPPED(child_status)) {
            getjobpid(jobs, pid)->state = ST;
            printf("Job [%d] (%d) stopped by signal %d\n",
                   pid2jid(pid),
                   pid,
                   WSTOPSIG(child_status)); // 정지된 상태가 되도록 한 시그널 번호
        }
        if (WIFEXITED(child_status)) {
            deletejob(jobs, pid);
        }
    }
}

SIGCHLD 는 자식이 정지한 경우에도 발생하므로, 결국 mytstpp 가 SIGTSTP 로 인해 정지된 경우 부모 프로세스에게 SIGCHLD 가 전달됩니다.

Trace08과는 달리 정지된 프로세스를 잡아와서 Stop 상태로 바꿔주어야 하므로 WNOHANG | WUNTRACED를 통해 종료되거나 정지한 자식의 pid를 받아오거나 없다면 바로 return되도록 해주었습니다.

이후 WIFSTOPPED를 통해 자식이 정지한 경우 요구사항에 맞게 처리해 주도록 코드를 작성하였습니다.

 

sigtstp_handler는 sigint_handler와 동일합니다.

void sigtstp_handler(int sig) {
    pid_t pid = fgpid(jobs);

    if (pid != 0) {
        kill(pid, sig);
    }
    return;
}

 

 

 

 

 

 

🧐 Trace10

SIGTERM시그널을 background job에게로 보냅니다.
foreground job은 SIGTERM를 받으면 해당 시그널을 발생시킨 process를 종료시킵니다.

아래 trace10.txt 파일을 통해 myspin1 프로그램을 background로 5초동안 실행시키며,

이후 /bin/kill을 통해 SIGTERM을 발생시키는 것을 알 수 있습니다. (아무런 인자가 없으므로 기본 동작이 SIGTERM 입니다.)

 

 

Trace09코드에서 sigchild_handler 코드를 보면 다음과 같습니다.

void sigchld_handler(int sig) {
    int child_status = 0;
    pid_t pid;

    while ((pid = waitpid(-1, &child_status, WNOHANG | WUNTRACED)) > 0) {
        if (WIFSIGNALED(child_status)) {
            printf("Job [%d] (%d) terminated by signal %d\n",
                   pid2jid(pid),
                   pid,
                   WTERMSIG(child_status));
            deletejob(jobs, pid);
        }
        if (WIFSTOPPED(child_status)) {
            getjobpid(jobs, pid)->state = ST;
            printf("Job [%d] (%d) stopped by signal %d\n",
                   pid2jid(pid),
                   pid,
                   WSTOPSIG(child_status)); // 정지된 상태가 되도록 한 시그널 번호
        }
        if (WIFEXITED(child_status)) {
            deletejob(jobs, pid);
        }
    }
}

Trace10의 경우 SIGTERM에 의해 종료되므로 WIFSIGNALED에 걸려서 처리됩니다.

 

 

 

 

 

 

 

🧐 Trace11 & Trace12

자식 프로세스가 자기 자신에게  SIGINT, SIGTSTP 시그널을 전송합니다.

Trace08, Trace09를 정확히 구현하였다면 올바르게 동작합니다.

Trace11과 Trace12에서는 각각 myints와 mytstps를 사용하는데 각각의 파일은 다음과 같습니다.

 

두 파일 모두 getpid() 를 통해 자기 자신의 pid를 얻어온 후, 시그널을 발생시킵니다.

위 두 경우 모두 자기 자신에게 시그널이 도착하므로 Trace08, Trace09와 동일한 과정을 거쳐 시그널이 처리되므로 따로 구현해 줄 필요 없이 통과할 수 있습니다.