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. 2. 3. 4. 5. 6. 7. 8. 9. A typical Plan 9 installation A traditional file server Some unusual file servers Namespace Overview of the 9P protocol User interface Programming under Plan9 The Inferno operating system The Limbo programming language

A Typical Plan 9 Installation

Fiber Network File server

CPU server

CPU server Ethernet

Gateway Terminal Terminal Terminal

The File System

Emelie

WORM media

SCSI disks

The Backup Service

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

/n /dump /2001

50 60 70 80 90 100

0416 usr glenda foo

0417 usr glenda foo

0418 usr glenda foo

The File Metaphor

Unix: most things are files
/dev/tty /proc network interfaces X Windows

Plan 9: everything is a file

emelie backup /dev/cons /prog network interfaces window system text editor ftp tar

Console Device: /dev or #c

Keyboard input/output, miscellaneous information /dev/cons is the equivalent of /dev/tty /dev/time: current date
% echo newtime > /tmp/newtime % bind /tmp/newtime /dev/time

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

Environment Device: /env or #e

Environment variables and their values /env/prompt: users prompt
% cd #e % echo newprompt > prompt

Network Protocols over IP: /net or #I

/net/dns: domain name lookup
% echo www.yahoo.co.jp!http > /net/dns

A machine with a Datakit interface can use the TCP interface of another machine
% import harp /net % telnet tcp!www.yahoo.co.jp

Network Protocols over IP: /net or #I

/net contains one directory per protocol
#I

tcp

udp

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

clone

ctl

status

data

local

remote

listen

Running Programs: /prog or #p

/prog is the equivalent of Linux /proc Remote debugging
% import harp /proc % db /prog/0/text /prog/0/mem

A raw ps command
% cat /prog/*/status

Graphics Device: /dev or #d

This device serves an interface to
The graphics system
% cat /dev/draw/new % cd 0 % lc ctl data refresh colormap

The window system (rio)

% 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 Linuxs 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

from_file /bin /n/remote

mount table to_file /$cputype/bin, /rc/bin 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 IP IL URP DK Fiber

9P Transaction
9P client
user process

9P server

mount (tcp!ip_address)

the clients kernel Tsession Tattach 50 Rattach 100 Tclone 50 70 Twalk 70 dev Twalk 70 cons Topen 70 Ropen 120

open (/dev/cons, OREAD)

mount table fid qid 50 100 70 120

file tree 100 110 120

9P Authentication
authorization server 9P client the clients kernel user process
challenge_c

9P server

Tsession () challenge_s, id_s

Rsession () challenge_s, id_s, id_c key_c{challenge_s, id_c, nonce} Ok, id_c can speak to id_s nonce{challenge_s} key_s{challenge_s, id_c, nonce} Tattach ()

Ok, id_c is authenticated

Ok, id_s is Rattach () authenticated nonce{challenge_c}

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 Dont require indications on which library to load Dont 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 declaration x: 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 slices y := x[1;3]; Explicit type cast b := byte 20; str := string 99; Lists, tuples Abstract data types can contain functions A ref keyword to build reference out of values

Limbo: Data Types

Return values can be tuples
foo (i:int): (int, string) { if (good) return (42, nil); else return (0, error code); } (val, err) := foo (x); if (err != nil) process (val); else print (err);

Limbo: Concurrent Programming

Thread
Start spawn function_name Exit by exit Communication by send/receive above channels
channel <-= 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 shouldve 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)