linear + no redundancy
Derived by hand from the Linux md rule — how the pages are sourced
Disks joined end to end into one volume: the first fills up, then the next. It uses every byte of disks of any size and can grow by adding a disk, but it is no faster than one disk and has no redundancy: one disk failing takes the whole volume with it.
JBOD is the pair linear + no redundancy: the members are joined end to end (segmentation), and nothing is added to protect them (redundancy). Linux md calls the mode linear: it "simply catenates the available space on each drive to form one large virtual drive". Each member covers one range of addresses of the array, the next member's range starting where the previous one ends. The RAID engine keeps the end address of every member and sends each request to the member whose range contains its address (raid engine). Nothing is cut into chunks and nothing is copied.
It is not a RAID level. The 1988 paper that named RAID defines five levels, all with redundancy, and a plain concatenation adds none. It has a page here because it is the simplest thing an array can be, and the point against which the levels are measured.
md names this as the advantage of linear over RAID 0: the array "is made bigger without disturbing the data that is on the array", and this "can even be done on a live array".md sees one member fail, it marks the array broken and logs "failing array"; Windows says that the entire volume fails and all its data becomes inaccessible.1 The blocks on the surviving disks are not touched, but the array no longer serves them: reaching them is a recovery job outside the array.The layout is right where capacity matters and the data can be lost or rebuilt from elsewhere: joining disks of different sizes into one volume, or extending a full volume onto a new disk without copying it. Two disks is the minimum, because an array of one member is that member.
Linux md calls it linear, Windows a spanned volume, and common speech JBOD (Just a Bunch of Disks), spanning or concatenation.
The same word has a second meaning on hardware controllers. There, JBOD is a state a single drive can be put in: Broadcom's MegaRAID guide says that a drive in the JBOD state "is exposed to the host operating system as a stand-alone drive", and that JBOD drives cannot be used "to create a RAID configuration". That JBOD is no array at all: each disk reaches the operating system on its own, as a separate device.
A third use names hardware, not a layout: vendors also call a disk enclosure, a box of drives attached to a server, a JBOD. Microchip's Adaptec SmartRAID guide lists "JBOD" among the names of an enclosure, and Dell describes its MD3060e as a "dense enclosure or JBOD (just-a-bunch-of-disks)".
This page is about the first meaning, the concatenation.
How an array splits its data across its member disks. Striped cuts the data into fixed-size chunks and deals them out to every member in turn; linear writes it as one run, filling the first member before touching the next. Segmentation is about how many disks take part in one request, not about whether the data survives a failure.
The grid below is the placement of a JBOD / spanned array of 3 disks of 2 TB, as the Linux md rule produces it. Each column is one disk, and each cell is the range of array addresses that disk holds. The ranges are as large as the disks: the first 2 TB of the array are on disk 0, the next 2 TB on disk 1, and so on up to the last disk. There is no chunk and no stripe: the array moves to the next disk only when the previous one is full. On a RAID 0 array of the same disks, each cell would be one chunk, 512 KB by default in mdadm, and the data would change disk after every chunk.
JBOD / spanned · 3 disks
disk 0 disk 1 disk 2
0–2 TB 2–4 TB 4–6 TBHow an array keeps its data readable when a member fails: by storing more than the data itself. Two techniques do it. Mirroring keeps whole copies on separate disks; parity keeps a computed summary from which any one missing block, or two with a second parity, can be rebuilt. Redundancy always costs capacity; the question is how much, and how many failures it covers.
Three quantities follow from the redundancy alone: usable capacity, fault tolerance and write penalty. Below they are worked out for the example array, 3 disks of 2 TB each. Each block states the general rule on its first line, then substitutes the numbers of the example on the lines that follow.
N × disk size
N = 3 disks of 2 TB → 3 × 2 TB = 6 TB usable
the members an adversary must kill, minus one
no redundancy: any one member gone fails the array → 1 → tolerance 0
one logical write costs
concatenation, no copies and no parity → 1 I/O, random or sequentialThe rule that says, stripe by stripe, which member holds the parity and where the data starts, or where a mirror's copies go. The level says what is stored; the algorithm says where. Left-symmetric for the parity levels and near for RAID 10 are the defaults nearly everything uses. The choice changes speed and compatibility, not capacity or safety.
Read more — Placement algorithm
A placement algorithm decides where the parity blocks or the copies go within each stripe. JBOD / spanned has none to choose from: a concatenation places nothing — members are joined end to end.
The component that turns a RAID layout into disk operations. It owns the array's metadata, translates every request from the array's addresses to the members', writes the copies or computes the parity, and keeps serving when a disk fails. It is a role, not a fixed device: a RAID-on-Chip on a controller card, the operating system's own driver, or a boot firmware working with that driver.
In any given system, exactly one component holds the role of RAID engine: a hardware controller with its own processor, a firmware chip that keeps the metadata while the operating system's driver does the work, or the operating system alone. They are alternatives, not layers, so a system has one of them and not the others. The list below names the components that can hold that role for a JBOD / spanned array, and what each of them does with the level.
JBOD / spanned has nothing below its minimum of 2 disks: an array of one member is that member, so two disks is the smallest array of any kind and no RAID level exists on one disk.
Open this example in the sandbox
A desktop link: on a phone or in a narrow window the sandbox is not offered.