Process Control & IPC#

Booting#

Bootstrapping#

開機用 program 在 BIOS 裡 (硬體檢查硬體)
並非 Unix kernel 本人

把 Unix kernel 的幾隻 process 叫起來 (OS 檢查硬體)
Unix kernel 將整個 system 叫起來到 single (super) user mode 做一些事情 e.g. check host name, timezone, disk data consistency
開啟 multiuser mode

Special process

PID 0: swapper (scheduler)
- kernel process 做一些 prior 的事情，躲在 partition
PID 1: init 所有 process 的共同祖先
- 把系統的 service 叫起來
- inetd: 管理 remote login 會 fork surface process 出來像是 telnetdaemon
PID 2: pagedaemon

Process Control Block (PCB)#

Process 的 metadate
Process states:
- New
- Running
- Waiting
- Ready
- Terminated
Program Counter (IP: Instruction Pointer)
CPU registers
- context switch 回來要 restore
CPU scheduling information
- priority 檢查
Memory-management information
Accounting information
- 紀錄任何時間參數
I/O status information

Process table#

每個 entry 都是 PCB，記錄當前所有 process
run 一次看看誰的 ppid 是自己就知道自己有多少 child 了

Context switch#

截圖 2025-10-16 上午9.53.12

Process Content & Metadata#

Content: Virtual memory
text: instruction
un-initialized data, initialized data: global variable
stack: local variable
heap: 只漲不縮

Process Creation & Termination#

截圖 2025-10-16 上午10.00.02

fork() 開始，會出現很多狀況: parent 先死, 直接 exec()
兩個 process 的關聯性只有 ppid

Virtual Memory 的運作

把整個 process copy 是 high-cost 的
把 virtual memory map 到 physical memory 上
- 對應在 p_ldt 上的 table
- Virtual Memory 用不完的，所以會有洞，但這樣浪費空間
Copy-on-write
- 當發現出現 share memory 要更改的時候再 copy
- 第一次開始寫入才真正複製

int     glob = 6;                        /* external > variable in initialized data */
char    buf[] = "a write to stdout\n";

int main(void) {
   int     var;                         /* automatic variable on the stack */
   pid_t   pid;

   var = 88;
   if (write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf)-1)
       err_sys("write error");
   printf("before fork\n");             /* we don't flush stdout */

   if ((pid = fork()) < 0)
       err_sys("fork error");
   else if (pid == 0) {                 /* child */
       glob++;                          /* modify variables */
       var++;
   } else {
       sleep(2);                        /* parent */
   }

   printf("pid = %d, glob = %d, var = %d\n", getpid(), glob, var);
   exit(0);
}

parent 睡兩秒
child 改變數

Result

$ ./a.out
a write to stdout
before fork
pid = 430, glob = 7, var = 89
pid = 429, glob = 6, var = 88

bash

$ ./a.out > temp.out
a write to stdout
before fork
pid = 430, glob = 7, var = 89
before fork
pid = 429, glob = 6, var = 88

bash

File 是 fully-buffered, Terminal 是 line-buffered.
- 有寫入 \n 但沒有 flush 出去，因為是 fully-buffered.
- 此時呼叫 fork() child copy 了一塊 parent 的 memeory 所以那句多出來的也被 copy 到了。

Normal cases in fork#

通常 parent 會等到 child 結束後 call wait() return 然後繼續運行
但也可以 parent 繼續做事 (跟 child 並行) 但 eventually 還是得呼叫 wait()
有 CHILD_MAX

Inherited properties

Effective UID, time, umask … etc

Differences on properties

PID/PPID
PCB 裡面的 time 是 process time 不是 program time
lock
pending SIGNAL

截圖 2025-10-16 上午10.51.20

int  glob = 6;        /* external variable in initialized data */

