Plan 9

• Worst movie ever made (by Ed Wood)• An operating system and associated utilities

(by the people who made Unix and C)• Three design principles:

– Resources are represented as file trees– Resources are privately assembled by processes– Resources are accessed by a standard protocol

• Inferno is a light version of Plan 9

Outline

1. A typical Plan 9 installation2. A traditional file server3. Some unusual file servers4. Namespace5. Overview of the 9P protocol6. User interface7. Programming under Plan98. The Inferno operating system9. The Limbo programming language

A Typical Plan 9 Installation

CPU server

Terminal

File serverCPU server

Fiber Network

Ethernet

Terminal

Gateway

Terminal

The File System

WORM media

Emelie

SCSI disks

The Backup Service

/n

0418

usr

glenda

foo

/dump

/2001

5060708090100

0416

usr

foo

glenda

0417

usr

glenda

foo

% grep ‘mouse bug fix’ 2000/*/sys/src/cmd/rio/file.c…% bind /n/dump/2000/0416/sys/include /sys/include…

The File Metaphor

• Unix: most things are files○ 　 /dev/tty × 　 network interfaces

○ 　 /proc × 　 X Windows

• Plan 9: everything is a file○ emelie ○ window system

○ backup ○ text editor

○ /dev/cons ○ ftp

○ /prog ○ tar

○ network interfaces ○ …

Console Device: /dev or #c

• Keyboard input/output, miscellaneous information

• /dev/cons is the equivalent of /dev/tty• /dev/time: current date

• /dev/cputime: process computation time• /dev/pid: process’ id• /dev/user: process’ owner

% echo newtime > /tmp/newtime

% bind /tmp/newtime /dev/time

Environment Device: /env or #e

• Environment variables and their values• /env/prompt: user’s prompt

% cd ‘#e’

% echo newprompt > prompt

• /net/dns: domain name lookup

• A machine with a Datakit interface can use the TCP interface of another machine

Network Protocols over IP: /net or #I

% echo www.yahoo.co.jp!http > /net/dns

% import harp /net

% telnet tcp!www.yahoo.co.jp

Network Protocols over IP: /net or #I

#I

tcp

clone 0

ctl status data

udp

local remote listen

% cd /net/tcp% cat clone% cd 0% echo connect ip_address!port_number > ctl

• /net contains one directory per protocol

Running Programs: /prog or #p

• /prog is the equivalent of Linux /proc• Remote debugging

• A raw ps command

% import harp /proc

% db /prog/0/text /prog/0/mem

% cat /prog/*/status

Graphics Device: /dev or #d

• This device serves an interface to– The graphics system

– The window system (rio)

% cat /dev/draw/new

% cd 0

% lc

ctl data refresh colormap

% echo new –dx 200 –dy 400 –cd /sys/src/cmd sam > /dev/wctl

% lp /dev/wsys/0/window

Serial Communication Control: /dev or #t

• Command a serial port – of a machine running Linux’s Inferno– from another running Windows’ Inferno

% mount tcp!piccolo.is.s.u-tokyo.ac.jp!styx/n/linux

% bind /n/linux/dev/eia0ctl /dev/eia0ctl

% echo b1200 > /dev/eia0ctl

A Per-process Namespace

• User processes construct namespace using– mount– bind– union– unmount

• Most services are conventionally located• Comparison

– Unix: a global mount table for all processes– Plan 9: a mount table per process stored in the kernel

mount tablefrom_file to_file/bin /$cputype/bin, /rc/bin/n/remote tcp!piccolo.is.s.u-tokyo.ac.jp!9p

The 9P Protocol

• The (invisible) glue that holds Plan 9 together• Similar to NFS• Composed of 17 messages

– 3 for authentication– 14 for object manipulation

• 14 pages long description

9P

UDP TCP ILFiber

IP

URP

DK

9P Transaction

Tattach 50

Tclone 50 70Twalk 70 “dev”

Twalk 70 “cons”Topen 70

Rattach 100

mount(“tcp!ip_address”)

mount tablefid

qid50

10070

120

9P client 9P server

Ropen 120

Tsession

open(“/dev/cons”, OREAD)

the client’s kerneluser process

100

110

120

file tree

9P Authenticationthe client’s kernel

