L1: C

CPU需要数据,但有些数据的获取需要很长时间,eg:获取磁盘上的数据.

处理方法: 轮询Polling: 周期性地检查数据是否就绪.

中断: 当数据就绪后会收到通知.

中断的分类:

• 程序: 除以0, 对null解引用…
• Timer定时器
• 输入/输出
• 硬件错误: 主电源断电

大多数时候,CPU是需要处理收到的中断的. 此时会先保存当前的执行状态, 然后去执行中断处理程序, 最后恢复先前的状态.

有时候CPU会处于不可被中断的状态(临时).

两个中断可以是线性执行的, 也可以是高优先级中断打断了低优先级的中断.

trap是中断的一种吗?

ChatGPT: 
在计算机编程中，“trap”（陷阱）通常是指一个中断或异常，也被称为软件中断。
它是由正在执行的程序或操作系统生成的，通常用于响应某些特定的事件或错误情况，
例如非法指令、除数为零、内存访问错误等等。

当一个程序触发一个trap时，处理器会停止当前正在执行的任务，
转而执行一段预定义的中断处理程序，来处理这个trap。
中断处理程序会在完成后返回原程序，使其可以继续执行。

因此，可以说“trap”是一种中断机制，用于让计算机处理特定的事件或错误情况。

trap可以用来实现系统调用, 其作用是在用户user模式下唤醒操作系统,从而进入kernel模式, kernel模式下可以直接操作硬件,有能力执行所有的指令.

系统调用的流程:

1. user-mode:在栈上压入参数
2. user-mode:跳转到系统调用函数
3. user-mode:系统调用函数将其id放到指定位置
4. user-mode:系统调用函数调用 "Trap" 指令.
5. OS接受中断,从指定位置处解析id,切换到kernel-mode,
6. OS调用id对应的中断处理程序.
7. OS离开kernel-mode, 重新回到user-mode,并回到系统调用函数中.
8. 从系统调用中返回.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

void print_tail_zero() {
  int z = '\0';
  printf("%c is %d \n", '\0', z);
  return;
}


void read_file(int fd);

int main(int argc, char** argv) {
  if( argc != 2 ){
    printf("Usage: %s <filepath> \n",argv[0]);
    return EXIT_FAILURE;
  }

  int fd = open(argv[1],O_RDONLY);
  if (fd <0 ){
    printf("Error: cannot open file: %s  \n",argv[1]);
    return EXIT_FAILURE;
  }

  read_file(fd);

  close(fd);
  return 0;
}

void read_file(int fd){

  const size_t buf_size = 256;

  char* buffer = malloc(buf_size);

  while(1) {
    // 0 == '\0'
    memset(buffer,0,buf_size); // <======= 每次读取之前要清空缓冲区!!
    int bytes_read = read(fd, buffer,buf_size-1);

    if (bytes_read  == 0 ){
      break;
    }else if (bytes_read < 0 ){
      printf("Error: cannot read file.\n");
      return;
    }
    printf("%s",buffer);
  }

  printf("\n");
  free(buffer);
}

1. 文件名
2. id
3. 类型
4. 物理位置
5. 大小
6. 保护位
7. 时间,日期,UserID(所有者)

创建,删除, 读写,在文件中定位,截断(清除内容)

FILE* f = fopen("./file.c", "r");
int fd = fileno(f); // FILE* -> 文件描述符
int res = flock(fd, LOCK_EX); // exclusive 排它锁.

fprintf(file, "%s", "hello");

while(fscanf(fp, "%d,%d\n",&i,&squared) == 2) {
  printf("i= %d, squared= %d",i,squared);
}

目录是一个符号表, 将文件名映射到其目录条目.

目录操作:

1. 搜索
2. 添加文件
3. 删除文件
4. 列出目录内容
5. 重命名文件
6. 导航文件系统 (父目录,子目录..)

删除目录:

可以直接删除空目录

1.读,写,执行

1. 追加
2. 删除
3. List: 查看文件属性

每个文件都有一个所有者owner和所有组group. setuid, setgid

每个文件都有三组文件权限: 分别代表 owner, 所在group, 其它任何人能对文件执行的操作.

-rw-r--r--  1 sun sun    50 May  6 00:55 note.org
10 bits表示

r: 100
w: 010
x: 001

r--: 100
rw-: 110
rwx: 111

- : 不是目录, 普通文件
d : 目录
l : 符号链接

用于管理进程的数据结构, OS在产生进程时创建此数据结构, 并在进程退出时销毁此结构. 通常包含了:

