Signals (Chap 10 in the book “Advanced Programming in the UNIX Environment”) Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ.

Slides:



Advertisements
Similar presentations
Recitation 8: 10/28/02 Outline Processes Signals –Racing Hazard –Reaping Children Annie Luo Office Hours: Thursday 6:00.
Advertisements

Week Fourteen Agenda Announcements Final Exam True/False -100 questions (1 point per question) Multiple Choice - 40 questions (2 points per question)
UNIX Process Control Bach 7 Operating Systems Course Hebrew University Spring 2007.
Page 1 Task Control: Signals and Alarms Chapter 7 and 8 B. Ramamurthy.
Process Process: the UNIX abstraction of a stand-along computer that manages resources (memory, CPU, I/O resources) comprising a running program. Processes.
Signals Hua LiSystems ProgrammingCS2690Signals. Topics: Sending Signals -- kill(), raise() Signal Handling -- signal() sig_talk.c -- complete example.
Operating Systems Course Hebrew University Spring 2007 Signals & User Thread.
Home: Phones OFF Please Unix Kernel Parminder Singh Kang Home:
Slide 6-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective, Chapter 6 Threads and Scheduling 6.
1 Signals COS Goals of Today’s Lecture Overview of signals  Notifications sent to a process  UNIX signal names and numbers  Ways to generate.
Process in Unix, Linux and Windows CS-3013 C-term Processes in Unix, Linux, and Windows CS-3013 Operating Systems (Slides include materials from.
CS Lecture 16 Outline Inter-process Communication (IPC) – Pipes – Signals Lecture 161CS Operating Systems 1.
Signal Signal : - is a notification sent to a process to notify it of some event - interrupts whatever the process is doing and force it to handle a signal.
CSc 352 Signal Handling in Unix Saumya Debray Dept. of Computer Science The University of Arizona, Tucson
UNIX Signals Bach 7.2 Operating Systems Course The Hebrew University Spring 2010.
Process Description and Control Chapter 3. Major Requirements of an OS Interleave the execution of several processes to maximize processor utilization.
Process in Unix, Linux, and Windows CS-3013 A-term Processes in Unix, Linux, and Windows CS-3013 Operating Systems (Slides include materials from.
1Reference “Introduction To Unix Signals Programming” in the reference material section Man page – sigprocmask, alarm “Understanding the Linux Kernel”
Operating Systems Chapter 2
* POSIX-Defined Signals * Signaling Processes * Signal Mask * sigaction * kill and sigaction * alarm Topics.
Week Fourteen Agenda Announcements Final Exam True/False -100 questions (1 point per question) Multiple Choice - 40 questions (2 points per question)
Agenda  Working with Processes: Purpose Running Programs within same process (execl, execlp, execle, execv, execvp, execve) “Spawning” other process (fork,
System calls for Process management
Chapter 11 Process Management
Unix Process Model Simple and powerful primitives for process creation and initialization. fork syscall creates a child process as (initially) a clone.
Scis.regis.edu ● CS 468: Advanced UNIX Class 5 Dr. Jesús Borrego Regis University 1.
Week Fourteen Agenda Announcements Final Exam True/False -100 questions (1 point per question) Multiple Choice - 40 questions (2 points per question)
Concurrent Processes Processes can concurrently run same program. Processes can concurrently run same program. Processes can start other processes. Processes.
Signals and Signal Processing CIS 370 Lab 7 Umass Dartmouth.
Outline for Today Objectives –Finish discussion of Birrell –UNIX Signals –Eraser Administrative –Spider talk after class.
Signals and Signal Handling. Signals A predefined message sent between two processes or from the kernel to a process, or by a user to a process A software.
Signals (Chap 10 in the book “Advanced Programming in the UNIX Environment”) Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ.
NCHU System & Network Lab Lab #8 Signals Operating System Lab.
1 Signals (continued) CS 241 April 9, 2012 University of Illinois.
UNIX Signals * POSIX-Defined Signals * Signaling Processes * Signal Mask * sigaction * kill and sigaction * alarm * Interval Timers * POSIX.1b Timers *
Interprocess Communication Mechanisms. IPC Signals Pipes System V IPC.
Operating Systems Recitation 4, April th, 2002 Signals.
Signals. Introduction r A signal is a mechanism for notifying a process that an event has occurred. m When a signal is sent to a process is normal execution.
© 숙대 창병모 1 제 10 장 신호 (Signal). © 숙대 창병모 2 Contents 1. Signal Concepts 2. signal() 3. Interrupted System Calls 4. kill() /raise() 5. alarm() pause() 6.
Today’s topic Environment variables Signal. The list of environment variables –try ‘env’ –Environment variables can be defined in shell setenv DISPLAY.
Process Description and Control Chapter 3. Source Modified slides from Missouri U. of Science and Tech.
Linux/UNIX Programming APUE (Signals) [Ch. 10] 최미정 강원대학교 컴퓨터과학전공.
Today’s topics Signals and how to control the program behavior in handling signals. Terminal I/O.
ACCESS CONTROL. Components of a Process  Address space  Set of data structures within the kernel - process’s address space map - current status - execution.
S -1 Processes. S -2 wait and waitpid (11.2) Recall from a previous slide: pid_t wait( int *status ) wait() can: (a) block; (b) return with status; (c)
System calls for Process management Process creation, termination, waiting.
1 Lecture 19: Unix signals and Terminal management n what is a signal n signal handling u kernel u user n signal generation n signal example usage n terminal.
Copyright ©: Nahrstedt, Angrave, Abdelzaher, Caccamo1 Signals.
Operating Systems Summer Semester 2011 Practical Session 2, Signals 1.
UNIX signals.
G.Jyostna.
Linux/UNIX Programming
Task Control: Signals and Alarms Chapter 7 and 8
Unix Process Management
제11장 프로세스 시스템 프로그래밍 2011 가을 숙명여대 창병모.
Processes in Unix, Linux, and Windows
Linux/UNIX Programming
Exceptional Control Flow Part II
Structure of Processes
Processes in Unix, Linux, and Windows
CSC Advanced Unix Programming, Fall 2015
Processes in Unix, Linux, and Windows
제11장 프로세스 관리.
Signals Tanzir Ahmed CSCE 313 Fall 2018.
Inter-Process Communication ENCE 360
Unix Process Control B.Ramamurthy 4/11/2019 B.Ramamurthy.
Processes in Unix, Linux, and Windows
Linux/UNIX Programming
Signals.
Presentation transcript:

Signals (Chap 10 in the book “Advanced Programming in the UNIX Environment”) Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ.

Page 2 Signals Signals are software interrupts from unexpected events an illegal operation (e.g., divide by 0) a power failure an alarm clock the death of a child process a termination request from a user (Ctrl-C) a suspend request from a user (Ctrl-Z) Process Signal #8

LINUX Signal handling information in task_struct 3

Signal 처리 1. Sending signal to other processes Kill() 2. Receiving signal from other processes task_struct 에 signal, pending 변수 이용 3. On receipt of a signal, call signal handler Signal() 함수 이용. task_struct 의 sighand 변수 이용 4. Blocking a signal Sigprocmask() 함수 이용 Blocked 변수의 비트 설정 4

Page 5 Predefined Signals (1/2) 31 signals / usr/include/signal.h Every signal has a name begin with ‘SIG’ SIGABRT: abort signal from abort() SIGALRM: alarm signal from alarm() Actions of the default signal handler terminate the process and generate a core(dump) ignores and discards the signal(ignore) suspends the process (suspend) resume the process Default signal handler can be overriden

6 Signal Sources a process window manager shell command terminal driver memory management kernel other user processes SIGWINCH SIGKILL SIGINTSIGHUP SIGQUIT SIGALRM SIGPIPE SIGUSR1

Page 7 Predefined Signals (2/2)

Page 8 Signal Generation Terminal-generated signals CTRL-C  SIGINT CTRL-Z  SIGSTP signal Hardware excepts generate signals divide by 0  SIGFPE invalid memory reference  SIGSEGV kill() sends any signal to a process or process group need to be owner or super-user Software conditions SIGALRM: alarm clock expires SIGPIPE: broken pipe SIGURG: out-of-band network data

Page 9 Handling of Signals Disposition or action: Process has to tell the kernel “if and when this signal occurs, do the following.” Ignore the signal: all signals can be ignored, except SIGKILL and SIGSTOP Let the default action apply: most are to terminate process

Page 10 Representative UNIX Signals (1/2) SIGART: generated by calling the abort function. SIGALRM: generated when a timer set with the alarm expires. SIGCHLD: whenever a process terminates or stops, the signal is sent to the parent. SIGCONT: this signal sent to a stopped process when it is continued. SIGFPE: signals an arithmetic exception, such as divide-by-0, floating point overflow, and so on SIGILL: indicates that the process has executed an illegal hardware instruction. SIGINT: generated by the terminal driver when we type the interrupt key and sent to all processes in the foreground process group.

Page 11 Representative UNIX Signals (2/2) SIGKILL: can’t be caught or ignored. a sure way to kill any process. SIGPIPE: if we write to a pipeline but the reader has terminated, SIGPIPE is generated. SIGSEGV: indicates that the process has made an invalid memory reference. (  core dumped) SIGTERM: the termination signal sent by the kill(1) command by default. SIGTSTP: Cntl-Z from the terminal driver which is sent to all processes in the foreground process group. SIGUSR1: user defined signal 1 SIGUSR2: user defined signal 2

Page 12 signal() Signal Handler Registration signal(int signo, void(*func)())) specify the action for a signal (signo  func) func − SIG_IGN (ignore) − SIG_DFL (default) − user-defined function Return: the previous func

13 Example int main() { signal( SIGINT, foo ); : /* do usual things until SIGINT */ return 0; } void foo( int signo ) { : /* deal with SIGINT signal */ return; /* return to program */ }

Page 14 Example : alarm2.c (w/ handler) (1/2) #include // alarm2.c #include int alarmFlag=0; void alarmHandler(); main( ) { signal(SIGALRM, alarmHandler); alarm(3); printf("Looping …\n"); while(!alarmFlag) { pause( ); } printf("Loop ends due to alarm signal \n"); } void alarmHandler( ) { printf("An alarm clock signal was received\n"); alarmFlag = 1; }

Page 15 Example : alarm2.c (w/ handler) (2/2) Execution

Page 16 SIGCHLD Whenever a process terminates or stops, the signal is sent to the parent. When a child process is killed, it sends SGICHILD signal to its parent process

Page 17 Example: timelimit.c (1/3) #include // timelimit.c #include int delay; void childHandler( ); main(int argc, char *argv[]) { int pid; sscanf(argv[1], "%d", &delay); signal(SIGCHLD,childHandler); pid = fork(); if (pid == 0) { // child execvp(argv[2], &argv[2]); perror("Limit"); } else { // parent sleep(delay); printf("Child %d exceeded limit and is being killed\n", pid); kill(pid, SIGINT); } $ timelimit N command // perform “command” in N seconds

Page 18 Example: timelimit.c (2/3) childHandler( ) /* Executed if the child dies before the parent */ { int childPid, childStatus; childPid = wait(&childStatus); printf(“Child %d terminated within %d seconds\n”, childPid, delay); exit(0); }

Page 19 Example : timelimit.c (3/3) Execution

20 Multiple Signals If many signals of the same type are waiting to be handled (e.g. two SIGINT s), then most UNIXs will only deliver one of them. the others are thrown away If many signals of different types are waiting to be handled (e.g. a SIGINT, SIGSEGV, SIGUSR1 ), they are not delivered in any fixed order.

The Reset Problem in early System V UNIC In early Unix, the signal disposition in a process is reset to its default action immediately after the signal has been delivered. Must call signal() again to reinstall the signal handler function.

Reset Problem Example int main() { signal(SIGINT, foo); : /* do usual things until SIGINT */ } void foo(int signo) { signal(SIGINT, foo); /* reinstall */ : return; }

Reset Problem : void ouch( int sig ) { printf( "OUCH! - I got signal %d\n", sig ); (void) signal(SIGINT, ouch); } int main() { (void) signal( SIGINT, ouch ); while(1) { printf("Hello World!\n"); sleep(1); } To keep catching the signal with this function, must call the signal system call again. Problem: from the time that the interrupt function starts to just before the signal handler is re-established the signal will not be handled. If another SIGINT signal is received during this time, default behavior will be done, i.e., program will terminate.

Re-installation may be too slow! There is a (very) small time period in foo() when a new SIGINT signal will cause the default action to be carried out -- process termination. POSIX, BSD signal functions solve it (and some other later UNIXs)

Modification in BSD 4.x signal environment Persistent Handlers Signal handlers remain installed even after the signal occurs and do not need to be explicitly reinstalled. Masking Signals are blocked for the duration of a signal handler (i.e. recursive signals are not normally allowed). A "signal mask" can be set to block most signals during critical regions. Signal handlers normally remain installed during and after signal delivery. 25

Page 26 kill(), raise() kill - sends a signal to a process or a group of process raise - function allows a process to send a signal to itself #include int kill(pid_t pid, int signo); int raise(int signo); Both return: 0 if OK, 1 on error

Page 27 kill() pid means pid > 0: signal to the process whose process ID is pid pid == 0: signal to the processes whose process group ID equals that of sender pid < 0: signal to the processes whose process group ID equals abs. of pid pid == -1: unspecified (used as a broadcast signal in SVR4, BSD) Permission to send signals The super-user can send a signal to any process. The real or effective user ID of the sender has to equal the real or effective user ID of the receiver.

Page 28 alarm() #include unsigned int alarm (unsigned int seconds); Returns: 0 or number of seconds until previously set alarm alarm() sets a timer to expire at a specified time in future. when timer expires, SIGALRM signal is generated, default action of the signal is to terminate the process. Only one alarm clock per process previously registered alarm clock is replaced by the new value. if alarm(0), a previous unexpired alarm is cancelled.

Page 29 pause() #include int pause (void); Returns: -1 with errno set to EINTR suspends the calling process until a signal is caught. returns only if a signal handler is executed and that handler returns. If signal handler is not registered, just quit If signal handler is registered, return after the handler is processed.

Page 30 abort() #include void abort(void); This function never returns Causes abnormal program termination. This function sends the SIGABRT signal to the process. SIGABRT signal handler to perform any cleanup that it wants to do, before the process terminated.

Page 31 sleep() #include unsigned int sleep(unsigned int seconds) ; Returns: 0 or number of unslept seconds This function causes the calling process to be suspended until either The amount of wall clock time specified by second has elapsed (returns 0) A signal is caught by the process and the signal handler returns (returns the number of unslept seconds)

Process group Group of related processes that should receive a common signal for certain events Identified by Process group ID Example grp = setpgrp(); Initialize process group id, the same as its pid After fork(), child process will have parent’s process group id 32

setpgrp() 33 #include main(){ register int i; setpgrp(); for(i=0;i<10;i++){ if(fork()==0){ /* child process */ if(i&1) setpgrp(); printf(“pid = %d pgrp= %d\n”, getpid(),getpgrp()); pause(); } kill(0,SIGINT); }

Treatment of Signals Sending a signal to a process issig() : check for receipt of signals Handling a signal psig() : handle signals after recognizing their existence 34

35 How to Send a Signal to Process Send a Signal sets a bit in the signal field in process table entry. process can remember different type of signal. process can not remember how many signals it receives of particular type. u area contains an array of signal-handler fields. kernel stores the address of the user-function in the field. Check for Signal about to return from kernel mode to user mode enters or leaves the sleep state at a suitably low scheduling priority. Handle Signals only when returns from kernel mode to user mode

36 How to Send a Signal to Process(Cont.) User Running Preempted Kernel Running Ready to Run In Memory Created Ready to Run, Swapped Sleep, Swapped Asleep In Memory Zombie sys call, interrupt fork return to user exit preempt reschedule process sleep wakeup swap out swap out swap in not enough mem (swapping system only) enough mem Check for Signal Check and Handle Signal no effect on a process running in the kernel mode a process never executes in user mode before handling outstanding signals

37 Algorithm for issig algorithm issig/* test for receipt of signals */ input : none output : true, if process receives signals that it does not ignore false otherwise { while(received signal field in process table entry not 0) { find a signal number sent to the process; if ( signal is death of child ) { if (ignoring death of child signals) free process table entries of zombie children; else if (catching death of child signals) return(true); } else if (not ignoring signal) return(true); turn off signal bit in received signal field in process table; } return(false); }

38 Algorithm for Handling Signal 1. determines signal type 2. turns off signal bit in the process table entry 3. if receives a signal to ignore continues as if the signal has never occurred. 4. If signal handling function is set to its default value, kernel dumps core image for signals that imply something is wrong with process and exit kernel does not dump core for signals that do not imply error. 5. If receives a signal to catch, accesses the user saved register context, and find the program counter and stack pointer clears the signal handler field in u area( undesirable side-effects ) kernel creates a new stack frame and writes a program counter and stack pointer from user saved register context kernel changes the user register context: program counter to the address of signal catcher function, and stack pointer to account for the growth of the user stack.

39 Algorithm for psig algorithm psig/* handle signals after recognizing their existence */ input : none output : none { get signal number set in process table entry; clear signal number in process table entry; if (user had called signal sys call to ignore this signal) return;/*done*/ if (user specified function to handle this signal) { get user virtual address of signal catcher stored in u area; /*the next statement has undesirable side-effects*/ clear u area entry that stored address of signal catcher; modify user level context; artificially create user stack frame to mimic call to signal catcher function; modify system level context; write address of signal catcher into program counter filed of user saved register context; return; }

40 Algorithm for psig(Cont.) if (signal is type that system should dump core image of process) { create file named "core" in current directory; write contents of user level context to file "core"; } invoke exit algorithm immediately; }