首页 > 其他分享 >【BUAA S4 OS】Lab4challenge sigaction实现

【BUAA S4 OS】Lab4challenge sigaction实现

时间：2024-09-24 19:54:27浏览次数：12  
标签：__ set int BUAA S4 sig env tf OS

文章目录

sigaction简介

当一个信号被发送给一个进程时, 内核会中断进程的正常控制流，转而执行与该信号相关的用户态处理函数进行处理

在执行该处理函数前，会将该信号所设置的信号屏蔽集加入到进程的信号屏蔽集中，在执行完该用户态处理函数后，又会将恢复原来的信号屏蔽集

任务描述

sigaction结构体用于设置所需要处理的信号集及其对应的处理函数

sigset_t使用32位表示MOS所需要处理的[1,32]信号掩码，对应位为1表示阻塞，为0表示未被阻塞

sigset_t与sigaction结构体定义如下:

typedef struct sigset_t {
    uint32_t sig;
} sigset_t;

struct sigaction {
    void     (*sa_handler)(int); //信号的处理函数
    sigset_t   sa_mask;
};

数据结构、宏等设计

信号相关设置

此处挂起信号队列沿用此前MOS中设计的TAILQ结构并使用相关函数，实现参考 kern\env.c 中env_sched_list 相关部分

// include/signal.h
// 信号掩码控制宏 __how的取值
#define SIG_BLOCK (0)	// 添加__set到当前掩码
#define SIG_UNBLOCK (1) // 从当前掩码中移除__set
#define SIG_SETMASK (2) // 设置当前掩码为__set

// SIGNUM编号
#define SIGINT (2)
#define SIGILL (4)
#define SIGKILL (9)
#define SIGSEGV (11)
#define SIGCHLD (17)
#define SIGSYS (31)

// 信号数量
#define SIG_MAX (32) 

// 掩码结构体
typedef struct sigset_t {
	uint32_t sig;
} sigset_t;

// 信号操作结构体
typedef void (*sa_handler)(int);
struct sigaction {
    void     (*sa_handler)(int);
    sigset_t   sa_mask;
};

// 信号描述符
struct signal {
	TAILQ_ENTRY(signal) sig_link;
	int signum;
	int time;
};

// 挂起的信号队列
TAILQ_HEAD(Sig_pend_list, signal);

Env结构体添加成员

// env.h
struct Env {
	// lab4-challenge
	u_int env_user_sighand_entry;	// 用户态信号处理函数入口
	u_int now_sig_time;		// 记录当前正在处理的信号的到达时间，重入处理的时候用
	u_int is_handling_SIGKILL;		// 判定现在正在被处理的是否是SIGKILL信号，若是则为1，反之为0
	u_int sig_exist[32];	// 每种信号在当前进程的存在性判断，保证每种信号的唯一性
	sigset_t sig_blocked;	       // 信号掩码
	struct Sig_pend_list sig_pend_list;	// 挂起信号队列
	struct sigaction sighand[32];  // 信号注册数组
};

错误返回值设置

// include/error.h
#define E_SIG 1    // 实际运用一般都是 return -E_SIG

头文件中添加相关函数声明

由于没有太多技术含量，此处省略，在实现具体函数后到相应头文件中添加即可

初始化与全局变量设置相关前置操作

// kern/env.c
// lab4-challenge
int sigsTime = 1;    // 用于标记信号到达时间，越小则到达时间越早
struct signal signals[SIG_MAX] __attribute__((aligned(PAGE_SIZE)));    // 进程信号数组

int env_alloc(struct Env **new, u_int parent_id) {
	// lab4-challenge
	// 最初都初始化为0
	e->sig_blocked.sig = 0;
	e->env_user_sighand_entry = 0;
	e->sig_pend_cnt = 0;
	e->now_sig_time = 0;
	e->is_handling_SIGKILL = 0;
	TAILQ_INIT(&e->sig_pend_list);
	for(int i=0; i<32; i++){
		e->sig_exist[i] = 0;
	}
	for(int i=0; i<32; i++){
		e->sighand[i].sa_handler = NULL;
		e->sighand[i].sa_mask.sig = 0;
	}
}

新增相关系统调用

统一流程