1. 进程id
2. 进程状态
3. 优先级
4. 程序计数器
5. 寄存器数据
6. 内存指针
7. IO状态信息: 打开的文件, 是否在等待IO..
8. 记账信息, 消耗了多少资源

当进程正在运行时, 会发生中断,或者主动呼叫了系统调用, 此时会触发进程切换: 将当前程序的相关信息存放到其对应的PCB中. 当OS再次调度进程执行时, 会选择某一个进程的PCB,将其中的数据恢复到寄存器等地.

途径

1. 系统启动

2. 用户创建

3. 进程fork() 为了提高并发度或者容错性.

1. 进程退出(自愿) exit 0;
2. 错误退出(自愿) exit 1;
3. 故障退出(非自愿) : 解null指针, 段错误, stack overflow..
4. 被另一个进程kill(非自愿): killall/ kill -9

每个进程都有一个父进程, 但不一定有子进程.

第一个进程通常是 init / systemd

每个进程终止时都会返回一个 退出码. 父进程可以获得此退出码. 通常 0 标识此进程时正常退出的,其它值则代表发生了错误.

在一个子进程完成后,直到其父进程收到其退出码之前, 此子进程处于一种 "僵尸" 状态. (任务已经执行完毕, 但此进程的数据结构仍未销毁.)

系统调用 wait 可以收集子进程的退出码.从而释放对应子进程的资源. wait()在当前进程的任意一个子进程的 状态 发生变化时返回.

状态变化:

1. 子进程终止.
2. 子进程被信号暂停.
3. 子进程被信号恢复.

# 发送信号:

$ kill -STOP 32360 # 暂停
stopped by signal 19

$ kill -CONT 32360 # 恢复
continued

$ kill -TERM 32360 # 终止
killed by signal 15

pid_t wait(int* 存放子进程返回码); -> 成功时返回对应子进程pid, 否则为-1.

pid_t waitpid(pid,&退出码地址,options);

默认情况下只在子进程收到终止信号时返回, 可以用options字段改变这一行为

pid > 0, 只等待特定子进程终止. pid = -1, 等待任意一个子进程终止

pid=0, 等待任意一个其 进程组 id = 调用进程id(父进程) pid=-1, 等待任意一个其 进程组 id == pid绝对值

失去了原父进程的进程会被init进程 "收养".

僵尸进程和孤儿进程的区别?

ChatGPT: 
僵尸进程和孤儿进程是操作系统中两种不同的进程状态，它们有以下区别：

*僵尸进程（Zombie Process）* ：
当一个进程（父进程）创建了一个子进程，然后子进程先于父进程结束，
并且父进程没有及时处理子进程的退出状态，那么子进程就会成为僵尸进程。
僵尸进程占据系统资源，但不会执行任何操作。
它们的进程号（PID）仍然存在于进程表中，以记录其退出状态以备父进程查看。

*孤儿进程（Orphan Process）* ：
当一个进程的父进程在其终止之前先于它结束，那么该进程成为孤儿进程。
孤儿进程将被操作系统的init进程（PID为1的特殊进程）接管，并由init进程扮演父进程的角色。
init进程会定期检查是否有孤儿进程，并负责回收它们的资源，确保它们不会成为僵尸进程。

因此，区分僵尸进程和孤儿进程的关键在于 *父进程是否存活* !
如果父进程仍然存在，但没有及时处理子进程的退出状态，那么子进程成为僵尸进程。
如果父进程在子进程终止之前结束，那么子进程成为孤儿进程，并由init进程接管.

• New: 刚创建, 尚未完成初始化.
• Running:
• Ready: 已经具备运行的条件,只是没有被调度.
• Blocked: 等待某种资源/事件.
• 终止: 僵尸进程(已完成任务,仍占据资源)就是被困在这个状态上

当进程所需要的内存空间无法全放到内存中时, OS会将一部分放在磁盘上: swapping

• Ready/Swapped: 进程已就绪,但处在磁盘上
• Block/Swapped: 进程还在等待资源/事件,并处在磁盘上

init -> login -> bash

当你运行一个命令后, 新进程会被创建,并且shell会等待这个子进程结束.

父进程通过fork创建一个子进程, 并通过wait等待子进程结束并回收资源. 子进程通过exit将code返回给父进程.

int execlp("程序路径","进程名",参数... );

execl("/usr/bin/emacs","emacs", NULL);

execlp("/usr/bin/emacs","emacs", NULL);
execlp("emacs","emacs", NULL);  // 首个参数可以是命令名, 它会自动从PATH中匹配 

