Vserbu: Pagină nouă: In the last lab, we used system calls to work with files. So far, each of our programs has been a single process. In this lab, we will create n...

2026-10-29T09:57:30Z

Pagină nouă: In the last lab, we used system calls to work with files. So far, each of our programs has been a single process. In this lab, we will create n...

Pagină nouă

In [[OS_Lab_3_-_Files._Memory_mapping|the last lab]], we used system calls to work with files. So far, each of our programs has been a single process. In this lab, we will create new processes with [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], run other programs in them with <code>exec</code>, wait for them to end with [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>], and send and handle '''signals'''. As an application, we will write a small '''shell'''.

== Learning objectives ==

By the end of this lab you should be able to:

# create a new process with [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], and tell the parent from the child by the value it returns;
# wait for a child with [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>], and read its exit status;
# run another program with the <code>exec</code> family of functions, and explain what the process keeps and what it loses;
# send signals with [https://man7.org/linux/man-pages/man2/kill.2.html <code>kill(2)</code>], and handle them with [https://man7.org/linux/man-pages/man2/sigaction.2.html <code>sigaction(2)</code>];
# put all of these together into a simple shell.

== Processes ==

The kernel runs '''tasks''', and a '''process''' is a group of tasks which share their memory, and usually their open files and more. In this lab, each process will have a single task, so we will only use the word process from now on.

