How to manage temporary files in /tmp
How to Manage Temporary Files in /tmp
The `/tmp` directory is one of the most critical yet often overlooked components of Linux and Unix-like systems. This temporary storage location serves as a workspace for applications, scripts, and system processes, but without proper management, it can quickly become a source of performance issues, security vulnerabilities, and storage problems. This comprehensive guide will teach you everything you need to know about effectively managing temporary files in the `/tmp` directory.
Table of Contents
1. [Understanding the /tmp Directory](#understanding-the-tmp-directory)
2. [Prerequisites and Requirements](#prerequisites-and-requirements)
3. [Basic File Management Operations](#basic-file-management-operations)
4. [Automated Cleanup Strategies](#automated-cleanup-strategies)
5. [Monitoring and Analysis](#monitoring-and-analysis)
6. [Security Considerations](#security-considerations)
7. [Advanced Management Techniques](#advanced-management-techniques)
8. [Troubleshooting Common Issues](#troubleshooting-common-issues)
9. [Best Practices](#best-practices)
10. [Conclusion](#conclusion)
Understanding the /tmp Directory
What is /tmp?
The `/tmp` directory is a standard filesystem location designated for temporary files that applications and users need during system operation. Unlike other directories, `/tmp` is designed to be volatile, meaning its contents are typically cleared during system reboots or through automated cleanup processes.
Key Characteristics
- World-writable: All users can create files in `/tmp`
- Sticky bit set: Users can only delete their own files
- Temporary nature: Files are expected to be short-lived
- High activity: Constant read/write operations occur here
Common Use Cases
Applications use `/tmp` for various purposes:
- Temporary data processing: Large datasets during computation
- Cache storage: Frequently accessed data for quick retrieval
- Inter-process communication: Named pipes and sockets
- Download staging: Temporary storage during file downloads
- Compilation artifacts: Object files and intermediate build products
Prerequisites and Requirements
System Requirements
- Linux or Unix-like operating system
- Root or sudo access for system-wide configurations
- Basic command-line knowledge
- Understanding of file permissions and ownership
Essential Tools
Ensure these tools are available on your system:
```bash
Check if essential tools are installed
which find cron systemd df du ls
```
Permission Verification
Verify the `/tmp` directory has correct permissions:
```bash
ls -ld /tmp
Expected output: drwxrwxrwt 15 root root 4096 Nov 15 10:30 /tmp
```
The `t` at the end indicates the sticky bit is set, which is crucial for security.
Basic File Management Operations
Listing Temporary Files
Start by understanding what's currently in your `/tmp` directory:
```bash
Basic listing
ls -la /tmp
Show files with human-readable sizes
ls -lah /tmp
Sort by modification time (newest first)
ls -lat /tmp
Show only files modified in the last 24 hours
find /tmp -type f -mtime -1 -ls
```
Analyzing Disk Usage
Monitor space consumption in `/tmp`:
```bash
Show total usage
du -sh /tmp
Show usage by subdirectory
du -sh /tmp/*
Show disk space information
df -h /tmp
Find largest files
find /tmp -type f -exec ls -lh {} \; | sort -k5 -hr | head -10
```
Safe File Removal
When removing files manually, always prioritize safety:
```bash
Remove files older than 7 days
find /tmp -type f -mtime +7 -delete
Remove empty directories
find /tmp -type d -empty -delete
Remove files by pattern (be very careful)
find /tmp -name "*.tmp" -mtime +1 -delete
Interactive removal for safety
find /tmp -type f -mtime +3 -ok rm {} \;
```
Warning: Always test find commands with `-print` before using `-delete`:
```bash
Test first
find /tmp -type f -mtime +7 -print
Then execute
find /tmp -type f -mtime +7 -delete
```
Automated Cleanup Strategies
Using Cron Jobs
Create automated cleanup schedules using cron:
```bash
Edit crontab
sudo crontab -e
Add cleanup job (runs daily at 2 AM)
0 2 * find /tmp -type f -mtime +7 -delete
More comprehensive cleanup
0 2 * /usr/local/bin/tmp-cleanup.sh
```
Create a comprehensive cleanup script:
```bash
#!/bin/bash
/usr/local/bin/tmp-cleanup.sh
Configuration
LOG_FILE="/var/log/tmp-cleanup.log"
MAX_AGE_DAYS=7
MIN_FREE_SPACE_MB=1000
Logging function
log_message() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}
Check available space
available_space=$(df /tmp | awk 'NR==2 {print $4}')
available_mb=$((available_space / 1024))
log_message "Starting cleanup. Available space: ${available_mb}MB"
Remove old files
files_removed=$(find /tmp -type f -mtime +${MAX_AGE_DAYS} -delete -print | wc -l)
log_message "Removed $files_removed old files"
Remove empty directories
dirs_removed=$(find /tmp -type d -empty -delete -print | wc -l)
log_message "Removed $dirs_removed empty directories"
Check if more aggressive cleanup is needed
if [ "$available_mb" -lt "$MIN_FREE_SPACE_MB" ]; then
log_message "Low space detected, performing aggressive cleanup"
find /tmp -type f -mtime +1 -delete
fi
log_message "Cleanup completed"
```
Make the script executable:
```bash
sudo chmod +x /usr/local/bin/tmp-cleanup.sh
```
Using systemd Timers
For modern systems, systemd timers offer more flexibility than cron:
Create a service file:
```bash
/etc/systemd/system/tmp-cleanup.service
[Unit]
Description=Temporary Files Cleanup
After=local-fs.target
[Service]
Type=oneshot
ExecStart=/usr/local/bin/tmp-cleanup.sh
User=root
```
Create a timer file:
```bash
/etc/systemd/system/tmp-cleanup.timer
[Unit]
Description=Run tmp-cleanup daily
Requires=tmp-cleanup.service
[Timer]
OnCalendar=daily
Persistent=true
[Install]
WantedBy=timers.target
```
Enable and start the timer:
```bash
sudo systemctl daemon-reload
sudo systemctl enable tmp-cleanup.timer
sudo systemctl start tmp-cleanup.timer
Check timer status
sudo systemctl status tmp-cleanup.timer
```
Configuring tmpfs
For systems with adequate RAM, consider mounting `/tmp` as tmpfs for automatic cleanup on reboot:
```bash
Add to /etc/fstab
tmpfs /tmp tmpfs defaults,noatime,nosuid,nodev,noexec,mode=1777,size=2G 0 0
Mount immediately
sudo mount -a
Verify tmpfs is active
mount | grep tmpfs
```
Monitoring and Analysis
Real-time Monitoring
Monitor `/tmp` activity in real-time:
```bash
Watch file creation/deletion
inotifywait -m -r -e create,delete /tmp
Monitor disk usage changes
watch -n 5 'df -h /tmp && echo "---" && du -sh /tmp'
Track largest files continuously
watch -n 10 'find /tmp -type f -exec ls -lh {} \; | sort -k5 -hr | head -5'
```
Creating Monitoring Scripts
Develop comprehensive monitoring solutions:
```bash
#!/bin/bash
/usr/local/bin/tmp-monitor.sh
THRESHOLD_PERCENT=80
ALERT_EMAIL="admin@example.com"
Get current usage percentage
usage_percent=$(df /tmp | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$usage_percent" -gt "$THRESHOLD_PERCENT" ]; then
# Generate detailed report
report="/tmp/usage-report-$(date +%Y%m%d-%H%M%S).txt"
echo "Temporary Directory Usage Report" > "$report"
echo "Generated: $(date)" >> "$report"
echo "Usage: ${usage_percent}%" >> "$report"
echo "" >> "$report"
echo "Largest files:" >> "$report"
find /tmp -type f -exec ls -lh {} \; | sort -k5 -hr | head -20 >> "$report"
echo "" >> "$report"
echo "Directory usage:" >> "$report"
du -sh /tmp/* | sort -hr >> "$report"
# Send alert (if mail is configured)
if command -v mail >/dev/null 2>&1; then
mail -s "High /tmp usage: ${usage_percent}%" "$ALERT_EMAIL" < "$report"
fi
echo "Alert: /tmp usage at ${usage_percent}%"
fi
```
Log Analysis
Analyze system logs for `/tmp` related issues:
```bash
Search for /tmp related errors
sudo journalctl | grep -i "/tmp"
Check for disk space issues
sudo journalctl | grep -i "no space left"
Monitor specific application tmp usage
sudo lsof | grep /tmp
```
Security Considerations
File Permissions and Ownership
Maintain proper security in `/tmp`:
```bash
Check for suspicious files
find /tmp -type f \( -perm -4000 -o -perm -2000 \) -ls
Look for files with unusual ownership
find /tmp -type f ! -user root -ls | head -20
Check for world-writable files (potential security risk)
find /tmp -type f -perm -002 -ls
```
Preventing Security Issues
Implement security measures:
```bash
#!/bin/bash
Security audit script for /tmp
echo "=== /tmp Security Audit ==="
echo "Date: $(date)"
echo
Check sticky bit
echo "Checking sticky bit on /tmp:"
ls -ld /tmp | grep -q "t$" && echo "✓ Sticky bit is set" || echo "✗ Sticky bit missing"
Check for setuid/setgid files
echo -e "\nChecking for setuid/setgid files:"
setuid_files=$(find /tmp -type f \( -perm -4000 -o -perm -2000 \) 2>/dev/null)
if [ -z "$setuid_files" ]; then
echo "✓ No setuid/setgid files found"
else
echo "✗ Found setuid/setgid files:"
echo "$setuid_files"
fi
Check for suspicious executables
echo -e "\nChecking for executable files:"
find /tmp -type f -executable -ls 2>/dev/null | head -10
```
Implementing Access Controls
Use systemd to restrict `/tmp` access:
```bash
Add to service files to restrict /tmp access
[Service]
PrivateTmp=yes
```
Advanced Management Techniques
Quota Management
Implement user quotas for `/tmp` if it's on a separate filesystem:
```bash
Enable quotas in /etc/fstab
/dev/sdb1 /tmp ext4 defaults,usrquota,grpquota 0 2
Initialize quota files
sudo quotacheck -cum /tmp
sudo quotaon /tmp
Set user quotas (1GB soft, 2GB hard limit)
sudo setquota -u username 1000000 2000000 0 0 /tmp
```
Custom Cleanup Policies
Implement intelligent cleanup based on file types and usage patterns:
```bash
#!/bin/bash
Advanced cleanup with custom policies
Configuration
declare -A CLEANUP_RULES=(
["*.log"]=1 # Log files: 1 day
["*.tmp"]=3 # Temp files: 3 days
["*.cache"]=7 # Cache files: 7 days
["core.*"]=0 # Core dumps: immediate
)
for pattern in "${!CLEANUP_RULES[@]}"; do
days=${CLEANUP_RULES[$pattern]}
echo "Cleaning $pattern files older than $days days"
if [ "$days" -eq 0 ]; then
find /tmp -name "$pattern" -type f -delete
else
find /tmp -name "$pattern" -type f -mtime +$days -delete
fi
done
```
Integration with Backup Systems
Preserve important temporary files before cleanup:
```bash
#!/bin/bash
Backup important temp files before cleanup
BACKUP_DIR="/var/backups/tmp-archive"
ARCHIVE_NAME="tmp-backup-$(date +%Y%m%d).tar.gz"
Create backup directory
mkdir -p "$BACKUP_DIR"
Find files to backup (example: files larger than 100MB)
find /tmp -type f -size +100M -mtime -30 > /tmp/backup-list.txt
if [ -s /tmp/backup-list.txt ]; then
echo "Creating backup of large temporary files..."
tar -czf "$BACKUP_DIR/$ARCHIVE_NAME" -T /tmp/backup-list.txt
echo "Backup created: $BACKUP_DIR/$ARCHIVE_NAME"
fi
Clean up backup list
rm -f /tmp/backup-list.txt
Remove old backups (keep 30 days)
find "$BACKUP_DIR" -name "tmp-backup-*.tar.gz" -mtime +30 -delete
```
Troubleshooting Common Issues
Disk Space Problems
When `/tmp` fills up completely:
```bash
Emergency cleanup - remove largest files first
find /tmp -type f -exec ls -lS {} \; | head -20
Force cleanup of specific applications
pkill -f "application-name"
rm -rf /tmp/application-temp-dir
Clear system temporary files
sudo systemctl stop systemd-tmpfiles-clean.service
sudo systemd-tmpfiles --clean
sudo systemctl start systemd-tmpfiles-clean.service
```
Permission Issues
Fix common permission problems:
```bash
Restore correct /tmp permissions
sudo chmod 1777 /tmp
Fix ownership if needed
sudo chown root:root /tmp
Remove files with problematic permissions
find /tmp -type f ! -perm -644 -exec chmod 644 {} \;
```
Performance Problems
Address performance issues in `/tmp`:
```bash
Check for I/O intensive processes
sudo iotop -o
Monitor file system performance
iostat -x 1 5
Check for fragmentation (ext4)
sudo e4defrag /tmp
Analyze inode usage
df -i /tmp
```
Application-Specific Issues
Handle applications that misuse `/tmp`:
```bash
Find applications creating excessive temp files
sudo lsof /tmp | awk '{print $2}' | sort | uniq -c | sort -nr
Monitor specific process temp file creation
strace -e trace=openat -p 2>&1 | grep /tmp
Set application-specific cleanup
Example for Firefox
find /tmp -name "firefox*" -type d -mtime +1 -exec rm -rf {} \;
```
Best Practices
Regular Maintenance Schedule
Establish a comprehensive maintenance routine:
1. Daily: Basic cleanup of files older than 7 days
2. Weekly: Comprehensive analysis and reporting
3. Monthly: Security audit and permission check
4. Quarterly: Review and update cleanup policies
Monitoring Guidelines
Implement effective monitoring:
- Set up alerts for usage above 80%
- Monitor unusual file creation patterns
- Track application-specific temp file usage
- Log all cleanup activities
Development Best Practices
For developers and system administrators:
```bash
Use mktemp for secure temporary files
temp_file=$(mktemp)
temp_dir=$(mktemp -d)
Always clean up in scripts
trap 'rm -f "$temp_file"; rm -rf "$temp_dir"' EXIT
Use application-specific subdirectories
mkdir -p /tmp/myapp-$$
```
Security Best Practices
Maintain security in temporary file management:
- Never store sensitive data in `/tmp`
- Use proper file permissions (644 for files, 755 for directories)
- Implement regular security audits
- Monitor for suspicious file creation patterns
- Use `PrivateTmp=yes` in systemd services when possible
Performance Optimization
Optimize `/tmp` performance:
- Consider tmpfs for systems with adequate RAM
- Use separate filesystem for `/tmp` on busy systems
- Implement appropriate cleanup frequencies
- Monitor and tune filesystem parameters
Conclusion
Effective management of temporary files in `/tmp` is crucial for maintaining system performance, security, and stability. This comprehensive guide has covered everything from basic file operations to advanced automation techniques, providing you with the tools and knowledge needed to implement robust temporary file management strategies.
Key takeaways include:
- Automation is essential: Implement automated cleanup using cron jobs or systemd timers
- Monitoring prevents problems: Regular monitoring helps identify issues before they become critical
- Security cannot be overlooked: Regular security audits and proper permissions are vital
- Customization improves efficiency: Tailor cleanup policies to your specific environment and applications
By following the practices outlined in this guide, you'll ensure that your `/tmp` directory remains a helpful resource rather than a system bottleneck. Remember to regularly review and update your management strategies as your system requirements evolve.
Start with basic monitoring and cleanup procedures, then gradually implement more advanced techniques as needed. Always test changes in a non-production environment first, and maintain proper backups of any critical data before implementing aggressive cleanup policies.
The investment in proper temporary file management will pay dividends in improved system performance, enhanced security, and reduced maintenance overhead. Your systems will run more smoothly, and you'll have better visibility into how applications use temporary storage space.