Exemplo n.º 1
0
void handler(int sig)
{
	if (sig == SIGINT || sig == SIGRTMIN) {

		printf("rev sig=%d\n", sig);
		printf("this is SIGINT | SIGRTMIN blockmask\n");
		printsigset(&oldset); //即main里面的newset
		printsigset(&newset); //block位依然为1
		printf("this is SIGINT | SIGRTMIN sigpending\n");
		sigpending(&pset); // SIGINT or SIGRTMIN的未决位为0
		printsigset(&pset);
	}

	else if (sig == SIGUSR1) {

		sigemptyset(&newset);
		sigaddset(&newset, SIGINT);
		sigaddset(&newset, SIGRTMIN);
		sigprocmask(SIG_UNBLOCK, &newset, &oldset);
		// 上句只是将未决标志位清0,block位依然为1,当处理SIGUSR1期间还会将此位置1
		// 此句结束立马先执行SIGINT or SIGRTMIN 的信号处理函数(开辟新的函数栈)
		// 再接下去执行
		printf("this is SIGUSR1 blockmask\n");
		printsigset(&oldset);
		printsigset(&newset); //block位依然为1
		printf("this is SIGUSR1 sigpending\n");
		sigpending(&pset); //信号全部处理完毕,故未决位都为0
		printsigset(&pset);
	}
}
Exemplo n.º 2
0
int main(int argc, char **argv)
{
    sigset_t block, pending;
    int sig, flag;

    /* 设置信号的handler */
    signal(MYSIGNAL, sig_handler);

    /* 屏蔽此信号 */
    sigemptyset(&block);
    sigaddset(&block, MYSIGNAL);
    printf("block signal\n");
    sigprocmask(SIG_BLOCK, &block, NULL);

    /* 发两次信号, 看信号将会被触发多少次 */
    printf("---> send a signal --->\n");
    kill(getpid(), MYSIGNAL);
    printf("---> send a signal --->\n");
    kill(getpid(), MYSIGNAL);

    /* 检查当前的未决信号 */
    flag = 0;
    sigpending(&pending);
    for (sig = 1; sig < NSIG; sig++) {
        if (sigismember(&pending, sig)) {
            flag = 1;
            psignal(sig, "this signal is pending");
        } 
    }
    if (flag == 0) {
        printf("no pending signal\n");
    }

    /* 解除此信号的屏蔽, 未决信号将被递送 */
    printf("unblock signal\n");
    sigprocmask(SIG_UNBLOCK, &block, NULL);

    /* 再次检查未决信号 */
    flag = 0;
    sigpending(&pending);
    for (sig = 1; sig < NSIG; sig++) {
        if (sigismember(&pending, sig)) {
            flag = 1;
            psignal(sig, "a pending signal");
        } 
    }
    if (flag == 0) {
        printf("no pending signal\n");
    }

    return 0;
}
Exemplo n.º 3
0
int
futex_wait(volatile intptr_t *lock_word, intptr_t oldval, long sec, unsigned long usec)
{
  struct thread_wakeup w;
  pthread_t self = pthread_self();
  DWORD msec = sec<0 ? INFINITE : (sec*1000 + usec/1000);
  DWORD wfso;
  int result;
  sigset_t pendset, blocked;
  int maybeINTR;
  int info = sec<0 ? WAKEUP_WAITING_NOTIMEOUT: WAKEUP_WAITING_TIMEOUT;

  sigpending(&pendset);
  if (pendset & ~self->blocked_signal_set)
      return FUTEX_EINTR;
  w.uaddr = lock_word;
  w.uval = oldval;
  w.info = info;

  if (cv_wakeup_add(&futex_pseudo_cond,&w)) {
      return FUTEX_EWOULDBLOCK;
  }
  self->futex_wakeup = &w;
  do {
      wfso = WaitForSingleObject(w.event, msec);
  } while (wfso == WAIT_OBJECT_0 && w.info == info);
  self->futex_wakeup = NULL;
  sigpending(&pendset);
  maybeINTR = (pendset & ~self->blocked_signal_set)? FUTEX_EINTR : 0;

  switch(wfso) {
  case WAIT_TIMEOUT:
      if (!cv_wakeup_remove(&futex_pseudo_cond,&w)) {
          /* timeout, but someone other removed wakeup. */
          result = maybeINTR;
          WaitForSingleObject(w.event,INFINITE);
      } else {
          result = FUTEX_ETIMEDOUT;
      }
      break;
  case WAIT_OBJECT_0:
      result = maybeINTR;
      break;
  default:
      result = -1;
      break;
  }
  futex_pseudo_cond.return_fn(w.event);
  return result;
}
Exemplo n.º 4
0
int main()
{
	sigset_t pendingset;
	struct sigaction act;
	act.sa_handler = myhandler;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);

	if (sigaction(SIGCHLD, &act, 0) != 0) {
                perror("Unexpected error while using sigaction()");
               	return PTS_UNRESOLVED;
        }

        if (sigset(SIGCHLD,SIG_HOLD) != SIG_HOLD) {
                perror("Unexpected error while using sigset()");
               	return PTS_UNRESOLVED;
        }

	raise(SIGCHLD);
	
        if (sigpending(&pendingset) == -1) {
                printf("Error calling sigpending()\n");
                return PTS_UNRESOLVED;
        }

        if (sigismember(&pendingset, SIGCHLD) != 1) {
		printf("Test FAILED: Signal SIGCHLD was not successfully blocked\n");
		return PTS_FAIL;
	}

	return PTS_PASS;
} 
Exemplo n.º 5
0
Arquivo: critical.c Projeto: y-c/APUE
int
main(void)
{
	sigset_t	newmask, oldmask, pendmask;

	if (signal(SIGQUIT, sig_quit) == SIG_ERR)
		err_sys("can't catch SIGQUIT");

	/*
	 * Block SIGQUIT and save current signal mask.
	 */
	sigemptyset(&newmask);
	sigaddset(&newmask, SIGQUIT);
	if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
		err_sys("SIG_BLOCK error");

	sleep(5);	/* SIGQUIT here will remain pending */

	if (sigpending(&pendmask) < 0)
		err_sys("sigpending error");
	if (sigismember(&pendmask, SIGQUIT))
		printf("\nSIGQUIT pending\n");

	/*
	 * Reset signal mask which unblocks SIGQUIT.
	 */
	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		err_sys("SIG_SETMASK error");
	printf("SIGQUIT unblocked\n");

	sleep(5);	/* SIGQUIT here will terminate with core file */
	exit(0);
}
Exemplo n.º 6
0
int main(void)
{
	sigset_t set, oset, pend;
	int i;

	sigemptyset(&set);
	sigaddset(&set, SIGINT);

	sigprocmask(SIG_BLOCK, &set, &oset);

	for (i = 0; ; i++) {
		if (i == 10) {
			sigprocmask(SIG_SETMASK, &oset, NULL);
		}
		sleep(1);
		sigpending(&pend);
		if (sigismember(&pend, SIGINT)) {
			printf("i = %d, SIGINT pending\n", i);
		} else {
			printf("i = %d\n", i);
		}
	}

	return 0;
}
Exemplo n.º 7
0
int main()
{

	signal(2, handler);
	sigset_t s, p, o;
	sigemptyset(&s);
	sigemptyset(&o);
	sigaddset(&s, SIGINT);
	sigprocmask(SIG_SETMASK, &s, &o);

	int count = 0;
	while(1)
	{
		sigemptyset(&p);
		sigpending(&p);
		print_sig(&p);
		sleep(1);
		if(count++ == 10)
		{
			sigprocmask(SIG_SETMASK, &o, NULL);
			printf("recover block\n");
			sleep(3);
		}
	}
	return 0;
}
Exemplo n.º 8
0
Arquivo: 9-1.c Projeto: Nan619/ltp-ddt
int main()
{

	struct sigaction act;
	sigset_t pendingset, selectset;

	act.sa_flags = 0;
	act.sa_handler = myhandler;

	sigemptyset(&pendingset);
	sigemptyset(&selectset);
	sigaddset(&selectset, SIGTOTEST);
	sigemptyset(&act.sa_mask);

	sigaction(SIGTOTEST, &act, 0);
	sighold(SIGTOTEST);
	raise(SIGTOTEST);

	sigpending(&pendingset);

	if (sigismember(&pendingset, SIGTOTEST) != 1) {
		perror("SIGTOTEST is not pending\n");
		return PTS_UNRESOLVED;
	}

	if (sigwaitinfo(&selectset, NULL) != SIGTOTEST) {
		perror("Call to sigwaitinfo() failed\n");
		return PTS_FAIL;
	}

	printf("Test PASSED\n");
	return PTS_PASS;
}
Exemplo n.º 9
0
int main(void)
{
    sigset_t base_mask, waiting_mask, oldmask;
    int sig;
     /* 阻塞使用者的中斷. */
    sigemptyset (&base_mask);
    sigaddset (&base_mask, SIGQUIT);
    sigaddset (&base_mask, SIGINT);
    if (sigprocmask (SIG_BLOCK, &base_mask, &oldmask)<0 )
       err_exit("SIG_BLOCK error");
    printf(" I have blocked SIGQUIT and SIGINT, and\n you can try "
           "to send these two signals and wait for my reply.\n");
    sleep(10);
     /* 過一會兒後,檢視是否有懸掛訊號. */
    printf("Let me see if there is any pending signal.\n");
    sigpending (&waiting_mask);
    for ( sig=1;sig<NSIG;sig++)
       if (sigismember (&waiting_mask, sig)){ 
          psignal(sig,"There is a pending signal" );
	       /* 對該訊號做出回應... */
       }
     /* 還原訊號屏蔽,這將放開SIGINT和SIGTSTP */
    if (sigprocmask(SIG_SETMASK,&oldmask,NULL)<0)
       err_exit("SIG_SETMASK error");
    /* 若果有訊號,下面的程式碼不會執行 */
    printf("Ther is no suspending signal. BYE!\n");	
    exit(EXIT_SUCCESS);
}
Exemplo n.º 10
0
int main(int argc, char *argv[]){
  int i = 0;
  sigset_t mask, pending;
  sigfillset(&mask);
  sigdelset(&mask, SIGALRM);
  sigprocmask(SIG_SETMASK, &mask, NULL);
  signal(SIGALRM, SIG_DFL);
  alarm(2);
  signal(SIGALRM, control_alarm);
  existe();
  while(i < ndir){
    printf("Creando\n");
    int signal;
    grabar = 1;
    sprintf(buffer, "./datos/a%d", i);
    i++;
    file = fopen(buffer, "w+");
    alarm(temp);
    while(grabar)
      fputc('x', file);
    sigpending(&pending);
    for(signal = 1; signal < NSIG; signal++)
        if(sigismember(&pending, signal))
            fprintf(file, "\nWas blocked: the signal %d\n", signal);
    fclose(file);
  }
  imprimir();
  printf("\n");
  return 0;
}
Exemplo n.º 11
0
main() {
    int sum = 0;
    int i;
    //1.声明
    signal(SIGINT, h);
    sigset_t sigs, sigp, sigq;
    sigemptyset(&sigs);
    sigemptyset(&sigp);
    sigemptyset(&sigq);

    sigaddset(&sigs, SIGINT);
    sigprocmask(SIG_BLOCK, &sigs, 0);

    for(i = 1; i <= 10; i++) {
        sum += i;
        sigpending(&sigp);
        if(sigismember(&sigp, SIGINT)) {
            printf("SIGINT信号在排队\n");
            sigsuspend(&sigq);  //这里等待信号处理,这么写的好处。你可以控制信号中断的位置
                                //+代码必须在这里中断。
            //使原来屏蔽信号无效,开放原来信号
            //使新的信号屏蔽,
            //当某个信号处理函数处理完毕
            //sigsuspend恢复原来屏蔽信号,返回
        }
        sleep(1);
    }
    printf("sum=%d\n", sum);
    sigprocmask(SIG_UNBLOCK, &sigs, 0);
    printf("over!\n");
}
Exemplo n.º 12
0
int main(int argc, char *argv[])
{
	struct sigaction act;
	act.sa_handler = handler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;

	sigset_t pset, oldset, newset;
	sigemptyset(&newset);
	sigaddset(&newset, SIGINT);
	sigaddset(&newset, SIGRTMIN);
	sigprocmask(SIG_BLOCK, &newset, &oldset);
	// 将block位置1,因为信号尚未产生,此时未决位都为0
	if (sigaction(SIGINT, &act, NULL) < 0)
		ERR_EXIT("sigaction error");

	if (sigaction(SIGRTMIN, &act, NULL) < 0)
		ERR_EXIT("sigaction error");
	
	if (sigaction(SIGUSR1, &act, NULL) < 0)
		ERR_EXIT("sigaction error");
	
	for (; ;) {
		printf("this is main blockmask\n");
		printsigset(&oldset); //全0
		printsigset(&newset); //两位为1
		printf("this is main sigpending\n");
		sigpending(&pset);
		printsigset(&pset); // 全0
		sleep(1);
	}

	return 0;

}
Exemplo n.º 13
0
int main(){
	int sum = 0;
	int i;

	sigset_t sigs;
	sigset_t sigp;
	sigset_t sigq;


	sigemptyset(&sigs);
	sigemptyset(&sigp);
	sigemptyset(&sigq);

	signal(SIGINT,h);
	sigaddset(&sigs,SIGINT);

	sigprocmask(SIG_BLOCK,&sigs,0);

	for(i = 1 ; i <= 10 ; i++){
		sum += 1;
		printf("%d\n",sum);
		sigpending(&sigp);
		if(sigismember(&sigp,SIGINT)){
			printf("SIGINT is queue....\n");
			sigsuspend(&sigq);
		}
		sleep(1);
	}
	printf("----%d\n",sum);
	sigprocmask(SIG_UNBLOCK,&sigs,0);
	printf("over!\n");
	while(1);

	return 0;
}
Exemplo n.º 14
0
int
main ()
{
  sigset_t set, oset;

  signal (SIGQUIT, mytest);
  sigemptyset (&set);
  sigemptyset (&oset);
  sigaddset (&set, SIGQUIT);
  if (sigprocmask (SIG_BLOCK, &set, &oset) == -1)
    {
      perror ("sigprocmask");
      return -1;
    }
  printf ("pid=%d\n", getpid ());
  sleep (10);
  sigemptyset (&set);
  if (!sigpending (&set))
    {
      if (sigismember (&set, SIGQUIT))
	{
	  printf ("sigquit\n");
	}
    }
  if (sigprocmask (SIG_SETMASK, &oset, NULL) == -1)
    {
      perror ("sigprocmask");
      return -1;
    }
  printf ("end\n");
  return 0;
}
Exemplo n.º 15
0
int main(void)
{
	sigset_t	newmask, oldmask, pendmask;

	if (signal(SIGQUIT, sig_quit) == SIG_ERR)
		printf("can't catch SIGQUIT\n");

	/*
	 * Block SIGQUIT and save current signal mask.
	 */

	sigemptyset(&newmask);
	sigaddset(&newmask, SIGQUIT);
	if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
		printf("SIG_BLOCK error\n");

	sleep(5);

	if (sigpending(&pendmask) < 0)
		printf("sigpending error\n");
	if (sigismember(&pendmask, SIGQUIT))
		printf("SIGQUIT pending\n");

	/*
	 * Reset signal mask which unblock SIGQUIT.
	 */
	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
		printf("SIG_SETMASK error\n");
	printf("SIGQUIT unblocked\n");

	sleep(5);
	return 0;
}
Exemplo n.º 16
0
main()
{
	int sum=0;
	int i;
	//1.
	signal(SIGINT,h);
	sigset_t sigs,sigp,sigq;
	//2.
	sigemptyset(&sigs);
	sigemptyset(&sigp);
	sigemptyset(&sigq);
	
	sigaddset(&sigs,SIGINT);
	//3.
	sigprocmask(SIG_BLOCK,&sigs,0);
	for(i=1;i<=10;i++)
	{
		sum+=i;
		sigpending(&sigp);
		if(sigismember(&sigp,SIGINT))
		{
			printf("SIGINT在排队!\n");
			sigsuspend(&sigq);
			//使原来屏蔽信号无效,开放原来信号
			//使新的信号屏蔽,
			//当某个信号处理函数处理完毕
			//sigsuspend恢复原来屏蔽信号,返回 
		}
		sleep(1);
	}
	printf("sum=%d\n",sum);
	sigprocmask(SIG_UNBLOCK,&sigs,0);
	printf("Over!\n");
}
Exemplo n.º 17
0
int main(int argc, const char * argv[])
{
    sigset_t conjunto, pendientes;
    int i;
    
    sigemptyset(&conjunto);
    
    sigaddset(&conjunto, SIGINT);
    
    sigprocmask(SIG_BLOCK, &conjunto, NULL);
    
    for( i= 0; i < 10; ++i)
    {
        printf("La señal SIGINT está bloqueada ... \n");
        sleep(1);
        sigpending(&pendientes);
        
        if (sigismember(&pendientes, SIGINT))
            printf("He recibido un Ctrl+C y no lo procesé por estar bloqueada. \n");
        
    }
    
    sigprocmask(SIG_UNBLOCK, &conjunto, NULL);
    printf("Ya se desbloqueó la señal");
    
    while(1);
    
    return 0;
}
Exemplo n.º 18
0
void main(int args, char * argv[]){
	int errn;
	setenv("SLEEP_SECS","7",1);
	char * sleep_secs=getenv("SLEEP_SECS");
	if(sleep_secs==NULL){
		errn=errno;
		printf("getenv:\t%s\n",strerror(errn));
	}
	int sl_sc;
	printf("sleep secs:\t%s\n",sleep_secs);
	sscanf(sleep_secs,"%d",&sl_sc);
	sigset_t set;
	sigset_t pending;
	sigemptyset(&set);
	sigaddset(&set,SIGINT);
	sigaddset(&set,SIGTSTP);
	sigprocmask(SIG_BLOCK,&set,NULL);
	printf("going to sleep\n");
	sleep(sl_sc);
	sigpending(&pending);
	if(sigismember(&pending,SIGINT))
		printf("SIGINT\n");
	if(sigismember(&pending,SIGTSTP)){
		printf("SIGTSTP\n");
		sigemptyset(&set);
		sigaddset(&set,SIGINT);
		sigprocmask(SIG_BLOCK,&set,NULL);
	}
	printf("reanuda y muere\n");
}
Exemplo n.º 19
0
main() {
	sigset_t new_mask, old_mask, pending_mask;
	struct sigaction act;

	sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO;
	act.sa_sigaction = (void*) user_func;

	if (sigaction(SIGRTMIN + 10, &act, NULL))
		printf("install signal SIGRTMIN+10 error\n");

	sigemptyset(&new_mask);
	sigaddset(&new_mask, SIGRTMIN + 10);

	if (sigprocmask(SIG_BLOCK, &new_mask, &old_mask))
		printf("block signal SIGRTMIN+10 error\n");

	sleep(20);

	printf("\n\nNow begin to get pending mask and unblock SIGRTMIN+10\n\n");
	if (sigpending(&pending_mask) < 0)
		printf("get pending mask error\n");
	if (sigismember(&pending_mask, SIGRTMIN + 10))
		printf("signal SIGRTMIN+10 is pending\n");

	if (sigprocmask(SIG_SETMASK, &old_mask, NULL) < 0)
		printf("unblock signal error\n");

	printf("signal unblocked ,ok ... ...\n\n\n");
}
Exemplo n.º 20
0
/*
 *	Discard any pending SIGPIPE and reset the signal mask.
 *
 * Note: we are effectively assuming here that the C library doesn't queue
 * up multiple SIGPIPE events.  If it did, then we'd accidentally leave
 * ours in the queue when an event was already pending and we got another.
 * As long as it doesn't queue multiple events, we're OK because the caller
 * can't tell the difference.
 *
 * The caller should say got_epipe = FALSE if it is certain that it
 * didn't get an EPIPE error; in that case we'll skip the clear operation
 * and things are definitely OK, queuing or no.  If it got one or might have
 * gotten one, pass got_epipe = TRUE.
 *
 * We do not want this to change errno, since if it did that could lose
 * the error code from a preceding send().  We essentially assume that if
 * we were able to do pq_block_sigpipe(), this can't fail.
 */
