TheHackersManual2015RevisedEdition

Building an all-singing, all-dancing media centre PC is great if you want to store and watch your media locally, whilst streaming high-definition content and using advanced features like recording TV with a PVR (personal video recorder) add-on, but if you already store all of your media on another device, such as a NAS drive, and just want a machine that streams that content across your home network, then you don’t need a very powerful machine.

In fact, the Raspberry Pi is an excellent device for doing just that. It’s small and quiet, and though it’s not very powerful it’s got enough oomph to be able to stream media, with a builtin HDMI port making it a great choice for hooking up to a HDTV.

Even better, quite a few of the media distros we’ve mentioned have versions that can be run on Raspberry Pi, most notably OpenELEC. All you need to do is download the current

Gelid Slim Hero is a good air cooling alternative. This is small enough to fit comfortably over the CPU, and most importantly it’s nice and quiet.

If you’re going to be playing media locally, then you’ll want a nice big hard drive to store your media on. We would suggest considering looking at any 2.5-inch SATA internal hard drives as a good choice as they’re fast enough and offer plenty of storage. These are laptop hard drives (2.5-inch) which mean thye can easily fit in to the smaller-sized chassis

– so make sure you check the physical size of the hard drive and your case’s compatibility before you buy.

Media codecs

To play media on your new system you’re going to need all the required codecs. These codecs can encode and decode the digital files for playback, and the codecs that are required will differ depending on the file types that you’re likely to try to play. Unfortunately, by their very nature most codecs are proprietary and use patented technology, with many licences being managed by MPEG-LA, LLC.

MPEG-LA, LLC has a reputation for guarding the patents it holds and acting swiftly if it believes there have been infringements. This has led it to going up against Google, which was pursuing its own WebM project, that was designed to use the VP8 codec in an open and free media format. Though this is just one case, it does highlight that behind the codecs there’s often a lot of politics and arguments.

“Unfortunately, by their nature most codecs are proprietary and use patented technology.”

Many distros give you the option to include proprietary codecs to play MP3 files and your DVDs, either during the distribution installation process or at a later time. However, what happens if you want to avoid proprietary formats?

There are a number of open source alternatives that you can use instead, including OpenH264, Xvid and FLAC. MP3 encoding alternative Lame is also available, though this is on shaky ground due to its reliance on patented technology that it doesn’t pay licences for. Unfortunately when creating your own media PC you may at some point have to weigh up convenience versus ethics when considering what sort of media you want to play. We’re hopeful the situation will get better soon – even the MPEG-LA, LLC and Google were able to come to an agreement over VP8 codec, so there is reason to believe that other codecs could follow suit.

The MiniITX platform is an excellent basis for a mini-media centre.

Shopping list

Total: £292

The more hard drives the better when running a RAID system.

Build your own home server? It’s an interesting proposition – we could say something silly like you could run a low-power server on an old laptop or

other spare old hardware. You could, but it wouldn’t be particularly clever in terms of data security. This is an important point, as you need to ask yourself why you want a home server? Is it just for fun and experimentation, serving up personal media files around your home and over the internet, or backing up and sharing files in your home or office? Perhaps all three and more?

For the first two you might get away with running this on older, spare hardware, but for anything that requires even a sniff of data integrity, a more convincing alternative would be to take the base desktop system (see p86) and beef up the storage section with a full RAID solution of four drives. Perhaps even adding a UPS solution too. Even a modest desktop case should enable you to install four drives, both in

terms of SATA data connections, power from the PSU and physical mounting points. If it falls a little short – in terms of mounting points – you can purchases 5.25-inch to 3.5-inch conversion kits to enable you to bring any spare optical bays into play as well. Let’s face it, who uses optical drives in this day and age?

A slightly more modest approach would be to use two drives in a mirrored RAID 1 configuration, but the thing to take home is if you’re at all considering running a home server to store and back up your files, then you want a reliable configuration that offers redundancy in its data storage, else you’re not much better off than running with no back up at all.

Getting the right drive

