Shells, System Calls, and Signals

What is a Shell? A shell is a command line interface to the operating system Fetch a command from the user and execute the command Sometimes the commands are built-in to the shell Other times the commands are external system programs or user programs There are lots of different shells available in UNIX

Bourne Shell Historically the sh language was the first to be created and goes under the name of The Bourne Shell It has a very compact syntax which makes it obtuse for novice users but very efficient when used by experts It also contains some powerful constructs built in

Bourne Shell On UNIX systems, most of the scripts used to start and configure the operating system are written in the Bourne shell It has been around for so long that is virtually bug free

C Shell The C Shell (csh) Similar syntactical structures to the C language The UNIX man pages contain almost twice as much information for the C Shell as the pages for the Bourne Shell, leading most users to believe that it is twice as good

C Shell Actually, there are several compromises within the C Shell which makes using the language for serious work difficult (Check the list of bugs at the end of the man pages!).

C Shell The real reason why the C Shell is so popular is that it is usually selected as the default login shell for most users The features that guarantee its continued use in this arena are aliases and history lists

tcsh – An Enhanced C Shell An enhanced but completely compatible version of the Berkeley UNIX C Shell, csh It is a command language interpreter usable both as an interactive login shell and a shell script command processor Uses a C-like syntax

tcsh – An Enhanced C Shell It includes: Command-line editor Programmable word completion Spelling correction History mechanism Job control

BASH GNU Bourne Again Shell A complete implementation of the IEEE POSIX.2 and Open Group Shell specificaiton with… Interactive command line editing Job control on architectures that support it Csh-like features such as history substitution and brace expansion …and a slew of other features

Korne Shell The ksh was made famous by IBM’s AIX version of UNIX The Korne Shell can be thought of as a superset of the Borne Shell as it contains the whole of the Borne Shell world within its own syntax rules

Processes and the CWD Every process runs in a directory The attribute is called the “current working directory” (cwd) Finding the CWD char *getcwd( char *buf, size_t size ); Returns a string that contains the absolute pathname of the current working directory There are functions that can be used to change the current working directory (chdir)

Other Process Attributes Getting the process id number #include <unistd.h> pid_t getpid( void ); Getting the group id number gid_t getgid( void ); Getting the real user ID of a process uid_t getuid( void );

Creating a Process The only way to create a new process is to issue the fork() system call Fork() splits the current process into 2 processes, one is called the parent and the other is called the child

Parent and Child Processes The child process is a copy of the parent process Same program Same place in the program Almost…. The child process get a new process ID

Process Inheritance The child process inherits many attributes from the parent including… Current working directory User id Group id

The fork() system call #include <unistd.h> Pid_t fork( void ); fork() returns a process id (small unsigned integer) fork() returns twice!!!!!!! In the parent process, fork returns the id of the child process In the child, fork returns a 0

Example #include <unistd.h> #include <iostream> using namespace std; int main( int argc, char *argv[] ) { if( fork() ) cout << "I am the parent" << endl; else cout << "I am the child" << endl; return( 0 ); }

Bad Example (don’t do this) #include <unistd.h> // This is called a #include <iostream> // fork bomb!!!!! using namespace std; // please don’t do this int main( int argc, char *argv[] ) { while( fork() ) cout << "I am the parent" << endl; cout << "I am the child" << endl; return( 0 ); }

Switching Programs fork() is the only way to create a new process This would be almost useless if there was not a way to switch what program is associated with a process The exec() system call is used to start a new program

exec() There are actually a number of exec functions execlp, execl, execle, execvp, execv, execve The difference between these functions is the parameters How the new program is identified and some attributes that should be set

The exec Family When you call a member of the exec family, you give it the pathname of the executable file that you want to run If all goes well, exec will never return!!! The process becomes the new program!!!

