RHCSA Series (3): Managing Processes

Alphabetical List of the Abbreviations used in this article:

CPU = Central Processing Unit
GNU = GNU's Not Unix
I/O = Input/Output
NIC = Network Interface Card
NUMA = Non-Uniform Memory Access
PID = Process ID
RHCSA = Red Hat Certified System Administrator
SIGKILL = Signal Kill
SIGTERM = Signal Terminate
TCP = Transmission Control Protocol
UNIX = Unix

Introduction

A Red Hat Certified System Administrator (RHCSA) is a master of managing processes on UNIX-like operating systems, such as GNU/Linux. He or she knows many essential commands for managing processes. A good RHCSA also has a great handle on process management. Another essential skill for a highly capable RHCSA is job control: the ability to manage processes in the foreground and background.  

What we've reviewed above is not even close to being the complete process skill set of an RHCSA. He or she must also be able to monitor processes. This includes monitoring the resource usage of running processes. An RHCSA should also be able to set system resource limits for processes and check what resource limits are already in place.  

Job scheduling is another important skill set in the RHCSA's professional toolbox. A GNU/Linux system administrator requires a lot of automation, and scheduling jobs to complete tasks autonomously is extremely important.  

Finally, process accounting and system performance tuning are two extremely powerful assets in the RHCSA's professional knowledge base.  

In this article, we'll take a deep dive into the firm foundation of managing processes in GNU/Linux at the level of a highly skilled RHCSA.

How I Used Reference 1 in This Article
Reference 1 cited many features that make up GNU/Linux and other computer operating systems. The second of these features is "managing processes". This second feature will be the 100% focus of this article.

Credits
Besides Refence 1, Mistral and HuggingChat both gave me a great deal of research assistance in preparing this article.

Managing Processes in GNU/Linux: Understanding the Basic Commands

The RHCSA must be proficient in using fundamental commands to manage processes in GNU/Linux systems. Essential tools like `ps` allow administrators to view active processes, with options such as `ps aux` providing detailed snapshots of all running tasks. The `top` or `htop` command offers dynamic, real-time monitoring of process activity, including CPU and memory usage. For hierarchical visualization, `pstree` displays processes in a tree structure, clarifying parent-child relationships.  

Process management involves controlling execution states. Commands like `kill` and `killall` send signals (e.g., `SIGTERM` or `SIGKILL`) to terminate processes gracefully or forcefully. Job control commands—`bg` to resume background processes, `fg` to bring them to the foreground, and `jobs` to list active tasks—enable efficient multitasking. The `nice` and `renice` utilities adjust process priorities, ensuring critical tasks receive adequate resources while minimizing system overload.  

Monitoring resource usage is critical. Tools like `uptime`, `free`, and `iostat` provide insights into system load, memory availability, and disk I/O performance. The `time` command measures resource consumption of specific processes, while `ulimit` checks or sets limits on resources such as open files or memory size. Administrators must also configure permanent limits via `/etc/security/limits.conf` and tune kernel parameters dynamically using `sysctl`.  

Automation through job scheduling is another cornerstone. The `at` and `batch` commands execute tasks once, while `cron` and `crontab` handle recurring schedules. An RHCSA must edit crontab entries accurately, verify scheduled jobs with `systemctl status cron`, and troubleshoot failures. Process accounting tools like `psacct` (or `acct`) track command usage and resource consumption, with utilities like `lastcomm` and `sa` analyzing historical data.  

Performance tuning requires mastering tools like `vmstat`, `mpstat`, and `sar` to identify bottlenecks in CPU, memory, or disk activity. Commands like `iostat` and `sar` provide granular metrics for long-term analysis. By combining these tools with system logs and proactive resource limits, an RHCSA ensures stable, efficient operations. Mastery of these commands ensures the ability to maintain system reliability, optimize workflows, and resolve process-related issues swiftly.

The Art of Process Management in GNU/Linux

A Red Hat Certified System Administrator (RHCSA) must master the nuanced discipline of process management in GNU/Linux systems, blending technical proficiency with strategic oversight. At its core, this involves understanding process states: running, sleeping, stopped, or zombie; and identifying them using tools like `ps` and `top`. The RHCSA must interpret process hierarchies via `pstree` to discern parent-child relationships, ensuring clarity in complex environments. Equally critical is signal handling: knowing when to gracefully terminate processes with `SIGTERM` (via `kill` or `killall`) or forcefully with `SIGKILL`, while avoiding unintended disruptions to dependent processes.  

