![● The return value of kill is zero if it succeeds or -1 if it fails.
● The following C program illustrates the implementation of the UNIX kill Command.
#include<iostream.h>
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<signal.h>
int main(int argc,char** argv)
{
int pid, sig = SIGTERM;
if(argc==3)
{
if(sscanf(argv[1],”%d”,&sig)!=1)
{
cerr<<”invalid number:” << argv[1] << endl;
return -1;
}
argv++,argc--;
}
while(--argc>0)
if(sscanf(*++argv, “%d”, &pid)==1)
{
if(kill(pid,sig)==-1)
perror(“kill”);
}
else
cerr<<”invalid pid:” << argv[0] <<endl;
return 0;
}
3.Kill
$ kill - < signal_num > < pid >](https://image.slidesharecdn.com/unixpresentation-230121144159-85e5edbb/85/Unix-presentation-pdf-12-320.jpg)
Unix presentation.pdf
- 1. Unix Programming Module 5 BY: S Guru Prasad -1BY20CS154 Saeed Ahmed Alojily -1BY20CS159 Sai Harshit B -1BY20CS162 Vigneshwaran P S -1BY20CS215
- 2. Contents ➔ Setjmp and Longjmp ➔ Sigsetjmp and Siglongjmp ➔ Kill ➔ Alarm ➔ Interval Timers ➔ Posix 1b Timers These are APIs that are used to create functions we use in higher level languages to make code simpler
- 3. 1. Setjmp and longjmp ● setjmp and longjmp are a pair of C function facilitating cross-procedure transfer of control. Typically they are used to allow resumption of execution at a known good point after an error. ● Both take as first argument a buffer, which is used to hold the machine state at the jump destination. When setjmp is called it populates that buffer with the current location state (which includes stack and frame pointers and the return address for the call to setjmp, and returns zero. ● longjmp takes a buffer previously populated by setjmp. It also takes a (non-zero) second argument, which will ultimately be the result of the function call. longjmp restores the machine state from the buffer. It then jumps to the return address it has just restored, passing its second argument as the result. That return address is the return address from the original call to setjmp, so the effect will be as if setjmp has just returned with a non-zero argument.
- 4. 1. Setjmp and longjmp setjmp and longjmp are typically used in a top level function in the following way.
- 5. 1. Setjmp and longjmp During normal processing if an error is found, the state held in buf can be used to return control back to the top level using longjmp. The program will behave as though the original call to setjmp had just returned with result 1.
- 6. 2. Sigsetjmp and siglongjmp ● The sigsetjmp and siglongimp APIs have similar functions as their corresponding setjmp and longjmp APIs. ● The sigsetjmp and siglongjmp APIs are defined in POSIX 1 and on most UNIX systems that support signal mask. ● The function prototypes of the APIs are: #include <setjmp.h> int sigsetjmp (sigjmpbuf env, int save_sigmask ); int siglongimp (sigjmpbuf env, int ret_val ):
- 7. 2. Sigsetjmp and siglongjmp ● The sigsetjmp and siglongimp are created to support signal mask processing Specifically, it is implementation dependent on whether a process signal mask is saved and restored when it invokes the setjmp and longjmp APIs respectively. ● The sigsetjmp API behaves similarly to the setjmp API, except that it has a second argument, save_sigmask, which allows user to specify whether a calling process signal mask should be saved to the provided env argument. ● If the save_sigmask argument is nonzero, the caller's signal mask is saved, else signal mask is not saved. ● The siglongjmp API does all operations as the longimp API, but it also restores a calling process signal mask if the mask was saved in its env argument.
- 8. 2. Sigsetjmp and siglongjmp ● The ret_val argument specifies the return value of the corresponding sigsetjmp API when called by siglongjmp API. Its value should be nonzero number, and if it is zero the siglongjmp API will reset it to 1.
- 9. 2. Sigsetjmp and siglongjmp #include <iostream.h> #include <stdio.h> #include <unistd.h> #include <signal.h> #include <setjmp.h> sigjmp_buf env; void callme(int sig_num) { cout<< “catch signal:” <<sig_num <<endl; siglongjmp(env,2); } int main() { sigset_t sigmask; struct sigaction action,old_action; sigemptyset(&sigmask); if(sigaddset(&sigmask,SIGTERM)==1)||sigprocmask(SIG_SETM ASK,&sigmask,0)==-1) perror(“set signal mask”); sigemptyset(&action.sa_mask); sigaddset(&action.sa_mask,SIGSEGV); action.sa_handler=(void(*)())callme; action.sa_flags=0; if(sigaction(SIGINT,&action,&old_action)==-1) perror(“sigaction”); if(sigsetjmp(env,1)!=0) { cerr<<”return from signal interruption”; return 0; } else cerr<<”return from first time sigsetjmp is called”; pause(); }
- 10. The kill API can be used by a process to send a signal to a related process. ➔ This is a simple means of IPC or control ➔ The sender and recipient processes must be related such that either sender process real or effective user ID matches that of the recipient process, or the sender has su privileges ➔ For example, a parent and child process can send signals to each other via the kill API. ➔ The kill API is defined in most UNIX system and is a POSIX.1 standard. 3.Kill
- 11. The function prototype is as ● The sig_num argument is the integer value of a signal to be sent to one or more processes designated by pid. ● The possible values of pid and its use by the kill API are: #include <signal.h> int kill ( pid_t pid, int signal_num); Pid value Effects on the Kill API A Positive Value pid is a process ID. Sends Signal to that process 0 Sends signal to all processes whose process group ID is the same as the calling process. -1 Sends signal to all processes whose real user ID is the same as the effective user ID of the calling process Negative value Sends signal to all processes whose process group ID matches the absolute value of pid 3.Kill
- 12. ● The return value of kill is zero if it succeeds or -1 if it fails. ● The following C program illustrates the implementation of the UNIX kill Command. #include<iostream.h> #include<stdio.h> #include<unistd.h> #include<string.h> #include<signal.h> int main(int argc,char** argv) { int pid, sig = SIGTERM; if(argc==3) { if(sscanf(argv[1],”%d”,&sig)!=1) { cerr<<”invalid number:” << argv[1] << endl; return -1; } argv++,argc--; } while(--argc>0) if(sscanf(*++argv, “%d”, &pid)==1) { if(kill(pid,sig)==-1) perror(“kill”); } else cerr<<”invalid pid:” << argv[0] <<endl; return 0; } 3.Kill $ kill - < signal_num > < pid >
- 13. 4. Alarm An API that can be used a process to request the kernel for an alarm, like setting an alarm clock. ➔ What is it for? To send the SIGALARM signal after a certain number of real clock seconds. ➔ Note Alarm api is a POSIX.1 standard Syntax: #include<signal.h> unsigned int alarm( unsigned int timeInterval); The arguement timeInterval denotes the number of CPU seconds elapse time.
- 14. 4. Alarm ➔ Example: #include<signal.h> #include<stdio.h> #include<unistd.h> Void wakeup() {} ; unsigned int sleep(unsigned int timer) { struct sigaction action; action.sa_handler=wakeup; action.sa_flags=0; sigemptyset(&action.sa_mask); if(sigaction(SIGALRM, &action, 0)==-1) { perror("sigaction");return -1; } (void)alarm(timer); (void)pause(); return 0; } ➔ Explanation: The sleep function defined in the code suspends calling a process for the specified number of seconds (timer variable). The process will be awakened by either the elapsed time exceeding the timer or when process is interrupted by a signal. The sleep function sets up a signal handler for the SIGALRM, calls the API to request the kernel to send the SIGALRM signal after the interval and and finally suspends its execution using the pause system call. The wakeup signal handler function is called when the SIGALRM signal is sent to the process. When it returns, the pause system is aborted and calling process will return from sleep function.
- 15. 5. Interval Timers #include<signal.h> #include<stdio.h> #include<unistd.h> #define INTERVAL 5 void call(int sig_no) {alarm(INTERVAL);/*Do scheduled actions*/} int main() { struct sigaction action; sigemptyset(&action.sa_mask); action.sa_handler=(void(*)())call; action.sa_flags=SA_RESTART; if(sigaction(SIGALRM, &action, 0)==-1) {perror("sigaction");return -1; } if(alarm(INTERVAL)==-1) {perror("alarm");} else while(1) {/*Do normal Operations*/} return 0; } ➔ Explanation: As seen earlier, we set up the call function handling function using sigaction for SIGALRM. The program then invokes the alarm API to call the call function to do the scheduled actions, and then carry on with its usual routine.
- 16. 5. Interval Timers In addition to alarm API, UNIX also has setitimer API which provides features in addition to alarm API 1. setitimer resolution time is in microseconds, while in alarm it is in seconds. 2. The alarm API can be used to set up one real time clock per timer per process, but setitimer allows defining upto 3 different types of timers per process, a real time clock timer, a timer based on user time spent on process, and timer based on total user and system time spent on process. The setitimer API is not available in POSIX as there is another set of timers specified under POSIX.1b. There is another related API called getitimer that users can use to query the timer values set by setitimer API.
- 17. 5. Interval Timers Syntax: (function prototypes) #include<sys/time.h> /*setitimer:*/ int setitimer(int which, const struct itimeval *val, struct itimerval *old); /*getitimer*/ int getitimer(int which, struct itimeval *old); Here: which = to specify which timer to process Possible argument values: - ITIMER_REAL: Real time clock. Generates SIGALRM signal. - ITIMER_VIRTUAL: User time spent on process. Generates SIGVTALRM signal. - ITIMER_PROF: Total user and system time spent on process. Generates SIGPROF signal.
- 18. 5. Interval Timers Syntax: (struct itimeval) struct itimeval { struct timeval it_interval; /*timer interval*/ struct timeval it_value; /*current value*/ }; Note: setitimer and getitimer return 0 if they succeed and -1 if they fail. They are not inherited by child processes, but are retained when a process exec’s a new program. The next slide shows the code on the first slide of the topic, but using setitimer API instead of alarm API.
- 19. 5. Interval Timers #include<signal.h> #include<stdio.h> #include<unistd.h> #define INTERVAL 5 void call(int sig_no) {/*Do scheduled actions*/} int main() { struct itimerval val; struct sigaction action; sigemptyset(&action.sa_mask); action.sa_handler=(void(*)())call; action.sa_flags=SA_RESTART; if(sigaction(SIGALRM, &action, 0)==-1) {perror("sigaction");return -1; } val.it_interval.tv_sec= INTERVAL; val.it_interval.tv_usec=0; val.it_value.tv_sec=INTERVAL; val.it_value.tv_usec=0; if(setitimer(ITIMER_REAL, &val, 0)==-1) {perror("alarm");} else while(1) {/*Do normal Operations*/} return 0; } ➔ Explanation: This code uses setitimer instead of alarm API
- 20. 6. Posix 1b Timers POSIX.1b defines a set of APIs for interval timer manipulation. The POSIX.1b timers are more flexible and powerful than UNIX timers. What makes POSIX.1b timers better? 1. Users may define multiple independent timers per system clock 2. The timer resolution is in nanoseconds 3. Users may specify, on a per timer basis, the signal to be raised when a timer expires. 4. The timer interval may be specified as an either absolute or relative time.
- 21. 6. Posix.1b Timers There is a limit on how many POSIX timers can be created per process. This limit is set by the TIMER_MAX constant, as defined in the <limits.h> header. POSIX timers are not inherited by child processes, but are retained across the exec system call, just like in interval timers. Unlike UNIX timers, POSIX timers do not use the SIGALRM signal when they expire, it can be used in the same program with sleep API. POSIX timers have 5 different functions: Create, set, get time, get overrun and delete. They are described in the following slide
- 22. 6. POSIX.1b Timers Syntax: (function prototypes) There are a few functions under POSIX timers, and their prototypes are as follows:- int timer_create(clockid_t clock, struct sigevent* spec, timer_t* timer_hdrp); Used to dynamically create a timer and returns its handler. The clock argument value may be CLOCK_REALTIME for creating a real time clock timer. Other values for the argument are system dependent. int timer_settime(timer_t timer_hdr, int flag, struct itimrspec* val, struct itimrspec* old); int timer_gettime(timer_t timer_hdr, struct itimrspec* old); int timer_getoverrun(timer_t timer_hdr); int timer_delete(timer_t timer_hdr);
- 23. 6. POSIX.1b Timers Syntax: There are a few structures and union, listed as follows:- struct sigevent { int sigev_notify; int sigev_signo; union sigval sigev_value; }; union sigval { int sival void *sival_ptr; };
- 24. 6. POSIX.1b Timers Syntax: There are a few structures and union, listed as follows:- struct itimerspec { struct timespec it_interval; struct timespec it_value; }; struct timespec { time_t tv_sec; long tv_nsec; };
- 25. 6. POSIX.1b Timers #include<stdio.h> #include<unistd.h> #include<time.h> #include<signal.h> #define fuse 12 void call (int signo, siginfo_t* evp, void* ucontext) { time_t tim=time(0); printf("Timer has rung!"); } int main { struct sigaction sigv; struct sigevent sigx; struct itimerspec val; struct tm do_time; timer_t t_id; sigemptyset( &sigv.sa_mask); sigv.sa_flags = SA_SIGINFO; sigv.sa_sigaction = call; if (sigaction(SIGUSR1, &sigv, 0) == -1) {perror("sigaction");return(1);} sigx.sigev_notify = SIGEV_SIGNAL; sigx.sigev_signo = SIGUSR1; sigx.sigev_value.sival_int = fuse; if(timer_create(CLOCK_REALTIME, &sigx, &t_id)==-1) {perror("timer_create");return(2);} val.it_value.tv_sec = 60; val.it_value.tv_nsec = 0; val.it_interval.tv_sec = 120; val.it_interval.tv_nsec = 0; if(timer_settime(t_id, 0, &val, 0) == -1) {perror("timer_settime");return(3);} /*Do something and wait for timer to expire*/ pause(); if(timer_delete(t_id) == -1) { perror("timer_delete");return(4); } return 0; }
- 26. Thank You