Multics and its impact on current secure operating systems

by Marius Marinescu / 5 November

The plan for Multics was presented to the 1965 Fall Joint Computer Conference in a series of six papers. It was a joint project with M.I.T., General Electric and Bell Labs. Bell Labs dropped out in 1969, and in 1970 GE’s computer business, including Multics, was taken over by Honeywell (now Bull).

MIT’s Multics research began in 1964, led by Professor Fernando J. Corbató at MIT Project MAC, which later became the MIT Laboratory for Computer Science (LCS) and then Computer Science And Artificial Intelligence Laboratory (CSAIL).


Starting in 1969, Multics was provided as a campus-wide information service by the MIT Information Processing Services organization, serving thousands of academic and administrative users.


It was conceived as a general purpose time-sharing utility and was a commercial product for GE, which sold time-sharing services. It became a GE and then a Honeywell product. About 85 sites ran Multics. However, it had a powerful impact in the computer field, due to its many novel and valuable ideas.


Since it was designed to be a utility, such as electricity and telephone services, this dictated a number of Multics’ features, including the modular structure of the hardware (with multiple CPUs and main memory banks, fully interconnected, and with the ability to take individual units out of service for maintenance, or to simply add additional units as demand increased over time), extremely robust security (so that individual users in a facility open to all comers would be protected from each other), etc.


In addition to the modular hardware and robust security, Multics had a number of other major technical features, some commonplace now (and some still not too common – alas!), but major advances when it was first designed, in 1967. They include:


• A single-level store

• Dynamic linking for libraries, etc

• A command processor implemented entirely in user code

A hierarchical file system

• Separate access control lists for each ‘file’


The single-level store architecture of Multics was particularly significant: it discarded the clear distinction between files (called segments in Multics) and process memory. The memory of a process consisted solely of segments that were mapped into its address space. To read or write on them, the process simply used normal instructions; the operating system took care of making sure that all the modifications were saved to secondary storage (disk).


In modern UNIX terminology, it was as if every file were ‘mmap()’ed, however, in Multics there was no concept of process memory, separate from the memory used to hold mapped-in files: all memory in the system was part of some segment, which appeared in the file system; this included the temporary scratch memory of the process, such as its kernel stack, etc.


Multics also implemented virtual memory, which was very new at that time (only a handful of other systems implemented it at that point); but this was not a new idea with Multics.

The segmentation and paging in Multics are often discussed together, but it is important to realize that they were not fundamentally connected. One could theoretically have an SLS system which did not page. Paging was added as well for practical reasons.

Multics also made popular the now-common technique of having separate per-process stacks in the kernel and this was apparently first seen in the Burroughs B5000, but was not well known.


This is an important kernel structuring advance since it greatly simplifies code. If a process discovers, somewhere deep inside a subroutine call stack that it needs to wait for an event, it can simply do so right there, instead of having to unwind its way out, and then return later when the waited-for event has happened.


The entire system was written almost entirely in higher-level language (PL/I) – which was quite rare at the time. The Burroughs B5000 had an OS written in ALGOL, but this was the only previous system to do so.

Multics ran only on special hardware, which provided hardware support for its single-level store architecture.

It initially ran on the GE 645, a modified version of the GE 635. After GE was bought by Honeywell, a number of models of the Honeywell 6000 series systems were produced to run Multics on.


Altough Multics introduced many innovations, it also had many problems, and in the end of 1960s, Bell Labs, frustrated by the slow progress and difficulties, pulled out of the project. Thus a young engineer at AT&T Bell Labs, Kenneth (Ken) Thompson, with the help of his colleagues, Dennis Ritchie, Douglas McIlroy and Joe Ossanna, decided to experiment with some Multics concepts and to redo it on a much smaller scale. Thus in 1969 the idea of now ubiquitous Unix was born.


While Ken Thompson still had access to the Multics environment, he wrote simulations for the new file and paging system on it. Later the group continued his work on blackboards and scribbled notes.

Also in 1969, Thompson developed a very attractive game, Space Travel, first written on Multics, then transliterated into Fortran for GECOS, and finally for a little-used PDP-7 at Bell Labs. The same PDP-7 he then decided to use for the implementation of the first UNIX. On this PDP-7, and using its assembly language, the team of researchers (initially without financial support from Bell Labs) led by Thompson and Ritchie, developed a hierarchical file system, the concepts of computer processes and device files, a command-line interpreter and some small utility programs.


The name Unics was coined in 1970 by the team member Brian Kernighan, who played on Multics name. Unics (Uniplexed information and computing system) could eventually support multiple simultaneous users, and was later shortened to Unix.


Structurally, the file system of PDP-7 Unix was nearly identical to today’s, for example it had:


• An i-list: a linear array of i-nodes each describing a file. An i-node contained less than it does now, but the essential information was the same: the protection mode of the file, its type and size, and the list of physical blocks holding the contents.

• Directories: a special kind of file containing a sequence of names and the associated i-number.

• Special files describing devices. The device specification was not contained explicitly in the i-node, but was instead encoded in the number: specific i-numbers corresponded to specific files.


In 1970, Thompson and Ritchie wanted to use Unix on a much larger machine than the PDP-7, and traded the promise of adding text processing capabilities to Unix to some financial support from Bell, porting the code for a PDP-11/20 machine. Thus for the first time in 1970, the Unix operating system was officially named and ran on the PDP-11/20. It added a text formatting program called roff and a text editor. All three were written in PDP-11/20 assembly language. Bell Labs used this initial „text processing system”, made up of Unix, roff, and the editor, for text processing of patent applications. Roff soon evolved into troff, the first electronic publishing program with a full typesetting capability.


In 1972, Unix was rewritten in the C programming language, contrary to the general notion at the time „that something as complex as an operating system, which must deal with time-critical events, had to be written exclusively in assembly language” (although Unix was not the first OS, written in high-level language, it was Burroughs B5000 from 1961). C language was created by Ritchie as an improved version of B language, created by Thompson as a translation of BCPL from Martin Richards. The migration from assembly language to the higher-level language C resulted in much more portable software, requiring only a relatively small amount of machine-dependent code to be replaced when porting Unix to other computing platforms.


AT&T made Unix available to universities and commercial firms, as well as the United States government, under licenses. The licenses included all source code including the machine-dependent parts of the kernel, which were written in PDP-11 assembly code. Copies of the annotated Unix kernel sources circulated widely in the late 1970s in the form of a much-copied book, which led to considerable use of Unix as an educational example. At some point, ARPA (Advanced Research Projects Agency) adopted Unix as a standard language for the Arpanet (the predecessor of Internet) community.

During the late 1970s and early 1980s, the influence of Unix in academic circles led to large-scale adoption of Unix (particularly of the BSD version, originating from the University of California, Berkeley) by many commercial startups, for example Solaris, HP-UX and AIX. Today, in addition to certified Unix systems such as those already mentioned, Unix-like operating systems such as Linux and BSD descendants (FreeBSD, NetBSD, and OpenBSD) are commonly encountered.