void
pq_reset_sigpipe(sigset_t *osigset, bool sigpipe_pending, bool got_epipe)
{
	int			save_errno = SOCK_ERRNO;
	int			signo;
	sigset_t	sigset;

	/* Clear SIGPIPE only if none was pending */
	if (got_epipe && !sigpipe_pending)
	{
		if (sigpending(&sigset) == 0 &&
			sigismember(&sigset, SIGPIPE))
		{
			sigset_t	sigpipe_sigset;

			sigemptyset(&sigpipe_sigset);
			sigaddset(&sigpipe_sigset, SIGPIPE);

			sigwait(&sigpipe_sigset, &signo);
		}
	}

	/* Restore saved block mask */
	pthread_sigmask(SIG_SETMASK, osigset, NULL);

	SOCK_ERRNO_SET(save_errno);
}
Exemplo n.º 21
0
int main(int argc,char **argv)
{
	sigset_t sigset;
	sigset_t pendingset;

	int i = 0;

	sigfillset(&sigset);
	sigprocmask(SIG_BLOCK,&sigset,&pendingset);

	printf("My PID %d\n",getpid());

	while(1)
	{
		printf("%d\n",i);
		i++;
		sleep(1);

		if(sigpending(&pendingset) == 0)
		{
			if(sigismember(&pendingset,SIGUSR1))
			{
				printf("BLOCK Signal : SIGUSR1\n");
				break;
			}
		}
	}

	return 0;
}
Exemplo n.º 22
0
intern int pth_util_sigdelete(int sig)
{
    sigset_t ss, oss;
    struct sigaction sa, osa;

    /* check status of signal */
    sigpending(&ss);
    if (!sigismember(&ss, sig))
        return FALSE;

    /* block signal and remember old mask */
    sigemptyset(&ss);
    sigaddset(&ss, sig);
    pth_sc(sigprocmask)(SIG_BLOCK, &ss, &oss);

    /* set signal action to our dummy handler */
    sa.sa_handler = pth_util_sigdelete_sighandler;
    sigfillset(&sa.sa_mask);
    sa.sa_flags = 0;
    if (sigaction(sig, &sa, &osa) != 0) {
        pth_sc(sigprocmask)(SIG_SETMASK, &oss, NULL);
        return FALSE;
    }

    /* now let signal be delivered */
    sigfillset(&ss);
    sigdelset(&ss, sig);
    sigsuspend(&ss);

    /* restore signal mask and handler */
    sigaction(sig, &osa, NULL);
    pth_sc(sigprocmask)(SIG_SETMASK, &oss, NULL);
    return TRUE;
}
Exemplo n.º 23
0
/*
 *	Block SIGPIPE for this thread.  This prevents send()/write() from exiting
 *	the application.
 */