添加系统调用 syscall_func(u_int envid, ......)：

  1. 在 user/include/lib.h 中添加 void syscall_func(u_int envid, ......);

  2. 在 user/lib/syscall_lib.c 中添加

    void syscall_func(u_int envid, ......) { 
	......
	msyscall(SYS_func, envid, ......);
}

  3. 在 include/syscall.h 中的 enum 的 MAX_SYSNO 前添加 SYS_func,

  4. 在 kern/syscall_all.c 的 void *syscall_table[MAX_SYSNO] 中加上 [SYS_func] = sys_func, （注意与前一步的对应）

  5. 在 kern/syscall_all.c 的 void *syscall_table[MAX_SYSNO] 之间完成函数
    void sys_func(u_int envid, ......); 的具体实现

新增功能实现所需系统调用的具体实现

  • sys_ 具体实现

    // kern/syscall_all.c
// 信号注册
int sys_sigaction(int signum, const struct sigaction *newact, 
														\struct sigaction *oldact) {
	struct Env *e;
	struct sigaction *sig = NULL;
	// 只需考虑signum小于或等于32的情况,超出该范围返回-1
	if (signum < 1 || signum > SIG_MAX) {
		return -E_SIG;
	}
	e = curenv;
	sig = &e->sighand[signum - 1];
	if (oldact) {
		*oldact = *sig;
	}
	if (newact) {
		*sig = *newact;
	}
	return 0;
}

// 设置进程的信号处理函数入口地址
int sys_set_sighand_entry(u_int envid, u_int func) {
	struct Env *env;
	try(envid2env(envid, &env, 1));
	env->env_user_sighand_entry = func;
	return 0;
}

// 向进程发送信号
extern int sigsTime;
extern struct signal signals[SIG_MAX] __attribute__((aligned(PAGE_SIZE)));
int sys_sendsig(u_int envid, int sig) {
	struct Env *e;
	// 当envid对应进程不存在，或者sig不符合定义范围时，返回异常码-1
	if ( sig < 1 || sig > SIG_MAX || envid2env(envid, &e, 0) != 0 ) {
		return -E_SIG;
	};
	// 当进程中已经有同种信号，则不再接收
	if ( e->sig_exist[sig-1] == 1 ){
		return 0;
	}
	// 将信号添加进对应进程的信号处理队列
	signals[sig-1].signum = sig;
	signals[sig-1].time = sigsTime;
	struct signal *s = (struct signal *)(&signals[sig-1]);
	e->sig_exist[sig-1] = 1;
	TAILQ_INSERT_HEAD(&e->sig_pend_list, (s), sig_link);
	sigsTime++;
	e->sig_pend_cnt++;
	return 0;
}

// 根据__how的值更改当前进程的信号屏蔽字
// __set是要应用的新掩码，__oset（如果非NULL）则保存旧的信号屏蔽字
// __how可以是SIG_BLOCK（添加__set到当前掩码）、SIG_UNBLOCK（从当前掩码中移除__set）
//         或SIG_SETMASK（设置当前掩码为__set）
int sys_sigprocmask(int __how, const sigset_t * __set, sigset_t * __oset){
	struct Env *e;
	sigset_t *sigset;
	e = curenv;
	sigset = &e->sig_blocked;
	if (__oset!=NULL) {
		*__oset = *sigset;
	}
	if (__set!=NULL) {
		switch (__how) {
			case SIG_BLOCK:
				sigset->sig |= __set->sig;
				break;
			case SIG_UNBLOCK:
				sigset->sig &= ~__set->sig;
				break;
			case SIG_SETMASK:
				sigset->sig = __set->sig;
				break;
			default:
				return -E_SIG;
		}
	}
	return 0;
}

// 检查信号__signo是否是__set信号集的成员。如果是，返回1；如果不是，返回0。
int _sigismember(const sigset_t *__set, int __signo){
	if (__set == NULL){
		return 0;
	}
	__signo -= 1;
	return 1 & (__set->sig >> (__signo));
}

// 获取当前被阻塞且未处理的信号集，并将其存储在__set中
int sys_sigpending(sigset_t *__set){
	struct signal *s = NULL;
	int t;
	uint32_t newSig = __set->sig;
	TAILQ_FOREACH (s, &curenv->sig_pend_list, sig_link) {
		// 检查掩码
		if ( _sigismember(&curenv->sig_blocked, s->signum) ) {
			t = s->signum;
			newSig |= (1 << (t-1));
		}
	}
	__set->sig = newSig;
	return 0;
}

