Understanding Process Replacement

Process control within an operating system involves managing the lifecycle of processes, including termination, waiting, and replacement. While termination and waiting handle the end of a process's life, process replacement allows a running process to overlay its current memory space with a new program. This mechanism is fundamental to how shells execute commands.

The Exec Family of Functions

The primary interface for process replacement in Linux is the exec family of system calls. These functions allow a process to replace its current text, data, heap, and stack segments with a new program image.

Consider the following example demonstrating basic process replacement:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main(void) {
    pid_t current_id = getpid();
    printf("Process ID before replacement: %d\n", current_id);
    
    // Attempt to replace the current process with 'whoami'
    if (execl("/usr/bin/whoami", "whoami", (char *)NULL) == -1) {
        perror("Execution failed");
        return 1;
    }
    
    // This line is only reachable if execl fails
    printf("Process replacement unsuccessful\n");
    return 0;
}

In this scenario, if the execution is successful, the code following the execl call will never run. The process ID remains constant, but the instruction pointer is reset to the entry point of the new program.

Mechanism of Action

When an exec function is invoked, the operating system locates the executable file specified by the path. It then tears down the existing user-space memory mappings of the calling process and establishes new mappings for the target program. The Process Control Block (PCB) remains largely intact, preserving the PID, open file descriptors (unless marked close-on-exec), and signal dispositions, but the virtual address space is completely refreshed.

Key characteristics include:

• No New Process: Unlike fork, exec does not create a new process ID.
• Entry Point: The kernel reads the ELF header of the new binary to determine the starting address for execution.
• Error Handling: The function only returns to the caller if an error occurs (e.g., file not found, permission denied).

Variant Interfaces

The exec family provides several variants to handle different argument passsing methods and path resolutions:

• execl: Arguments are passed as a list (variadic).
• execv: Arguments are passed as an array (vector).
• execlp / execvp: Searches for the executable in the directories listed in the PATH environment variable.
• execve: The underlying system call that allows explicit specification of the environment array.

Implementing a Minimal Shell

Building a custom shell provides practical insight into process control. A shell essentially loops through reading user input, parsing commands, and executing them via process replacement.

Command Prompt and Input Handling

A functional shell must display a prompt indicating the current user, host, and working directory. This requires querying environment variables. Special care must be taken with the current working directory, as it changes dynamically.

Input is typically read using fgets to capture the entire line, including spaces between command arguments. The input buffer must be null-terminated properly before processing.

Parsing Command Arguments

Once input is captured, it must be tokenized. The standard C library function strtok is commonly used to split the command string by whitespace. This generates an array of strings compatible with the exec family's argument vector.

#include <string.h>
#include <stdio.h>

void parse_input(char *buffer, char **args, int max_args) {
    int i = 0;
    char *token = strtok(buffer, " \n");
    while (token != NULL && i < max_args - 1) {
        args[i++] = token;
        token = strtok(NULL, " \n");
    }
    args[i] = NULL; // Null-terminate the argument array
}

Execution Logic

The core loop distinguishes between built-in commands and external binaries. Built-in commands modify the shell's internal state and must run in the current process. External commands require a child process.

Built-in Commands

Common built-ins include:

• cd: Changes the shell's current directory using chdir. After changing, the prompt logic must refresh the stored path.
• export: Modifies the environment variable table using setenv, ensuring child processes inherit these values.
• echo: Prints arguments to stdout. If an argument starts with $, the shell should resolve it to the corresponding environment variable value.

External Commands

For standard utilities, the shell forks a child process. The child calls execvp to run the command, while the parent waits for the child to terminate using waitpid. This preserves the shell's continuity.

Special handling can be applied to specific commmands. For instance, invoking ls can automatically append the --color flag to enhance readability without user intervention.

Shell Implementation Structure

The following structure outlines the main execution loop:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

#define MAX_CMD_LEN 1024
#define MAX_ARGS 64

int execute_builtin(char **args);
void execute_external(char **args);

int main(void) {
    char input_buffer[MAX_CMD_LEN];
    char *args[MAX_ARGS];

    while (1) {
        // Display prompt logic here (USER, HOST, PWD)
        printf("myshell> ");
        fflush(stdout);

        if (fgets(input_buffer, MAX_CMD_LEN, stdin) == NULL) {
            break;
        }

        parse_input(input_buffer, args, MAX_ARGS);

        if (args[0] == NULL) {
            continue;
        }

        if (!execute_builtin(args)) {
            execute_external(args);
        }
    }
    return 0;
}

This architecture ensures that internal state changes persist in the shell process, while external tools run in isolated child processes, mimicking the behavior of standard Linux shells like Bash.