int main(int argc, char const *argv[])
{
sigset_t newmask,oldmask,waitmask;
sigemptyset(&waitmask);
sigaddset(&waitmask,SIGUSR1);
sigemptyset(&newmask);
sigaddset(&newmask,SIGINT);
sigprocmask(SIG_BLOCK,&newmask,&oldmask);
// THE BLEW IS CRICITLE RIGION
// signal()
pr_mask("the next is region: ");
if (signal(SIGINT,sig_int)==SIG_ERR)
{
/* code */
printf("err sig\n");
}
// sleep(5);
#if 0
if (sigsuspend(&waitmask)!=-1)
{
/* code */printf("susupend err\n");
}
// printf("sigsuspend usr1\n");
pr_mask("after sigsuspend: ");
#endif
sigprocmask(SIG_SETMASK,&oldmask,NULL);
pr_mask("not sigint block:");
// printf("SIG INT NOT SIG_BLOCK\n");
sleep(5);
return 0;
}
int main ( int argc, char *argv[] )
{
sigset_t newmask, oldmask, waitmask;
pr_mask("program start:");
if (signal(SIGINT, sig_int) == SIG_ERR)
err_sys("signal(SIGINT) error");
sigemptyset(&waitmask);
sigaddset(&waitmask, SIGUSR1);
sigemptyset(&newmask);
sigaddset(&newmask,SIGINT);
//block SIGINT and save current signal mask.
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
err_sys("sigprocmask error!");
// critical region of code.
pr_mask("in critiacl region: ");
//pause allowing all signlas except SIGUSR1
if (sigsuspend(&waitmask) != -1)
err_sys("sigsuspend error!");
pr_mask("after return from sigsuspend: ");
// reset signal mask which unblocks SIGINT.
if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
err_sys("SIG_SETMASK erroR!");
// and continuse processing ...
pr_mask("program exit:" );
return 0;
} /* ---------- end of function main ---------- */
int main(void)
{
int ret;
if(signal(SIGUSR1, sig_usr1) == SIG_ERR)
{
printf("signal (SIGUSR1) error");
}
if(signal(SIGALRM, sig_alrm) == SIG_ERR)
{
printf("signal(SIGALRM) error");
}
pr_mask("starting main: ");
ret = sigsetjmp(jmpbuf, 1);
if(ret)
{
pr_mask("ending main: ");
exit(0);
}
canjump = 1;
for(;;)
pause();
}
int main(void){
sigset_t newmask,oldmask,waitmask;
pr_mask("pro start:");
if(signal(SIGINT,sig_int)==SIG_ERR)
err_sys("sigint err");
sigemptyset(&waitmask);
sigaddset(&waitmask,SIGUSR1);
sigemptyset(&newmask);
sigaddset(&newmask,SIGINT);
if(sigprocmask(SIG_BLOCK,&newmask,&oldmask)<0)
err_sys("sig_block err");
pr_mask("in critical region:");
if(sigsuspend(&waitmask)!=-1)
err_sys("sigsupend err");
pr_mask("after return sigsuspend:");
if(sigprocmask(SIG_SETMASK,&oldmask,NULL)<0)
err_sys("sigsetmask err");
pr_mask("pro exit:");
exit(0);
}
int main(void) {
sigset_t newmask, oldmask, waitmask;
pr_mask("program start ");
if (signal(SIGINT, sig_int) == SIG_ERR) {
err_sys("signal(SIGERR) error");
}
sigemptyset(&waitmask);
sigaddset(&waitmask, SIGUSR1);
sigemptyset(&newmask);
sigaddset(&newmask, SIGINT);
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
err_sys("SIG_BLOCK error");
}
pr_mask("in critical region: ");
if (sigsuspend(&waitmask) != -1) {
err_sys("sigsuspend error");
}
pr_mask("after erturn from sigsuspend: ");
if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) {
err_sys("SIG_SETMASK error");
}
pr_mask("program exit: ");
exit(0);
}
int
main(void)
{
sigset_t newmask, oldmask, zeromask;
if (signal(SIGINT, sig_int) == SIG_ERR)
err_sys("signal(SIGINT) error");
sigemptyset(&zeromask);
sigemptyset(&newmask);
sigaddset(&newmask, SIGINT);
/* block SIGINT and save current signal mask */
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
err_sys("SIG_BLOCK error");
/* critical region of code */
pr_mask("in critical region: ");
/* allow all signals and pause */
if (sigsuspend(&zeromask) != -1)
err_sys("sigsuspend error");
pr_mask("after return from sigsuspend: ");
/* reset signal mask which unblocks SIGINT */
if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
err_sys("SIG_SETMASK error");
/* and continue processing ... */
exit(0);
}
void sig_usr1(int signo)
{
time_t starttime;
if (canjmp == 0)
return;
pr_mask("starting sig_usr1: ");
alarm(3);
starttime = time(NULL);
for ( ; ; )
if (time(NULL) > starttime + 5)
break;
pr_mask("finishing sig_usr1: ");
canjmp = 0;
siglongjmp(sig_env, 1);
}
int main(){
if(signal(SIGALRM,sig_alrm)==SIG_ERR)
err_sys("signal alrm error");
if(signal(SIGUSR1,sig_usr1)==SIG_ERR)
err_sys("signal usr1 error");
pr_mask("in main:");
if(sigsetjmp(buf,1)!=0){
//ret from siglongjmp
pr_mask("back from siglongjmp:");
exit(0);
}
canjmp=1;
for(;;)
pause();
}
int main(int argc, char *argv[])
{
struct sigaction act, oact;
sigset_t set, newset;
#if 1
sigfillset(&newset);
sigaddset(&newset, SIGUSR1);
sigdelset(&newset, SIGQUIT);
sigdelset(&newset, SIGINT);
sigprocmask(SIG_SETMASK, &newset, NULL);
#endif
/* set signal function mask */
act.sa_handler = sig_quit_int;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGUSR2);
sigaction(SIGQUIT, &act, NULL);
sigaction(SIGINT, &act, NULL);
pr_mask("main function signal set");
for ( ; ; )
{
write(STDOUT_FILENO, ".", sizeof("."));
sleep(1);
}
return 0;
}
static void sig_usr1(int signo)
{
time_t starttime;
if (canjump == 0)
return;
pr_mask("in sig_usr1(): ");
alarm(3);
starttime = time(NULL);
while (1)
if (time(NULL) > starttime + 5)
break;
pr_mask("finishing sig_usr1: ");
canjump = 0;
siglongjmp(jmpbuf, 1);
}
static void sig_usr1(int signo){
time_t starttime;
pr_mask("in sig_usr1:");
if(canjmp==0)
return;
alarm(3);
starttime=time(NULL);
for(;;)
{
if((time(NULL)-starttime)>5)
break;
}
pr_mask("back from sig_alrm:");
canjmp=0;
siglongjmp(buf,1);
}
int main(void)
{
sigset_t newmask,oldmask,waitmask;
pr_mask("program start:");
if(signal (SIGINT,sig_int) == SIG_ERR)
err_sys("signal(SIGINT) error");
sigemptyset(&waitmask);
sigaddset(&waitmask,SIGUSR1);
sigemptyset(&newmask);
sigaddset(&newmask,SIGINT);
/*
Block SIGINT and save current signal mask.
*
*/
if(sigprocmask(SIG_BLOCK,&newmask,&oldmask) < 0)
err_sys("SIG_BLOCK error");
/*
critical region of code.
*/
pr_mask("in critical region:");
/*
Pause, allowing all signals except SIGUSR1
*/
if(sigsuspend(&waitmask) != -1)
err_sys("sigsupsend error");
pr_mask("after return from sigsuspend:");
/*
* Reset signal mask which unblocks SIGINT.
*/
if(sigprocmask(SIG_SETMASK,&oldmask,NULL) < 0)
err_sys("SIG_SETMASK error");
/*
* And continue processing ...
*/
pr_mask("program exit:");
exit(0);
}
static void sig_usr1(int signo)
{
time_t starttime;
if(0 == canjump)
return; /* unexpected signal, ignore */
pr_mask("starting sig_usr1: ");
alarm(3); /* SIGALRM in 3 seconds */
starttime = time(NULL);
for(; ;) /* busy wait for 5 seconds */
if(time(NULL) > starttime + 5)
break;
pr_mask("finishing sig_usr1: ");
canjump = 0;
siglongjmp(jmpbuf, 1); /* jump back to main, don't return */
}
int main(void)
{
if(signal(SIGUSR1, sig_usr1) == SIG_ERR)
err_sys("signal(SIGUSR1) error");
if(signal(SIGALRM, sig_alrm) == SIG_ERR)
err_sys("signal(SIGALRM) error");
pr_mask("starting main: ");
if(sigsetjmp(jmpbuf, 1))
{
pr_mask("ending main: ");
exit(0);
}
canjump = 1; /* now sigsetjmp() is OK */
for(; ;)
pause();
}
int main(void)
{
if (signal(SIGUSR1, sig_usr1) == SIG_ERR)
err_sys("signal(SIGUSR1) error");
if (signal(SIGALRM, sig_alrm) == SIG_ERR)
err_sys("signal(SIGALRM) error");
pr_mask("stating main: ");
if (sigsetjmp(jmpbuf, 1) != 0) {
pr_mask("ending main: ");
exit(0);
}
canjump = 1;
while (1)
pause();
}
int main(int argc, char **argv)
{
if (signal(SIGUSR1, sig_usr1) == SIG_ERR)
err_sys("signal error");
if (signal(SIGALRM, sig_alrm) == SIG_ERR)
err_sys("signal error");
pr_mask("starting main: ");
if (sigsetjmp(sig_env, 1)) { // for siglongjmp
pr_mask("ending main: ");
exit(0);
}
canjmp = 1;
for ( ; ; )
pause();
}
static void sig_int(int signo)
{
pr_mask("\nin sig_int: ");
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
if(sigprocmask(SIG_BLOCK, &set, NULL) < 0)
err_sys("BLOCK error");
}
int main(void)
{
if (signal(SIGUSR1,sig_usr1) == SIG_ERR) {
err_sys("signal(SIGUSR1) error");
}
if (signal(SIGUSR2,sig_alrm) == SIG_ERR) {
err_sys("signal(SIGALRM) error");
}
pr_mask("starting main:");
if (sigsetjmp(jmpbuf,1)) {
pr_mask("ending main:");
exit(0);
}
canjump = 1;
for (; ;) {
pause();
}
}
void sig_quit(int signum)
{
pr_mask("sig_quit");
int i;
for (i = 0; i < 10; i++)
{
write(STDOUT_FILENO, "+", sizeof("+"));
sleep(1);
}
return;
}
static void
sig_usr1(int signo)
{
time_t starttime;
if (canjump == 0)
return; // unexpected signal, ignore
pr_mask("starting sig_usr1: ");
alarm(3);
starttime = time(NULL);
for (;;) // busy wait for 5 seconds
if (time(NULL) > starttime + 5)
break;
pr_mask("finishing sig_usr1: ");
canjump = 0;
siglongjmp(jmpbuf, 1);
}
int main(void) {
if(signal(SIGUSR1, sig_usr1) == SIG_ERR)
err_sys("signal(SIGUSR1) error");
if(signal(SIGALRM, sig_alrm) == SIG_ERR)
err_sys("signal(SIGALRM) error");
pr_mask("starting main: ");
if(sigsetjmp(jmpbuf, 1)) {
// if(setjmp(jmpbuf)) { /* main sig mask is not saved */
pr_mask("ending main: ");
return 0;
}
canjmp = 1;
for( ; ; )
pause();
return 0;
}
int
main(void)
{
if (signal(SIGUSR1, sig_usr1) == SIG_ERR) {
fprintf(stderr, "signal(SIGUSR1) error");
exit(1);
}
if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
fprintf(stderr, "signal(SIGALRM) error");
exit(1);
}
pr_mask("starting main: ");
/* Figure 10.14 */
if (sigsetjmp(jmpbuf, 1)) {
pr_mask("ending main: ");
exit(0);
}
canjump = 1;
/* now sigsetjmp() is OK */
for (;;)
pause();
}
void sig_quit_int(int signum)
{
char buf[64], prbuf[2];
int i;
sprintf(buf, "in sig_quit_int signal %d", signum);
pr_mask(buf);
sprintf(prbuf, "%d", signum);
for (i = 0; i < 10; i++)
{
write(STDOUT_FILENO, prbuf, 2);
sleep(1);
}
return;
}
static void sig_usr1(int signo)
{
time_t starttime;
if (0 == canjump) {
return ;
}
pr_mask("starting sig_usr1:");
alarm(3);
starttime = time(NULL);
/* 时间太长了!
for (; ;) {
if (time(NULL) > starttime + 5) {
break;
}
}
*/
pr_mask("finishing sig_usr1:");
canjump = 0;
siglongjmp(jmpbuf,1);
}
int main(int argc, char *argv[])
{
sigset_t sigset, oldmask;
if (sigemptyset(&sigset) < 0)
err_sys("initialization sigset error");
if (sigaddset(&sigset, SIGINT) < 0)
err_sys("sigaddset error");
if (sigaddset(&sigset, SIGALRM) < 0)
err_sys("sigaddset error");
sigprocmask(SIG_BLOCK, &sigset,&oldmask);
pr_mask("hello world");
exit(EXIT_SUCCESS);
}
int main(void)
{
sigset_t nmask, omask, zmask;
if (signal(SIGINT, sig_int) == SIG_ERR) {
perror("signal(SIGINT) error");
exit(1);
}
sigemptyset(&zmask);
sigemptyset(&nmask);
sigaddset(&nmask, SIGINT);
if (sigprocmask(SIG_BLOCK, &nmask, &omask) < 0) {
perror("sigprocmask(SIG_BLOCK) error");
exit(1);
}
pr_mask("in critical region");
if (sigsuspend(&zmask) != -1) {
perror("sigsuspend error");
exit(1);
}
pr_mask("after return from sigsuspend");
if (sigprocmask(SIG_SETMASK, &omask, NULL) < 0) {
perror("sigprocmask(SIG_SETMASK) error");
exit(1);
}
exit(0);
}
int main(int argc, char *argv[])
{
sigset_t waitset;
sigset_t sysset;
struct sigaction act;
act.sa_handler = sig_quit;
act.sa_flags = SA_NODEFER;
sigemptyset(&act.sa_mask);
sigaction(SIGQUIT, &act, NULL);
sigfillset(&sysset);
sigdelset(&sysset, SIGQUIT);
sigdelset(&sysset, SIGINT);
sigprocmask(SIG_SETMASK, &sysset, NULL);
pr_mask("befer suspend");
int i;
for (i = 0; i < 10; i++)
{
write(STDOUT_FILENO, "-", sizeof("-"));
sleep(1);
}
#if 1
sigemptyset(&waitset);
sigaddset(&waitset, SIGINT);
sigsuspend(&waitset);
#endif
for ( ; ; )
{
write(STDOUT_FILENO, ".", sizeof("."));
sleep(1);
}
pr_mask("after suspend");
return 0;
}
static void sig_int(int signo){
pr_mask("in sig_int:");
}
void sig_int(int signo)
{
pr_mask("\n in sig_int");
return;
}
void sig_alrm(int signo)
{
pr_mask("in sig_alrm: ");
}