Resource allocation and prioritization form another pillar of expertise. The RHCSA must adeptly use `nice` and `renice` to adjust process priorities, balancing system load to prevent resource starvation. They should configure hard and soft limits using `ulimit` and `/etc/security/limits.conf`, ensuring applications adhere to predefined constraints on memory, open files, or CPU time. This proactive management prevents runaway processes from destabilizing the system while accommodating legitimate resource demands.  

Automation through job scheduling is indispensable. The RHCSA must harness `cron` for recurring tasks, editing crontabs with `crontab -e` and validating schedules with `systemctl status cron`. They should also employ `at` and `batch` for one-time or load-dependent executions, verifying job integrity through logs and system monitoring. Integrating these tools into workflows ensures routine maintenance, backups, and updates occur seamlessly, minimizing manual intervention.  

Process accounting and performance tuning elevate process management from reactive to predictive mastery. Tools like `psacct` (or `acct`) enable logging of command usage, resource consumption, and historical trends via `sa` and `lastcomm`. By analyzing this data, the RHCSA identifies inefficient processes or anomalies. Performance metrics gathered through `vmstat`, `iostat`, and `sar` reveal bottlenecks in CPU, memory, or disk I/O, guiding optimizations like adjusting kernel parameters via `sysctl` or reallocating resources.  

Finally, the RHCSA must excel at troubleshooting process-related issues. This includes diagnosing stalled or unresponsive processes using `strace` to trace system calls, analyzing logs in `/var/log/messages` or `journalctl`, and resolving resource contention. They should understand dependencies between processes, ensuring critical services remain unaffected during maintenance. Mastery of these skills ensures system stability, efficiency, and resilience, embodying the true artistry of process management in GNU/Linux environments.

Job Control on GNU/Linux Computer Systems

A Red Hat Certified System Administrator (RHCSA) must develop a deep understanding of job control on GNU/Linux systems to manage processes effectively. This begins with mastering commands like `bg`, `fg`, and `jobs` to transition processes between the foreground and background. The ability to suspend running processes with `Ctrl+Z` and resume them using `bg` or `fg` is essential for multitasking without disrupting workflows. Administrators must also interpret job numbers and process identifiers to manage tasks efficiently while avoiding conflicts or resource contention.  

Job control extends to process signaling and termination. The RHCSA must know how to send signals such as `SIGTERM` or `SIGKILL` using `kill` or `killall` to gracefully or forcefully stop unresponsive processes. They should also understand signal numbers and their effects, ensuring minimal disruption to system stability. Tools like `pstree` help visualize process hierarchies, clarifying dependencies between parent and child processes during termination or suspension.  

Integration with automation tools is another critical aspect. The RHCSA must configure scheduled tasks using `cron` and `crontab` for recurring operations, ensuring entries are correctly formatted and validated with commands like `systemctl status cron`. One-time jobs managed via `at` or `batch` require familiarity with time-based syntax and system load thresholds. Administrators should also verify job execution through logs and system monitoring to troubleshoot failures.  

Process accounting and resource monitoring further refine job control expertise. Tools like `psacct` (or `acct`) track command usage and resource consumption, enabling administrators to analyze historical data with `sa` or `lastcomm`. The RHCSA must set and enforce resource limits using `ulimit` and `/etc/security/limits.conf` to prevent processes from exceeding predefined constraints on memory, CPU time, or open files. This proactive approach ensures system reliability under varying workloads.  

Performance tuning and troubleshooting complete the skill set. Commands like `vmstat`, `iostat`, and `sar` identify bottlenecks in CPU, memory, or disk I/O, guiding adjustments to process priorities with `nice` and `renice`. The RHCSA should also use `strace` to trace system calls for debugging problematic processes and consult logs in `/var/log/messages` or `journalctl` for diagnosing issues. By combining these tools with process accounting data, administrators optimize workflows and resolve resource conflicts swiftly.  

Ultimately, the RHCSA’s proficiency in job control ensures seamless process management, balancing automation, resource efficiency, and system stability. Mastery of these skills allows administrators to maintain responsive, secure, and high-performing GNU/Linux environments while addressing challenges proactively.

Monitoring Processes in GNU/Linux

