ch10. signal

◆ Signal

#include<signal.h>

 void (*signal(int signo, void (*func) (int))) (int);

(ret)  success : 포인터

   failed : NULL

 

◆ 리눅스에서 signal 함수 정의

#include<signal.h>

 typedef vod (*__sighadler_t) (int);

__sighandler_t signal (int __sig, __sighandler_t handler);

(ret)  success : 포인터

   failed : NULL

 

 

#include<stdio.h> #include<stdlib.h> #include<signal.h> static void sig_usr(int); int main(void) { if(signal(SIGUSR1, sig_usr) == SIG_ERR) { printf("cannot catch SIGUSR1"); exit(1); } if(signal(SIGUSR2, sig_usr) == SIG_ERR) { printf("cannot catch SIGUSR2"); exit(1); } for( ; ; ) pause(); } static void sig_usr(int signo) { if(signo == SIGUSR1) printf("recieved SIGUSR1\n"); else if(signo == SIGUSR2) printf("recieved SIGUSR2\n"); else { printf("recieved signal %d\n", signo); exit(1); } }

 

 

[ Kill, raise ]  

◆ kill

#include<signal.h>

int kill(pid_t pid, int signo);

(ret)  success : 0

   failed : -1

 

◆ raise 

#include<signal.h>

 int raise(int signo);

(ret)  success : 0

   failed : -1

 

[alarm, pause]

 

◆  alarm

#include<unistd.h>

unsigned int alarm(unsigned int seconds);

(ret)  0 또는 이전에 설정된 타이머가 만료될때까지의 시간(초)

 

 

 ◆ pause

#include<unistd.h>

 int pause(void);

(ret) -1 (errno 가 EINTR 로 설정됨)

 

 

#include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<signal.h> #define MAXLINE 4096 static void sig_alrm(int signo); int main(void) { int n; char line[MAXLINE]; if(signal(SIGALRM, sig_alrm) == SIG_ERR) { printf("signal(SIGALRM) error\n"); exit(1); } alarm(10); if((n=read(STDIN_FILENO, line, MAXLINE)) < 0) { printf("read() error"); exit(1); } alarm(0); write(STDOUT_FILENO, line, n); exit(0); } static void sig_alrm(int signo) { }

 

#include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<signal.h> #include<setjmp.h> #define MAXLINE 4096 static void sig_alrm(int signo); static jmp_buf env_alrm; int main(void) { int n; char line[MAXLINE]; if(signal(SIGALRM, sig_alrm) == SIG_ERR) { printf("signal(SIGALRM) error\n"); exit(1); } if(setjmp(env_alrm) != 0) { printf("read timeout\n"); exit(1); } alarm(10); if((n=read(STDIN_FILENO, line, MAXLINE)) < 0) { printf("read() error"); exit(1); } alarm(0); write(STDOUT_FILENO, line, n); exit(0); } static void sig_alrm(int signo) { longjmp(env_alrm, 1); }

 

 

-------------------------------------------------------------------------------------------------------------------

 

 [sig ___ set]

 ◆ sigemptyset : sigset_t 전부 0 으로 설정

 #include<signal.h>

 int sigemptyset(sigset_t *set);

(ret)  success : 0

   failed : -1

 

 

 ◆ sigfillset : sigset_t 전부 1으로 설정

#include<signal.h>

 int sigfillset(sigset_t *set); 

(ret)  success : 0

   failed : -1

 

 

 ◆ sigaddset : signo 에 해당하는 값을 1으로 설정

#include<signal.h>

 int sigaddset(sigset_t *set, int signo);

(ret)  success : 0

   failed : -1

 

 

 ◆ sigdelset : signo 에 해당하는 값을 0으로 설정

#include<signal.h>

 int sigdelset(sigset_t *set, int signo);

(ret)  success : 0

   failed : -1

 

 

 ◆ sigismember :  signo가 시그널 집합에 포함되어있는지 확인 

#include<signal.h>

 int sigismember(const sigset_t *set, int signo);

(ret)  success : (true) 1, (false) 0

   failed : -1

 

 

 

 ◆ sigprocmask : 시그널마스크 조회, 수정

#include<signal.h>

 int sigprocmask(int how, const sigset_t *nset, sigset_t *restrict oset);

(ret)  success :  0

   failed : -1

 

(참고) how 인자 : SIG_BLOCK / SIG_UNBLOCK / SIG_SETMAST

 

 ◆ sigpending : 현재 pending중인 시그널 집합을 가져옴

#include<signal.h>

 int sigpending(sigset_t *set);

(ret)  success : 0

   failed : -1

 

