How to fix SQLITE_IOERR_READ: Disk I/O error during read in SQLite

# Check file ownership and permissions
ls -la /path/to/your/database.db

# Check directory permissions
ls -la /path/to/

# Expected permissions:
# -rw-r--r--  1 youruser  yourgroup  database.db
# The user running SQLite needs read permission

# Try to read the file directly
head -c 100 /path/to/your/database.db

# Check if file is readable by current user
test -r /path/to/your/database.db && echo "File is readable" || echo "File is NOT readable"

# Check if directory is accessible
test -x /path/to/ && echo "Directory is accessible" || echo "Directory is NOT accessible"

# Make file readable by current user (if you own it)
chmod u+r /path/to/your/database.db

# Make directory accessible
chmod u+x /path/to/

# Change ownership if needed (use with caution)
sudo chown $(whoami):$(whoami) /path/to/your/database.db

# Check SELinux context
ls -Z /path/to/your/database.db

# Check for SELinux denials
sudo ausearch -m avc -ts recent

# Check AppArmor status
sudo aa-status

# Linux: Check filesystem for errors
sudo fsck /dev/sdX

# Force filesystem check on next reboot
sudo touch /forcefsck

# Check mount options
mount | grep /path/to/database

# Check filesystem type and options
findmnt -T /path/to/your/database.db

# Check kernel messages for I/O errors
dmesg | grep -i "error|fail|io|disk"

# Check system logs
journalctl -k | grep -i "disk|io|error"

# Monitor I/O statistics
iostat -x 1

# Check for bad blocks
sudo badblocks -v /dev/sdX

# Install smartmontools if needed
# sudo apt install smartmontools  # Debian/Ubuntu
# sudo yum install smartmontools  # RHEL/CentOS

# Check SMART status
sudo smartctl -a /dev/sdX

# Look for these warning signs:
# - Reallocated_Sector_Ct > 0
# - Current_Pending_Sector > 0
# - Offline_Uncorrectable > 0
# - Temperature_Celsius too high
# - Power_On_Hours very high

# Run short self-test
sudo smartctl -t short /dev/sdX

# Check test results after 2 minutes
sudo smartctl -l selftest /dev/sdX

# Check disk space
df -h /path/to/database

# Check inode usage
df -i /path/to/database

# Check memory availability
free -h

# Check file descriptor limits
ulimit -n
cat /proc/sys/fs/file-max

# Use dd with error handling
sudo dd if=/path/to/corrupted.db of=/safe/location/copy.db bs=4k conv=noerror,sync

# Or use cp with progress
cp -v /path/to/corrupted.db /safe/location/copy.db

# Verify copy succeeded
cmp /path/to/corrupted.db /safe/location/copy.db && echo "Copy successful" || echo "Copy may have errors"

# Attempt to open the copied database
sqlite3 /safe/location/copy.db "SELECT sqlite_version();"

# Run integrity check
sqlite3 /safe/location/copy.db "PRAGMA integrity_check;"

# Check if basic operations work
sqlite3 /safe/location/copy.db ".schema"

# The issue is likely filesystem-related
# Move original aside and use the copy
mv /path/to/corrupted.db /path/to/corrupted.db.backup
cp /safe/location/copy.db /path/to/corrupted.db

# Fix permissions on new file
chmod 644 /path/to/corrupted.db
chown $(whoami):$(whoami) /path/to/corrupted.db

# Try different block sizes for dd
sudo dd if=/path/to/corrupted.db of=/safe/location/copy2.db bs=1k conv=noerror,sync

# Or skip potentially bad sectors
sudo dd if=/path/to/corrupted.db of=/safe/location/copy3.db bs=512 skip=1000 count=10000

# Use specialized recovery tools
sudo ddrescue /path/to/corrupted.db /safe/location/recovered.db /safe/location/recovery.log

# Try to dump readable data
sqlite3 /safe/location/copy.db ".dump" > recovery.sql 2>/dev/null

# Check what was recovered
head -50 recovery.sql

# If .dump works, create new database
sqlite3 new_database.db < recovery.sql

# Verify new database
sqlite3 new_database.db "PRAGMA integrity_check;"

# Monitor system load
top
htop

# Check I/O wait
vmstat 1 10

