Concept
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.
An array is a set of disks presented as one. Its members are disks, or, in the nested levels, smaller arrays; here the members are disks. The operating system does not see the members. It sees one block device, and it addresses it the way it addresses any disk: by sector number, the logical block address (LBA), counting from 0 to the last sector. Each member disk has its own sector numbers, also counting from 0. So on every read and every write something has to translate the array's sector number into a member and a sector on that member: array sector s becomes member m, sector t.
That translation is done by the raid engine, wherever it lives: the firmware of a RAID-on-Chip on a hardware controller, or the operating system's driver in software RAID (md in Linux, Storage Spaces in Windows). The rule it applies is the array's layout, chosen once, by whoever creates the array (with mdadm --level, in the controller's configuration utility, as the resiliency type of a storage space), and fixed from then on. Segmentation is the part of that layout that says where the data goes, and every standard RAID level is built on one of two answers:
Linear: the members joined end to end. The array's address space is the first member's sectors, then the second's, then the third's. The translation is a lookup: the engine keeps the sector where each member's range starts, finds the member m whose range contains s, and subtracts:
m = the member with start(m) ≤ s < start(m + 1)
t = s − start(m)linear, three disks of 100, 200 and 150 sectors
array sector 0 … 99 → disk 0, sector s
array sector 100 … 299 → disk 1, sector s − 100
array sector 300 … 449 → disk 2, sector s − 300
sector 250 → disk 1, sector 150Data written from the start fills disk 0 before disk 1 is touched. Linux md calls this mode linear and describes it as simply catenating the space of each drive into one large virtual drive. It takes disks of any size, and it can grow later by appending one more. What it does not do is make anything faster: one request lands on one disk, so the array reads and writes at the speed of a single disk. Linux does not count it as a RAID level, and neither does this knowledge base: it is the layout of JBOD (Just a Bunch of Disks).
Striped: the members laid side by side. Picture the members as columns, each with its own sectors from 0 downwards. The data is cut into pieces of a fixed size, the chunk (set when the array is created; 512 KiB by default in mdadm), and the chunks are dealt out across the columns: chunk 0 to disk 0, chunk 1 to disk 1, and so on, wrapping back to disk 0 once every member has one. One round of chunks, one per member, is a stripe; the next stripe sits just below it in every column.
The translation is arithmetic. With C the chunk size in sectors and N the number of members, array sector s lands on member m, sector t:
chunk = s div C which chunk s is in
offset = s mod C where inside that chunk
m = chunk mod N the member: chunks go round the members in turn
row = chunk div N the stripe: one full round per row
t = row × C + offsetstriped, three disks, chunk = 4 sectors
┌──────────┬──────────┬──────────┐
│ chunk 0 │ chunk 1 │ chunk 2 │ stripe 0 disk sectors 0 … 3
│ chunk 3 │ chunk 4 │ chunk 5 │ stripe 1 disk sectors 4 … 7
│ chunk 6 │ chunk 7 │ chunk 8 │ stripe 2 disk sectors 8 … 11
└──────────┴──────────┴──────────┘
disk 0 disk 1 disk 2
s = 13, C = 4, N = 3
chunk = 13 div 4 = 3 offset = 13 mod 4 = 1
m = 3 mod 3 = 0 row = 3 div 3 = 1
t = 1 × 4 + 1 = 5 → disk 0, sector 5A request larger than a chunk now spans several members, and they serve it at the same time: a striped array can use all of its members for one request, a linear array uses one disk. This is where the speed of a striped array comes from. The cost is that every disk holds a piece of every file. Lose one disk and every file larger than a chunk has a piece missing: none survives whole. Linux md calls this mode raid0; Windows Storage Spaces calls it a simple space and describes it the same way, data striped across the drives with no resiliency.
Segmentation and Redundancy are two separate things. How the data is split and how it is protected are chosen independently, and a level is named by the pair. Striping alone is not "RAID 0": RAID 5 stripes, RAID 6 stripes, RAID 10 stripes. The RAID levels are characterized by both concepts:
RAID 1 shows the linear case at its simplest: mdadm does not even accept a chunk size for it, because there is nothing to cut. The chunk size is a striping parameter, meaningful for RAID 0, 4, 5, 6 and 10 and no other level.
So the segmentation axis determines two things: the name, when there is no redundancy (RAID 0 and JBOD differ on this axis alone), and how many disks one request can use. It does not determine capacity or fault tolerance: those come from the redundancy axis, with one exception, the flat striped mirror of RAID 10, explained under mirroring.
One practical consequence: striping needs every member to contribute the same amount of space, because every stripe takes one chunk from each. Linux raid0 copes with unequal disks by splitting the array into zones: the stripe runs across all disks until the smallest is full, then continues across the larger ones only. Linear never needs equal members, so it has no such problem; it has none of the speed either.
Linux md is quoted throughout these pages, and not only here, because its source is public and every rule can be read and checked; hardware controllers and Windows are documented by their vendors without the source. Where they differ, the page says so. See why Linux md is the reference.