// 获取进程状态
int sys_check_env_status(u_int envid){
	struct Env * e;
	try(envid2env(envid, &e, 0));
	return e->env_status;
}

  • 部分除 msyscall 还有其他操作的 syscall_

    // user/lib/syscall_lib.c
int syscall_sigaction(int signum, const struct sigaction *newact, 
																	\struct sigaction *oldact) {
	if (oldact) {
		memset(oldact, 0, sizeof(oldact));
	}
	return msyscall(SYS_sigaction, signum, newact, oldact);
}

int syscall_sigprocmask(int __how, const sigset_t * __set, sigset_t * __oset) {
	if (__oset) {
		memset(__oset, 0, sizeof(__oset));
	}
	return msyscall(SYS_sigprocmask, __how, __set, __oset);
}

信号处理流程实现

信号处理的触发

在 ret_from_exception 中加入跳转到 do_signal 的代码，使得每次从用户态到内核态都调用一次信号检查函数

// kern/genex.S
FEXPORT(ret_from_exception)
	// 加入跳转到do_signal的代码（每次从用户态到内核态都调用一次）
		 move    a0, sp
     addiu   sp, sp, -8
     jal     do_signal
     addiu   sp, sp, 8

各类信号的发送触发

  • SIGINT 与 SIGKILL 一般在程序中手动触发，不会直接在MOS代码中发送

  • SIGILL

    发送契机 ：在进行异常处理前，发现当前异常由非法指令引发，向自身发送 SIGILL

    // kern/traps.c
void do_reserved(struct Trapframe *tf) {
    if(((tf->cp0_cause >> 2) & 0x1f) == 10){
        sys_sendsig(0, SIGILL);
        return;
    }
}

  • SIGSEGV

    发送契机 ：当前地址过低不允许访问，则向自身发送 SIGSEGV

    // kern/tlbex.c
static void passive_alloc(u_int va, Pde *pgdir, u_int asid) {
	if (va < UTEMP) {
		// panic("address too low");
		sys_sendsig(curenv->env_id, SIGSEGV);
	}
}

  • SIGCHLD

    发送契机 ：子进程退出时，若父进程仍在运行，则子进程向父进程发送 SIGCHLD

    // kern/env.c
void env_destroy(struct Env *e) {
	// lab4-challenge
	if( e->env_parent_id != 0){
		sys_sendsig( e->env_parent_id, SIGCHLD);
	}
}

  • SIGSYS

    发送契机 ：当前系统调用号不存在时，需要先忽视（跳过）此条语句，再向自身发送 SIGSYS

    // kern/syscall_all.c
void do_syscall(struct Trapframe *tf) {
	int sysno = tf->regs[4];
	if (sysno < 0 || sysno >= MAX_SYSNO) {
		tf->regs[2] = -E_NO_SYS;
		tf->cp0_epc += 4;
		sys_sendsig(curenv->env_id, SIGSYS);
		return;
	}
}

信号的注册与发送

// 信号注册函数
int sigaction(int signum, const struct sigaction *newact, struct sigaction *oldact) {
	// 确保设置好信号处理函数入口地址
	if (env->env_user_sighand_entry != (u_int)sighand_entry) {
		try(syscall_set_sighand_entry(0, (u_int)sighand_entry));
		try(syscall_set_tlb_mod_entry(0, (u_int)entry_wrapper));
	}
	int r = syscall_sigaction(signum, newact, oldact);
	return r;
}

// 信号发送函数
int kill(u_int envid, int sig) {
	// 如果sig为SIGCHLD,SIGILL,SIGSYS,SIGSEGV信号，返回异常码-1
	if (sig == SIGILL || sig == SIGSYS || sig == SIGCHLD || sig == SIGSEGV) {
		// debugf("Only MOS can send SIGCHLD & SIGILL & SIGSYS & SIGSEGV signal.\n");
		return -E_SIG;
	}
	// 确保设置好信号处理函数入口地址
	if (env->env_user_sighand_entry != (u_int)sighand_entry) {
		try(syscall_set_sighand_entry(0, (u_int)sighand_entry));
	}
	int r = syscall_sendsig(envid, sig);
	return r;
}

信号检查

  • do_signal 实现对当前挂起信号队列的检查，选择合适的信号后调用 sig_setuptf 跳转到信号处理函数入口并为其传递参数
  • 保存寄存器上下文函数 sig_setuptf 参照 kern\tlbex.c 中 do_tlb_mod 实现，具体参数设计见后续信号处理函数入口