A Red Hat Certified System Administrator (RHCSA) must master process monitoring in GNU/Linux to ensure system stability, optimize resource usage, and troubleshoot performance issues. This begins with proficiency in core commands like `ps`, which provides snapshots of running processes. The RHCSA should use `ps aux` to view all processes, including their CPU and memory consumption, and `ps -ef` to display hierarchical relationships. The `top` or `htop` command offers real-time dynamic views of active processes, enabling administrators to prioritize tasks, identify resource hogs, or kill unresponsive processes. Tools like `pstree` visualize process hierarchies, clarifying parent-child dependencies critical for debugging or system analysis.  

Monitoring resource usage is essential. The `free` command reports available and used memory, including swap space, while `uptime` shows system load averages over 1, 5, and 15 minutes. For granular CPU and I/O metrics, `vmstat` and `iostat` from the `sysstat` package reveal bottlenecks in memory, CPU, or disk activity. The `sar` command, also part of `sysstat`, archives historical performance data, allowing administrators to analyze trends and correlate resource usage with specific events. The RHCSA must interpret metrics like `%iowait` (CPU idle time waiting for I/O) or `bmem` (buffer memory) to diagnose inefficiencies.  

System logging integrates deeply with process monitoring. The RHCSA should use `dmesg` to review kernel logs for hardware or driver-related issues and `journalctl` to query systemd’s structured logs for process-related errors. For example, if a service fails abruptly, cross-referencing `journalctl -u service_name` with `ps` or `top` output helps pinpoint root causes. The `lsof` command lists open files and network connections associated with processes, aiding in troubleshooting resource leaks or unauthorized access.  

Advanced diagnostics require tools like `strace` to trace system calls and signals for debugging problematic processes. The RHCSA might use `strace -p PID` to attach to a running process and identify where it is stalled, such as waiting for a locked file or misconfigured socket. Memory mapping with `pmap -x PID` reveals address spaces and shared libraries, helping resolve memory leaks or segmentation faults.  

Automation and proactive monitoring are critical. The RHCSA must configure `cron` jobs or systemd timers to run scripts that log resource metrics periodically, ensuring historical data is available for analysis. Tools like `sar` can be automated via `cron` to generate daily reports stored in `/var/log/sa/`. Threshold-based alerts using `cron` scripts or `systemd` path units can notify administrators of abnormal conditions, such as sustained high load averages or memory exhaustion.  

Troubleshooting process-related issues involves correlating data from multiple sources. For example, if a process consumes excessive CPU, the RHCSA should verify its priority with `nice`, check for resource limits via `ulimit`, and inspect logs for recurring errors. If disk I/O is saturated, `iostat -xmt 1` provides extended metrics to identify slow devices or queue depth issues.  

By mastering these tools and techniques, the RHCSA ensures GNU/Linux systems operate efficiently, proactively identifies performance bottlenecks, and maintains system reliability. This expertise enables administrators to balance responsiveness, security, and resource governance while meeting organizational demands for uptime and scalability.

GNU/Linux System Resource Limits

A Red Hat Certified System Administrator (RHCSA) must master the configuration and enforcement of system resource limits in GNU/Linux environments to ensure stability, security, and efficient resource allocation. This involves understanding both soft and hard limits, which define the default and maximum thresholds for resource usage by processes or users. Tools like `ulimit` allow administrators to set or display these limits within shell sessions, controlling aspects such as maximum memory size, open file descriptors, CPU time, or stack size. The RHCSA must know how to adjust these limits dynamically using commands like `ulimit -n` to modify open file limits or `ulimit -v` for virtual memory, ensuring critical applications operate within safe boundaries.  

Persistent resource limits require editing system-wide configuration files such as `/etc/security/limits.conf` and `/etc/security/limits.d/`. The RHCSA must define user-specific or group-specific limits here, specifying directives like `soft nofile` or `hard memlock` to enforce constraints across reboots. For example, limiting the number of concurrent processes for a user with `nproc` or restricting core dump sizes with `core` prevents resource exhaustion and potential denial-of-service scenarios. Proper syntax and placement of entries in these files are crucial to avoid misconfigurations that could destabilize the system.  

Kernel-level resource management extends this control. The RHCSA must use `sysctl` to adjust runtime parameters in `/proc/sys/`, such as network buffer sizes or file handle limits, by editing `/etc/sysctl.conf` or files in `/etc/sysctl.d/`. Commands like `sysctl -p` apply changes instantly, while parameters like `fs.file-max` govern system-wide file descriptor limits. Understanding how these settings interact with user-level limits ensures cohesive resource governance, preventing conflicts between application-specific needs and global system constraints.  

