Disk Management

On a system with a master boot record, the first block holds the partition table and a small loader, and the partition marked bootable holds the next stage. The reason for the indirection is that ROM is fixed at manufacture and everything after it can be replaced: a new kernel does not need a new motherboard.

A disk with no bootstrap in its boot block is a perfectly good disk that cannot start the machine. That is why the boot block is written by a separate step and not by the file system.

Bad blocks

Disks develop bad sectors, and there are three ways of living with them. A question asks for the difference between the last two.

Sector sparing defeats disk scheduling, and that is the point worth making. Chapters ninety four to ninety six spent their effort on the order of block numbers; a remapped block is not where its number says it is, so the arm goes where the schedule did not intend. Controllers reduce the damage by keeping spare sectors in every cylinder, so the substitute is at least nearby.

And the honest part: the data in a bad sector is usually lost. Remapping gives you a working block number, not the bytes that were in it, which is why a system with important data has backups rather than confidence.

Swap space management

The next section of the same chapter in MU's textbook, and it finishes the module's memory story.

Where swap space lives

Swap space is optimised for speed, not for space efficiency, which is the sentence to remember. The data in it lives only as long as the process does, so nothing is worth the overhead that protects a file.

How much

The traditional rule of twice physical memory dates from machines whose memory was small; a modern figure depends entirely on what the machine runs. The asymmetry is what matters in an answer: too little is fatal and too much merely wasteful.

Two designs worth naming

The second is better for the reason Chapter eighty gave: most of a program is never touched, so copying it all into swap is work thrown away. Note also that pages of program text need no swap at all, because they can always be read again from the program file, which is Chapter eighty four's clean victim.

What the lab machine has

$ swapon --show | wc -l
0
$ grep -c . /proc/swaps
1
$ grep -E '^Swap' /proc/meminfo
SwapCached:            0 kB
SwapTotal:             0 kB
SwapFree:              0 kB

No swap areas at all: swapon lists none, /proc/swaps has only its header line, and the totals are zero. This is the limitation Chapter eighty one and Chapter ninety one ran into and named. With no swap space there is nowhere to write a page of data, so this machine cannot page anonymous memory out, cannot show a major fault on data, and cannot be made to thrash. It kills a process that asks for too much instead.

What it can still do is everything the earlier measurements used: pages arriving on first touch, faults counted one per page, and copy on write. A missing swap area is a fact about this container, stated here rather than worked around.

Distinctions that carry marks

What it does not mean

Formatting a disk does not erase it securely. Logical formatting writes new structures; the old blocks are still there until something writes over them.

The boot block is not the kernel. It holds the bootstrap that finds the kernel.

A remapped sector does not recover the data. It gives a working block number.

Swap space is not virtual memory. It is the place pages go; Chapter eighty is why they can.

More swap space does not make a machine faster. It stops it failing when memory runs out; the paging is the cost.

Quick revision

• Low level formatting makes sectors of header, data and an error correcting code. The

code fixes soft errors silently; a hard error is a failed read.

• Partitioning divides the block array into ranges; logical formatting writes the file

system's initial structures. Raw disk access skips the file system, and databases use it.

• Boot: ROM bootstrap, then the boot block's full bootstrap, then the kernel from the

boot partition. ROM is fixed, so everything after it can be replaced.

• Bad blocks: marked at format time; sector sparing, which remaps to a spare and

defeats disk scheduling, so spares are kept per cylinder; or sector slipping, which renumbers and keeps sequential order.

• The data in a bad sector is usually lost either way.
• Swap space: a raw partition is faster, a file is more flexible; it is optimised for

speed, not space. Too little is fatal, too much is merely wasteful.

• Better design: nothing copied at start, pages read from the program file, swap used

only for pages that are replaced; program text needs no swap.

• The lab machine has no swap area, which is why it cannot show a major fault on data and

cannot thrash.

Test yourself

1. What are the three parts of a formatted sector, and what is the third for? A header with

the sector number, the data area of usually 512 bytes, and a trailer holding an error correcting code, which detects and often repairs decay.

1. Distinguish a soft error from a hard error. A soft error is repaired by the error

correcting code and never reported; a hard error cannot be repaired and the read fails.

1. What does logical formatting do? It writes a file system's initial structures into a

partition: the free space map and an empty root directory among them.

1. Why do some databases ask for a raw partition? Because they know their own access pattern

and can organise the blocks better than a general purpose file system.

1. Give the boot sequence in four steps. The ROM bootstrap runs; it loads the full bootstrap

program from the boot block; that finds and loads the kernel from the boot partition; the kernel starts.

1. Why is the bootstrap split between ROM and the boot block? ROM cannot be changed after

manufacture, so only a tiny loader lives there and everything replaceable lives on the disk.

1. Distinguish sector sparing from sector slipping. Sparing remaps a bad sector's number to a

spare elsewhere on the disk, which costs a seek and breaks sequential order; slipping renumbers the sectors to move past the bad one and preserves the order, at the cost of copying the data along by one place.

1. Why is sector sparing bad for disk scheduling? Because the schedule assumes block numbers

reflect position, and a remapped block is somewhere else; controllers keep spares in each cylinder to limit the damage.

1. Compare swap space in a raw partition with swap space in a file. The partition is faster,

with no file system structures in the way and large contiguous runs; the file is easier to create, grow and remove.

1. Why is it worse to have too little swap space than too much? Too little means processes

are aborted or the system stops; too much only wastes disk.