shells system calls and signals n.
Skip this Video
Download Presentation
Shells, System Calls, and Signals

Loading in 2 Seconds...

play fullscreen
1 / 45

Shells, System Calls, and Signals - PowerPoint PPT Presentation

  • Uploaded on

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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Shells, System Calls, and Signals' - eben

Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
what is a shell
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
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 shell1
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
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 shell1
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 shell2
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
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 shell1
tcsh – An Enhanced C Shell
  • It includes:
    • Command-line editor
    • Programmable word completion
    • Spelling correction
    • History mechanism
    • Job control
  • 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
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
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
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
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
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
Process Inheritance
  • The child process inherits many attributes from the parent including…
    • Current working directory
    • User id
    • Group id
the fork system call
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
  • #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
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
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
  • 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
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!!!
  • int execl( char *path,

char *arg0,

char *arg1,


char *argN,

(char *) 0);

execl( “/home/bin/foobar”, “alpha”, “beta”, NULL );

a complete execl example
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
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
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
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
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
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
execandfork.cpp (output)] {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] {59}%

a more concise example
A More Concise Example

int main()


pid_t pid;

/* fork another process */

pid = fork();

if (pid < 0) { /* error occurred */

fprintf(stderr, "Fork Failed");



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");




a simple shell
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
Signaling Processes
  • 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
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
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
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
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
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.
  • 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
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
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
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
  • 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