PATH=/home/sun/.opam/cs3110-2021fa/bin:/home/sun/.cabal/bin:/home/sun/.ghcup/bin:/home/sun/.emacs.d/bin:/home/sun/.local/bin:/home/sun/.cargo/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/home/sun/.dotnet/tools:/usr/lib/jvm/default/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl:/home/sun/understand_5_1/scitools/bin/linux64:https://debuginfod.archlinux.org:/home/sun/.bin

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h> // pid_t , waitpid
#include <unistd.h> // fork

int main(int argc , char** argv) {
  pid_t pid = -1;
  int child_code = 0;

  pid = fork();
  if(pid == -1) {
    fprintf(stderr, "Error: fork()\n");
    return EXIT_FAILURE;
  }

  if(pid == 0) {
    printf("Child process.\n");
    execlp("/usr/bin/ls","clear");
  }else {
    printf("Parent process.\n");
    waitpid(pid,&child_code,0);
    printf("Parent: child process returned with %d\n",child_code);
  }
  return 0;
}

Unix系统使用信号来表示事件的发生. 信号本质上是 一个带有数字ID的中断

默认情况下, 进程会用默认的信号处理程序来处理任何收到的信号.(来者不拒)

SIGHUP: 表示电话挂断, 因为早期的unix使用的是电话网络.现在这个信号经常被用作通知进程重新加载配置. SIGINT: 可以让其在退出前执行一些清理工作.

SIGKILL和SIGSTOP无法被捕获, 忽略,或者阻塞.

kill <pid> 默认发送SIGHUP给程序, 通常可以杀死程序.但此信号若被忽略,则要发送无法被忽略的SIGKILL: kill -9

进程发送信号 涉及到进程间通信的知识:

被OS标记过的一块内存, 可以让多个进程对其进行 读写 操作.

通常来讲, 一个块内存只属于一个进程, 只有此进程可以对其进行读写操作.其它进程对其进行读写操作时, OS会阻止并报错.

另外只有这块内存被OS标记为由多个进程共享后, 当某个进程结束时, 这块内存才不会被回收.

为了使用共享内存, 必须还要有某种协作机制.

消息传递需要知道接收者的名字, eg 进程id.

int kill(pid, 信号); // 可发送给指定的进程

int raise(信号); //发送给当前进程

pid = 0: 将信号发送给和caller同进程组的所有进程

pid = -1: 广播给所有能发送到的进程.

pid < 0:  发送给 进程组id == |pid| 的所有进程

/var/run/mysqld/mysqld.pid

int sigprocmask(动作: int, 新的 sigset_t, 旧的 sigset_t );

int sigemptyset(sigset_t *set);

int sigaddset(sigset_t* set, int signal);

int sigdelset(sigset_t* set, int signal);

int sigismember(sigset_t *set,int signal); 

int sigfillset(sigset_t *set);

typedef void (*sighandler_t)(int);

    signal(信号 : int, 新的处理程序 : fn(int) -> void )
-> 旧的信号处理程序 : fn(int) -> void

void handler(int sig_num) {

}

创建一个新的消息队列:
msgget(消息队列的key_t, 0666|IPC_CREAT);

int mq_id = msgget(IPC_PRIVATE,0666|IPC_CREAT);

int msgsnd(mq_id,&msg,sizeof(msg),0);

int msgrcv(mq_id,&msg,sizeof(msg),42 ,0);

type > 0 : 接收指定类型的消息
type = 0 : 接收任意类型的消息
type < 0 : 接收类型小于 |type| 的消息 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/msg.h>
#include <sys/wait.h>

typedef struct _message{
  long type; // must exist and the type is long

  int data ;
  double other_data;
} Message;

int main() {

  int mq_id = msgget(IPC_PRIVATE,0666|IPC_CREAT);
  if (mq_id<0 ) {
    perror("fail to create a message queue.");
    abort();
  }

  int pid = fork();
  if (pid > 0) { // parent process
    Message msg ;
    msg.type = 42; // <==!!
    msg.data = 233;
    msg.other_data = 233.333;
    if (msgsnd(mq_id,&msg,sizeof(msg),0) < 0 ) {
  perror("fail to send message.");
  abort();
    }
    wait(NULL); // wait for child process!
  }else if(pid == 0) { // child process
    Message msg ;
    if( msgrcv(mq_id,&msg,sizeof(msg),42 ,0) <0) {
  perror("fail to receive message.");
  abort();
    }
    printf("[receive]: %d %lf",msg.data,msg.other_data);

  }else { 
    perror("fork");
    abort();
  }


  return 0;
}