int main(void)
{
    int     var;         /* automatic variable on the stack */
    pid_t   pid;

    var = 88;
    printf("before vfork\n");    /* we don't flush stdio */
    if ((pid = vfork()) < 0) {
        err_sys("vfork error");
    } else if (pid == 0) {       /* child */
        glob++;                  /* modify parent's variables */
        var++;
        _exit(0);                /* child terminates */
    }
    /*
     * Parent continues here.
     */
    printf("pid = %d, glob = %d, var = %d\n", getpid(), glob, var);
    exit(0);
}

Child 先行，改動 parent 的 virtual memory 的空間
此處用 _exit() 因為 exit() 會被 flush 掉，parent 的 filestream 也會被關掉，要小心，如果 parent 要呼叫 Buffered I/O 會出問題

Deadlock#

三個 process 互相 lock 著對方需要的 condition
Lock 必須互斥，並且系統不可干預

int main(void) {
    int var;
    pid_t pid;

    var = 88;
    printf("before vfork\n");
    if ((pid = vfork()) < 0) {
        err_sys("vfork error");
    } else if (pid == 0) {      /* child */
        while (var < 100)
            ;                   /* busy wait */
        _exit(0);               /* child terminates */
    }

    /* parent continues here */
    var = 100;
    exit(0);
}

child 想等 var >= 100
parent 要等 child terminate

Process Termination#

Normal termination
- main 內部 call exit() 直接回到 kernel 直接消失
- 你不 exit()，C start-up routine 會幫你 exit(main(argc, argv));
- _exit() 就直接死，不 clean up
Abnormal termination
- Signal 傳出

int atexit(void (*func)(void));

可以註冊一連串 function先註冊再執行
在要死前執行（main return 後）
反向往回叫 stack

pid_t wait(int *statloc)

Blocking mode，任何一個 child 死掉就死了
return 值會是死掉 child 的 PID
statloc 會是死亡結束碼

pid_t waitpid(pid_t pid, int *statloc, int op)

可以選擇 non-blocking 直接 return
- op 塞 WNOHANG 可以製造這種效果
可以指定哪個 child
wait 到不是自己的 child 會 return error，沒 child 也一樣

#include "apue.h"
#include <sys/wait.h>

void pr_exit(int status) {
    if (WIFEXITED(status))
        printf("normal termination, exit status = %d\n",                 WEXITSTATUS(status));
    else if (WIFSIGNALED(status))
        printf("abnormal termination, signal number = %d%s\n",
                WTERMSIG(status),
#ifdef WCOREDUMP
                WCOREDUMP(status) ? " (core file generated)" : "");
#else
                "");
#endif
    else if (WIFSTOPPED(status))
        printf("child stopped, signal number = %d\n", WSTOPSIG(status));
}

int main(void) {
    pid_t   pid;
    int     status;

    if ((pid = fork()) < 0)
        err_sys("fork error");
    else if (pid == 0)              /* child */
        exit(7);

    if (wait(&status) != pid)       /* wait for child */
        err_sys("wait error");
    pr_exit(status);                /* and print its status */

    if ((pid = fork()) < 0)
        err_sys("fork error");
    else if (pid == 0)              /* child */
        abort();                    /* generates SIGABRT */

    if (wait(&status) != pid)       /* wait for child */
        err_sys("wait error");
    pr_exit(status);                /* and print its status */

    if ((pid = fork()) < 0)
        err_sys("fork error");
    else if (pid == 0)              /* child */
        status /= 0;                /* divide by 0 generates SIGFPE */

    if (wait(&status) != pid)       /* wait for child */
        err_sys("wait error");
    pr_exit(status);                /* and print its status */

    exit(0);
}

Zombie & Orphan#

Zombie#

Child 死了但 Parent 還沒呼叫 wait() 就會出現 Zombie process，雖然沒有 virtual memory 但會有 PCB.
Keep minimal information aka PCB
一定要 kill -9

Orphan#

Process 死的時候，child 還沒有死掉，init 會把所有沒有 ppid 的 process 轉成自己
init 會定期掃描整個 PCB 執行 wait()

Double fork

不想呼叫 wait() 但也不希望有 zombie process
Grandchild 才是真正我們想要的

