How to Look at Contents of sda1 on Raspberry Pi (Python USB Mounter)

In the Linux block device hierarchy, /dev/sda1 designates the first partition (1) of the first SCSI, SATA, or USB mass storage device (sda) detected by the kernel. If you are trying to look at the contents of sda1 on a Raspberry Pi, you are almost certainly dealing with an external USB flash drive, an external SSD, or an SD card plugged into a USB card reader. (The Pi's internal microSD slot maps to /dev/mmcblk0pX instead).

This guide walks through building a Python-based automated mounter and inspector that detects /dev/sda1, mounts it, reads the directory structure, and triggers a physical GPIO LED indicator. We will also cover the exact kernel errors you will hit when filesystems mismatch and how to debug USB Attached SCSI (UAS) quirks specific to the Pi 4 and Pi 5.

Project Overview & Hardware Requirements

This build targets the Raspberry Pi 5 (8GB variant) and the Raspberry Pi 4 Model B, running Raspberry Pi OS Bookworm (64-bit). Bookworm shifted the default filesystem mount points and uses NetworkManager and udisks2 under the hood for desktop environments, but headless server deployments still require manual or scripted mounting.

Parts List

• Microcontroller: Raspberry Pi 5 (8GB) or Raspberry Pi 4 Model B (4GB/8GB)
• Storage: SanDisk Ultra 32GB USB 3.0 Flash Drive (or any USB mass storage device formatted as FAT32, exFAT, or ext4)
• Indicator: 5mm Green LED
• Current Limiting: 330Ω through-hole resistor
• Wiring: 2x male-to-female jumper wires, breadboard

Pin Mapping & Wiring the Status Indicator

We use a physical LED to confirm when the script has successfully mounted sda1 and verified read access. This is invaluable for headless Pi deployments where you don't have an SSH session open to check lsblk.

Wire the resistor inline with the anode to prevent overdriving the GPIO pin. The Pi's GPIO pins source a maximum of 16mA per pin safely; the 330Ω resistor limits the current to roughly 10mA at 3.3V, well within the official Raspberry Pi hardware specifications.

Python Script to Inspect and Mount /dev/sda1

The following script uses the modern gpiozero library (pre-installed on Bookworm) and the subprocess module to handle mounting and directory reading. Because mounting requires root privileges, this script must be executed with sudo.

#!/usr/bin/env python3
import os
import subprocess
import time
import sys
from gpiozero import LED

# --- Pin & Path Definitions ---
STATUS_LED = LED(17)       # GPIO 17 (Physical Pin 11)
DEVICE_NODE = "/dev/sda1"
MOUNT_POINT = "/mnt/usb"

def ensure_mount_point():
    """Create the mount directory if it doesn't exist."""
    if not os.path.exists(MOUNT_POINT):
        os.makedirs(MOUNT_POINT)
        print(f"[INFO] Created mount point at {MOUNT_POINT}")

def mount_drive():
    """Attempt to mount /dev/sda1 to the designated mount point."""
    # Check if already mounted
    result = subprocess.run(["mountpoint", "-q", MOUNT_POINT])
    if result.returncode == 0:
        print("[INFO] Drive is already mounted.")
        return True

    print(f"[ACTION] Mounting {DEVICE_NODE} to {MOUNT_POINT}...")
    # -o uid=pi,gid=pi ensures the default 'pi' user has read/write access
    mount_cmd = ["mount", "-o", "uid=1000,gid=1000", DEVICE_NODE, MOUNT_POINT]
    result = subprocess.run(mount_cmd, capture_output=True, text=True)

    if result.returncode == 0:
        print("[SUCCESS] Drive mounted successfully.")
        return True
    else:
        print(f"[ERROR] Mount failed:\n{result.stderr.strip()}")
        return False

def inspect_contents():
    """Look at the contents of sda1 and print the top-level directory."""
    try:
        contents = os.listdir(MOUNT_POINT)
        print(f"\n--- Contents of {MOUNT_POINT} ({len(contents)} items) ---")
        for item in sorted(contents)[:10]: # Print first 10 items to avoid terminal spam
            item_path = os.path.join(MOUNT_POINT, item)
            item_type = "[DIR]" if os.path.isdir(item_path) else "[FILE]"
            print(f"{item_type} {item}")
        if len(contents) > 10:
            print(f"... and {len(contents) - 10} more items.")
        print("-" * 40)
    except PermissionError:
        print("[ERROR] Permission denied. Ensure mount options include correct uid/gid.")

def main():
    if os.geteuid() != 0:
        print("[FATAL] This script requires root privileges to mount drives.")
        print("Please run with: sudo python3 " + sys.argv[0])
        sys.exit(1)

    ensure_mount_point()
    
    try:
        if mount_drive():
            STATUS_LED.on()
            inspect_contents()
        else:
            STATUS_LED.blink(on_time=0.2, off_time=0.2) # Fast blink indicates error
    except KeyboardInterrupt:
        print("\n[INFO] Interrupted by user.")
    finally:
        # Cleanup: Unmount and turn off LED on exit
        print("[ACTION] Unmounting drive...")
        subprocess.run(["umount", MOUNT_POINT])
        STATUS_LED.off()
        print("[INFO] Safe to remove USB drive.")

if __name__ == "__main__":
    main()

Debugging: Exact Error Strings and Ranked Causes

When interacting with raw block devices on the Pi, the kernel is unforgiving. If your script fails, here are the exact error strings you will encounter, ranked by frequency, along with their fixes.

Error 1: "mount: /mnt/usb: wrong fs type, bad option, bad superblock on /dev/sda1..."

The Cause: The Linux kernel doesn't recognize the filesystem on the USB drive. Raspberry Pi OS Lite (headless) images often omit proprietary or heavy filesystem drivers to save space. If your sda1 is formatted as exFAT (standard for >32GB USB drives) or NTFS, the base kernel lacks the userspace helpers to mount it.

The Fix: Install the exfatprogs package or NTFS-3G.

sudo apt update
sudo apt install exfatprogs ntfs-3g

Error 2: "mount: /mnt/usb: special device /dev/sda1 does not exist."

The Cause: The kernel hasn't assigned the sda node to your USB drive. This happens if you plug the drive into a powered hub that enumerates slowly, or if you already have another SCSI/SATA device (like a USB-to-SATA SSD adapter) that claimed sda, pushing your thumb drive to sdb1.

The Fix: Run lsblk -f to verify the actual device node. Do not assume sda1; always verify the label and UUID.

Error 3: "[ERROR] Mount failed: mount: /mnt/usb: mount(2) system call failed: Structure needs cleaning."

The Cause: The filesystem's dirty bit is set, or the FAT/exFAT allocation table is corrupted. This almost always happens when a drive is yanked out of a Windows PC without using "Safely Remove Hardware," or if the Pi experienced a brownout and the USB controller reset mid-write.

The Fix: Run a filesystem check. For exFAT: sudo fsck.exfat -a /dev/sda1. For FAT32: sudo fsck.fat -a /dev/sda1.

Extending and Simplifying the Build

How to Simplify

If you don't need a custom Python script and just want the Pi desktop to handle it, rely on udisks2. On the desktop version of Raspberry Pi OS, inserting a USB drive triggers udisks2 to automatically mount it to /media/pi/[VOLUME_NAME]. You can trigger this manually from the terminal without root privileges using:

udisksctl mount -b /dev/sda1

This bypasses the need for sudo and manual fstab edits entirely.

How to Extend

To turn this inspector into an automated backup kiosk, extend the Python script to trigger an rsync payload upon successful mounting. Add a 0.96" I2C OLED display (SSD1306) wired to the Pi's I2C1 bus (GPIO 2/3) to scroll the filenames physically on the enclosure. You can also implement a systemd udev rule that triggers this Python script automatically the moment the kernel detects a new USB mass storage block device, eliminating the need to run it manually.

Frequently Asked Questions

Why does my Raspberry Pi show mmcblk0p1 instead of sda1?

The mmcblk prefix is reserved by the Linux kernel for internal SD/MMC card readers connected via the SDIO bus. The Pi's built-in microSD slot will always be mmcblk0 (with mmcblk0p1 as the boot partition and mmcblk0p2 as the root OS partition). The sd prefix (SCSI disk) is used for USB mass storage devices, SATA drives, and NVMe drives connected via PCIe adapters. If you are looking at the internal boot partition, you want mmcblk0p1, not sda1.

How do I look at the contents of sda1 on Raspberry Pi without the terminal?

If you are running the Raspberry Pi OS Desktop environment, simply plug the USB drive into the Pi. The File Manager (PCManFM) will display an icon for the drive in the left sidebar and on the desktop. Click it to mount and browse. If you are running headless but want a GUI alternative, install a web-based file manager like Filebrowser or Samba to share the /mnt/usb directory over your local network to your Windows/Mac machine.

Can I boot my Raspberry Pi directly from an sda1 USB partition?

Yes, but sda1 alone isn't enough. The Pi's bootloader requires the first partition to be a FAT32 formatted boot partition containing the start.elf and kernel files. If you clone a working microSD card to a USB drive using the Raspberry Pi Imager or dd, the USB drive will have both the boot partition (which the bootloader reads) and the root partition. You must also ensure your Pi's EEPROM bootloader configuration is set to prioritize USB boot (BOOT_ORDER=0xf41 or similar) via the rpi-eeprom-config tool.

What happens if I unplug the USB drive while the Python script is reading sda1?

If you yank the drive while the script is executing os.listdir() or reading a file, the Python process will throw an OSError: [Errno 5] Input/output error. More critically, the Linux kernel will mark the filesystem as read-only or crash the USB controller driver. Always use the umount command (or let the script's finally block handle it) to flush the write cache before physically disconnecting the drive to prevent silent data corruption.