Monitoring and auditing resource usage are equally vital. The RHCSA should employ tools like `time` to measure resource consumption of specific commands, `lsof` to list open files by process, and `pmap` to analyze memory mappings. For long-term insights, `sar` from the `sysstat` package tracks historical usage patterns, while `vmstat` and `iostat` reveal bottlenecks in memory, CPU, or disk I/O. Process accounting tools like `psacct` (or `acct`) log resource-intensive tasks, allowing administrators to identify anomalies using `sa` or `lastcomm`.  

Integration with automation and security practices completes the skill set. The RHCSA must configure resource limits for cron jobs, ensuring scripts do not inadvertently consume excessive memory or CPU time. They should also leverage cgroups (control groups) for advanced resource partitioning, though this extends beyond RHCSA-level tasks. Additionally, the RHCSA must troubleshoot limit violations by reviewing logs in `/var/log/messages` or `journalctl`, addressing issues like "Too many open files" errors by adjusting `ulimit` or `limits.conf` entries.  

By mastering these techniques, the RHCSA ensures GNU/Linux systems operate reliably under varying workloads, prevents resource abuse, and maintains optimal performance. This expertise safeguards against both accidental overuse and malicious exploitation, aligning system behavior with organizational requirements.

Job Scheduling in GNU/Linux

A Red Hat Certified System Administrator (RHCSA) must master job scheduling in GNU/Linux to automate routine tasks, optimize system efficiency, and ensure timely execution of critical operations. The cornerstone of scheduling is the `cron` utility, which manages recurring tasks through crontab files. The RHCSA must edit user-specific crontabs with `crontab -e`, system-wide entries in `/etc/crontab`, or files in `/etc/cron.d/`, understanding the five-field syntax (minute, hour, day, month, weekday) to define schedules. For example, `0 2 * * * /script.sh` runs `script.sh` daily at 2:00 AM. They should also validate entries with `crontab -l` and verify execution through logs like `/var/log/cron` or `journalctl`.  

One-time scheduling relies on `at` and `batch`. The `at` command allows setting tasks to run at a specific time (e.g., `at now + 5 minutes`), while `batch` executes jobs when system load permits. The RHCSA must manage these jobs using `atq` to list pending tasks and `atrm` to remove them. They should also understand time specifications like `HH:MM`, relative times (`now + 10 minutes`), or natural language inputs (`midnight`).  

Systemd timers provide a modern alternative to `cron`, integrating with systemd services for precise control. The RHCSA must create unit files (e.g., `mytask.timer`) defining `OnCalendar` or `OnActiveSec` triggers and link them to corresponding service units (`mytask.service`). Commands like `systemctl enable mytask.timer` activate timers, while `systemctl status mytask.timer` confirms their status. This method offers improved logging, dependencies, and synchronization with boot cycles or system uptime.  

Managing execution environments is critical. The RHCSA must ensure scripts or commands run in the correct path, setting `PATH` variables explicitly in crontabs or systemd units. They should also handle permissions, verifying that scheduled jobs have access to required files and directories. For `cron`, `/etc/cron.allow` and `/etc/cron.deny` control user access, while systemd timers inherit user permissions from their service units.  

Troubleshooting scheduled tasks requires analyzing logs and testing configurations. The RHCSA should use `systemctl list-timers` to review active systemd timers or check `/var/spool/cron/` for user crontabs. For `cron`, examining `/var/log/cron` identifies syntax errors, missing environment variables, or permission issues. For `at`, logs in `/var/log/cron` or `journalctl` confirm job execution. Testing scripts outside of schedules ensures they behave as expected before automation.  

Resource considerations and dependencies round out the skill set. The RHCSA must assess system load before scheduling resource-intensive jobs, using `batch` or `nice` to avoid contention. They should also chain dependencies, ensuring one job triggers another via `&&` in shell commands or systemd `After=` directives. For systems that are not always running, configuring `anacron` ensures missed daily, weekly, or monthly jobs execute upon reboot.  

By mastering these tools and techniques, the RHCSA ensures seamless automation, reduces manual intervention, and maintains system reliability. This expertise enables proactive management of backups, updates, monitoring, and maintenance, aligning system behavior with organizational needs while minimizing disruptions.

Process Accounting in GNU/Linux