int main(void)
{
  pid_t   pid;

  if ((pid = fork()) < 0) {
      err_sys("fork error");
  } else if (pid == 0) {   /* first child */
      if ((pid = fork()) < 0)
          err_sys("fork error");
      else if (pid > 0)
          exit(0);  /* parent from second fork == first child */
      /*
       * We're the second child; our parent becomes init as soon
       * as our real parent calls exit() in the statement above.
       * Here's where we'd continue executing, knowing that when
       * we're done, init will reap our status.
       */
      sleep(2);
      printf("second child, parent pid = %d\n", getppid());
      exit(0);
  }

  if (waitpid(pid, NULL, 0) != pid)   /* wait for first child */
      err_sys("waitpid error");

  /*
   * We're the parent (the original process); we continue executing,
   * knowing that we're not the parent of the second child.
   */
  exit(0);
}

$ ./a.out
second child, parent pid = 1

plaintext

sleep() 是為了讓 CPU schedule 到 kill first child 這個動作
可以讓 grandchild 短暫變 orphan 然後 init 成為 parent，會自己 wait 他
可以讓他變成 background process
- 組成 group 可以控制誰是 background or 前面

pid_t waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

可以用 idtype 指定要等
- P_PID: wait for a particular process
- P_PGID: wait for a group of process
- P_ALL: wait for any child process
可以選擇 blocking or non-blocking
WNOWAIT 是一個 option 可以把 PCB 留下

pid_t wait3(int *statloc, int op, struct rusage *rusage);, pid_t wait4(pid_t pid, int *statloc, int op, struct rusage *rusage);

檢查 CPU time 跟 Mem usage

Race Condition#

兩個 Process 的執行先後順序不一定是誰，要看 CPU Schedule，是個 Nondeterministic 的過程
可能因為順序不同，造成不想要的結果

static void charatatime(char *);

int main(void)
{
    pid_t   pid;

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {
        charatatime("output from child\n");
    } else {
        charatatime("output from parent\n");
    }
    exit(0);
}

static void charatatime(char *str)
{
    char    *ptr;
    int     c;

    setbuf(stdout, NULL);          /* set unbuffered */
    for (ptr = str; (c = *ptr++) != 0; )
        putc(c, stdout);
}

$ ./a.out
ooutput from child
utput from parent

$ ./a.out
ooutput from child
utput from parent

$ ./a.out
output from child
output from parent

plaintext

雖然是 buffer I/O 但是我們得從 unbuffered I/O 走，因為 NULL
child, parent 會 share terminal 這個資源
- 因為是 unbuffered 所以會產生 context switch，在 terminal 的 buffer 滿的時候會 context switch
真正要進行 I/O 才會創建 buffer，並且決定 type
- 在執行真正 I/O 前設定 buffer 就有效

其實 double fork 的情況，sleep() 可能會發生 race condition，可能產生錯誤
用這段 code 可以等，但是這是一段 busy waiting
```
while (getppid() != 1)
    sleep(1);
```
c

int execl(const char *pathname, const char *arg0, … /* (char *) 0 */); int execv(const char *pathname, char *const argv[]); int execle(const char *pathname, const char *arg0, … /* (char *) 0, char *const envp[] */); int execve(const char *pathname, char *const argv[], char *const envp[]);

程式執行一定要在一個 process 上，但執行並非從 exec 開始算，而是 fork 開始
- spawn() 會同時 fork(), exec()
exec 是把既有的 process 換成另一隻 process，instruction, data (virtual memory) 全部替換，但是不改 open file descriptor table
l, v argument 用 list 還是 vector 表示 e 是 environment

int execlp(const char *filename, const char *arg0, … /* (char *) 0 */); int execvp(const char *filename, , char *const argv[]);

p 家族放 filename
用 PATH=/bin:/usr/bin:. 的順序找執行檔
p 會把東西 binary file 當 shell script 執行，先呼叫 /bin/sh 讓他去執行

Close on exec 截圖 2025-10-26 晚上7.53.58