#include<stdio.h> #include<stdlib.h> #include<signal.h> static void sig_quit(int); int main(void) { sigset_t newmask, oldmask, pendmask; if(signal(SIGQUIT, sig_quit) == SIG_ERR) { printf("cannot catch SIGQUIT"); exit(1); } sigemptyset(&newmask); sigaddset(&newmask, SIGQUIT); if(sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) { printf("SIG_BLOCK() error\n"); exit(1); } sleep(5); if(sigpending(&pendmask) < 0) { printf("sigpending() error"); exit(1); } if(sigismember(&pendmask, SIGQUIT)) printf("\nSIGQUIT pending\n"); if(sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) { printf("SIG_SETMASK() error"); exit(1); } printf("SIGQUIT unblocked\n"); sleep(5); exit(0); } static void sig_quit(int signo) { printf("caught SIGQUIT\n"); if(signal(SIGQUIT, SIG_DFL) == SIG_ERR) { printf("cannot reset SIGQUIT"); exit(1); } }

 

 

 

 ◆ sigaction : 시그널의 처분 방식을 설정, 조회

 

#include<signal.h>

 int sigaction(int signo, const struct sigaction *restrict nact, struct sigaction *restrict oact);

(ret)  success : 0

   failed : -1

 

*** 

[일반적 사용순서]

struct sigaction act, oact;

...

act.sa_handler = (함수명);

sigemptyset(&act.sa_mask);

if(sigaction(signo, &act, &oact) < 0)

{

...

}

***

설정 --- act가 NOT NULL

조회 --- act가 NULL 

 

 

 ◆ sigsetjmp 

 

#include<setjmp.h>

 int sigsetjmp(sigjmp_buf env, int savemask);

(ret)  직접 호출되었을 때에는 0, siglongjmp 호출에서 반환된 경우에는 0이 아닌 값

   

 

 

 ◆ siglongjmp

 

#include<setjmp.h>

 void siglongjmp(sigjmp_buf env, int val);

 

 

 

#include<stdio.h> #include<stdlib.h> #include<signal.h> #include<setjmp.h> #include<time.h> static void sig_usr1(int), sig_alrm(int); static sigjmp_buf jmpbuf; static volatile sig_atomic_t canjump; #include<stdio.h> #include<signal.h> #include<errno.h> void pr_mask(const char *str) { sigset_t sigset; int errno_save; errno_save = errno; if(sigprocmask(0, NULL, &sigset) < 0) { printf("sigprocmask() error\n"); exit(1); } printf("%s", str); if(sigismember(&sigset, SIGINT)) printf("SIGINT "); if(sigismember(&sigset, SIGQUIT)) printf("SIGQUIT "); if(sigismember(&sigset, SIGUSR1)) printf("SIGUSR1"); if(sigismember(&sigset, SIGALRM)) printf("SIGALRM "); printf("\n"); errno = errno_save; } int main(void) { if(signal(SIGUSR1, sig_usr) == SIG_ERR) { printf("signal(SIGUSR1) error"); exit(1); } if(signal(SIGALRM, sig_alrm) == SIG_ERR) { printf("signal(SIGALRM) error"); exit(1); } pr_mask("starting main : "); if(sigsetjmp(jmpbuf, 1)) { pr_mask("ending main: "); exit(0); } canjump = 1; for( ; ; ) pause(); } static void sig_usr1(int signo) { time_t starttime; if(canjump == 0) 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); } static void sig_alrm(int signo) { pr_mask("in sig_alrm : "); }

 

 -------------------------------------------------------------------------------------------------------------------

 

 

 ◆ sigsuspend : 마스크 재설정과 재우는 연산을 하나의 원자적 연산으로 수행

#include<signal.h>

 int sigsuspend(const sigset_t *sigmask);

(ret)  -1 ( errno은 EINTR로 설정 )

 

 

 

#include<stdio.h> #include<stdlib.h> #include<signal.h> volatile sig_atomic_t quitflag; static void sig_int(int signo) { if(signo == SIGINT) printf("\n interrupt \n"); else if(signo == SIGQUIT) quitflag = 1; } int main(void) { sigset_t newmask, oldmask, zeromask; if(signal(SIGINT, sig_int) == SIG_ERR) { printf("signal(SIGINT) error"); exit(1); } if(signal(SIGQUIT, sig_int) == SIG_ERR) { printf("signal(SIGQUIT) error"); exit(1); } sigemptyset(&zeromask); sigemptyset(&newmask); sigaddset(&newmask, SIGQUIT); if(sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) { printf("SIG_BLOCK() error\n"); exit(1); } while(quitflag == 0) sigsuspend(&zeromask); quitflag = 0; if(sigprocmask(SIG_SETMASK, &oldmask, NULL) <0 ) { printf("SIG_SETMASK() error\n"); exit(1); } exit(0); }

 

 

 

 ◆ abort : 프로그램 비정상 종료

#include<stdlib.h>

 void abort(void);

 

 

 ◆ sleep : 호출한 프로세스를 일시정지 상태로 만드는 함수

 

#include<unistd.h>

 unsigned int sleep(unsigned int seconds);

(ret)   0 또는 덜 잠든 시간(초)

   

 

 

 ◆ psignal

#include<signal.h>

 void psignal(int signo, const char *msg);

 

 ◆ stsignal

#include<string.h>

 char *strsignal(int signo);

(ret)  신호를 설명하는 문자열을 가리키는 포인터