int
pq_block_sigpipe(sigset_t *osigset, bool *sigpipe_pending)
{
	sigset_t	sigpipe_sigset;
	sigset_t	sigset;

	sigemptyset(&sigpipe_sigset);
	sigaddset(&sigpipe_sigset, SIGPIPE);

	/* Block SIGPIPE and save previous mask for later reset */
	SOCK_ERRNO_SET(pthread_sigmask(SIG_BLOCK, &sigpipe_sigset, osigset));
	if (SOCK_ERRNO)
		return -1;

	/* We can have a pending SIGPIPE only if it was blocked before */
	if (sigismember(osigset, SIGPIPE))
	{
		/* Is there a pending SIGPIPE? */
		if (sigpending(&sigset) != 0)
			return -1;

		if (sigismember(&sigset, SIGPIPE))
			*sigpipe_pending = true;
		else
			*sigpipe_pending = false;
	}
	else
		*sigpipe_pending = false;

	return 0;
}
Exemplo n.º 24
0
int main()
{
  sigemptyset(&sig);
  sigaddset(&sig,SIGINT);
  sigaddset(&sig,SIGQUIT);
  sigprocmask(SIG_SETMASK,&sig,NULL);
  sigact.sa_mask=sig;
  sigact.sa_flags=0;
  sigact.sa_handler=sig_int;
  sigaction(SIGINT,&sigact,NULL);
  sleep(5);
  sigdelset(&sig,SIGINT);
  sigprocmask(SIG_SETMASK,&sig,NULL);
  sigpending(&sigpendings);
  
  int i = 2;
  
  while(i!=28)
    {
      if((sip=sigismember(&sigpendings,i))==-1) {printf("error sigismember\n");}
      else if(sip==1) {printf("sig no %d is pending\n",i);}
      else {printf("%d, not\n",i);}
      i++;
    }
  
  return EXIT_SUCCESS;
}
Exemplo n.º 25
0
void handler(int sig)
{
	int ret;
	sigset_t pending;
	called++;

	if (called == 2) {
		FAILED("Signal was not masked in signal handler");
	}

	if (called == 1) {

		/* Raise the signal again. It should be masked */
		ret = raise(SIGNAL);

		if (ret != 0) {
			UNRESOLVED(ret, "Failed to raise SIGABRT again");
		}

		/* check the signal is pending */
		ret = sigpending(&pending);

		if (ret != 0) {
			UNRESOLVED(ret, "Failed to get pending signal set");
		}

		ret = sigismember(&pending, SIGNAL);

		if (ret != 1) {
			FAILED("signal is not pending");
		}
	}

	called++;
}
Exemplo n.º 26
0
int main(int argc,char * argv[])
{
	sigset_t newmask,oldmask,pendmask;

	if(signal(SIGQUIT,sig_quit)==SIG_ERR)
		printf("can't catch SIGQUIT\n");

	sigemptyset(&newmask);
	sigaddset(&newmask,SIGQUIT);

	if(sigprocmask(SIG_BLOCK,&newmask,&oldmask)<0)
		printf("SIG_BLOCK error\n");

	sleep(5);

	if(sigpending(&pendmask)<0)
		printf("sigpending error\n");
	if(sigismember(&pendmask,SIGQUIT))
		printf("\nSIGQUIT pending\n");

	if(sigprocmask(SIG_SETMASK,&oldmask,NULL)<0)
		printf("SIG_SETMASK error\n");
	printf("SIGQUIT unblocked\n");

	sleep(5);
	exit(0);
}
Exemplo n.º 27
0
int main()
{
    sigset_t    newmask, oldmask, pendmask;
    if(signal(SIGQUIT, sig_quit) == SIG_ERR){
        printf("Signal SIGQUIT error\n"); 
    }

    /**
     * Block SIGQUIT and save current signal mask
     **/
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGQUIT);
    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask)){
        printf("sigprocmask set SIG_BLOCK failed\n"); 
    }

    sleep(5);           // SIGQUIT here will remain pending
    if (sigpending(&pendmask) < 0){
        printf("sigpending error\n"); 
    }

    // SIG_BLOCK must be pending
    if(sigismember(&pendmask, SIGQUIT)){
        printf("\nSIGQUIT pending\n");         
    }

    // Reset the signal mask which unblocks SIGQUIT
    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0){
        printf("SIG_SETMASK errro\n"); 
    }

    printf("SIGQUIT unblocked\n");
    sleep(5);
    exit(0);
}
Exemplo n.º 28
0
// Returns true iff the signal is pending.
inline bool pending(int signal)
{
  sigset_t set;
  sigemptyset(&set);
  sigpending(&set);
  return sigismember(&set, signal);
}
Exemplo n.º 29
0
/*
 *  stress_timer_handler()
 *	catch timer signal and cancel if no more runs flagged
 */
