Signals & Message queue Inter process mechanism in Linux system 3/24/2011 1.
-
Upload
margaret-bryant -
Category
Documents
-
view
224 -
download
0
description
Transcript of Signals & Message queue Inter process mechanism in Linux system 3/24/2011 1.
Signals & Message queue
Inter process mechanism in Linux system
3/24/2011 1
What is signals
■ In short: Signals are a way of sending simple messages to processes.
■ Signals are usually used by the operating system to notify processes that some event occurred, without these processes needing to poll for the event.
3/24/2011 2
Definition : Signals
■ A signal is an asynchronous event which is delivered to a process.
■ Asynchronous means that the event can occur at any time■ may be unrelated to the execution of the process■ e.g. user types ctrl-C, when the system hangs
3/24/2011 3
Linux Signals
■ A LINUX signal corresponds to an event
■ It is raised by one process (or OSg) to call another process’s attention to an event
■ It can be caught (or ignored) by the subject process
3/24/2011 4
More on Signals
■ LINUX has a fixed set of signals■ signal.h defines the signals in the OS
■ Each LINUX signal has an integer number and a symbolic name Defined in <signal.h>
3/24/2011 5
◼The command ‘kill –l’ lists all the signals that are available.
7
Signals
Most signals have predefined meanings:
❑ sighup (HangUp): when a terminal is closed, the hangup signal is sent to every process in control terminal.
❑ sigint(interrupt): ask politely a process to terminate.
❑ sigquit(quit): ask a process to terminate and produce a core dump.
❑ sigkill (kill): force a process to terminate.
Signal Sources
a process
windowmanager
shell command
terminaldriver
memorymanagement
kernel
other userprocesses
SIGWINCH
SIGKILL
SIGINT SIGHUPSIGQUIT
SIGALRM
SIGPIPE
SIGUSR1
8
Sending signals to process. (by keyboard)
■ Ctrl-c This causes the system to send an INT signal(SIGINT) to the running process which causesThe process to immediately terminates.■ Ctrl-zThis causes the system to send an TSTP
signal(SIGTSTP) to the running process this causes The process to Suspend execution.
■ Ctrl-\This is same as ctrl-c but with better flexibilityThis sends ABRT Signal (SIGABRT)3/24/2011 9
Signal transmission
■Signal Generation: The kernel updates data structure of the destination process to represent that a new signal has been sent
■Signal delivery: The kernel forces the destination process to react to the signal by changing its execution state, by starting the execution of a specified signal handler.
■ The mechanics consist of two distinct steps:
3/24/2011 10
Delivering a Signal
■ Actions performed upon Delivering a Signal
1. Explicitly ignore the signal
2. Execute the default action associated with the signal
3. Catch the signal by invoking a user defined signal handler function
3/24/2011 11
Ignoring the signal
■ Do_signal() simply continues with a new execution of the loop.
ka= ¤t->sig->action[signr-1]; If (ka->sa.sa_handler== SIG_IGN ) Continue ;
3/24/2011 12
Default action for the signal
■ Execute the default action associated with the signal
■ The important actions are (based on signal type)■ Terminate (kill)■ Dump (core file for execution context is created)■ Ignore (signal is ignored)■ Stop (process is stopped.■ Continue
3/24/2011 13
Pre-defined Signal Handlers
■ There are two pre-defined signal handler functions that we can use, instead of writing our own:
■ SIG_IGN: Causes the process to ignore the specified signal. For example, in order to ignore Ctrl-C completely, write this: signal(SIGINT, SIG_IGN);
■ SIG_DFL: Causes the system to set the default signal handler for the given signal signal(SIGTSTP, SIG_DFL);
3/24/2011 14
Executing the default action for the signal
■ The signals whose default action is stop may stop all processes in the thread group
■ The signals whose default action is dump may create a core file in the process working directory.
■ The default action of terminate is simply killing the process.
3/24/2011 15
Catching the signal
■ If a handler has been established for the signal, do_signal() function must enforces its execution.
■ Signal handlers are functions defined by User mode processes and included in the User mode Segment.
■ Handle_signal() function runs in kernel mode while signal handlers run in user mode.
■ .
3/24/2011 16
Catching the signal
3/24/2011 17
Signal Handling
■Use the signal handling library: signal.h
■Then can use the signal call:
#include <signal.h>
void (*signal( int sig, void (*handler)(int))) (int) ;
■signal returns a pointer to the PREVIOUS signal handler
■ #include <signal.h> typedef void Sigfunc(int); /* my defn */ Sigfunc *signal( int signo, Sigfunc *handler );■ Signal (SIGINT, handler);
3/24/2011 18
System calls related to signal handling
■Kill() - sys call send signals to processes kill(pid,sig)
#include<sys/types.h>#include<signal.h>Int kill (pid_t pid, int sig); // C library/wrapper function//returns 0 on success -1 on fail
Sample programs
3/24/2011 19
Summary
• A signal is an asynchronous event which is delivered to a process
• Signals are a way of sending simple messages to processes
• Signal generation and delivery
• Various system calls related to signals
3/24/2011 20
Conclusion
❑Knowledge of the signaling mechanism and familiarity with signal-related functions help one write programs more efficiently.
❑In case of an error or any anomaly during the execution of a program, the kernel can use signals to notify the process.
❑Signals also have been used to communicate and synchronize processes and to simplify inter-process communications (IPCs).
3/24/2011 21
Message Queue
■Message queue.
■ A linked list of messages stored within the kernel and identified by a message queue identifier.
■ Every message has a type field, and a nonnegative length, and the actual data bytes.
■ Msgsnd puts a message at the end of the queue■ Msgrcv gets a message, may not follow FIFO order (can
be based on type)
Operating Systems: A Modern Perspective, Chapter 9
Operating Systems: A Modern Perspective, Chapter 9
Refined IPC Mechanism• OS manages the mailbox space• More secure message system
Info to beshared Info copy
Address Space for p0 Address Space for p1
MessageMessage
Message
Mailbox for p1
send function receive function
OS Interfacesend(… p1, …); receive(…);
◼msgget▪ Returns a message descriptor to be used
by other system calls◼msgsnd
▪ Sends a message ◼msgrcv
▪ Receives a message◼msgctl
▪ Controls the message queue
◼Syntax
◼Example
#include<sys/msg.h>Int msgget(key_t key, int msgflg);
msgid = msgget((key_t)1234,IPC_CREAT | IPC_EXCL) ;if(msgid < 0){
printf(“Message queue already exists\n") ;msgid = msgget((key_t)1234,0666) ;
}
◼Syntax:
◼Example
int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);
struct msgbuf {long mtype; /* message type, must be > 0 */char mtext[5]; /* message data */};
mbuf.mtype =1 ;strcpy(mbuf.mtext,"hello") ;retval = msgsnd(msgid,&mbuf,5,0) ;
◼Syntax:
◼Example
int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int
msgflg);
retval = msgrcv(msgid,&mbuf,5,1,0) ;if(retval < 0){perror("msgrcv: ") ;}
◼Syntax:
◼The msqid_ds structure has at least the following members:struct msqid_ds {
uid_t msg_perm.uid;uid_t msg_perm.gidmode_t msg_perm.mode;}
Int msgctl(int msg_id, int command, struct shmid_ds *buf);
retval = msgctl(msgid,IPC_RMID,NULL) ;if(retval < 0){ printf("removing the message queue had failed\n") ;}
Command DescriptionIPC_STAT To retrieve the values associated with the
shared memory.IPC_SET Sets the valuesIPC_RMID Deletes the shared memory segment.
int main() {int msgid, retval ;struct msgbuf mbuf ;
if(msgid = msgget((key_t)5678,IPC_CREAT | IPC_EXCL) ) < 0); {printf("msgget already created\n") ;msgid = msgget((key_t)5678,0666) ; }
mbuf.mtype =1 ;strcpy(mbuf.mtext,"hello") ; // trying to send
hello If( (retval = msgsnd(msgid,&mbuf,5,0)) <0){
perror("msgsnd: ") ; }
return 0 ;}
int main() {int msgid, retval ;struct msgbuf mbuf ;If((msgid =
msgget((key_t)5678,IPC_CREAT | IPC_EXCL))<0) {printf("msgget already created\n") ;msgid = msgget((key_t)5678,0666) ;
}if((retval = msgrcv(msgid,&mbuf,5,1,0))
< 0){perror("msgrcv: ") ;
}printf("message from process 1 is %s\
n",mbuf.mtext) ;return 0 ;}
◼Pros▪ Lies in the kernel space▪ Doesn’t require any external
synchronization.
◼Cons▪ Limit in the size of data to be sent▪ Over all size limit in the complete
system