9P server

user processauthorization

server

challenge_c

challenge_s,id_s

challenge_s, id_s,id_c

key_c{challenge_s, id_c, nonce}

key_s{challenge_s, id_c, nonce}

nonce{challenge_s}

nonce{challenge_c}

Tattach ()

Rattach ()

Rsession ()

Tsession ()

9P client

Ok, id_c can speak to id_s

Ok, id_c isauthenticated

Ok, id_s isauthenticated

Programming

• New C compilers– 8c for Intel, kc for SPARC, …– ANSI C + goodies (inheritance, …)– Simplified preprocessor (no #if, …)– No nested include files– Smaller library– Slightly difference syntax (nil, void main (…))– Preprocessing, parsing, register allocation, code

generation, assembly

Programming

• A new make: mk– Simplified

• New Linkers– 8l, kl, …– Perform instruction selection, branch folding,

instruction scheduling, executable writing– Don’t require indications on which library to load– Don’t do dynamic linking!

• A new debugger: acid• A new shell: rc

The File Hierarchy• /386/bin: Intel binaries • /386/include: machine dependent• /acme: acme programs • /adm: administrative data• /dev/drivers: device drivers built

into the kernel• /lib: databases • /lib/keyboard: Unicode shortcuts • /lib/ndb: networking data• /mnt: user file servers• /mnt/plumb: plumbing rules• /mnt/acme: acme configuration• /mnt/keys: shortcuts• /n: archives and remote systems• /n/tapefs: archives• /n/ftp: ftpfs• /n/harp: remote system

• /sys/include: machine independent headers

• /sys/src/9/fs: file server • /sys/src/9/port: portable

part of the kernel• /sys/src/9/pc: Intel

specific part of the kernel• /sys/src/9/pc/devxxx.c:

device drivers• /sys/src/libc: libc• /sys/src/libdraw: graphics

library• /sys/src/libio: buffered io• /usr: users

User Interface

• Commands: Unix-like• Text edition: cat, ed, sam, acme• Unicode everywhere• Mouse centric:

– no cursor-addressed programs– 3 buttons unavoidable (chored actions)

• Plumbing– text-based inter application mechanism

Inferno

• A small Plan 9• Can run

– As the native operating system – As a hosted operating system– As a plug-in for Internet Explorer

• A different looking: – wm/wm and prefab window managers– Graphics with Tk

• Mostly open source

Limbo

• User applications run above the DIS virtual machine

• A C-like language that compile to bytecodes and that run– Over the VM (30/40 times slower than C)– JIT compilation (2/3 times slower than C)

Limbo

• Garbage collection:– References counting – A special keyword for cyclic data

structures

• Exceptions• Dynamically loaded modules

– OS interface in sys (written in C)– Tk 4.0 in draw (written in Limbo)

Limbo: Syntax

• Pascal-like type declarationx: int;x := 42;

• C-like assignments• Constants

EOF: con –1;• Enumeration

enum {Red, Blue, … }: con iota;• Strings are not \0 terminated

Limbo: Data Types

• Array slicesy := x[1;3];

• Explicit type castb := byte 20;str := string 99;

• Lists, tuples• Abstract data types can contain functions• A ref keyword to build reference out of

values

Limbo: Concurrent Programming

• Thread– Start spawn function_name– Exit by exit– Communication by send/receive above

channelschannel <-= value;

value =<- channel;

Compatibility Issues

• Compatibility is not an issue (sic)• However:

– vt: provides vt100 terminals emulation– APE: ANSI POSIX Environment (ape/psh: POSIX shell, /bin/cpp: an ANSI C preprocessor, cc: an ANSI C compiler…)

– vnc: to use remote X application– wm/brutus: emulates emacs under Inferno– drawterm: to use CPU and file servers from Unix or

Windows– u9fs: runs on NFS machines and understand 9P– Plan 9 has an implementation of X

Conclusion

• My 2 円 : Small implementations suitable for educational purposes

• Systems Software Research is Irrelevant – Rob Pike

• “I think Plan 9 was a great idea and it should’ve been released under an open-source license when it was first done, eight years ago (…)” – Brian Kernighan

• After all, Unix took 10 years to catch on… (in a world without Windows nor Linux though)