Execl() int execl( char *path, char *arg0, char *arg1, …, char *argN, execl( “/home/bin/foobar”, “alpha”, “beta”, NULL );

A Complete execl Example #include <unistd.h> #include <iostream> using namespace std; int main( int argc, char *argv[] ) { char buf[ 1000 ]; cout << "Here are the files in " << getcwd( buf, 1000 ) << endl; execl( "/bin/ls", "ls", "-al", NULL ); cout << "If all goes well, this line will not be printed!!!" << endl; return( 0 ); }

fork() and exec() Together The following program does the following: fork() – results in 2 processes Parent prints out it’s PID and waits for child process to finish (to exit) Child process prints out it’s PID and then exec() “ls” and then exits

execandfork.cpp (1) #include <unistd.h> // exec, fork, getpid #include <iostream> // cout #include <sys/types.h> // needed for wait #include <sys/wait.h> // wait() using namespace std;

execandfork.cpp (2) void child( void ) { int pid = getpid(); cout << "CHILD: Child process PID is " << pid << endl; cout << "CHILD: Child process now ready to exec ls" << endl; execl( "/bin/ls", "ls", NULL ); }

execandfork.cpp (3) void parent( void ) { int pid = getpid(); int stat; cout << "PARENT: Parent process PID is " << pid << endl; cout << "PARENT: Parent waiting for child" << endl; wait( &stat ); cout << "PARENT: Child is done. Parent returning" << endl; }

execandfork.cpp (4) int main( int argc, char *argv[] ) { cout << "MAIN: Starting fork system call" << endl; if( fork() ) parent(); else child(); cout << "MAIN: Done" << endl; return( 0 ); }

execandfork.cpp (output) neptune.cs.kent.edu] {58}% a.out MAIN: Starting fork system call CHILD: Child process PID is 32557 CHILD: Child process now ready to exec ls PARENT: Parent process PID is 32556 PARENT: Parent waiting for child a.out lowcost_DB_NOW.pdf Project 1.pdf asc mail public_html Backup MASC Software bin MPISpawn2 ZephyrDemo hybrid_parallel_system.pdf Parallaxis icp_fall2004_prj4.txt Pictures PARENT: Child is done. Parent returning MAIN: Done neptune.cs.kent.edu] {59}%

