Visit here for our full LPI 010-160 exam dumps and practice test questions.
Question 196:
What is the purpose of the uname command?
A) To create new user accounts
B) To display system information
C) To unmount filesystems
D) To list usernames
Answer: B
Explanation:
The uname command displays system information including the operating system name, kernel version, hardware architecture, and hostname. This command provides essential information for troubleshooting, compatibility checking, system documentation, and understanding the environment where scripts or applications will run. System administrators and users frequently use uname to quickly identify system characteristics without navigating through multiple configuration files or system tools.
Default uname output shows only the operating system name, typically “Linux” on Linux systems. The -a option displays all available information including kernel name, hostname, kernel release, kernel version, machine hardware architecture, processor type, hardware platform, and operating system. For example, uname -a might output “Linux server1 5.15.0-56-generic #62-Ubuntu SMP x86_64 GNU/Linux” providing comprehensive system identification in one line.
Individual information elements can be displayed with specific options: -s shows kernel name (same as default), -n displays the hostname, -r shows kernel release version, -v shows kernel version with build information, -m displays machine hardware architecture like x86_64 or aarch64, -p shows processor type, -i shows hardware platform, and -o displays operating system name. Combining options selects multiple elements, such as uname -sr showing kernel name and release.
Common uname usage includes checking kernel versions before installing software or drivers, verifying system architecture when downloading binaries, identifying systems in scripts for platform-specific logic, documenting system configurations, and troubleshooting compatibility issues. Scripts often use uname output to determine appropriate actions for different systems, such as if [ “$(uname)” = “Linux” ]; then … fi for Linux-specific code.
The uname command information comes from kernel runtime data and compiled constants, making it authoritative for kernel and architecture identification. The /proc/version file contains similar information in text format. The hostnamectl command in systemd systems provides more detailed system information including virtualization detection. Uname does not create users (useradd), unmount filesystems (umount), or list usernames (users, who). It specifically displays system identification information.
Question 197:
Which command is used to display disk usage for directories?
A) df
B) du
C) ls -s
D) size
Answer: B
Explanation:
The du command displays disk usage for directories by calculating and reporting the space consumed by files and subdirectories. The name du stands for “disk usage,” and it recursively examines directory trees to provide accurate space consumption information. Unlike df which shows filesystem-level capacity, du analyzes actual file sizes at the directory level, making it essential for identifying which directories consume the most space, finding large files, and managing disk capacity.
Default du output shows disk usage in 1K blocks for each subdirectory, with a summary total at the end. The -h option displays sizes in human-readable format with units like K, M, G making output easier to interpret. For example, du -h /var might show “150M /var/log”, “2.3G /var/lib”, “2.5G /var”. The -s option provides summary mode showing only the total for specified directories without subdirectory details, useful for quick directory size checks.
Common du options include -a displaying sizes for individual files in addition to directories, -c producing a grand total across all specified paths, –max-depth=N limiting recursion depth to N levels preventing excessive detail, –exclude=PATTERN skipping files or directories matching patterns, and –time showing modification times alongside sizes. The du command can be combined with sort for ranking by size, such as du -sh * | sort -hr listing directories by size in descending order.
Typical du usage patterns include finding large directories consuming disk space with du -sh /home/* | sort -hr, analyzing specific directory trees like du -h –max-depth=2 /var identifying major space consumers, finding the largest files with du -ah /path | sort -hr | head -20, and monitoring directory growth over time. Performance considerations include du being I/O intensive on large directory trees and potentially taking significant time on network filesystems.
The df command shows filesystem-level free space, not directory-level usage. The ls -s command shows individual file sizes but not directory totals. There is no size command in standard Linux. The du command specifically calculates and displays disk usage for directories and files, making it the essential tool for disk space analysis at the file and directory level.
Question 198:
What does the | symbol represent when used between commands?
A) Logical OR operator
B) Pipe connecting stdout to stdin
C) Background execution
D) Command separator
Answer: B
Explanation:
The pipe symbol (|) connects stdout (standard output) of one command to stdin (standard input) of another command, enabling command chaining where output from one program becomes input for the next. Pipes are fundamental to Unix philosophy, which emphasizes combining small, specialized tools to accomplish complex tasks. This mechanism allows powerful data processing workflows without creating intermediate files, providing efficient streaming processing of data through multiple transformation stages.
Pipe operation involves the shell creating a unidirectional data channel (pipe), launching both commands concurrently, connecting the first command’s output to the pipe’s write end, and connecting the second command’s input to the pipe’s read end. Data flows from the producer through the pipe to the consumer as it is generated, enabling real-time streaming without waiting for the first command to complete. This concurrent execution and streaming capability makes pipes memory-efficient even for large data volumes.
Common pipe patterns include filtering with grep as in ps aux | grep apache showing only Apache processes, pagination with less like dmesg | less making kernel messages browsable, sorting and counting with sort and uniq such as history | sort | uniq -c finding command frequency, transformation with awk or sed for text processing, and multi-stage pipelines combining several operations like cat access.log | grep error | awk ‘{print $7}’ | sort | uniq -c | sort -nr analyzing error URLs by frequency.
Multiple pipes can be chained creating complex processing pipelines: command1 | command2 | command3 | command4. Each command processes input from the previous stage and produces output for the next. Pipeline failure behavior varies: by default, only the last command’s exit status matters, but set -o pipefail in bash makes pipelines fail if any stage fails. Error streams (stderr) do not pass through pipes by default, requiring 2>&1 to merge stderr with stdout for pipe inclusion.
The || symbol (double pipe) represents logical OR in command lists, not the data pipe. The & symbol backgrounds commands. The semicolon separates sequential commands. The single | specifically creates data pipes connecting command output to input, enabling the powerful command composition that characterizes effective Unix-style command-line usage.
Question 199:
Which command is used to change a user’s password?
A) usermod
B) passwd
C) chpass
D) pwchange
Answer: B
Explanation:
The passwd command changes user passwords, providing the standard interface for password management in Linux systems. Regular users can change their own passwords, while root can change any user’s password. Passwd enforces password policies including complexity requirements, minimum length, history checking, and aging rules as configured in system security policies. Proper password management through passwd is fundamental to system security and user account administration.
Basic passwd usage without arguments changes the current user’s password. The command prompts for the current password for verification, then requests the new password twice for confirmation. The new password must meet configured complexity requirements including minimum length, character diversity, and non-dictionary word requirements. For example, a user types passwd, enters their current password, then enters and confirms the new password.
Root users can change any user’s password with passwd username syntax, such as passwd john changing john’s password. Root is not prompted for the current password, enabling administrative password resets for locked-out users. The -l option locks accounts by prefixing the password hash with an exclamation mark, preventing password authentication while keeping the account active. The -u option unlocks accounts. The -d option deletes passwords, creating passwordless accounts (generally not recommended).
Password aging controls include -n setting minimum days between password changes, -x setting maximum days a password remains valid, -w setting warning days before expiration, and -i setting inactivity days before account disablement. These options implement password expiration policies. The -S option displays password status information including last change date, expiration settings, and account lock status. The chage command provides more detailed password aging management.
Password information is stored in /etc/shadow (password hashes and aging) and /etc/passwd (account information). The passwd command updates these files atomically with proper locking to prevent corruption. There is no usermod for password changes (usermod modifies other account attributes), no chpass in standard Linux, and no pwchange command. The passwd command specifically manages user password changes and aging policies.
Question 200:
What is the purpose of the echo command?
A) To test network connectivity
B) To display text or variables
C) To create empty files
D) To repeat previous commands
Answer: B
Explanation:
The echo command displays text or variables to standard output, printing specified arguments separated by spaces followed by a newline. Echo is one of the simplest yet most frequently used commands in Linux, serving roles in scripts for user messages, debugging by displaying variable values, generating output for redirection to files, and creating formatted text. Its simplicity makes it ideal for learning command-line basics while its utility ensures continued use in advanced scenarios.
Basic echo usage involves specifying text to display, such as echo “Hello World” outputting “Hello World” to the terminal. Multiple arguments are separated by spaces in output: echo one two three displays “one two three”. Variable expansion occurs within arguments, so echo HOME displays the home directory path, and echo “Current user: $USER” might output “Current user: john”. Single quotes prevent variable expansion, making echo ‘ HOME’ literally output “$HOME” rather than the directory path.
Echo options modify behavior: -n suppresses the trailing newline making subsequent prompts appear on the same line, -e enables interpretation of backslash escape sequences like \n for newline, \t for tab, and \c for suppressing final newline. For example, echo -e “Line 1\nLine 2” produces two lines. The -E option disables escape sequence interpretation (default behavior in many shells). Some shells provide echo as a builtin with slightly different behavior than external /bin/echo.
Common echo usage includes script messages informing users of progress like echo “Processing files…”, debugging by displaying variable values such as echo “DEBUG: value=$variable”, generating content for redirection as in echo “log entry” >> logfile.txt, creating simple text files with echo “content” > file.txt, and formatting output with escape sequences. Echo combined with command substitution displays command output, such as echo “Today is $(date)”.
Echo does not test network connectivity (ping, nc), create empty files (touch), or repeat commands (history, !!). While echo can redirect to create files, its primary purpose is displaying text and variables. Understanding echo is fundamental to shell usage and scripting, as it provides the basic mechanism for producing output and communicating information.
Question 201:
Which command shows the path to an executable?
A) where
B) which
C) find
D) search
Answer: B
Explanation:
The which command shows the path to an executable by searching directories in the PATH environment variable for the specified command and displaying the full path to the first matching executable. This command helps users understand which version of a program will execute, verify command availability, troubleshoot PATH issues, and document software locations. Which is essential for environments with multiple versions of software or when diagnosing command resolution problems.
When users type a command name without a path, the shell searches directories listed in PATH in order, executing the first matching executable found. Which performs this same search, displaying the result without executing the command. For example, which python might return /usr/bin/python indicating that typing “python” executes /usr/bin/python. The which -a option shows all matching executables in PATH rather than just the first, useful for identifying multiple installations.
Understanding PATH and which relationship is crucial for command resolution. The PATH variable contains colon-separated directory paths like /usr/local/bin:/usr/bin:/bin searched in order. First match wins, so executables earlier in PATH shadow later ones with the same name. Users modify PATH to prioritize different directories, enabling custom program versions or local installations to override system defaults.
Alternative tools include type (bash builtin) providing more information about commands including aliases and functions, whereis locating binaries, source files, and man pages across standard locations, and command -v for portable command location in scripts. Each tool serves slightly different purposes, with which specifically focusing on PATH-based executable location.
There is no where command in standard Linux. The find command searches filesystems broadly but is not optimized for PATH searching. There is no search command. The which command specifically locates executables in PATH, making it the correct answer for finding executable paths and understanding command resolution.
Question 202:
What is the purpose of the sleep command?
A) To hibernate the system
B) To pause execution for a specified time
C) To put processes in stopped state
D) To schedule tasks
Answer: B
Explanation:
The sleep command pauses execution for a specified time period, suspending the current process for a defined number of seconds, minutes, hours, or days before continuing. Sleep is primarily used in shell scripts for timing control, creating delays between operations, waiting for services to start, implementing retry logic with delays, and throttling operations to prevent resource overload. Its simple function of controlled waiting makes it essential for script timing and coordination.
Basic sleep syntax is sleep NUMBER specifying seconds to sleep, such as sleep 5 pausing for 5 seconds. Suffix letters specify time units: s for seconds (default), m for minutes, h for hours, and d for days. For example, sleep 2m pauses for 2 minutes, sleep 1h for 1 hour. Multiple values can be combined: sleep 1h 30m 45s totaling 1 hour, 30 minutes, and 45 seconds. Fractional values are supported like sleep 0.5 for half-second delays.
Common sleep usage in scripts includes waiting for services to initialize after starting like systemctl start service && sleep 10 && check_service ensuring adequate startup time, implementing retry loops with for i in {1..5}; do command && break || sleep 30; done retrying with 30-second delays, creating periodic tasks with while true; do command; sleep 3600; done running hourly, and throttling operations to prevent overwhelming systems like for file in *; do process_file; sleep 2; done adding 2-second delays between processing.
Sleep accuracy depends on system load and scheduler behavior. Heavy load may cause actual sleep time to exceed requested time due to scheduling delays. For high-precision timing, more sophisticated tools may be required. Sleep is interruptible with signals: Ctrl+C sends SIGINT terminating sleep, and kill commands can terminate sleeping processes.
Sleep does not hibernate systems (systemctl hibernate), put processes in stopped state (kill -STOP), or schedule tasks (cron, at). It specifically implements timed delays in script execution, pausing for specified durations before allowing execution to continue. Understanding sleep is fundamental for creating well-timed shell scripts.
Question 203:
Which command displays real-time system processes?
A) ps
B) top
C) pstree
D) jobs
Answer: B
Explanation:
The top command displays real-time system processes with automatic updates, providing dynamic monitoring of system performance, resource usage, and process activity. Unlike ps which shows static snapshots, top continuously refreshes, showing current CPU usage, memory consumption, process states, and system load. Top is essential for system monitoring, performance troubleshooting, identifying resource-intensive processes, and understanding real-time system behavior.
Top’s display consists of a summary header showing system uptime, user count, load averages, CPU usage breakdown, memory and swap usage, and a process list table showing PID, user, priority, CPU percentage, memory percentage, time, and command for each process. The display updates at regular intervals (default 3 seconds, configurable), with high-CPU processes typically appearing first due to default sorting by CPU usage.
Interactive commands within top enable real-time control: k kills processes by PID, r changes process priority (renice), space immediately updates display, M sorts by memory usage, P sorts by CPU usage, T sorts by running time, u filters by username, and q quits. The f key opens field selection for customizing displayed columns, and W saves the current configuration for future sessions. These interactive capabilities make top powerful for both monitoring and intervention.
Alternative process monitors include htop providing enhanced visual interface with color coding, easier navigation, and mouse support, atop recording historical data for forensic analysis, and glances offering more comprehensive system monitoring including disk and network I/O. Each tool has strengths for different monitoring needs, with top remaining ubiquitous due to universal availability on Linux systems.
The ps command shows process snapshots, not real-time updates. The pstree command shows process hierarchy trees, not dynamic monitoring. The jobs command lists background jobs in the current shell, not system-wide processes. Top specifically provides real-time, continuously updated process monitoring making it the correct answer for dynamic system process observation.
Question 204:
What is the purpose of the chmod +x command?
A) To compress a file
B) To make a file executable
C) To create a symlink
D) To change file ownership
Answer: B
Explanation:
The chmod +x command makes a file executable by adding execute permission for user, group, and others. This is essential for shell scripts, compiled programs, and other executable files that need permission to run. Without execute permission, attempting to run a file produces “Permission denied” errors even if the file contains valid executable code. Adding execute permission enables the file to be run as a command or program.
The +x syntax uses symbolic notation for permission modification where + adds permissions, x represents execute permission, and absence of user specifiers (u, g, o) means all user classes receive the permission. This makes chmod +x filename equivalent to chmod ugo+x filename or chmod a+x filename. The command adds execute permission while preserving existing read and write permissions, making it safe for enabling execution without disturbing other permission bits.
Script creation workflow typically involves creating the file with a text editor, adding the shebang line (#!/bin/bash or similar) indicating the interpreter, saving the file, and executing chmod +x scriptname to make it executable. After these steps, the script runs as ./scriptname. The execute permission combines with shebang interpretation, where the kernel reads the shebang to determine which interpreter executes the script.
Execute permission behaves differently for directories versus files. For files, execute permission enables running the file as a program. For directories, execute permission enables traversing the directory (cd into it) and accessing files within it, even without read permission. This distinction is important for proper filesystem security configuration.
Alternative permission modifications include chmod 755 file setting specific rwxr-xr-x permissions numerically, chmod u+x adding execute only for the owner, and chmod a-x removing execute from all users. Chmod does not compress files (gzip), create symlinks (ln -s), or change ownership (chown). The chmod +x specifically makes files executable, essential for script and program execution.
Question 205:
Which file contains the list of mounted filesystems?
A) /etc/fstab
B) /proc/mounts
C) /etc/mtab
D) Both B and C
Answer: D
Explanation:
Both /proc/mounts and /etc/mtab contain lists of currently mounted filesystems, though they serve slightly different purposes and have different maintenance mechanisms. These files provide essential information about active mount points, filesystem types, mount options, and device mappings. Understanding the relationship and differences between these files is important for system administration and filesystem troubleshooting.
The /proc/mounts file is part of the proc filesystem, a kernel interface exposing kernel data structures as files. It shows the authoritative current mount state directly from kernel information, updated in real-time as filesystems are mounted and unmounted. The /proc/mounts contents come directly from the kernel’s namespace subsystem, making it the most reliable source for current mount state. Reading /proc/mounts always reflects actual kernel state without possibility of user-space inconsistencies.
The /etc/mtab file traditionally served as a user-space maintained table of mounted filesystems, updated by mount and umount commands. However, in modern systems with systemd, /etc/mtab is often a symbolic link to /proc/mounts or /proc/self/mounts, unifying the mount table representation. When /etc/mtab is a separate file rather than a symlink, it may become inconsistent with actual mount state if mount operations fail to update it properly or if low-level kernel operations bypass user-space updates.
The mount command without arguments displays mounted filesystems by reading these files, typically /proc/mounts. The findmnt command provides enhanced mount point display with tree formatting and filtering capabilities, also reading from /proc/mounts. The /etc/fstab file differs fundamentally as it contains filesystem definitions for mounting at boot and mount command reference, not the current mount state.
Modern best practice recognizes /proc/mounts as authoritative for current state. System administrators should primarily reference /proc/mounts for accurate current information. The /etc/fstab file defines persistent mount configurations but does not show current state. Both /proc/mounts and /etc/mtab (when not symlinked) show currently mounted filesystems, making “Both B and C” the most accurate answer.
Question 206:
What does the sudo command do?
A) Switches to root permanently
B) Executes commands with elevated privileges
C) Creates new user accounts
D) Displays user information
Answer: B
Explanation:
The sudo command executes commands with elevated privileges, allowing authorized users to run specific commands as root or other users without logging in as those users or knowing their passwords. Sudo implements fine-grained access control through configuration files defining which users can run which commands with which privileges. This approach improves security through principle of least privilege, accountability via logging, and elimination of shared root password requirements.
Basic sudo usage involves prefixing commands with sudo, such as sudo apt update running apt update with root privileges. When first used in a session, sudo prompts for the user’s own password (not root’s password) to verify identity. After successful authentication, sudo caches credentials for a timeout period (default 15 minutes), allowing subsequent sudo commands without re-authentication. The timeout enhances usability while maintaining security.
The /etc/sudoers file configures sudo permissions, defining which users or groups can execute which commands as which users. The visudo command safely edits sudoers files with syntax checking preventing configuration errors. Common configurations include granting full root access with username ALL=(ALL:ALL) ALL, restricting to specific commands like username ALL=/usr/bin/systemctl, or allowing password-less execution with NOPASSWD: tag.
Sudo benefits include security through limited privilege elevation and individual authentication, accountability with detailed logging of all sudo commands in /var/log/auth.log or similar, convenience avoiding frequent su usage or root logins, and granularity permitting command-specific privileges. The sudo -i option starts a root shell similar to su -, while sudo -u username command runs commands as different non-root users.
Sudo differs from su which switches user accounts requiring the target user’s password. Sudo uses the invoking user’s password and provides temporary privilege elevation per command rather than persistent user switching. Sudo does not create user accounts (useradd) or display user information (id, whoami). It specifically executes commands with configurable elevated privileges, fundamental to secure system administration.
Question 207:
Which command is used to extract files from a tar archive?
A) tar -x
B) untar
C) extract
D) tar -c
Answer: A
Explanation:
The tar -x command extracts files from tar archives, restoring archived files and directories to the filesystem. Extraction is the inverse of archiving, unpacking bundled files while preserving attributes like permissions, ownership, and timestamps. The x option (extract) is fundamental to tar functionality, enabling retrieval of backed-up or distributed content. Combined with other options, tar -x provides flexible extraction capabilities for various archive formats.
Complete extraction syntax typically includes tar -xf archive.tar where -x specifies extract operation, -f specifies the archive filename, and the filename follows. The tar command automatically detects archive format and handles extraction appropriately. Adding -v (verbose) as in tar -xvf shows files as they are extracted, useful for monitoring progress and verifying contents. The -z, -j, or -J options handle compressed archives: tar -xzf archive.tar.gz for gzip, tar -xjf archive.tar.bz2 for bzip2, tar -xJf archive.tar.xz for xz compression.
Selective extraction extracts specific files or directories rather than entire archives. Syntax like tar -xf archive.tar path/to/file extracts only specified files. The -C option changes extraction destination: tar -xf archive.tar -C /tmp/extract extracts to /tmp/extract instead of the current directory. The –strip-components=N option removes N leading directory components during extraction, useful for avoiding unwanted directory nesting.
Safety considerations include inspecting archives before extraction with tar -tf archive.tar listing contents without extracting, using tar -xf on trusted archives only as extraction can overwrite existing files, and considering –no-overwrite-dir option preventing directory metadata overwriting. Archives from untrusted sources should be extracted to isolated directories preventing unintended filesystem modifications.
There is no untar command in standard Linux (though some systems create aliases). There is no extract command. The tar -c option creates archives, not extracts them. The tar -x specifically extracts files from archives, making it fundamental to archive usage for software distribution, backups, and data transfer.
Question 208:
What is the purpose of the env command?
A) To encrypt files
B) To display or modify environment variables
C) To enable services
D) To edit configuration files
Answer: B
Explanation:
The env command displays or modifies environment variables, providing control over the execution environment for commands. When run without arguments, env displays all currently set environment variables and their values, similar to printenv. With arguments, env sets or unsets variables for the duration of a single command execution, enabling temporary environment modification without affecting the current shell. This capability is essential for testing, running programs with specific configurations, and script flexibility.
Basic env usage for display simply executes env, outputting all environment variables in VAR=value format. This provides quick environment inspection useful for debugging or documentation. For environment modification, syntax like env VAR=value command runs the command with VAR set to the specified value. Multiple variables can be set: env VAR1=value1 VAR2=value2 command. The -u option unsets variables: env -u VAR command runs the command with VAR removed from environment.
Common env usage patterns include testing software with different configurations like env DEBUG=1 ./program enabling debug mode, isolating command environments with env -i command running with empty environment (all variables cleared), specifying interpreter paths in script shebangs such as #!/usr/bin/env python3 finding python3 in PATH for portability, and temporarily overriding system settings like env LANG=C grep searching with C locale.
The #!/usr/bin/env interpreter shebang pattern is particularly important for portability. Instead of hard-coding interpreter paths like #!/usr/bin/python3 which breaks if python3 is elsewhere, #!/usr/bin/env python3 uses env to locate python3 in PATH, working across systems with different installation locations. This pattern has become standard in portable scripts.
Env differs from export which modifies the current shell’s environment persistently for child processes. Env provides temporary single-command environment modification. It does not encrypt files (gpg), enable services (systemctl), or edit files (vi, nano). The env command specifically displays and temporarily modifies environment variables for command execution.
Question 209:
Which command is used to create an empty file?
A) mkfile
B) touch
C) create
D) newfile
Answer: B
Explanation:
The touch command creates empty files or updates timestamps of existing files. When used with a filename that does not exist, touch creates a new empty file with that name. When used with an existing file, touch updates the file’s access and modification timestamps to the current time without changing content. Touch is commonly used for creating placeholder files, triggering timestamp-dependent processes, and testing filesystem permissions.
Basic touch syntax is touch filename creating an empty file named filename if it does not exist, or updating timestamps if it does exist. Multiple files can be created simultaneously: touch file1 file2 file3 creates three empty files. The -c option prevents file creation, only updating timestamps for existing files useful when you specifically want to avoid creating files accidentally.
Touch options control timestamp modification: -a updates only access time, -m updates only modification time, and -t specifies exact timestamp in [[CC]YY]MMDDhhmm[.ss] format enabling backdating or setting specific times. The -r option copies timestamps from a reference file: touch -r template.txt newfile.txt giving newfile.txt the same timestamps as template.txt. The -d option sets times using flexible date strings like touch -d “2024-01-01” file.txt.
Common touch usage includes creating empty files for script placeholders, testing write permissions with touch testfile checking if files can be created, updating timestamps to trigger make or other timestamp-dependent tools, and creating lock files for inter-process coordination. Touch combined with other commands enables various workflows: touch file && echo content > file creates and populates a file atomically.
There are no mkfile, create, or newfile commands in standard Linux. While other methods can create empty files (like > filename or echo -n > filename), touch is the standard, purpose-built command for empty file creation and timestamp manipulation, making it the correct answer.
Question 210:
What is the purpose of the exit command in a script?
A) To terminate the system
B) To end script execution and return an exit status
C) To close all windows
D) To logout users
Answer: B
Explanation:
The exit command ends script execution and returns an exit status (exit code) to the calling process or shell. Exit codes communicate success or failure of script operations, with 0 conventionally indicating success and non-zero values indicating various error conditions. Proper exit code usage enables scripts to integrate with error handling, conditional execution, and automation pipelines. Understanding exit codes is fundamental to reliable script development and system automation.
Exit command syntax is exit [N] where N is the exit code (0-255). For example, exit 0 terminates the script with success status, while exit 1 indicates general error. If N is omitted, the exit code is that of the last executed command. Scripts should explicitly exit with appropriate codes reflecting execution outcomes. The special variable $? contains the exit code of the last executed command, enabling exit code checking: command; if [ $? -eq 0 ]; then echo success; fi.
Exit code conventions include 0 for success, 1 for general errors, 2 for misuse of shell commands, 126 for command cannot execute (permission problem), 127 for command not found, and 128+N for termination by signal N. Custom exit codes (1-125) can indicate specific application errors. Following conventions ensures script behavior aligns with system expectations and integrates properly with automation tools.
Scripts typically validate conditions and exit early on errors with patterns like [ ! -f “$file” ] && { echo “File not found”; exit 1; } terminating immediately when prerequisites fail rather than continuing execution that would likely fail. This fail-fast approach prevents cascading errors and provides clear error reporting. The set -e option makes scripts exit automatically on any command failure, though careful use is required.
Exit in interactive shells closes the shell session (logout). In scripts, exit terminates only the script, not the calling shell. Exit does not terminate systems (shutdown, poweroff), close windows, or logout users system-wide. The exit command specifically ends script execution with a status code, essential for error handling and script integration in automation pipelines.