A Red Hat Certified System Administrator (RHCSA) must understand process accounting in GNU/Linux to track command execution, resource consumption, and user activity for auditing, troubleshooting, and performance analysis. Process accounting is typically managed using the `psacct` (on Red Hat-based systems) or `acct` (on Debian-based systems) utilities, which log detailed records of processes, including start and end times, executed commands, CPU usage, and memory consumption. The RHCSA must install and enable these tools, ensuring the associated service (`psacct` or `acct`) starts at boot via `systemctl enable psacct` or `systemctl enable acct` and activates logging with `accton /var/account/pacct` to begin capturing data.  

Key commands for analyzing accounting logs include `lastcomm` and `sa`. The `lastcomm` command displays historical process data, allowing administrators to filter by user, command, or terminal. For example, `lastcomm user username` lists all commands run by a specific user, while `lastcomm command` shows executions of a particular program. The `sa` command generates summary reports, aggregating data such as total CPU time per command, frequency of execution, and user-specific usage patterns. The RHCSA must interpret these reports to identify resource-intensive processes, detect anomalies, or verify compliance with system policies.  

Integration with auditing and security practices is critical. Process accounting logs complement tools like `auditd` or `journalctl`, providing granular insights into user behavior and system activity. The RHCSA should correlate accounting data with system logs to trace unauthorized access, troubleshoot failed commands, or validate that scheduled tasks executed as expected. For example, if a backup script fails silently, checking `lastcomm` for its execution history and `sa` for resource metrics can clarify whether it completed successfully or encountered resource limits.  

Resource monitoring and performance tuning benefit significantly from process accounting. By analyzing historical usage with `sa`, the RHCSA can identify trends such as recurring high-memory commands or inefficient scripts that degrade system performance. This data informs decisions to optimize workflows, adjust resource limits via `ulimit` or `/etc/security/limits.conf`, or prioritize critical processes using `nice` and `renice`. Additionally, accounting logs help justify hardware upgrades or resource reallocation by quantifying system demands over time.  

Automation of reporting ensures consistency and proactive management. The RHCSA should configure daily or weekly summaries using `cron` jobs to generate `sa` reports, compress old logs, or purge obsolete records to conserve disk space. Scripts that parse `lastcomm` output can alert administrators to suspicious activity, such as repeated failed command executions or unexpected processes running outside scheduled windows.  

Troubleshooting process accounting involves verifying service status, log integrity, and configuration. The RHCSA must ensure `accton` is active to write logs to `/var/account/pacct` and check file permissions to prevent unauthorized access. If logs appear incomplete, commands like `sa -u` validate data consistency, while `file /var/account/pacct` confirms the file type and structure. Issues like log rotation errors or disk quotas exceeding limits must be resolved promptly to maintain accurate records.  

By mastering process accounting, the RHCSA gains a powerful toolset for auditing system activity, optimizing performance, and ensuring accountability. This expertise enables administrators to maintain secure, efficient GNU/Linux environments while meeting organizational requirements for compliance and resource governance.

System Performance Tuning in GNU/Linux

A Red Hat Certified System Administrator (RHCSA) must master system performance tuning in GNU/Linux to ensure optimal resource utilization, responsiveness, and reliability. This involves identifying bottlenecks, adjusting kernel parameters, and optimizing hardware and software configurations. The RHCSA uses tools like `top`, `htop`, `vmstat`, `iostat`, and `sar` from the `sysstat` package to analyze CPU, memory, disk I/O, and network performance. Metrics such as load averages, memory usage (`free`), disk wait times (`%iowait`), and network latency guide tuning decisions. Regular monitoring of historical data with `sar` helps correlate performance trends with system changes or workload spikes.  

Kernel-level tuning is critical for performance optimization. The RHCSA adjusts runtime parameters using `sysctl` to modify settings in `/proc/sys/`, such as `vm.swappiness` to control swap usage, `net.ipv4.tcp_tw_reuse` to manage TCP connection recycling, or `fs.file-max` to increase file descriptor limits. Permanent configurations are stored in `/etc/sysctl.conf` or `/etc/sysctl.d/`, ensuring settings persist across reboots. Commands like `sysctl -p` apply changes instantly, while understanding dependencies between parameters prevents unintended side effects. For example, increasing `net.core.somaxconn` improves network throughput but must align with application requirements for connection queues.  