A More Concise Example int main() { pid_t pid; /* fork another process */ pid = fork(); if (pid < 0) { /* error occurred */ fprintf(stderr, "Fork Failed"); exit(-1); } else if (pid == 0) { /* child process */ execlp("/bin/ls", "ls", NULL); else { /* parent process */ /* parent will wait for the child to complete */ wait (NULL); printf ("Child Complete"); exit(0);

System Calls for Files and Directories Description fd = open( name, how ) Open a file for reading and/or writing s = close( fd ) Close and open file n = read( fd, buffer, size ) Read data from a file into a buffer n = write( fd, buffer, size ) Write data from a buffer into a file s = lseek( fd, offset, whence ) Move the “current” pointer for a file s = stat( name, &buffer ) Get a file’s status information( in buffer ) s = mkdir( name, mode ) Create a new directory s = rmdir( name ) Remove a directory (must be empty) s = link( name1, name2 ) Create a new entry (name2) that points to the same object as name1 s = unlink( name ) Remove the name as a link to an object (deletes the object if name was the only link to it)

More System Calls Call Description pid = fork() Create a child process identical to the parent pid = waitpid( pid, &statloc, options ) Wait for a child to terminate s = execve( name, argv, environp ) Replace a process’ core image exit( status ) Terminate process execution and return status s = chdir( dirname ) Change the working directory s = chmod( name, mode ) Change a file’s protection bits s = kill( pid, signal ) Send a signal to a process seconds = time( &seconds ) Get the elapsed time since January 1, 1970

A Simple Shell while( true ) // repeat forever { type_prompt(); // display prompt read_command( command, parameters ); // input from terminal if( fork() != 0 ) // fork off child process { // parent code waitpid( -1, &status, 0 ); // wait for child to exit } else // child code execve( command, parameters, 0 ); // execute command

Signaling Processes Signal Features of Signal A signal is a notification to a process that an event has occurred. Signals are sometimes called “software interrupts”. Features of Signal Signal usually occur asynchronously. The process does not know ahead of time exactly when a signal will occur. Signal can be sent by one process to another process (or to itself) or by the kernel to a process.

Sources for Generating Signals Hardware A process attempts to access addresses outside its own address space. Divides by zero. Kernel Notifying the process that an I/O device for which it has been waiting is available. Other Processes A child process notifying its parent process that it has terminated. User Pressing keyboard sequences that generate a quit, interrupt or stop signal.

Three Courses of Action Process that receives a signal can take one of three action: Perform the system-specified default for the signal notify the parent process that it is terminating; generate a core file; (a file containing the current memory image of the process) terminate. Ignore the signal A process can do ignoring with all signal but two special signals: SIGSTOP and SIGKILL. Catch the Signal (Trapping) When a process catches a signal, except SIGSTOP and SIGKILL, it invokes a special signal handing routine.

POSIX-Defined Signals (1) SIGALRM: Alarm timer time-out. Generated by alarm( ) API. SIGABRT: Abort process execution. Generated by abort( ) API. SIGFPE: Illegal mathematical operation. SIGHUP: Controlling terminal hang-up. SIGILL: Execution of an illegal machine instruction. SIGINT: Process interruption. Can be generated by <Delete> or <ctrl_C> keys. SIGKILL: Sure kill a process. Can be generated by “kill -9 <process_id>“ command. SIGPIPE: Illegal write to a pipe. SIGQUIT: Process quit. Generated by <crtl_\> keys. SIGSEGV: Segmentation fault. generated by de-referencing a NULL pointer.

POSIX-Defined Signals (2) SIGTERM: process termination. Can be generated by “kill <process_id>” command. SIGUSR1: Reserved to be defined by user. SIGUSR2: Reserved to be defined by user. SIGCHLD: Sent to a parent process when its child process has terminated. SIGCONT: Resume execution of a stopped process. SIGSTOP: Stop a process execution. SIGTTIN: Stop a background process when it tries to read from its controlling terminal. SIGTSTP: Stop a process execution by the control_Z keys. SIGTTOUT: Stop a background process when it tries to write to its controlling terminal.

Sending Signals You may send signals to a process connected to your terminal by typing ^C SIGINT terminate execution ^\ SIGQUIT terminate and core dump ^Z SIGSTOP suspend for later The terminal driver is a program that processes I/O to the terminal can detect these special character sequences and send the appropriate signal to your interactive shell. The shell in turn generates an appropriate signal to the foreground process.

Kill The user can use the csh built-in kill command or use regular UNIX kill command to send a specific signal to a named process. % kill [-sig] process If no signal is specified, then SIGTERM (15)(terminate) is assumed In C/C++ the system call is #include <signal.h> int kill( int pid, int sig_id ); Return values: Success = 0, Failure = -1, Sets errno…YES

Signal Delivery and Processing When an interrupt or event causes a signal to occur, the signal is added to a set of signals that are waiting for delivery to a process. Signals are delivered to a process in a manner similar to hardware interrupts.

Signal Delivery If the signal is not currently blocked by the process, it is delivered to the process following these steps: The same signal is blocked from further occurrence until delivery and processing are finished The current process context is saved and a new one built A handler function associated with the signal is called If the handler function returns, then the process resumes execution from the point of interrupt, with its saved context restored. Among other things, the signal mask is restored. Signals have the same priority But processes can block listening to specific signals via a signal mask

Signal Trapping The system call signal() is used to trap signals #include <signal.h> signal( int sig_id, void * handler() ); Example: Write a C++ program to count the number of times CTRL-C is pressed at the terminal cc_counter.cpp

Alarms Function The alarm API requests the kernel to send the SIGALRM signal after a certain number of real clock seconds. #include <signal.h> int alarm( unsigned int time_interval); Return: Success: the number of CPU seconds left in the process timer; Failure: -1; Sets errno: Yes Argument time_interval: the number of CPU seconds elapse time. After which the kernel will send the SIGALRM signal to the calling process. Example: Write a C++ program to set an alarm for signal 5 seconds after process startup and trap the alarm signal. alarmer.cpp