// kern/env.c
// lab4-challenge
void do_signal(struct Trapframe *tf) {
	// 在为进程设置sigpri之前也可能会发生一些异常产生异常重入的现象
	// 而异常重入的时候不可能产生任何新的信号,没必要处理信号,直接return
	if (((int)tf->cp0_epc)<0){
		return;
	}
	// 如果没有待处理信号，直接返回
	if (TAILQ_EMPTY(&curenv->sig_pend_list)){
		return;
	}
	
	struct signal *s = NULL, *s_min = NULL;
	int signo = 10000;    // 初始化为10000，后续用于判断当前信号优先级是否高于之前选中的信号
	int time = 0;
	
	// 从进程的队列中取出未被阻塞的signal
	// SIGKILL优先级最高
	if (curenv->sig_exist[SIGKILL-1] == 1){
,		TAILQ_FOREACH (s_min, &curenv->sig_pend_list, sig_link) {
			if (s_min->signum == SIGKILL) {
				signo = s_min->signum;
				time = s_min->time;
				curenv->is_handling_SIGKILL = 1;
				break;
			}
		}
	}else if(curenv->is_handling_SIGKILL == 0){
		TAILQ_FOREACH (s, &curenv->sig_pend_list, sig_link) {
			// 如果当前有信号正在处理且此信号比当前信号到达时间早，则break
			if ( s->time <= curenv->now_sig_time ){
				break;
			}
			// 选取优先级最高的
			if ( s->signum < signo 
						&& ( (curenv->sig_blocked.sig & (1<<(s->signum-1))) == 0 )){
				signo = s->signum;
				time = s->time;
				s_min = s;
			}
		}
	}
	// 若存在未被阻塞的signal, 则修改进程上下文, 转到用户态的信号处理函数
	if (s_min) {
		curenv->now_sig_time = time;
		curenv->sig_exist[signo-1] = 0;
		TAILQ_REMOVE(&curenv->sig_pend_list, s_min, sig_link);
		// 保存寄存器上下文，给信号处理函数传递参数
		sig_setuptf(tf, signo);
	} else { 
		return;
	}
}

// 保存寄存器上下文（仿写do_tlb_mod）
void sig_setuptf(struct Trapframe *tf, int signum) {
	struct Trapframe tmp_tf = *tf;
	if (tf->regs[29] < USTACKTOP || tf->regs[29] >= UXSTACKTOP) {
		tf->regs[29] = UXSTACKTOP;
	}
	tf->regs[29] -= sizeof(struct Trapframe);
	*(struct Trapframe *)tf->regs[29] = tmp_tf;
	// 将信号处理需要传递的相关参数保存至异常现场栈中
	tf->regs[4] = tf->regs[29];
	tf->regs[5] = signum;
	tf->regs[6] = (unsigned int)(curenv->sighand[signum-1].sa_handler);
	uint32_t newMask = 0;
	newMask = curenv->sighand[signum-1].sa_mask.sig | curenv->sig_blocked.sig 
																									\ | (1 << (signum - 1)) ;
	tf->regs[7] = (uint32_t)newMask;
	tf->regs[29] -= sizeof(tf->regs[4]);
	tf->regs[29] -= sizeof(tf->regs[5]);
	tf->regs[29] -= sizeof(tf->regs[6]);
	tf->regs[29] -= sizeof(tf->regs[7]);
	tf->cp0_epc = curenv->env_user_sighand_entry;
}

信号的实际处理

// 执行信号
void __attribute__((noreturn)) sighand_entry(struct Trapframe *tf, int signum, 
																	\	void (*sa_handler)(int), uint32_t newMask) {
	int r;
	// 若设置了处理函数
	if (sa_handler && signum != SIGKILL ) {
		// 处理前修改进程掩码
		sigset_t oldSigset={0}, newSigset={0};
		newSigset.sig = newMask;
		r= syscall_sigprocmask(2, (sigset_t *)&newSigset, (sigset_t *)&oldSigset);
		sa_handler(signum);
		// 恢复进程原掩码
		syscall_sigprocmask(2, (sigset_t *)&oldSigset, NULL);
		// 恢复上下文
		r = syscall_set_sig_trapframe(0, tf);
		user_panic("sig_entry syscall_set_sig_trapframe returned %d", r);
	} 
	switch (signum) {
        case SIGINT: case SIGILL: case SIGKILL: case SIGSEGV: 
				// 退出用exit
            exit(); 
            user_panic("sig_entry syscall_env_destroy returned");
        default:
            r = syscall_set_sig_trapframe(0, tf);
            user_panic("sig_entry syscall_set_sig_trapframe returned %d", r);
    }
}

