Plan 9 (operating system) |
Plan 9 is an operating system descended from Unix and developed by Bell Laboratories. It is not a Unix variant, but is very similar. Plan 9 explored several simplifications to the original Unix model that improved the experience of using and programming the system, notably in distributed multi-user environments. Plan 9 was a Bell Labs internal project for a number of years, but a public release was made in 1993, followed by a shrink-wrapped version in 1995. Bell lost commercial interest in the project in the later 1990s, and released a third version under a non-free license (but with source code available) in 2000, and finally under a new open source license in 2002. This is the 4th, and current, edition of the system.
Rights to a derivative product, Inferno_(operating_system), are held by a United Kingdom company, Vita Nuova. Inferno shares many of the same design concepts as Plan 9, but uses a new application programming language, Limbo programming language, and an accompanying virtual machine, Limbo programming language. Inferno is marketed as an open source embedded operating system.
A readily installable runtime environment exists for x86, but versions of Plan 9 have run on Intel, MIPS architecture, DEC Alpha, SPARC, PowerPC, ARM architecture and other architectures. The system itself is written in a dialect of ISO/ANSI C_programming_language; several applications were previously written in a language called Alef programming language, these have since been rewritten in the same C dialect. It can import POSIX applications and can emulate the Berkeley socket interface. It has complete UTF-8 support, and a windowing system called rio .
The name comes from the Science fiction movie Plan 9 from Outer Space .
=Background=
Prior to the development of Plan 9, much of the ongoing research and development in operating systems had centered around several hot topics; multiprocessing and parallel computing, computer networking, and the idea of subprograms known as threads. Eventually it became clear that all operating systems were attempting to add these features at the same time. Development of these features was somewhat difficult, because if the feature under development were to have a bug, its placement inside the operating system s kernel would cause the entire machine to crash and need to be rebooted.
In the early 1980s a new concept started to develop, that of the microkernel. The idea of a microkernel is to reduce the kernel to the bare minimum functions shared by all operating systems at their core. This includes such duties as arbitrating access to hardware, memory, and time on the Central processing unit. A complete OS would then be created as a selection of programs running on top of the kernel, known as servers , communicating to each other by passing messages. The advantage to this approach was that it modularized the operating system, as well as allowing those messages to be passed among machines to create a single larger computer.
=Design concepts=
Plan 9 s designers were interested in similar goals as the microkernel world, but made rather different architecture and design choices to achieve them. Instead of asking the question what do all operating systems want to do , Plan 9 asked what is Unix really trying to do The answers to these two questions are very different, and in the case of Plan 9 this included:
Unix was the first operating system to attempt to describe the computing environment largely as a file system. However many key concepts simply didn t seem to map onto files at the time, and as new features were added they tended to exist outside the file system concept. By the time Plan 9 started to be developed, these distinctions no longer seemed to be as obvious.
Plan 9 extended the system beyond files to names , that is, a unique path to any object whether it be a file, screen, user, or computer. All were handled using the existing Unix standards, but extended such that any object could be named and addressed, similar in concept to the more widely known Uniform Resource Identifier system of the Internet. In prior versions of Unix, devices such as printers had been represented by names using software converters in /dev, but these were local names only and somewhat artificial. Under Plan 9 these distinctions no longer existed, files were as virtualized as printers, and both could be accessed anywhere.
Another key addition in Plan 9 was the ability for users to have different names for the same real world objects. In effect each user could create their own customized meta-computer by collecting various named objects into their workspace. Unix has a similar concept in which users gain privileges by being copied from another user, but in Plan 9 this can be extended to any object. In fact the user can easily spawn another copy of themselves, modify that copy, and then kill it without affecting any of the original resources.
A particularly interesting feature of Plan 9 was union directories , allowing directories across different media or across a network to be bound to other directories transparently. For example, another computer s /bin directory can be bound to one s own, and then this directory will hold both local binaries and the remote binaries and can use both transparently. Under Unix, mapping directories in this fashion would make the original disappear, one covered the other. Using the same system, under Plan 9 external devices and resources can be bound to /dev, making all devices network devices without additional code.
To illustrate how these features worked together to produce a greater whole, consider the rather interesting /proc directory, in which all running applications were listed. Applications are named objects under Plan 9, like anything else, and therefore it made sense to list them in a directory, like anything else. This simple change has fairly useful side-effects, allowing the user to use tools such as ls to search and sort the process list, which was previously available only to specialized tools. But even more interesting, users could union remote applications into their namespace as well, interacting with them as if they were local, and making network-wide processing almost a triviality.
The result is a distributed computing environment assembled from separate machines – terminals that sit on users desks, file servers that store permanent data, and other servers that provide faster CPUs, user authentication, and Gateway (telecommunications)s, all using the existing hierarchical directory/name system familiar to most computer users. A user could build a system by collecting up directories on fileservers, applications running on servers, printers on the network and then bind them all together into their account running on a terminal.
Plan 9 is based on the best features of UNIX but was developed to demonstrate a concept, that of making communication the central function of the computing system. All system resources are named and accessed as if they were files and multiple views of the distributed system can be defined dynamically for each program running on a particular machine. This approach improves generality and modularity of application design by encouraging servers that hold any information to appear to users and to applications just like collections of ordinary files.
Key to supporting the network transparency of Plan 9 was a new low-level networking protocol known as 9P. Simply put, 9P was a system for connecting one named object to another using a file-like system. 9P can be thought of as a fast byte-oriented (as opposed to block-oriented) version of Network File System, one that can talk to any object and not just an NFS server on the remote machine. The protocol is used to refer to and communicate with processes, programs, and data, including both the user interface and the network. With the release of the 4th edition, it was upgraded and renamed 9P2000.
=License=
The [http://angband.tip9ug.jp/magic/srcgw/n/sources/plan9/sys/src full source code] is freely available, and Plan 9 s license is now considered Open Source by the Open Source Initiative and free software by the FSF.
=See also=
==Standard Plan 9 utilities==
*rc shell - the Plan 9 shell *sam (program) - a text editor *acme (Plan 9) - a user interface for programmers *plumber (Plan 9) - interprocess messaging *Mk (Plan 9) - a tool for building software, analogous to the traditional Unix make utility *namespace_(programming) *rio (program) - the new Plan 9 windowing system *8½ (Plan 9) - the old Plan 9 windowing system *Fossil (file system)/Venti - the new archival file system and permanent data store
==Implementation artifacts==
*9P - a filesystem protocol *Rendezvous (Plan 9) - a basic synchronization mechanism *Brazil (operating system) - what became the Fourth Edition of Plan 9
==Influenced==
*Plan 9 from User Space - a port of many Plan 9 libraries and applications to Unix-like operating systems *Inferno (operating system) - distributed operating system following up Plan 9 *Plan B (operating system) - research operating system based in Plan 9 *9wm - X Window manager that clones the Plan 9 interface *wmii - X Window manager that uses a file system-like interface based on 9P
=External links=
*[http://cm.bell-labs.com/plan9dist/ Plan 9] homepage *[http://plan9.bell-labs.com/wiki/plan9/Overview/ Plan 9 Overview] *[http://plan9.bell-labs.com/wiki/plan9/1/index.html Plan 9 Wiki] *[http://swtch.com/plan9port/ plan9port] A port of the bulk of the Plan 9 software and build environment to Unix systems. *[http://v9fs.sourceforge.net/ v9fs] 9P file system support for Unix/Linux/*BSD *[http://www.tip9ug.jp/magic/srcgw/sys/src srcgw] Browseable full source code *[http://www.fywss.com/plan9/ Steve Kotsopoulos Plan 9 page] *[http://www.eecs.harvard.edu/~rsc/plan9.html Russ Cox Plan 9 page] *[http://www.caldo.demon.co.uk/plan9/ Charles Forsyth s Plan 9 Pages] *[http://www.vitanuova.com/plan9/index.html Vita Nuova Plan 9 page] *[http://www.faqs.org/docs/artu/plan9.html Eric S. Raymond s take on why Plan 9 failed to usurp Unix]|
|