Every process is identified by a number, its '''PID''' (''process ID''), and has a '''parent''': the process that created it. A process can find its own PID using [https://man7.org/linux/man-pages/man2/getpid.2.html <code>getpid(2)</code>], and the PID of its parent using [https://man7.org/linux/man-pages/man2/getppid.2.html <code>getppid(2)</code>].

<syntaxhighlight lang="c">
// In: <unistd.h>
pid_t getpid(void); // The PID of the process itself
pid_t getppid(void); // The PID of its parent
</syntaxhighlight>

=== fork(2) ===

A new process is created with:

<syntaxhighlight lang="c">
// In: <unistd.h>
pid_t fork(void);
</syntaxhighlight>

[https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] creates a copy of the calling process, the '''child'''. Both processes continue from the same point, the return from [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], so [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] '''returns twice''', once in each process:

{| class="wikitable"
! In the !! [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] returns
|-
| Parent || The PID of the child
|-
| Child || 0
|-
| Parent, on error (no child was created) || -1, and sets <code>errno</code>
|}

[[File:OS_Lab_4_-_fork.png|center|thumb|650px|[https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] returns twice: the PID of the child in the parent, and 0 in the child. From there on, the two processes run independently, each with its own copy of the memory.]]

The child gets a copy of everything the parent has:

* its memory: the code, the global variables, the heap and the stack. The copy is made with ''copy-on-write'' (see the course), so it is fast, but after [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] a change made by one process is not seen by the other;
* its file descriptor table: the same numbers point to the same open files, so the two processes share the file offsets;
* its current working directory, its signal handlers (see below) and more.

The following program creates a child, and both processes print their PIDs and a variable:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(void)
{
int x = 1;

pid_t pid = fork();
if (pid == -1) {
print_error("fork");
return EXIT_FAILURE;
}

char msg[256];
if (pid == 0) {
// The child: its own copy of x.
x = 2;
snprintf(msg, sizeof msg, "child: PID %d, parent %d, x = %d\n", getpid(), getppid(), x);
write(STDOUT_FILENO, msg, strlen(msg));
return EXIT_SUCCESS;
}

// The parent: pid is the PID of the child.
waitpid(pid, nullptr, 0);
snprintf(msg, sizeof msg, "parent: PID %d, child %d, x = %d\n", getpid(), pid, x);
write(STDOUT_FILENO, msg, strlen(msg));
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
child: PID 2741, parent 2740, x = 2
parent: PID 2740, child 2741, x = 1
</syntaxhighlight>

The parent calls [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>], which we will look at next, to wait for the child to end before printing, so the child's line always comes first. Without it, the two lines could come in either order: after [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], the kernel runs the two processes independently.

=== waitpid(2) ===

A parent waits for a child to end with:

<syntaxhighlight lang="c">
// In: <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);
</syntaxhighlight>

{| class="wikitable"
! Parameter !! Description
|-
| <code>pid</code> || The PID of the child to wait for, or <code>-1</code> for any child
|-
| <code>wstatus</code> || Where to store the status of the child, or <code>nullptr</code> if we do not need it
|-
| <code>options</code> || 0 to block until the child ends. <code>WNOHANG</code>: do not block, return 0 if the child has not ended yet
|}

[https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>] returns the PID of the child that ended, or <code>-1</code> on error (for example, <code>ECHILD</code> if there is no such child). The status is an <code>int</code> which packs several pieces of information. It is read with the following macros:

{| class="wikitable"
! Macro !! Description
|-
| <code>WIFEXITED(status)</code> || True if the child ended normally, by returning from <code>main()</code> or calling [https://man7.org/linux/man-pages/man3/exit.3.html <code>exit(3)</code>]
|-
| <code>WEXITSTATUS(status)</code> || The exit status, from 0 to 255. Only valid if <code>WIFEXITED(status)</code>
|-
| <code>WIFSIGNALED(status)</code> || True if the child was killed by a signal
|-
| <code>WTERMSIG(status)</code> || The number of the signal. Only valid if <code>WIFSIGNALED(status)</code>
|}

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(void)
{
pid_t pid = fork();
if (pid == -1) {
print_error("fork");
return EXIT_FAILURE;
}
if (pid == 0) {
exit(3);
}

int status;
if (waitpid(pid, &status, 0) == -1) {
print_error("waitpid");
return EXIT_FAILURE;
}

char msg[256];
if (WIFEXITED(status)) {
snprintf(msg, sizeof msg, "child %d exited with status %d\n", pid, WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
snprintf(msg, sizeof msg, "child %d was killed by signal %d\n", pid, WTERMSIG(status));
}
write(STDOUT_FILENO, msg, strlen(msg));
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
child 2803 exited with status 3
</syntaxhighlight>

<div class="regula">'''Note:''' A child that has ended, but has not been waited for yet, is a '''zombie''': the kernel has freed its memory and files, and keeps only its PID and its status, for when the parent waits for it. <code>ps</code> shows it as <code><defunct></code>. A parent should always wait for its children: leaving zombies around for a long time is bad practice. If the parent ends first, the child is adopted by process 1, which waits for it.</div>

=== exec ===

[https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>] can only make copies of the running program. To run a '''different''' program, a process calls [https://man7.org/linux/man-pages/man2/execve.2.html <code>execve(2)</code>]:

<syntaxhighlight lang="c">
// In: <unistd.h>
int execve(const char *path, char *const argv[], char *const envp[]);
</syntaxhighlight>

The kernel loads the executable file at <code>path</code> into the process, in place of the program that is running, and starts it with the given arguments and environment. Both <code>argv</code> and <code>envp</code> are arrays of strings ending with <code>nullptr</code>.

On success, [https://man7.org/linux/man-pages/man2/execve.2.html <code>execve(2)</code>] '''does not return''': the program that called it is gone. If it returns, it failed, and it returns <code>-1</code> and sets <code>errno</code> (for example, <code>ENOENT</code> if there is no such file).

The process is the same: it keeps its PID, its parent, its open file descriptors and its current working directory. Only its memory, and the program in it, are replaced.

''glibc'' provides several functions on top of [https://man7.org/linux/man-pages/man2/execve.2.html <code>execve(2)</code>], which differ in how they take the arguments and how they find the program:

{| class="wikitable"
! Function !! Arguments !! The program is !! Environment
|-
| <code>execl(path, arg0, arg1, ..., nullptr)</code> || A list || <code>path</code> || Inherited
|-
| <code>execlp(file, arg0, arg1, ..., nullptr)</code> || A list || Searched for in <code>PATH</code> || Inherited
|-
| <code>execv(path, argv)</code> || An array || <code>path</code> || Inherited
|-
| <code>execvp(file, argv)</code> || An array || Searched for in <code>PATH</code> || Inherited
|-
| <code>execve(path, argv, envp)</code> || An array || <code>path</code> || <code>envp</code>
|}

A common pattern when launching new programs is calling <code>exec</code> in the child, right after [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>]. The following program runs <code>ls -l /</code> and waits for it:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(void)
{
pid_t pid = fork();
if (pid == -1) {
print_error("fork");
return EXIT_FAILURE;
}

if (pid == 0) {
char *argv[] = {"ls", "-l", "/", nullptr};
execvp(argv[0], argv);
// execvp() only returns if it failed.
print_error(argv[0]);
_exit(127);
}

int status;
waitpid(pid, &status, 0);
char msg[256];
snprintf(msg, sizeof msg, "ls exited with status %d\n", WEXITSTATUS(status));
write(STDOUT_FILENO, msg, strlen(msg));
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
total 64
lrwxrwxrwx 1 root root 7 Apr 22 2024 bin -> usr/bin
drwxr-xr-x 4 root root 4096 Sep 3 15:07 boot
...
drwxr-xr-x 12 root root 4096 Sep 3 21:06 var
ls exited with status 0
</syntaxhighlight>

[[File:OS_Lab_4_-_fork_exec_wait.png|center|thumb|700px|How a shell runs a command: it forks a copy of itself, the copy prepares itself and calls <code>exec</code> to become the command, and the shell waits for it to end.]]

== Signals ==

A '''signal''' is a small number that the kernel sends to a process, to tell it that something happened, right away, whatever the process is doing. Signals come from the kernel itself (an invalid memory access, a child that ended), from the terminal (Ctrl+C), or from other processes. Each signal has a name, a number and a '''default action''', which is what happens to a process that does nothing about it:

{| class="wikitable"
! Signal !! Number !! Default action !! Sent when
|-
| <code>SIGINT</code> || 2 || End the process || Ctrl+C is pressed in the terminal
|-
| <code>SIGKILL</code> || 9 || End the process. '''Cannot be caught or ignored''' || <code>kill -KILL</code>, <code>kill -9</code>
|-
| <code>SIGSEGV</code> || 11 || End the process || An invalid memory access
|-
| <code>SIGPIPE</code> || 13 || End the process || Writing to a pipe that nobody reads
|-
| <code>SIGTERM</code> || 15 || End the process || <code>kill</code>: a polite request to end
|-
| <code>SIGCHLD</code> || 17 || Ignore || A child ended or stopped
|-
| <code>SIGCONT</code> || 18 || Continue a stopped process || <code>kill -CONT</code>
|-
| <code>SIGSTOP</code> || 19 || Stop (pause) the process. '''Cannot be caught or ignored''' || <code>kill -STOP</code>
|-
| <code>SIGTSTP</code> || 20 || Stop the process || Ctrl+Z is pressed in the terminal
|}

<code>kill -l</code> lists all of them.

=== Sending signals: kill(2) ===

<syntaxhighlight lang="c">
// In: <signal.h>
int kill(pid_t pid, int sig);
</syntaxhighlight>

Despite its name, [https://man7.org/linux/man-pages/man2/kill.2.html <code>kill(2)</code>] sends any signal, not only those which end the process. A process may only send signals to processes of the same user, unless it runs as the superuser (<code>root</code>).

The following program starts a child which waits forever, and ends it with <code>SIGTERM</code>:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(void)
{
pid_t pid = fork();
if (pid == -1) {
print_error("fork");
return EXIT_FAILURE;
}
if (pid == 0) {
pause(); // Wait forever, or until a signal ends the process.
_exit(0);
}

sleep(1);
if (kill(pid, SIGTERM) == -1) {
print_error("kill");
return EXIT_FAILURE;
}

int status;
waitpid(pid, &status, 0);
if (WIFSIGNALED(status)) {
char msg[256];
snprintf(msg, sizeof msg, "child %d: %s\n", pid, strsignal(WTERMSIG(status)));
write(STDOUT_FILENO, msg, strlen(msg));
}
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
child 2911: Terminated
</syntaxhighlight>

[https://man7.org/linux/man-pages/man3/strsignal.3.html <code>strsignal(3)</code>] (from <code><string.h></code>) returns the description of a signal, the way [https://man7.org/linux/man-pages/man3/strerror.3.html <code>strerror(3)</code>] does for <code>errno</code>.

<div class="regula">'''Note:''' Ctrl+C sends <code>SIGINT</code> to all the processes running in the foreground of the terminal: a program, and the children it creates, all receive it.</div>

=== Handling signals: sigaction(2) ===

A process can choose what happens when it receives a signal, with:

<syntaxhighlight lang="c">
// In: <signal.h> (simplified)
struct sigaction {
void (*sa_handler)(int); // A function, SIG_DFL or SIG_IGN
sigset_t sa_mask; // Signals to block while the handler runs
int sa_flags; // SA_RESTART, ...
};

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
</syntaxhighlight>

{| class="wikitable"
! <code>sa_handler</code> !! When the signal arrives
|-
| A function <code>void handler(int sig)</code> || The kernel interrupts the program and calls the function, the '''signal handler''', with the number of the signal. When the handler returns, the program continues where it was
|-
| <code>SIG_IGN</code> || The signal is ignored
|-
| <code>SIG_DFL</code> || The default action (see the table above)
|}

[[File:OS_Lab_4_-_signal_handler.png|center|thumb|700px|A signal handler is the reverse of a system call: the kernel calls into the program. After the handler, [https://man7.org/linux/man-pages/man2/sigreturn.2.html <code>sigreturn(2)</code>] takes the program back to where it was interrupted.]]

The following program counts Ctrl+C presses, and ends after the third one:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static volatile sig_atomic_t count = 0;

static void on_sigint(int sig)
{
(void) sig;
count++;
}

int main(void)
{
struct sigaction sa = {.sa_handler = on_sigint};
sigemptyset(&sa.sa_mask);
if (sigaction(SIGINT, &sa, nullptr) == -1) {
char msg[256];
snprintf(msg, sizeof msg, "sigaction: %s\n", strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
return EXIT_FAILURE;
}

while (count < 3) {
pause(); // Sleep until a signal arrives.
const char msg[] = " Caught SIGINT\n";
write(STDOUT_FILENO, msg, strlen(msg));
}
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
^C Caught SIGINT
^C Caught SIGINT
^C Caught SIGINT
</syntaxhighlight>

A signal handler can run between any two instructions of the program, so it must be careful:

* It should only change global variables of type <code>volatile sig_atomic_t</code>, which the program reads after it returns, like <code>count</code> above.
* It should only call '''async-signal-safe''' functions, such as [https://man7.org/linux/man-pages/man2/write.2.html <code>write(2)</code>], [https://man7.org/linux/man-pages/man2/kill.2.html <code>kill(2)</code>] and [https://man7.org/linux/man-pages/man2/_exit.2.html <code>_exit(2)</code>]. [https://man7.org/linux/man-pages/man3/printf.3.html <code>printf(3)</code>] and [https://man7.org/linux/man-pages/man3/malloc.3.html <code>malloc(3)</code>] are '''not''' safe: the handler may have interrupted the program in the middle of one of them.

<div class="regula">'''Note:''' If a signal arrives while the process is blocked in a system call, such as [https://man7.org/linux/man-pages/man2/read.2.html <code>read(2)</code>] or [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>], the system call is interrupted: after the handler returns, it fails with <code>errno</code> set to <code>EINTR</code>. With <code>SA_RESTART</code> in <code>sa_flags</code>, most system calls are restarted instead, as if nothing happened.</div>

=== Blocking signals: sigprocmask(2) ===

A process can also '''block''' signals for a while, for example during a part of the program that should not be interrupted. A blocked signal is not lost: it stays '''pending''', and is delivered as soon as it is unblocked.

<syntaxhighlight lang="c">
// In: <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
</syntaxhighlight>

<syntaxhighlight lang="c">
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigprocmask(SIG_BLOCK, &set, nullptr); // Ctrl+C waits from here...
// ...
sigprocmask(SIG_UNBLOCK, &set, nullptr); // ...until here
</syntaxhighlight>

=== Signals, fork(2) and exec ===

{| class="wikitable"
! !! After [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], in the child !! After <code>exec</code>
|-
| Signals with a handler || Same handler || Back to the default action: the handler was part of the old program
|-
| Ignored signals (<code>SIG_IGN</code>) || Still ignored || Still ignored
|-
| Blocked signals || Still blocked || Still blocked
|}

== Reading lines: readline ==

The project template already uses the GNU ''readline'' library, which reads a line from the terminal and lets the user edit it and recall earlier lines with the arrow keys:

<syntaxhighlight lang="c">
// In: <readline/readline.h> and <readline/history.h>
char *readline(const char *prompt);
void add_history(const char *line);
</syntaxhighlight>

[https://man7.org/linux/man-pages/man3/readline.3.html <code>readline(3)</code>] prints the prompt and returns the line, without the newline, in memory allocated with [https://man7.org/linux/man-pages/man3/malloc.3.html <code>malloc(3)</code>], which the program must [https://man7.org/linux/man-pages/man3/free.3.html <code>free(3)</code>]. At the end of the input (Ctrl+D on an empty line), it returns <code>nullptr</code>. <code>add_history()</code> saves a line for the arrow keys.

By default, [https://man7.org/linux/man-pages/man3/readline.3.html <code>readline(3)</code>] installs signal handlers of its own while it waits for a line, to put the terminal back in order before the program is interrupted. A program which handles signals itself turns this off, before anything else, with:

<syntaxhighlight lang="c">
rl_catch_signals = 0;
</syntaxhighlight>

== Exercises ==

Write the program in a new copy of the project template. As a reminder from [[OS_Lab_1_-_Linux_setup._Bash_primer._C_primer#getting-the-template|the first lab]]:

<syntaxhighlight lang="bash">
mkdir -p ~/oslab && cd ~/oslab
curl -OL https://wiki.dcae.pub.ro/images/9/93/Os_lab_skeleton.zip
unzip -d lab04 Os_lab_skeleton.zip
</syntaxhighlight>

For this lab:

* Use the ''glibc'' wrappers for the system calls ([https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], [https://man7.org/linux/man-pages/man3/execvp.3.html <code>execvp(3)</code>], [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>], [https://man7.org/linux/man-pages/man2/kill.2.html <code>kill(2)</code>], ...).
* As in the last lab, do not use the standard I/O library for output: build the text with [https://man7.org/linux/man-pages/man3/snprintf.3.html <code>snprintf(3)</code>] and [https://man7.org/linux/man-pages/man2/write.2.html <code>write(2)</code>] it. Use [https://man7.org/linux/man-pages/man3/readline.3.html <code>readline(3)</code>] for input.

=== A simple shell ===

Write a shell: a program which reads commands with [https://man7.org/linux/man-pages/man3/readline.3.html <code>readline(3)</code>], runs them, and waits for them to end, until the user types <code>exit</code> or presses Ctrl+D.

<syntaxhighlight lang="bash">
$ ./build/debug/app
$ echo hello world
hello world
$ ls /nonexistent
ls: cannot access '/nonexistent': No such file or directory
[exit status 2]
$ nosuchcmd
nosuchcmd: command not found
[exit status 127]
$ cd /usr
$ pwd
/usr
$ exit
</syntaxhighlight>

# Read a line, and split it into words, at spaces and tabs, into an array of strings ending with <code>nullptr</code>. [https://man7.org/linux/man-pages/man3/strtok_r.3.html <code>strtok_r(3)</code>] can be used.
# Run the command: [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], call [https://man7.org/linux/man-pages/man3/execvp.3.html <code>execvp(3)</code>] in the child, and [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>] for it in the parent. If [https://man7.org/linux/man-pages/man3/execvp.3.html <code>execvp(3)</code>] fails, print <code>NAME: command not found</code> on standard error, and end the child with status 127.
# After the command ends, print its exit status on standard error if it is not 0, as <code>[exit status N]</code>, or the signal that killed it, as <code>[killed by signal N: NAME]</code>.
# Add two '''built-in''' commands, which the shell runs itself, without [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>]: <code>exit</code>, and <code>cd DIR</code>, which changes the current working directory with [https://man7.org/linux/man-pages/man2/chdir.2.html <code>chdir(2)</code>], or to <code>$HOME</code> (<code>getenv("HOME")</code>) if there is no <code>DIR</code>.

'''Bonus:''' Set <code>rl_catch_signals = 0</code> as the first thing in <code>main()</code>, and install a handler for <code>SIGINT</code> which passes the signal on to the running command, with [https://man7.org/linux/man-pages/man2/kill.2.html <code>kill(2)</code>].

<syntaxhighlight lang="bash">
$ sleep 10
^C[killed by signal 2: Interrupt]
$ echo still here
still here
</syntaxhighlight>

* Keep the PID of the running command in a <code>volatile sig_atomic_t</code> global variable, and set it back to 0 when the command ends. At the prompt, there is no command to pass the signal to.
* Use <code>SA_RESTART</code>, or check for <code>EINTR</code> around [https://man7.org/linux/man-pages/man2/waitpid.2.html <code>waitpid(2)</code>].
* The handler is installed before [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>]. What happens to it in the child, after <code>exec</code>? Why would <code>SIG_IGN</code> not work instead of a handler?

'''Extra:''' Support output redirection: <code>ls -l / > listing.txt</code>. In the child, before [https://man7.org/linux/man-pages/man3/execvp.3.html <code>execvp(3)</code>], open the file, and make the standard output point to it with [https://man7.org/linux/man-pages/man2/dup2.2.html <code>dup2(2)</code>]: <code>dup2(fd, STDOUT_FILENO)</code> makes file descriptor 1 point to the same open file as <code>fd</code>, which can then be closed. Remove <code>></code> and the file name from the arguments.

OS Lab 4 - Processes. Signals - Revizia istoricului

Vserbu: Pagină nouă: In the last lab, we used system calls to work with files. So far, each of our programs has been a single process. In this lab, we will create n...