信号处理后上下文的信号

参考同文件中的 sys_set_trapframe 实现

// kern/syscall_all.c
int sys_set_sig_trapframe(u_int envid, struct Trapframe *tf) {
	if (is_illegal_va_range((u_long)tf, sizeof *tf)) {
		return -E_INVAL;
	}
	struct Env *env;
	try(envid2env(envid, &env, 1));
	// 当前信号处理完毕，故重置 env->now_sig_time 为 0
	env->now_sig_time = 0;
	if (env == curenv) {
		*((struct Trapframe *)KSTACKTOP - 1) = *tf;
		// return `tf->regs[2]` instead of 0, because return value overrides regs[2] on
		// current trapframe.
		return tf->regs[2];
	} else {
		env->env_tf = *tf;
		return 0;
	}
}

信号集处理函数实现

注意如果传入参数不合法，返回值为 -E_SIG

// user/lib/syscall_lib.c
// 计算两个信号集__left和__right的并集，并将结果存储在__set中
int sigorset(sigset_t *__set, const sigset_t *__left, const sigset_t *__right){
	if ( __left == NULL ||  __right == NULL ){
		return -E_SIG;
	}
	__set->sig = __left->sig | __right->sig;
    return 0;
}

// 根据__how的值更改当前进程的信号屏蔽字。__set是要应用的新掩码
// __oset（如果非NULL）则保存旧的信号屏蔽字
// __how可以是SIG_BLOCK（添加__set到当前掩码）、SIG_UNBLOCK（从当前掩码中移除__set）
//   或SIG_SETMASK（设置当前掩码为__set）
int sigprocmask(int __how, const sigset_t * __set, sigset_t * __oset){
	syscall_sigprocmask(__how, __set, __oset);
	return 0;
}

// 清空参数中的__set掩码，初始化信号集以排除所有信号。这意味着__set将不包含任何信号。(清0)
int sigemptyset(sigset_t *__set){
	if ( __set == NULL){
		return 0;
	}
	__set->sig = 0;
	return 0;
}

// 将参数中的__set掩码填满，使其包含所有已定义的信号。这意味着__set将包括所有信号。(全为1)
int sigfillset(sigset_t *__set){
	if ( __set == NULL){
		return -E_SIG;
	}
	sigemptyset(__set);
	__set->sig = ~(__set->sig);
	return 0;
}

// 向__set信号集中添加一个信号__signo。如果操作成功，__set将包含该信号。(置位为1)
int sigaddset(sigset_t *__set, int __signo){
	if ( __set == NULL){
		return -E_SIG;
	}
	if ( __signo < 1 || __signo > SIG_MAX ) {
		return -E_SIG;
	};
	__set->sig |= (1<<(__signo-1));
	return 0;
}

// 从__set信号集中删除一个信号__signo。如果操作成功，__set将不再包含该信号。(置位为0)
int sigdelset(sigset_t *__set, int __signo){
	if ( __set == NULL){
		return 0;
	}
	if ( __signo < 1 || __signo > SIG_MAX ) {
		return -E_SIG;
	};
	__set->sig &= ~(1<<(__signo-1));
	return 0;
}

// 检查信号__signo是否是__set信号集的成员。如果是，返回1；如果不是，返回0
int sigismember(const sigset_t *__set, int __signo){
	if ( __set == NULL){
		return 0;
	}
	return 1 & (__set->sig >> (__signo-1));
}

// 检查信号集__set是否为空。如果为空，返回1；如果不为空，返回0
int sigisemptyset(const sigset_t *__set){
	if ( __set == NULL){
		return 1;
	}
	return __set->sig == 0;
}

// 计算两个信号集__left和__right的交集，并将结果存储在__set中。
int sigandset(sigset_t *__set, const sigset_t *__left, const sigset_t *__right){
	if ( __left == NULL ||  __right == NULL ){
		return -E_SIG;
	}
	__set->sig = __left->sig & __right->sig;
    return 0;
}

