Unix Archive
In this post we will learn the useful skill of writing a device driver for Unix V6 (released in 1975) and run it on an emulator. The implemented device is fairly trivial: it will open a message box on the host OS. Read this article now. Everybody needs to know how to do this.
When I talk about things involving the history of Unix, I often wind up mentioning V7, also known as Seventh Edition of Research Unix from Bell Labs (for a recent example, in my entry on when Unix got stack size limits). If you’re relatively new to the history of Unix, you might wonder why V7 keeps coming up so often. There are a number of reasons that V7 matters so much both for the history of Unix and for what is what we think of as being ‘Unix’ and the Unix way. The history of Unix is… Complicated.
So, I stole the bulk of my old 86sim-based Venix implementation, installed a i386 VM using bhyve on my FreeBSD/amd64 box and write a quick little test program. The test program worked, so in a fit of “why not give this a try” I ported the pcvenix.cc from 86sim to being driven from SIGSEGV in vm86 mode. Hello world quickly worked. I didn’t even know what Venix was before coming across this post, but it turns out it was a lightweight UNIX implementation for a variety of platforms.
The HP-UX Porting and Archive Centre was established in August 1992 in the Department of Computer Science at Liverpool University in the United Kingdom, but has been run by Liverpool-based Connect Internet Solutions Limited since 1995. Its primary aim is to make public domain, freeware and Open Source software more readily available to users of Hewlett-Packard UNIX systems. I’m about to buy a HP-UX workstation for OSNews (become an OSNews Patreon if you want to help!) since I’ve found an amazing deal, so I’ve been diving into the – to me – unknown world of HP-UX. I stumbled upon this software archive, which could prove to be quite useful to other people considering snapping up an old HP-UX workstation.
V7/x86 is a port of the Seventh Edition of the UNIX operating system to the x86 (i386) based PC. UNIX V7 was the last general distribution (around 1979) to come from the Research group at Bell Labs, the original home of UNIX. The port was done mostly around 1999 when “Ancient UNIX” source code licenses first became available, and was revised for release, with some enhancements, during 2006-7. The distribution includes the full UNIX Version 7 operating system, with source code, pre-built binaries, man pages, and original Version 7 documentation. Also included are a custom UNIX-style x86 assembler, an ACK-based C compiler, and several key early UCB software components such as the C shell, the editors ex and vi, and the pager more. I’m inclined to try and run this virtually, to see just how bastardised and messy UNIX has become in our current UNIX derivatives.
xv6 is a re-implementation of Dennis Ritchie’s and Ken Thompson’s Unix Version 6 (v6). xv6 loosely follows the structure and style of v6, but is implemented for a modern RISC-V multiprocessor using ANSI C. Exactly what it says on the tin. It runs on Qemu’s RISC-V target.
Maybe its pervasiveness has long obscured its origins. But Unix, the operating system that in one derivative or another powers nearly all smartphones sold worldwide, was born 50 years ago from the failure of an ambitious project that involved titans like Bell Labs, GE, and MIT. Largely the brainchild of a few programmers at Bell Labs, the unlikely story of Unix begins with a meeting on the top floor of an otherwise unremarkable annex at the sprawling Bell Labs complex in Murray Hill, New Jersey. I acknowledge the importance of UNIX – who doesn’t – but I hate how it has become a huge roadblock to any meaningful rethinking and improvement in lower-level operating system design. The best we can do seems to be to hide the ’60s guts underneath ever more layers, instead of addressing the actual shortcomings of such an old design. But hey, I’ve learned over the years that criticizing UNIX is akin to drowning kittens, so maybe I should just fall in line and parrot the party line – UNIX is great, UNIX is perfect, and UNIX needs zero modernisation because it was instantly perfect.
Commodore built this prototype UNIX workstation/server computer in the same time frame as the Amiga and their PC-Clone and then decided that they only had production capacity for two out of three, and the CBM900 lost. All the approx 300-500 prototypes were recalled for destruction, but due to some kind of “mistake” this particular machine, which was on loan to a favored customer in Denmark, never made it back. The machine resurfaced when this company cleaned up their basement, and sent 3 euro-pallets of Commodore artifacts our way. I never knew Commodore tried to build a UNIX workstation. I shouldn’t be surprised though; virtually everyone dabbled in UNIX workstations in the ’80s. This page has more information about the CBM900.
Killing processes in a Unix-like system can be trickier than expected. Last week I was debugging an odd issue related to job stopping on Semaphore. More specifically, an issue related to the killing of a running process in a job. Here are the highlights of what I learned. Interesting technical dive.
This post is about vintage gaming in vintage unusual operating systems, focused on Xenix/x86. Tried Hampa’s turnkey xenix86 images while they had been tested in fake86, 8086tiny and other emulators. The installation was surprisingly easy, because most software packages in floppy/tape images are basically in .tar format, so let’s check GAMES 360k floppy image’s content on host. I can’t get enough of articles like these.
RetroBSD is a port of 2.11BSD Unix intended for embedded systems with fixed memory mapping. The current target is Microchip PIC32 microcontroller with 128 kbytes of RAM and 512 kbytes of Flash. PIC32 processor has MIPS M4K architecture, executable data memory and flexible RAM partitioning between user and kernel modes.
In what's never going to be a regular occurance, I'm linking to a Twitter thread. Chris Espinosa tweets:
Just as I was wrapping up an email and getting ready to leave work, a co-worker rolled his chair over to show me an "interesting" thing.
Go ahead, read it.
UNIX, man. Not even once.
AT&T has a
YouTube channel, where a few times a week they post old videos from the glory days. A few years ago, they posted a cool video from 1982 called
The UNIX System: Making Computers More Productive. It's worth a watch. There's lots of other gems on the channel. For example, how about an
interview with Arthur C Clarke from 1976?
But today's breakthroughs would be nowhere and would not have been possible without what came before them - a fact we sometimes forget. Mainframes led to personal computers, which gave way to laptops, then tablets and smartphones, and now the Internet of Things. Today much of the interoperability we enjoy between our devices and systems - whether at home, the office or across the globe - owes itself to efforts in the 1980s and 1990s to make an interoperable operating system (OS) that could be used across diverse computing environments - the UNIX operating system.
As part of the standardization efforts undertaken by IEEE, it developed a small set of application programming interfaces (APIs). This effort was known as POSIX, or Portable Operation System Interface. Published in 1988, the POSIX.1 standard was the first attempt outside the work at AT&T and BSD (the UNIX derivative developed at the University of California at Berkeley) to create common APIs for UNIX systems. In parallel, X/Open (an industry consortium consisting at that time of over twenty UNIX suppliers) began developing a set of standards aligned with POSIX that consisted of a superset of the POSIX APIs. The X/Open standard was known as the X/Open Portability Guide and had an emphasis on usability. ISO also got involved in the efforts, by taking the POSIX standard and internationalizing it.
A short look at the history of UNIX standardisation and POSIX.
It has often been told how the Bell Labs law department became the first non-research department to use Unix, displacing a newly acquired stand-alone word-processing system that fell short of the department's hopes because it couldn't number the lines on patent applications, as USPTO required. When Joe Ossanna heard of this, he told them about roff and promised to give it line-numbering capability the next day. They tried it and were hooked. Patent secretaries became remote members of the fellowship of the Unix lab. In due time the law department got its own machine.
Fascinating bit of Unix history.
Programs written to run on conventional operating systems typically depend on OS abstractions like processes, pipes, signals, sockets, and a shared file system. Compiling programs into JavaScript, asm.js, or WebAssembly with tools like Emscripten or GopherJS isn't enough to successfully run many programs client-side, as browsers present a non-traditional runtime environment that lacks OS functionality. Porting these applications to the web currently requires extensive rewriting or paying to host significant portions of code in the cloud.
Browsix is our answer to these challenges.
Neat.
The history and evolution of the Unix operating system is made available as a revision management repository, covering the period from its inception in 1970 as a 2.5 thousand line kernel and 26 commands, to 2016 as a widely-used 27 million line system. The 1.1GB repository contains about half a million commits and more than two thousand merges. The repository employs Git system for its storage and is hosted on GitHub. It has been created by synthesizing with custom software 24 snapshots of systems developed at Bell Labs, the University of California at Berkeley, and the 386BSD team, two legacy repositories, and the modern repository of the open source FreeBSD system. In total, about one thousand individual contributors are identified, the early ones through primary research. The data set can be used for empirical research in software engineering, information systems, and software archaeology.
The project aims to put in the repository as much metadata as possible, allowing the automated analysis of Unix history.
In a sane world, Unix vendors would have either replaced their version of more with the clearly superior less or at least updated their version of more to the 4.3 BSD version. Maybe less wouldn't have replaced more immediately, but certainly over say the next five years, when it kept on being better and most people kept preferring it when they had a choice. This would have been Unix evolving to pick a better alternative. In this world, basically neither happened. Unix fossilized around more; no one was willing to outright replace more and even updating it to the 4.3 BSD version was a slow thing (which of course drove more and more people to less). Eventually the Single Unix Specification came along and standardized more with more features than it originally had but still with a subset of less's features (which had kept growing).
This entire history has led to a series of vaguely absurd outcomes on various modern Unixes.
The latest problem I was working out was how to run Unix on the Atari ST. The Tramiels had somehow wrangled a license for AT&T's SVR-something-or-other version of Unix (might have been SVR3, but this was in the bad old days when AT&T was actively fucking up Unix, and it could have been just about any version, including SVR666). The license was for a mind boggling, nay, jaw-dropping ten bucks a seat. The problem was that the ST didn’t have any kind of memory management hardware, just a raw CPU flinging real addresses at naked DRAM, and the machine's cheap-ass vanilla 68000 was incapable of recovering from a fault unless you cheated.
On a related note, there's MiNT.
The subject of process management, supervision and init(8) for Unix-like systems is one plagued by a large degree of ahistoricity and "pop culture" explanations. This leads to a lot of confusion and misunderstanding surrounding feature sets and how one formulates the problems surrounding reliable process management on Unix in general, making it a ripe topic for demagogues of all persuasions.
The purpose of this article is to set the record straight on the history of attempts to create "modern" init systems, where we define "modern" somewhat broadly as anything that tries to improve the classical BSD and System V styles of initialization and service management.
Guest post by 
Guest post by