Linux on Obsolete Hardware
Copyright © 2014 – 2017 Finn Thain
People sometimes ask why anyone would care about a Linux port for old
m68k systems. Surely one Linux system works the same as another? And Moore's
law means that everyone should just upgrade, right? Maybe not.
Re-using old hardware prevents waste. You don't need 100x more compute
capacity until you have 100x more work to do.
Re-using old code is important because old designs continually reappear
in new systems — albeit in systems that are smaller, faster and more
highly integrated. Some problems only need to be solved once.
The m68k architecture has a very long tail of production systems.
Coldfire devices are still in production and 680x0 cores continue to
execute in new re-programmable hardware.
If you stop people installing their own software on systems they
supposedly own then you are part of the problem, and whatever whining and
marketing you do you share responsibility with the powers who abuse what
— Alan Cox
[The Nexus 1] broke the promise of open source, making it impossible for
users to put a new kernel onto their devices.
— Jonathan Corbet
Keeping legacy systems secure is a sizeable problem — witness the
growing Internet of Things, or the sheer volume of mobile device
By sharing the maintenance burden, open source software tends to protect
an end-user's hardware investment by filling the void left by the OEM who
abandons its "obsolete" designs in order to push new ones.
The incomplete Linux port to the 68k Apple Mac is like the missing Linux
port to the Apple iPhone, iPad or iPod: they are consequences of a business
model which deliberately restricts technical collaboration. This model
tends to either generate waste hardware or keep devices in service after
hidden flaws have developed into security vulnerabilities.
If a Linux port can mitigate these problems, then old proprietary
hardware should be the ideal test case.
The purpose of computing is insight not just numbers
— R.W. Hamming, Bell Labs 1955
Historically, different computer architectures have made different design
trade-offs. To evaluate those compromises, one needs to execute a
realistic workload on a variety of architectures. A modern code-base like a
Linux distribution offers such a workload.
An interesting experiment is to run a typical UNIX workload on stock
UNIX hardware, but with a modern Linux kernel in place of the stock UNIX
If and when a machine designed and built to run UNIX is no longer capable of
running Linux then it follows that UNIX has finally failed as a design or
Linux is no longer equivalent to UNIX (or both). Those outcomes may hold
Similarly, by keeping the architecture constant whilst varying the workload,
one can evaluate diverse software algorithms and their time/space trade-offs.
By comparing the series of Linux kernel releases for a given architecture
spanning two decades, one can measure the effects of changes that Linux
itself has undergone. Only a few architectures (alpha, x86 and m68k)
can be used in such an experiment.
Porting code to a wide variety of architectures means dealing with
corner cases by increasing generality. This tends to make source code more
robust and more easily re-usable regardless of the number of systems deployed.
Porting to old resource-constrained machines helps to identify and resolve
bloat. This in turn helps ports to more modern architectures: both small
embedded systems and large high performance clusters.
Re-use fosters further re-use. Open Source Software benefits from
unforeseen synergies between different groups of end users: between users of
very small and of very large systems and between different projects having
different purposes, and so on.
For example, porting an open source operating system to a particular
architecture helps the developers of an emulator for that architecture.
That open source emulator in turn helps those attempting to preserve
the actual hardware.
The enthusiasts who develop emulators and operating systems and restore
vintage hardware do so to mutual advantage, and this work also assists
that of archivists, curators and librarians whose job it is to preserve
Collections of antique machinery have long been kept and preserved for
posterity. Keeping old computers useful helps to keep them around, and
running modern software helps to keep them useful.
Enthusiasts, like other special interest groups, depend on an inclusive
software development process; one that serves the broader community.
The Open Source process fails everyone when it fails those groups.
Porting an open source software project to an obsolete or commercially
nonviable platform is an ideal litmus test as to whether commercially
sponsored maintainers are able to serve the project's users and contributors
(past and present) and derive the most value from the code base and its license.
Restoring old computers is its own reward, like restoring vintage cars or
antique furniture or historic buildings. If you enjoy nostalgia, or the
satisfaction of repairing something, there's plenty of work to do!