| Tested on | Editorial baseline — Linux block layer and udev naming (RHEL, Debian, Ubuntu, and other distributions) |
|---|---|
| Package | N/A — conceptual overview; use check disk type in Linux for lsblk, smartctl, and nvme commands |
| Applies to | Any Linux host with local disks, VM disks, or SAN-presented block devices |
| Privilege | Normal user (reading and planning); no commands required on this page |
| Scope | Storage media (HDD, SSD, optical), interface/transport (PATA, SATA, SAS, NVMe, Fibre Channel, USB), and how Linux device names reflect those layers. Does not cover partitioning, LVM, RAID configuration, filesystem choice, or performance tuning. |
| Related guides | Check disk type in Linux Linux check disk space parted command Monitor disk I/O Change I/O scheduler |
Linux documentation throws several words at storage—HDD, SSD, SATA, SCSI, NVMe, /dev/sda, /dev/nvme0n1—and they do not line up one-to-one. Media type is what stores bits (spinning platters, flash cells, or an optical layer). Interface or transport is how those bits reach the host (SATA cable, SAS backplane, NVMe over PCIe, Fibre Channel fabric, or USB bridge). Block device names are how the kernel exposes whatever it sees after drivers, RAID controllers, hypervisors, or SAN masking get involved.
This guide maps the hardware vocabulary. When you need commands to inspect a live system, use check disk type in Linux—that article covers lsblk, sysfs, and related tools; this one explains what the columns mean.
Quick answer: media vs interface vs Linux names
| Layer | Question it answers | Examples |
|---|---|---|
| Media / disk type | Rotational, flash, or optical? | HDD, SSD, optical (CD/DVD/Blu-ray) |
| Interface / protocol | Physical or logical attachment | PATA, SATA, SAS, NVMe over PCIe, FC, iSCSI, USB |
| Linux block device | What path do tools use? | /dev/sda, /dev/nvme0n1, /dev/sr0, /dev/vda (VM) |
| What tools report | Often a mix of the above | ROTA, TRAN, MODEL, SCSI inquiry strings |
Three rules that prevent most confusion:
- HDD vs SSD is about media behavior (rotational vs non-rotational), not the cable type.
- SATA vs SAS vs NVMe is about transport or protocol; SSDs exist on SATA, SAS, and NVMe over PCIe.
/dev/sdXdoes not mean “SCSI disk” on the server floor—it is the generic disk name Linux uses for many transports, including SATA and USB.
Disk media types (what stores the data)
Hard disk drives (HDD)
An HDD stores data on magnetic platters spun by a motor, with a moving read/write head. Capacity is high and cost per gigabyte is low; latency and IOPS lag behind flash because seeks take milliseconds.
Common characteristics:
- Rotational speed rated in RPM (5400–7200 on laptops and desktops, 10k–15k on some enterprise spindles)
- Kernel usually reports
ROTA=1when the real disk is exposed without virtualization in the way - Typical Linux names:
/dev/sda,/dev/sdbon SATA/SAS/USB attachments
HDDs remain common for bulk data, backups, and cost-sensitive tiers. They are a poor fit for latency-sensitive databases unless paired with caching or flash tiers above them.
Solid-state drives (SSD)
SSDs store data in non-volatile flash with no moving parts. They offer lower latency, higher random IOPS, and lower power draw than HDDs at the same form factor, at a higher cost per gigabyte.
SSDs appear on several transports:
- SATA SSD — same connector family as SATA HDD; often
/dev/sdX,TRAN=sata - SAS SSD — enterprise backplanes;
/dev/sdX,TRAN=saswhen exposed - NVMe SSD — common local case uses NVMe over PCIe;
/dev/nvme0n1style names,TRAN=nvme
The kernel normally reports ROTA=0 for flash-backed devices, but virtual disks, RAID volumes, and SAN LUNs can also show ROTA=0 without being a local SSD—always read MODEL and controller context on production systems.
Hybrid drives (SSHD) combine a small flash cache with HDD platters; Linux still tends to classify them as rotational unless the driver exposes otherwise.
Optical discs and drives
Optical storage uses a laser to read pits on a disc (CD, DVD, Blu-ray). Drives are mechanical like HDDs but media is removable and capacities are far smaller than modern disks.
On Linux, optical drives usually appear as /dev/sr0 (SCSI generic ROM) with TYPE=rom in lsblk. Writable formats (CD-R, DVD±R, rewritable variants) differ by dye and layer technology, but all are legacy for server workloads—installer ISOs and archival use cases excepted.
Disk interface and transport types (how data reaches the host)
Interface types describe the bus, protocol, or network path—not the media. One interface can carry both HDDs and SSDs.
PATA (Parallel ATA) and legacy IDE
Parallel ATA (PATA), often called IDE in older documentation, used wide parallel cables and integrated drive controllers on the drive electronics. It is obsolete on new servers but still appears in vintage PCs and industrial gear.
Linux may show these as /dev/hdX on very old kernels; current systems rarely expose PATA directly.
SATA (Serial ATA)
SATA replaced PATA with a smaller serial cable. SATA evolved from 1.5 Gb/s to 3 Gb/s and then 6 Gb/s. Later SATA 3.x revisions added features and clarifications while retaining the 6 Gb/s maximum link rate.
SATA carries both HDDs and SSDs in 2.5" and 3.5" form factors. Despite the SATA physical link, Linux usually presents SATA disks as /dev/sdX through the libata/scsi disk stack—so parted, smartctl, and dmesg may say “SCSI” while the port is SATA.
SAS (Serial Attached SCSI)
SAS is the enterprise successor to parallel SCSI: point-to-point serial links, dual ports for redundancy, and support for expanders on backplanes. SAS handles HDDs and SSDs on the same infrastructure and scales to many drives per controller.
Linux names are typically /dev/sdX with TRAN=sas when udev exposes it. SAS is common on rack servers and JBOD shelves. Many SAS controllers and backplanes also accept SATA drives, but SATA-only controllers generally cannot operate SAS drives—even though device names look similar.
NVMe (Non-Volatile Memory Express)
NVMe is a storage protocol designed for non-volatile storage. Local NVMe SSDs normally use NVMe over PCIe, bypassing legacy ATA/SCSI command shapes and delivering lower latency and higher queue depth than SATA SSDs on the same generation of NAND. The NVMe specification also defines fabric transports such as RDMA and TCP for remote access; this guide focuses on local PCIe-attached namespaces.
Linux exposes NVMe namespaces as /dev/nvme0n1, /dev/nvme1n2, and so on—namespace numbering is part of the name. Controllers may expose multiple namespaces per card; nvme list (see the check disk type guide) maps controller, namespace, and serial detail.
NVMe over PCIe is the default attachment for modern performance SSDs in servers, workstations, and cloud instance stores.
Parallel SCSI (legacy SPI)
Parallel SCSI (SPI) used shared parallel buses with terminators and SCSI IDs. Throughput improved across Ultra-wide generations, but parallel SCSI is legacy compared with SAS. You may still see it on older arrays; Linux device naming follows the same /dev/sdX pattern when exposed.
Fibre Channel and network block storage
Fibre Channel (FC) is a high-speed fabric for SAN storage. Host bus adapters (HBAs) present remote LUNs as local block devices—often /dev/sdX or multipath names such as /dev/mapper/mpath*—while the physical media sits in an array.
Related protocols extend SCSI block semantics over networks:
- iSCSI — SCSI commands encapsulated in IP; common on Ethernet SANs
- FCoE — Fibre Channel frames over Ethernet; less common today but still documented in enterprise designs
These are transports to remote block storage, not media types. Linux sees a block device; the array may use HDD, SSD, or tiered pools underneath.
USB and other external bridges
USB-to-SATA or USB-to-NVMe adapters expose disks as /dev/sdX with TRAN=usb. Performance and SMART passthrough depend on the bridge chip; the media behind the bridge can still be HDD or SSD.
How Linux ties the layers together
Administrators care about three separate questions—media, transport, and the device path tools use—and Linux answers them through different fields.
| What you want to know | Where to look (on a live system) | This guide’s vocabulary |
|---|---|---|
| HDD vs SSD behavior | ROTA, /sys/block/.../queue/rotational |
Media type |
| SATA vs NVMe vs USB | TRAN, ID_BUS, device name prefix |
Interface / transport |
| Vendor and model | MODEL, SERIAL, SMART/NVMe identify |
Hardware identity |
| Local vs SAN vs VM disk | Multipath, hypervisor model strings, empty TRAN |
Presentation layer |
Device name patterns worth remembering:
sdX— generic SCSI disk layer (SATA, SAS, USB, FC, iSCSI, many VMs)nvmeXnY— NVMe namespace (commonly NVMe over PCIe locally)srX— optical / CD-ROM classvdX,xvdX,nvme*n*on clouds — hypervisor or platform-specific presentation
When a RAID controller or VMware/VirtIO presents a single logical volume, Linux may hide individual drive models entirely—that is a presentation limit, not proof that the media is HDD or SSD.
Comparison tables
Media types at a glance
| Media | Moving parts | Typical ROTA |
Strengths | Weaknesses |
|---|---|---|---|---|
| HDD | Yes (platters, head) | 1 | Low cost per TB, sequential throughput | Latency, random IOPS, fragility while spinning |
| SSD (SATA, SAS, or NVMe over PCIe) | No | 0 (when locally exposed) | Latency, IOPS, efficiency | Cost per TB, wear on flash cells |
| Optical | Yes (drive) | 0 on many drives | Removable archival media | Tiny capacity, slow, rare on servers |
Interface types at a glance
| Interface | Typical media | Linux device pattern | Common deployment |
|---|---|---|---|
| SATA | HDD, SSD | /dev/sdX |
Desktops, small servers |
| SAS | HDD, SSD | /dev/sdX |
Rack servers, JBOD |
| NVMe over PCIe | SSD | /dev/nvme0n1 |
Performance tiers, cloud local NVMe |
| FC / iSCSI | Array-defined | /dev/sdX, multipath |
SAN shared storage |
| USB | HDD, SSD | /dev/sdX, TRAN=usb |
External/portable disks |
Common misconceptions
| Misread | Reality |
|---|---|
“/dev/sda means SCSI hardware” |
Linux reuses the sd driver for SATA, SAS, USB, and many SAN LUNs. |
| “NVMe is a separate disk type from SSD” | NVMe is a storage protocol; the media is still SSD-class flash. Local SSDs often use NVMe over PCIe. |
“ROTA=0 always means local SSD” |
VMs, RAID, and thin-provisioned LUNs can report non-rotational without local flash. |
| “SATA and SAS are interchangeable” | No. Many SAS controllers can also support SATA drives, but SATA-only controllers generally cannot use SAS drives. |
“Optical sr0 is an HDD” |
ROM type in lsblk marks optical drives, not fixed magnetic disks. |
References
- lsblk(8) — Linux man page —
ROTA,TRAN, and device topology columns - Linux kernel block device documentation
- NVMe specification — NVM Express
- Serial ATA technology — Serial ATA International Organization
- SCSI primary commands — INCITS T10
Summary
Disk type in everyday admin language means the storage media—spinning HDD, flash SSD, or optical disc—not the cable or PCI slot. Interface type means how that media attaches: SATA and SAS for cabled drives, NVMe over PCIe for most local flash SSDs, Fibre Channel or iSCSI for SAN block devices, USB for external enclosures. Linux adds a third layer: block device names (sdX, nvme0n1, sr0) that reflect kernel drivers and virtualization as much as physical labels.
The practical split is media versus transport versus presentation. SATA SSDs and SATA HDDs share a transport but behave differently under ROTA. Local NVMe SSDs use the NVMe protocol—usually over PCIe—and a different naming scheme from sdX devices. SAN and hypervisor disks may hide the underlying media until you inspect the array or cloud console.
When you move from vocabulary to a live host, open check disk type in Linux and read ROTA, TRAN, and MODEL together—no single column tells the whole story on its own.