# Monitor disk I/O
iotop

# Check for memory pressure
cat /proc/meminfo | grep -i "memavailable|swap"

# Check for OOM killer activity
dmesg | grep -i "oom|kill"

# Check RAID status (if applicable)
cat /proc/mdstat
sudo mdadm --detail /dev/mdX

# Check LVM status
sudo lvs
sudo vgs
sudo pvs

# Check multipath (if applicable)
sudo multipath -ll

# Check for storage alerts
sudo dmesg | grep -i "scsi|sata|nvme"

# For ext4 filesystems
sudo tune2fs -l /dev/sdX | grep -i "features|errors"

# Check filesystem errors count
sudo dumpe2fs /dev/sdX | grep -i "error"

# For XFS filesystems
sudo xfs_info /mount/point
sudo xfs_repair -n /dev/sdX

# For ZFS filesystems
sudo zpool status
sudo zpool scrub poolname

# For NFS mounts
showmount -e nfs-server
nfsstat -c
nfsstat -s

# For SMB/CIFS mounts
smbstatus
testparm -s

# Check network connectivity
ping -c 4 nfs-server
traceroute nfs-server

# Check mount options
cat /proc/mounts | grep nfs
cat /proc/mounts | grep cifs

# Stop antivirus temporarily (if safe)
sudo systemctl stop clamav-daemon  # Example for ClamAV

# Disable real-time scanning for database directory
# (Check your antivirus documentation)

# Check for other monitoring software
ps aux | grep -i "monit|audit|tripwire"

#!/bin/bash
# Schedule regular filesystem checks
# Add to crontab: 0 5 * * 0 /path/to/fs-check.sh

FS_DEVICE="/dev/sdX"
MOUNT_POINT="/path/to/database"

# Check filesystem
if ! mountpoint -q "$MOUNT_POINT"; then
    echo "Filesystem not mounted at $MOUNT_POINT"
    exit 1
fi

# Run read-only check
fsck -n "$FS_DEVICE"

# Monitor disk health
smartctl -H "$FS_DEVICE"

# Log results
echo "$(date): Filesystem check completed" >> /var/log/fs-maintenance.log

#!/bin/bash
# Daily database backup
BACKUP_DIR="/backups/sqlite"
DB_PATH="/app/data/database.db"
RETENTION_DAYS=7

# Create backup using SQLite .backup command
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
sqlite3 "$DB_PATH" ".backup $BACKUP_DIR/db_backup_$TIMESTAMP.db"

# Verify backup integrity
sqlite3 "$BACKUP_DIR/db_backup_$TIMESTAMP.db" "PRAGMA integrity_check;" > /dev/null

if [ $? -eq 0 ]; then
    echo "$(date): Backup successful" >> /var/log/db-backup.log

    # Clean up old backups
    find "$BACKUP_DIR" -name "db_backup_*.db" -mtime +$RETENTION_DAYS -delete
else
    echo "$(date): Backup verification failed!" >> /var/log/db-backup.log
    # Alert administrator
    echo "Database backup failed!" | mail -s "Backup Alert" admin@example.com
fi

#!/bin/bash
# Monitor for I/O errors
LOG_FILE="/var/log/io-monitor.log"
ALERT_EMAIL="admin@example.com"

# Check dmesg for I/O errors
RECENT_ERRORS=$(dmesg -T | grep -i "I/O error|disk error|read error" | tail -5)

if [ -n "$RECENT_ERRORS" ]; then
    echo "$(date): I/O errors detected:" >> "$LOG_FILE"
    echo "$RECENT_ERRORS" >> "$LOG_FILE"

    # Send alert
    echo "I/O errors detected on $(hostname):" | mail -s "I/O Error Alert" "$ALERT_EMAIL"
    echo "$RECENT_ERRORS" | mail -s "I/O Error Details" "$ALERT_EMAIL"
fi

# Monitor disk health
SMART_STATUS=$(smartctl -H /dev/sdX | grep -i "test result")

if echo "$SMART_STATUS" | grep -q "FAILED"; then
    echo "$(date): Disk SMART test failed" >> "$LOG_FILE"
    echo "Disk SMART test failed on $(hostname)" | mail -s "Disk Failure Alert" "$ALERT_EMAIL"
fi