// 获取当前被阻塞且未处理的信号集，并将其存储在__set中
int sigpending(sigset_t *__set){
	if ( __set == NULL){
		return -E_SIG;
	}
	syscall_sigpending( __set);
	return 0;
}

其他修改（踩过的坑）

寄存器Trapframe保存与传递设置

当 env_pop_tf 函数被调用时，它会将 curenv->env_tf（即当前进程的上下文）加载到处理器寄存器中，并且将 curenv->env_tf 的地址赋值给堆栈指针 sp。进入 do_signal 函数时，堆栈指针 sp 指向 curenv->env_tf 的位置。

假设 do_signal 函数会在其执行过程中使用堆栈保存临时数据和函数调用信息，则这些数据会覆盖 curenv->env_tf 的内容，导致进程控制块中的数据被意外修改。

所以需要通过将 curenv->env_tf 复制到当前栈上一个临时变量 tmp_tf，然后传入 env_pop_tf 函数，从而避免直接使用进程控制块中的地址。

将 kern/env.c 文件中 env_run 函数的末尾修改为：

- env_pop_tf(&curenv->env_tf, curenv->env_asid);
+ struct Trapframe tmp_tf = curenv->env_tf;
+ env_pop_tf(&tmp_tf, curenv->env_asid);

Q：为什么不能将 curenv->env_tf 复制到 (struct Trapframe *)KSTACKTOP - 1？

因为KSTACKTOP 是内核栈的顶部，直接在此位置存储 Trapframe 结构体稍有不慎可能导致堆栈溢出，从而覆盖其他关键的内核数据，干扰内核栈的正常使用

fork时相关设置的继承

// kern/syscall_all.c
int sys_exofork(void) {
	// lab4-challenge
	// 全部和sigaction有关的都要复制
	e->sig_blocked = curenv->sig_blocked;
	e->env_user_sighand_entry = curenv->env_user_sighand_entry;
	e->sig_pend_cnt = curenv->sig_pend_cnt;
	e->now_sig_time = curenv->now_sig_time;
	e->is_handling_SIGKILL = 0;
	e->sig_pend_list = curenv->sig_pend_list;
	for(int i=0; i<32; i++){
		e->sig_exist[i] = curenv->sig_exist[i];
	}
	for(int i=0; i<32; i++){
		e->sighand[i].sa_handler = curenv->sighand[i].sa_handler;
		e->sighand[i].sa_mask.sig = curenv->sighand[i].sa_mask.sig;
	}
}

同时，为了防止父进程没有注册信号处理函数，在fork时可以“再加一层保险”

// user/lib/fork.c
int fork(void) {
	// lab4-challenge
	if (env->env_user_sighand_entry != (u_int)sighand_entry) {
		try(syscall_set_sighand_entry(0, (u_int)sighand_entry));
	}
}

页错误处理函数入口的同步设置

在实际编码中，发现可能会出现页错误情况，报错未注册页错误处理函数。因此，在注册信号时也实现页错误处理函数入口的同步设置

由于 cow_entry 是静态函数，因此需要用一个函数将其包裹以便在其他文件中调用

// user/lib/fork.c
void entry_wrapper(struct Trapframe *tf) {
    cow_entry(tf);
}

其他踩过的坑/关键设计

  • 需要区分“打断”与“早已到”并妥善设计
    • 问题：在一个信号处理完成之前，也可能会进行一些系统调用，这些系统调用在返回之前也会扫描信号队列，怎么防止系统转而去执行更早到达的信号（早已到）？但同时，我们也要允许当前处理完成之前，晚于当前信号到达的信号（打断）能够被先处理。
    • 解决思路：
      1. 先在 env.c 里设置一个全局变量 sigsTime
      2. 每次发送信号的时候让 s->sig_time=sigsTime ，然后 sigsTime++
      3. 给 Env 结构体增加成员变量 handlingSig_time ，进程每开始处理一个信号就让 curenv->handlingSig_time=s->sig_time
      4. 在 dosignal 中根据比较 s->sig_time 和 curenv->handlingSig_time=s->sig_time 的大小来判断信号发出的先后
    • 不严谨的地方：发送信号的时间不严格等于信号开始被处理的时间，后续可以优化
  • 处理前修改进程掩码，处理后恢复进程原掩码的实现需要小心谨慎，要想清楚到底要恢复成什么样

标签：__,set,int,BUAA,S4,sig,env,tf,OS
From： https://blog.csdn.net/lyxjtsdmfz/article/details/142497114