static void MLOCKED_TEXT stress_timer_handler(int sig)
{
	struct itimerspec timer;
	sigset_t mask;

	(void)sig;

	if (!stress_timer_keep_stressing())
		goto cancel;
	timer_counter++;

	if (sigpending(&mask) == 0)
		if (sigismember(&mask, SIGINT))
			goto cancel;
	/* High freq timer, check periodically for timeout */
	if ((timer_counter & 65535) == 0)
		if ((time_now() - start) > (double)g_opt_timeout)
			goto cancel;
	if (g_keep_stressing_flag) {
		int ret = timer_getoverrun(timerid);
		if (ret > 0)
			overruns += ret;
		stress_timer_set(&timer);
		return;
	}

cancel:
	g_keep_stressing_flag = false;
	/* Cancel timer if we detect no more runs */
	(void)memset(&timer, 0, sizeof(timer));
	(void)timer_settime(timerid, 0, &timer, NULL);
}
Exemplo n.º 30
0
Arquivo: irq_cpu.c Projeto: JMR-b/RIOT
void native_print_signals(void)
{
    sigset_t p, q;
    puts("native signals:\n");

    if (sigemptyset(&p) == -1) {
        err(EXIT_FAILURE, "native_print_signals: sigemptyset");
    }

    if (sigpending(&p) == -1) {
        err(EXIT_FAILURE, "native_print_signals: sigpending");
    }

    if (sigprocmask(SIG_SETMASK, NULL, &q) == -1) {
        err(EXIT_FAILURE, "native_print_signals: sigprocmask");
    }

    for (int i = 1; i < (NSIG); i++) {
        if (native_irq_handlers[i] != NULL || i == SIGUSR1) {
            printf("%s: %s in active thread\n",
                   strsignal(i),
                   (sigismember(&_native_sig_set, i) ? "blocked" : "unblocked")
                  );
        }

        if (sigismember(&p, i)) {
            printf("%s: pending\n", strsignal(i));
        }

        if (sigismember(&q, i)) {
            printf("%s: blocked in this context\n", strsignal(i));
        }
    }
}