What is the difference between SIGTERM and SIGKILL?

SIGTERM (default signal from kill) asks the process to terminate gracefully, allowing cleanup. If the process ignores it or hangs, you can use SIGKILL to force termination, which cannot be caught or ignored.

How do I find which process is using a specific port?

Use tools like lsof -i :PORT, ss -tlnp | grep :PORT, or netstat -tlnp to identify the PID and then act with kill/pkill/killall.

How can I view detailed information about a single PID?

Inspect /proc/PID/status for state, /proc/PID/cmdline for the command, and /proc/PID/fd for open file descriptors to understand what the process is doing.

How do I keep a long-running job alive after you log out?

Use nohup to detach the process and redirect output, or manage the session with screen or tmux to reattach later.

process-management

Scanned

linux process kill signal jobs

npx machina-cli add skill chaterm/terminal-skills/process-management --openclaw

Files (1)

SKILL.md

3.9 KB

Process Management

Overview

Linux process viewing, signal handling, resource limiting and other management skills.

Process Viewing

ps Command

# Common formats
ps aux                              # All process details
ps -ef                              # Full format
ps -eo pid,ppid,cmd,%mem,%cpu       # Custom columns

# Find specific process
ps aux | grep nginx
ps -C nginx                         # By command name

# Process tree
ps auxf
pstree
pstree -p                           # Show PID

top/htop

# top interactive commands
top
# P - Sort by CPU
# M - Sort by memory
# k - Kill process
# q - Quit

# htop (more user-friendly)
htop

Other Tools

# Sort by resource
ps aux --sort=-%cpu | head -10      # Highest CPU
ps aux --sort=-%mem | head -10      # Highest memory

# View process details
cat /proc/PID/status
cat /proc/PID/cmdline
ls -la /proc/PID/fd                 # Open file descriptors

Signal Handling

Common Signals

# Signal list
kill -l

# Common signals
# SIGTERM (15) - Graceful termination (default)
# SIGKILL (9)  - Force termination
# SIGHUP (1)   - Reload configuration
# SIGSTOP (19) - Pause process
# SIGCONT (18) - Continue process

kill Command

# Terminate process
kill PID                            # Send SIGTERM
kill -9 PID                         # Force terminate
kill -HUP PID                       # Reload config

# Terminate by name
pkill nginx
pkill -9 -f "python script.py"

# Terminate all processes of a user
pkill -u username

# killall
killall nginx
killall -9 nginx

Background Tasks

Job Control

# Run in background
command &
nohup command &                     # Ignore hangup signal
nohup command > output.log 2>&1 &

# Job management
jobs                                # View jobs
fg %1                               # Foreground
bg %1                               # Background
Ctrl+Z                              # Pause current process

screen/tmux

# screen
screen -S session_name              # Create session
screen -ls                          # List sessions
screen -r session_name              # Resume session
Ctrl+A D                            # Detach session

# tmux
tmux new -s session_name
tmux ls
tmux attach -t session_name
Ctrl+B D                            # Detach session

Resource Limits

ulimit

# View limits
ulimit -a

# Set limits
ulimit -n 65535                     # Max file descriptors
ulimit -u 4096                      # Max processes
ulimit -v unlimited                 # Virtual memory

# Permanent settings /etc/security/limits.conf
# * soft nofile 65535
# * hard nofile 65535

cgroups

# View cgroup
cat /proc/PID/cgroup

# Limit CPU (systemd)
systemctl set-property service.service CPUQuota=50%

# Limit memory
systemctl set-property service.service MemoryLimit=512M

Common Scenarios

Scenario 1: Find and Kill Zombie Processes

# Find zombie processes
ps aux | awk '$8=="Z" {print}'

# Find parent process
ps -o ppid= -p ZOMBIE_PID

# Kill parent process
kill -9 PARENT_PID

Scenario 2: Find Process Using Port

# Find process using port 80
lsof -i :80
ss -tlnp | grep :80
netstat -tlnp | grep :80

# Kill process
fuser -k 80/tcp

Scenario 3: Monitor Process Resources

# Real-time monitor single process
top -p PID
watch -n 1 "ps -p PID -o %cpu,%mem,cmd"

# View files opened by process
lsof -p PID

Troubleshooting

Problem	Solution
Process unresponsive	`strace -p PID` to view system calls
CPU 100%	`top`, `perf top` to analyze hotspots
Memory leak	`pmap -x PID`, `/proc/PID/smaps`
Zombie process	Find parent process, restart or kill parent
Process OOM killed	`dmesg

Source

git clone https://github.com/chaterm/terminal-skills/blob/main/linux/process-management/SKILL.mdView on GitHub

Overview

This skill equips you to inspect running processes, send signals to terminate or reload, manage background tasks, and enforce resource limits on Linux. You’ll learn practical workflows for process viewing, signal handling, and lightweight session persistence using tools like ps, top/htop, kill, pkill, screen, and tmux. It also covers basic resource control via ulimit and cgroups (via systemd properties) to keep services under control.

How This Skill Works

You interact with the kernel’s process table using standard Linux utilities. You’ll identify targets by PID or name, send appropriate signals (TERM, HUP, KILL, etc.), and manage background jobs with nohup, bg/fg, and screen/tmux sessions. You’ll also inspect resource usage and limits through /proc, ulimit, and cgroup settings (CPUQuota, MemoryLimit) to constrain or observe behavior of running processes.

When to Use It

When you need to terminate misbehaving or zombie processes gracefully before forcing termination
When you must identify which process is listening on a specific port and stop it
When you want real-time monitoring of a single PID’s CPU/memory usage
When you need long-running tasks to survive logouts or disconnects (nohup, screen, tmux)
When you want to enforce per-service resource limits (ulimit or systemd/cgroups) to prevent resource contention

Quick Start

List and identify processes with ps: ps aux | head -n 20
Find a target by name or PID: ps -C nginx or pgrep nginx
Terminate gracefully, then force if needed: kill PID; if needed, kill -9 PID
Keep a task running after logout: nohup command &; manage sessions with screen or tmux

Best Practices

Always try SIGTERM (kill PID) before resorting to SIGKILL (kill -9 PID) to allow graceful shutdown
When targeting by name, prefer specific matches or use -f with pkill/killall to avoid unintended terminations
Use nohup, screen, or tmux to detach long-running tasks and keep logs for auditing
Limit resources per service with ulimit for local shells and systemd/cgroups (CPUQuota, MemoryLimit) for persistent services
Verify the outcome by inspecting exit codes, logs, and the /proc filesystem (status, cmdline, fd) to confirm the right process was affected

Example Use Cases

Example: Find and terminate the nginx process after verifying it’s safe to stop with ps -C nginx and kill PID
Example: Reload a daemon’s configuration by sending SIGHUP (kill -HUP PID) and confirm it reopens its config
Example: Locate a port-bound process (80/tcp) using lsof or ss, then gracefully terminate it with fuser or kill
Example: Monitor a critical PID in real time with top -p PID and watch to keep resource usage in check
Example: Enforce memory limits on a service via systemd properties (CPUQuota, MemoryLimit) to prevent it from consuming all host memory

Frequently Asked Questions

Add this skill to your agents

Related Skills

network-tools

chaterm/terminal-skills

Linux network tools and diagnostics

shell-scripting

chaterm/terminal-skills

Bash Shell 脚本编写

file-operations

chaterm/terminal-skills

Linux file and directory operations

user-permissions

chaterm/terminal-skills

Linux user and permission management

systemd

chaterm/terminal-skills

Systemd 服务管理

system-admin

chaterm/terminal-skills

Linux system administration and monitoring