相关文章

  • 408OS_PV操作大题总结
    咸鱼今年压了读者写者问题，前几年没考过。死锁的四个条件是：禁止抢占（nopreemption）：系统资源不能被强制从一个线程中退出。持有和等待（holdandwait）：一个线程在等待时持有并发资源。持有并发资源并还等待其它资源，也就是吃着碗里的望着锅里的。互斥（mutualexclusion）：资源只能同时......
  • 华为HarmonyOS灵活高效的消息推送服务(Push Kit) - 5 发送通知消息
    场景介绍通知消息通过PushKit通道直接下发，可在终端设备的通知中心、锁屏、横幅等展示，用户点击后拉起应用。您可以通过设置通知消息样式来吸引用户。开通权益PushKit根据消息内容，将通知消息分类为服务与通讯、资讯营销两大类别，开放通知消息自分类权益。两种类型的通知消息......
  • 【HarmonyOS】开启沉浸式（全屏）并获取顶部状态栏和底部导航条高度
    鸿蒙开启沉浸式（全屏）并获取顶部状态栏和底部导航条高度1.获取主窗口constwin=windowStage.getMainWindowSync()2.开启沉浸式win.setWindowLayoutFullScreen(true)3.顶部状态栏高度//获取状态栏区域 letarea=win.getWindowAvoidArea(window.AvoidAreaType.......
  • Microsoft 365 消息速递：Microsoft 365 PnP Management Shell注册变化
    51CTOBlog地址：https://blog.51cto.com/u_13969817PnPPowerShell和CLIforMicrosoft365是社区提供的开源工具，很多Office365Admin习惯性使用脚本执行一些配置和管理策略的应用，使用名为PnPManagementShell的多租户应用程序注册来授予脚本所需的权限，然而，这个多租户应用程序注册......
  • [Paper Reading] CAPE: Camera View Position Embedding for Multi-View 3D Object De
    目录名称TL;DRMethodKeyPositionEmbeddingConstructionQueryPositionEmbeddingConstructionKey/QueryPositionEmbedding两者结合关系参考下图temporalmodelingExperiment总结与发散相关链接资料查询名称link时间：23.03机构：Baidu/华科TL;DR提出CAPE(CAmeraviewPosi......
  • OSPF 默认路由的发布原则 | 类型详解
    默认路由默认路由是指目的地址和掩码都是0的路由。当设备无精确匹配的路由时，就可以通过默认路由进行报文转发。一般多用于网络边界路由器访问互联网所需要的一条路由。同时，企业内，在精确的内部路由基础上，边界路由器通告一条默认路由，使所有访问未知目的地的数据报文都送至......
  • 如何在 CentOS 中进入 root 权限
    作为一名服务器管理员，有时您需要以root用户身份执行任务以进行管理操作。以下是两种在CentOS中执行此操作的方法：方法1：使用sudosudo命令允许您以root用户的身份执行特定命令，而无需更改用户会话。要使用此方法：在终端中键入以下命令：1sudo-i系统会提......
  • Linux系统CentOS下挂载磁盘
    1.挂载磁盘步骤总结如下1.对磁盘进行分区2.对磁盘进行格式化3.将磁盘挂载到对应目录4.设置开机自动挂载磁盘2.对磁盘进行分区2.1查看系统设备信息lsblk指令显示所有块设备信息：显示系统中所有的块设备信息，包括磁盘和分区lsblk2.2查看未挂载的磁盘fdisk-l2.3对新建的磁盘进......
  • Linux系统CentOS下挂载磁盘
    1.挂载磁盘步骤总结如下1.对磁盘进行分区2.对磁盘进行格式化3.将磁盘挂载到对应目录4.设置开机自动挂载磁盘2.对磁盘进行分区2.1查看系统设备信息lsblk指令显示所有块设备信息：显示系统中所有的块设备信息，包括磁盘和分区lsblk2.2查看未挂载的磁盘fdisk-l2.3......
  • ehviewer安卓和IOS怎样安装？（已解决）
    ehviewer是一款非常流行的办公软件套件，它提供了类似Microsoftehviewer的功能，包括文字处理（ehviewerWriter）、电子表格（ehviewerSpreadsheet）和演示文稿（ehviewerPresentation）。以下是安装和配置ehviewerOffice的详细步骤及技巧，适用于Windows操作系统。对于其他操作系统（如......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99