Resource allocation and limits play a key role. The RHCSA configures `ulimit` settings in shell sessions and defines persistent limits in `/etc/security/limits.conf` to restrict memory, CPU time, or open files for users or services. This prevents resource exhaustion from runaway processes or misconfigured applications. Tools like `pmap` and `ltrace` help debug memory leaks or inefficient library calls, while `numactl` optimizes memory access on NUMA architectures. For disk I/O, `ionice` sets process priorities to ensure critical tasks receive adequate throughput, and `hdparm` or `dd` test disk read speeds for hardware validation.  

Filesystem and disk optimization are essential. The RHCSA selects appropriate filesystems (e.g., XFS, ext4) based on workload requirements and tunes mount options in `/etc/fstab`, such as `noatime` to reduce metadata updates or `data=writeback` for faster journaling. Tools like `tune2fs` adjust filesystem parameters, while `xfs_growfs` or `resize2fs` expand logical volumes dynamically. Monitoring disk queues with `iostat -xmt 1` identifies slow devices, and `smartctl` checks drive health to preempt hardware failures. Swap space management involves balancing `swappiness` values and configuring multiple swap partitions for redundancy.  

Networking performance tuning ensures low latency and high throughput. The RHCSA adjusts TCP window sizes, congestion control algorithms (`/proc/sys/net/ipv4/tcp_congestion_control`), and buffer sizes (`net.core.rmem_max`, `net.core.wmem_max`) to optimize network transfers. Tools like `ethtool` configure NIC settings (e.g., disabling checksum offloading for troubleshooting) or `ss` to analyze socket statistics. Firewalld or iptables rules are optimized to minimize packet processing overhead, and `tc` manages traffic shaping for bandwidth-critical environments.  

Automation and proactive maintenance complete the skill set. The RHCSA schedules performance audits using `cron` or systemd timers to generate `sar` reports, rotate logs with `logrotate`, or trigger alerts when thresholds (e.g., disk usage, load averages) are exceeded. Scripts that parse `vmstat` or `iostat` output can automatically adjust parameters like `dirty_ratio` for memory-to-disk writes. Integration with tools like `tuned` allows dynamic profile-based tuning for specific workloads (e.g., "throughput-performance" or "power-saving").  

Troubleshooting is a core competency. The RHCSA uses `dmesg` to check kernel logs for hardware errors, `journalctl` to trace systemd-related issues, and `strace` to debug system calls for stalled processes. Commands like `mpstat` isolate CPU bottlenecks per core, while `slabtop` reveals memory consumption by kernel objects. For disk-related stalls, `blktrace` traces block device I/O patterns.  

By mastering these techniques, the RHCSA ensures GNU/Linux systems operate at peak efficiency, balancing responsiveness with resource constraints. This expertise enables proactive resolution of performance degradation, alignment of system behavior with workload demands, and adherence to organizational goals for scalability and reliability.

 Conclusions

This concludes Article 3 of my RHCSA series. We discussed many aspects of managing processes on GNU/Linux computer systems:

• The RHCSA must be proficient in using fundamental commands to manage processes in GNU/Linux systems. 
• A Red Hat Certified System Administrator (RHCSA) must master the nuanced discipline of process management in GNU/Linux systems, blending technical proficiency with strategic oversight.
• A Red Hat Certified System Administrator (RHCSA) must develop a deep understanding of job control on GNU/Linux systems to manage processes effectively. 
• A Red Hat Certified System Administrator (RHCSA) must master process monitoring in GNU/Linux to ensure system stability, optimize resource usage, and troubleshoot performance issues.
• A Red Hat Certified System Administrator (RHCSA) must master the configuration and enforcement of system resource limits in GNU/Linux environments to ensure stability, security, and efficient resource allocation.
• A Red Hat Certified System Administrator (RHCSA) must master job scheduling in GNU/Linux to automate routine tasks, optimize system efficiency, and ensure timely execution of critical operations. 
• A Red Hat Certified System Administrator (RHCSA) must understand process accounting in GNU/Linux to track command execution, resource consumption, and user activity for auditing, troubleshooting, and performance analysis.
• A Red Hat Certified System Administrator (RHCSA) must master system performance tuning in GNU/Linux to ensure optimal resource utilization, responsiveness, and reliability.

In Article 4 of my RHCSA series, we'll take a deep dive into managing memory on GNU/Linux computer systems. Thank you for reading this article!

References:

[1] 2020 - Lecture - CSCI 275: Linux Systems Administration and Security - Moe Hassan - CUNY John Jay College - NYC Tech-in-Residence Corps. Retrieved June 22, 2025 from https://academicworks.cuny.edu/cgi/viewcontent.cgi?article=1053&context=jj_oers