As we’ve seen even a modestly priced motherboard is going to offer enough SATA ports to support Linux-based software RAID. But what drives should you buy? The usual three things come into play: price, performance and reliability. Running RAID mitigates the reliability issue to a degree but the BlackBlaze drive report (http://bit.ly/LXFdrives) firmly placed Hitachi Deskstar 7K(1/2/3)000 drives as the most reliable, closely followed by Western Digital Red 3TB (WD30EFRX) drives, and Seagate coming a weak third.

The argument is almost irrelevant as the Hitachi hard drive division was bought by Western Digital, leaving the WD drives on the market with Seagate and Toshiba. In terms of performance most 3.5-inch 7,200rpm drives in this category are similar performers. Prices do fluctuate but generally Seagate are the most competitive, but it’s a close run thing.

While this feature is about putting together the best box for the job, what happens if someone has already done that? HP does manufacture purpose-designed and low-cost homeserver boxes. These are sold under the same HP ProLiant brand as its big, grown-up workstation range. The point being every part of the server box from the door latch to the

It’s a RAID

Redundant Array of Individual Disks or RAID is a fault-tolerant system that enables you to create storage systems that are able to withstand the failure of drives. There are many hardware-based RAID disk controllers out there, but with Linux you can also create RAID arrays in software, using standard storage hardware and for most home applications this is adequate.

If you’ve never had a hard drive fail on you, you’re either very young or very lucky. Drives simply don’t last forever. Typically manufacturers quote a Mean Time Between Failure figure of up to one million hours but this is over the entire population of drives and could mean one is actually failing every hour or an annual failure rate of 1%.

The truth is the real figure could be far higher. The Google paper Failure Trends in a Large Disk

Drive Population (http://bit.ly/LXFdrivefail) points to figures between 2% and 6% depending on the age of the drive. If you’re running five drives – a real possibility – our in-house mathematics PhD-wielding technical editor says there’s up to a 26% chance of one drive failing in a year, taking all of its/your data with it. Unless it’s backed with some data redundancy.

RAID was originally envisioned to add redundancy to arrays of drives. At its most basic RAID 1 mirrors equal numbers of drives. This is rather wasteful in terms of storage – a 50% loss in capacity – but works with just two hard drives and requires minimal resources to process.

RAID 5 is where the party starts, this stripes data across multiple drives alongside a parity bit. If any one drive should fail the entire array can be rebuilt. An additional advantage is that it loses

less space, in fact adding more drives reduces this loss. It requires a minimum of three drives (with a 30% loss in space) and expands up from there, with five drives the loss goes down to a more acceptable 20% of space.

The rebuild process for RAID 5 does take time and if you decide to use larger 1TB+ capacity drives that amount of time can become problematic, as it opens the array to a window of potential failure. This has become such an issue that Dell in 2012 took the step of advising against the use of RAID 5.

Fortunately, RAID 6 has introduced double parity and enables the array to cope with two drives failing, this makes it more attractive for much larger arrays and capacity drives, where the probability of experiencing dual-drive failures becomes more likely.

A dual NIC offers redundancy if a port fails.

motherboard has been specifically designed, built and constructed by the HP server team. The HP ProLiant Microserver is a tiny self-contained server box just 30cm wide and 40cm high and deep, but offers four quick-release hard drive bays. The specification is typically based on a low-end AMD Turion II Neo N54L processor and comes with 4GB of memory. The motherboard, processor and cooler are all preinstalled and come bundled in the price. The model also usually comes with a 250GB hard drive and a £100 cash-back offer, if you hunt around. So for around £185 you get a fourbay (five if you convert the optical bay) server ready to go.

It comes with neat features you simply won’t find anywhere else. Things like a mounting point for the hex-tool inside the lockable door. Quick-release drive bays with easymount trays, plus a slide-out motherboard tray all with custom quick-release data cables. It’s not perfect, there’s just two (hard to access) expansion slots, it’s also only running a single Gigabit LAN port and is limited to just USB 2.0 on its six ports. The sort of acceptable compromises for a home or small-office environment and we’ve been running one for over two years 24/7 without hitch.

We’re all redundant

Linux supports RAID (more on this over the page) through the device mapper layer in the kernel, and is configured using mdadm. To get the package installed use sudo apt-get install mdadm (on a Debian-based distro) and you can create RAIDs relatively simply. Say you have four disk drives (sdb, sdc, sdd and sde) and you’d like to build a RAID 5 array, type the following:

mdadm -C /dev/md0 -n4 /dev/sdb /dev/sdc /dev/sdd /dev/sde -l5 and you can validate it with mdadm -D /dev/md0.

It’s possible to create a filesystem on the RAID device using mke2fs -j /dev/md0 and it can be mounted in the usual way. The last issue to remove is that the new /dev/ md0 device you’ve just created won’t be re-assembled when the system reboots unless you add a line for it to /etc/ mdadm.conf. Get mdadm to add the line for you using: mdadm --examine --scan >> /etc/mdadm.conf

The point of RAID is mitigation against drive failure. The same goes for network ports and power supply. In a home

environment network port failure

is likely the least troublesome. It’s something

we’ve come across more than we’d have expected with both onboard Ethernet ports failing and add-in cards failing. It’s an annoyance and can be awkward to diagnose, as you usually attribute the issue to another part of the network rather than a failed network card.

Running two Ethernet ports is the solution, covered by a host of protocols, such as Link Aggregation, Link Bundling, Port Trunking,NIC Bonding, NIC Teaming, LACP and our favourite IEEE 802.1ax previously IEEE 802.1ac. Certain configurations require a compatible switch but typically loadbalancing, round-robin and active-backup should work over any switch. Configuration is beyond this feature, but a guide for Ubuntu can be found here: http://bit.ly/LXFbonding.

The overview is you’ll need to sudo apt-get install ifenslave-2.6 then sudo stop networking and add the bonding module with sudo modprobe bonding. The complex part is correctly editing the /etc/network/ interfaces file for your installation before restarting the network with sudo start networking. We’ll save the correct editing for another time, but we will point out that contrary to much that is said on the internet Link Aggregation does not increase network speed.

A final point you may like to consider is an uninterruptible power supply. A UPS in a home environment enables enough time for a server to gracefully shutdown, ideally completing any tasks it was running. A home UPS isn’t much more than a lead-acid battery in a box with serial communication to the PC that tells it when the power has gone. It’ll offer that vital five to ten minutes of extra runtime needed to safely shutdown. At about £80 basic units are affordable, but it’s possibly overkill for a home solution. Θ

e will on page 98 creat a Wglorious NAS box with 24TB

of drives set up as a RAID 6 array formatted as ext4. But before we break out the drives, we’ll show

you how to set up an alternative filesystem.

While ext4 is fine for volumes up to 100TB, even principal developer Ted Ts’o admitted that the filesystem is just a stop-gap to address the shortcomings of ext3 while

maintaining backwardscompatibility. Ext4 first appeared in the kernel in 2008; up until then the most exciting filesystem around was ReiserFS. It had some truly next-gen

features, including combined B+ tree structures for file metadata and directory lists (similar to btrfs). However, interest in this filesystem flagged just a touch when its creator, Hans Reiser, was found guilty of murdering his wife. Development of its successor, Reiser4, continues in his absence, but the developers have no immediate plans for kernel inclusion.

However, we now have a new generation of filesystems, providing superior data integrity and extreme scalability. They break a few of the old rules too: traditional ideologies dictate that the RAID layer (be it in the form of a hardware controller or a software manager such as mdadm) should be independent of the filesystem and that the two should be blissfully ignorant of each other. But by integrating them

we can improve error detection and correction

– if only at the cost of traditionalists decrying ‘blatant layering violations’.

The (comparatively) new kids on the block are btrfs (B-tree filesystem: pronounced ‘butter-FS’ or ‘better-FS’), jointly developed by Oracle, Red Hat, Intel, SUSE and many others, and ZFS, developed at Sun Microsystems prior to its acquisition by Oracle. ZFS code was

originally released in 2005 as part of OpenSolaris, but since 2010 this has been disbanded and Oracle’s development of ZFS in Solaris is closed source. Open source development continues as a fork, but since ZFS is licensed under the CDDL, and hence incompatible with the GPL, it’s not possible to incorporate support into the Linux kernel directly. However, support via a third-party

module is still kosher and this is exactly what the ZFS on Linux project (http://zfsonlinux. org) does. This project is largely funded by the Lawrence Livermore National Laboratory, which has sizeable storage

requirements, so ZFS can support file sizes up to 16 exabytes (224 TB) and volumes up to 256 zettabytes (238 TB).

Being an out-of-tree module, ZFS will be sensitive to kernel upgrades. DKMS-type packages will take care of this on Debianbased Linux distros, Fedora, CentOS, and so on, but for other distros you’ll need to rebuild the module every time you update your kernel.

ZFS Adaptive Replacement Cache (ARC, simplified)

Recently used data

LRU data is evicted

Frequently used data

LFU data evicted

MRU data

MFU data

Ghost lists

Ghost hits tracked Recent/frequent balance adjusted accordingly

would mirror the data twice, making for a usable capacity of 1TB. With btrfs, though, RAID 1 means that each block is mirrored once on a different drive, making (in the previous example) for a usable capacity of 1.5TB at the cost of slightly less redundancy. You can also use multiple drives of different

sizes with btrfs RAID 1, but there may be some unusable space (hence less than half of the total storage present is available) depending on the combinatorics.

Additionally btrfs enables you to specify different RAID levels for data and metadata; ZFS features mirroring in much the same manner as RAID 1, but it does not call it that.

Mirroring with both of the filesystems is actually more advanced than traditional RAID, since errors are detected and healed automatically. If a block becomes corrupted (but still readable) on one drive of a conventional RAID 1 mirror and left intact on another, then mdadm has no way of knowing

which drive contains the good data; half of the time the good block will be read, and half of the time you’ll get bad data. Such errors are called silent data errors and are a scourge – after all, it’s much easier to tell when a drive stops responding, which is what RAID mitigates against. ZFS stores SHA-256 hashes of each block and btrfs uses CRC32C checksums of both metadata and data. Both detect and silently repair discrepancies when a dodgy block is read. One can, and should, periodically perform a scrub of one’s nextgeneration volumes. This is an online check (no need to unmount your pools), which runs in the background and does all the detecting and repairing for you.

All this CoW-ing (Copy-on-Writing) around can lead to extreme fragmentation, which would manifest itself through heavy disk thrashing and CPU spikes, but there are safeguards in place to minimise this. ZFS uses a slab allocator with a large 128k block size, while btrfs uses B-trees. In both approaches the idea is the same: to pre-allocate sensible regions of the disk to use for new data. Unlike btrfs, ZFS has no defragmentation capabilities,

In the beginning, data was stored on punch cards or magnetic tape. The concept of a file didn’t exist: data was stored as a single stream. You could point to various addresses in that stream (or fast-forward, using the tape counter to find where you recorded something), but it was all essentially a single amorphous blob. Single-directory, or flat, filesystems emerged in the mid ’80s. These enabled discrete files, but not subdirectories, to exist on a device. Their release coincided with increasing usage of floppy disks, which enabled random access of

data (you can read/write at any region of the disk). Early Mac file managers abstracted a hierarchical directory structure on top of a flat filesystem, but this still required files to be uniquely named.

By the late ’80s filesystems that enabled proper directories were necessary to support growing storage technologies and increasingly complex operating systems. These had in fact been around since the days of IBM PC-DOS 2, but the poster child for this generation is FAT16B, which allowed 8.3 filenames and

drives and then striped across an additional pair of mirrored drives. Each mirrored pair is also a vdev, and together they form our pool.

Let’s assume you’ve got the ZFS module installed and enabled, and you want to set up a zpool striped over several drives. You must ensure there is no RAID information present on the drives, otherwise ZFS will get confused. The recommended course of action is then to find out the ids of those disks. Using the /dev/sdX names will work, but these are

not necessarily persistent, so instead do:

# ls -l /dev/disk/by-id

and then use the relevant ids in the following command, which creates a pool called tank:

#zpool create -m <mountpoint> tank <ids>

If your drives are new (post-2010), then

they probably have 4kB sectors, as opposed to the old style 512 bytes. ZFS can cope with either, but some newer drives emulate the oldstyle behaviour so people can still use them in Windows 95, which confuses ZFS. To force the pool to be optimally arranged on newer drives, add -o ashift=12 to the above command. You also don’t have to specify a mountpoint: in our case, omitting it would just default to /tank. Mirrors are set up using the keyword mirror, so the RAID 10-style pool in the diagram (where we didn’t have room to use disk ids but you really should) could be set up with:

# zpool create -o ashift=12 mirrortank mirror / dev/sda /dev/sdb mirror /dev/sdc /dev/sdd

We can use the keyword raidz1 to set RAID-Z1 up instead, replacing 1 with 2 or 3 if you want double or triple parity. Once created, you can check the status of your pool with:

# zpool status -v tank

You can now add files and folders to your zpool, as you would any other mounted filesystem. But you can also add filesystems (a different, ZFS-specific kind), zvols, snapshots and clones. These four species are collectively referred to as datasets, and ZFS can do a lot with datasets. A filesystem inside a ZFS pool behaves something like a disk partition, but is easier to create and resize (resize in the sense that you limit its maximum size with a quota). You can also set compression on a per-filesystem basis.

Have a CoW, man

Even if you have no redundancy in your next-gen filesystem, it will be significantly more robust than its forbears. This is thanks to a technique called Copy-on-Write (CoW): a new version of a file, instead of overwriting the old one in-place, is written to a different location on the disk. When, and only when, that is done, the file’s metadata is updated to point to the new location, freeing the previously occupied space. This means that if the system crashes or power fails during the write process, instead of a corrupted file, you at

least still have a good copy of the old one Besides increased reliability, CoW allows for a filesystem (or more precisely a subvolume) to be easily snapshotted. Snapshots are a feature, or even the feature, that characterises our nextgeneration filesystems. A snapshot behaves like a byte-for-byte copy of a subvolume at a given time (for now think of a subvolume as a glorified directory – the proper definition is different for btrfs and ZFS), but when it is initially taken, it takes up virtually no space. In the beginning, the

snapshot just refers to the original subvolume. As data on the original subvolume changes, we need to preserve it in our snapshot, but thanks to CoW, the original data is still lying around; the snapshot is just referred to the old data, so the filesystem will not mark those blocks as unused, and old and new can live side by side. This makes it feasible to keep daily snapshots of your whole filesystem, assuming most of its contents don’t change too drastically. It is even possible to replicate snapshots to remote pools via SSH.

be a problem. The on-chip controller natively supports only two SATA drives, but 2-port PCIExpress cards are cheap. Just make sure to get one that supports FIS-based switching (ie nothing based around the ASM1061 chip). If you prefer chipzilla, then the J1900 Celeron is a good and cheap CPU to go for. There are plenty of Mini-ITX motherboards that come with one built in. Like the AM1 boards, some allow power to be supplied by a standard 19V laptop brick.

RAID Alert

You’ll see this warning on any RAID article but we’ll add it into ours anyway: RAID isn’t the same as backing up! RAID is only a first line of defence, and will not protect you from accidental deletions. (And neither fire, electromagnetic pulses nor dark wizards.)

If your data is really important, you must back it up off-site. This tutorial shows you how to set up software RAID and it is worth dispelling some myths on this topic.

Dedicated hardware RAID controllers are available, though at a premium. For the most

part, they are not necessary either – certainly there is a small processing cost associated with calculating parity bits, but on modern hardware this is negligible. Also hardware controllers typically use proprietary disk layouts, so if your controller fails you need to replace it with an identical one in order to get at your disks.

A software RAID array can be accessed by any Linux OS via the mdadm command. Hardware RAID controllers can also be very fussy about SATA drive compatibility, with software RAID if the OS can see the drive, then it can RAID it.

Finally, your motherboard may claim to support various RAID configurations. This is what is known as FakeRAID, or sometimes host RAID. Despite the slightly derogatory name (the onboard controller passes all the RAID calculations to the CPU), this is still a robust setup (though usually it only supports RAID 0, 1 and 10) and will enable you to stripe your boot drive and in some cases even recover your array from the BIOS. Sometimes though, recovery requires you to use Windows software. Sorry, but it’s true.