How the original unix kernel adressed memory?

Question

Today pretty much all kernels use virtual memory provided by the MMU. They do that with the global page table, the address of which is located in a CPU register, and a page supervisor/mapper of pages to processes. The "vm" in vmlinuz, for example, means that the linux kernel supports virtual memory.

All that is possible because the MMU maps continuous addresses of memory to the memory segments understood by the x86 architecture.

The original UNIX kernel did have a vmunix version, which, I believe, must have used a similar technique. Yet, the original UNIX kernel was written before MMUs were available. If I'm not mistaken the original UNIX kernel (called simply unix), was written before the existence of the x86 architecture. Historically it did run on the PDP-9 and PDP-11.

How that kernel performed memory addressing and management? Was it a segment based addressing (two numbers) or full memory addressing (a single number)? How it separated memory between processed?

Answer 1

Virtual memory is almost a decade older than Unix: there was one in the Burroughs B5000 in 1961. It didn't have an MMU in the modern sense (i.e. based on pages) but provided the same basic functions. IBM System/360 Model 67 in 1965 (still older than Unix) had an MMU. Intel x86 processors didn't get an MMU until the 80386 in 1986.

Implementing a Unix system doesn't actually require an MMU. It does require some form of virtual memory, otherwise implementing the fork system call is prohibitively difficult. The fork system call, to create processes by copying an existing process, was a fundamental part of Unix ever since the very first version, so it did require virtual memory. See D. M. Ritchie and K. Thompson, The UNIX Time-Sharing System, CACM, 1974, §V “Processes and images”.

I don't know the details of the hardware that the first Unix versions ran on, but they did have virtual memory in the form of a segmented architecture. The CPU translated between pointers dereferenced by a program (virtual addresses) and actual locations in memory (physical addresses). The mapping was performed by adding an offset to the virtual address. On each context switch between processes, the register containing the offset was adjusted.

Although virtually all Unix implementations provide process isolation, this was not the case of some historical implementations on hardware that didn't have memory protection (both in the 1970s, and also in the 1980s with MINIX on 8088 and 80286). Memory protection is somewhat orthogonal to address virtualization; an MMU provides both, a simple segmented architecture doesn't, an MPU¹ provides protection without virtualization. There is a Linux implementation for systems without an MMU, uCLinux, but due to the lack of fork many programs can't run (the only supported of fork is vfork which requires an execve call in the child immediately afterwards).

¹ _{An MPU (memory protection unit) records access rights for each page of memory.}

Answer 2

You don't need a paging MMU to get memory protection.

Paging MMUs solve a lot of more advanced problems, such as fragmentation of memory (unavailability of large blocks) and mmap (keep only recently used parts of a file in memory). And paging MMUs are required for implementing a "unified page cache" to cache file accesses across all processes.

But basic memory protection can be done with simpler "segmentation" alone, which was probably available to early Unix implementations. For example, the protected kernel memory can be placed in a segment that is set to "no access" when user-mode code is executed. Even on the modern paged OS Linux, the system calls brk() and sbrk() exist as compatibility hold-overs from the days of segmented implementations.

Essentially, segmentation is kind of like a paged MMU, except you only get a fixed number of variable-size "pages" (actually called segments), instead of a variable number of fixed-size pages.

Even today, segmentation lives on in low-cost microcontrollers that might have only a few kilobytes of SRAM, making it possible to implement a small OS with protected memory, despite the absence of a real paging MMU.