要不要再執行後把 element 關掉
child 的 open fd table 就是 parent 的
- 預設是 close，只有 open 的時候才會長得不一樣

IPC (Inter-process Communication)#

Pipe#

int pipe( int filedes[2] );

一端寫一端讀，不一定多少人
fork() 時如何送資訊給別人
- 都是單向讀寫，一個 process 只會有一個 fd 開著
- 一端寫了另一端還沒讀就 suspend 因為這是 fd blocking mode
- Multiplexing 就 poll 就好了，因為也是 file
- pipe 完畢再 fork 就可以繼承 pipe
$ ls | more
- 就是 $ shell 先呼叫 pipe 然後 fork 出兩個 process

int main(void) {
    int     n;
    int     fd[2];
    pid_t   pid;
    char    line[MAXLINE];

    if (pipe(fd) < 0)
        err_sys("pipe error");
    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {          /* parent */
        close(fd[0]);
        write(fd[1], "hello world\n", 12);
    } else {                      /* child */
        close(fd[1]);
        n = read(fd[0], line, MAXLINE);
        write(STDOUT_FILENO, line, n);
    }
    exit(0);
}

close() 掉自己不用的 pipe 防止出錯

#include "apue.h"

static int pfd1[2], pfd2[2];

void TELL_WAIT(void) {
    if (pipe(pfd1) < 0 || pipe(pfd2) < 0)
        err_sys("pipe error");
}

void TELL_PARENT(pid_t pid) {
    if (write(pfd2[1], "c", 1) != 1)
        err_sys("write error");
}

void WAIT_PARENT(void) {
    char c;

    if (read(pfd1[0], &c, 1) != 1)
        err_sys("read error");

    if (c != 'p')
        err_quit("WAIT_PARENT: incorrect data");
}

void TELL_CHILD(pid_t pid) {
    if (write(pfd1[1], "p", 1) != 1)
        err_sys("write error");
}

void WAIT_CHILD(void) {
    char c;

    if (read(pfd2[0], &c, 1) != 1)
        err_sys("read error");

    if (c != 'c')
        err_quit("WAIT_CHILD: incorrect data");
}

static void charatatime(char *);

int main(void) {
    pid_t pid;

    TELL_WAIT();

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {
        WAIT_PARENT();   /* parent goes first */
        charatatime("output from child\n");
    } else {
        charatatime("output from parent\n");
        TELL_CHILD(pid);
    }

    exit(0);
}

static void charatatime(char *str) {
    char *ptr;
    int c;

    setbuf(stdout, NULL);          /* set unbuffered */
    for (ptr = str; (c = *ptr++) != 0; )
        putc(c, stdout);
}

截圖 2025-10-26 晚上8.34.33

用這樣的 one way pipe 讓雙方互相溝通

FIFO#

為了讓 pipe 不必要用 fork() 形成繼承關係
另外創建一個獨立的 file，當作 pipe 的 fd
- 無法 random access
- 把 data 讀掉就沒了，不會像傳統檔案留東西在裡面
- 沒人去 reference 那個 pipe 裡面的 data 會被 remove

int mkfifo(const char *pathname, mode_t mode);

跟傳統 open 相同，權限都跟傳統檔案一樣
O_NONBLOCK
- NO: 會讓沒人 write 的時候 suspend，寫端也一樣
- YES: 直接 return
Write for no-reader FIFO: 會收到 SIGPIPE
PIPE_BUF 指定最多讀多少，避免資料混淆

Back to the content

NTU PJ System Programming

2025 Fall

← Back to the content

NTU-SP 系統程式設計 Ch6 Process Control & IPC

Process Control & IPC#

Booting#

Bootstrapping#

Process Control Block (PCB)#

Process table#

Context switch#

Process Content & Metadata#

Process Creation & Termination#

Normal cases in fork#

Deadlock#

Process Termination#

Zombie & Orphan#

Zombie#

Orphan#

Race Condition#

IPC (Inter-process Communication)#

Pipe#

FIFO#

Back to the content