Plan 9

No soy responsable del uso que usted haga de la información contenida o vinculada desde estas páginas web.

Plan 9 de los Laboratorios Bell es un sistema de investigación desarrollado en los laboratorios Bell a finales de 1980s. Sus diseñadores originales son Ken Thompson, Rob Pike, Dave Presotto y Phil Winterbottom.

Introducción

El sistema puede parecer tentador a los usuarios de unix, pero extraño al mismo tiempo.

Plan 9 es un kernel de sistema operativo, pero también una colección de software que lo acompaña. La mayoría del software es predominantemente new, escrito para Plan 9 en vez de importar de Unix u otros sistemas. El sistema de ventanas, compiladores, servidor de archivos y servicios de red fueron escritos para Plan 9. Aunque programas clásicos de Unix, como dc, ed incluso troff han sido incluidos, pero actualizados, por ejemplo para manejar UTF-8 como hace el resto del sistema.

Plan 9 es un sistema distribuido capaz de usar diferentes tipos de recursos y servidores distribuidos a través de casi cualquier red. requiere pocos recursos comparado a la mayoría de los sistemas.

Todos los recursos en Plan 9 son presentados como archivos (en oposición a Unix, donde casi todo son archivos, pero no todos los archivos son “verdaderos archivos”)) y el sistema utiliza un método común para acceder a todos los recursos. (9P Styx).

Instalación

  • Inicia desde el CD-ROM
  • Selecciona 1. Install Plan 9 from this CD
  • Selecciona [yes] cuando el instalador pregunte por DMA. solo si tienes problemas durante la instalación, deberías seleccionar ‘no’
  • Enseguida el instalador pregunta por el puerto del mouse, si tienes un mouse USB ignora la pregunta. No podrás usar el mouse durante la instalación, pero no hay problema.
  • El instalador pregunta por la resolución de la tarjeta VGA. El default esta bien para la instalación, puedes cambiar esto una vez que el sistema esté instalado.
  • Instalación gráfica.
  • Selecciona el sistema de archivos, configfs (fossil) o venti. Fosil esta bien.
  • Selecciona el dispositivo de disco donde instalar Plan9. Plan 9 …blah blah sdC0
  • selecciona 'y’ para instalar mbr
  • Enseguida se ejecuta fdisk, este automáticamente crea (pero no escribe) una partición para Plan 9, si encuentra espacio libre suficiente. Escribe 'w’ para escribir la tabla de particiones y 'q’ para salir de fdisk
  • Enseguida subdivide la partición recién creada en p9fat, fossil y swap. p9fat debe ser la primera partición del disco para que Plan 9 pueda iniciar. El programa prep sugiere una distribución de las sub-particiones. Igual que en fdisk usa 'w’ y 'q’ para aceptar el default.
  • Formato del sistema de archivos fossil.
  • En mountfs, monta la partición fossil que acabas de formatear.
  • configdist, pregunta por la localización del archivo de la distribución; como estas instalando desde el CD, selecciona 'local
  • mountdist explora los dispositivos y te da una lista de los dispositivos donde encuentra el archivo de la distribución. Selecciona 'sdD0/data (iso9660 cdrom)
  • Enseguida el instalador pregunta cual directorio contiene los archivos de la distribución, instalando desde CD-ROM la raíz de este es el indicado.
  • Una vez que el archivo de la distribución es localizado, inicia la tarea copydist.
  • bootsetup configura el disco duro para iniciar Plan 9, cuando te pregunte; especifica 'plan9’ para hacer la partición del disco de plan 9 la default y selecciona 'Plan 9 master boot record
  • La instalación ha terminado, re-inicia la PC y saca el CD-ROM para que Plan 9 inicie desde el disco duro. Cuando el bootloader pida el usuario, usa 'glenda

Virtualización de Plan 9

Qemu

Ejecutar qemu como root o con privilegios elevados (sudo).

qemu-img create -f qcow2 plan9.img 2G
qemu -hda plan9.img -cdrom plan9.iso -boot d
qemu -m 256 -vnc :1 -net nic -net tap,ifname=tap0,script=no plan9.img

VirtualBox

  • VirtualBox 5.0.8
  • 512 MB RAM, 8 GB Disco Duro
  • SoundBlaster 16
  • Intel PRO/1000 MT Server Bridged

Gráficos

Lista los modos vesa soportados y configura a 1024x768x24.

aux/vga -m vesa -p
aux/vga -m vesa -l 1024x768x24

Inicia sesión como 'adm

cp /adm/timezone/Mexico_General /adm/timezone/local

Configuración de Red

Configuración de la red

⚠ Estos 3 pasos son temporales y se pierden si el sistema reinicia, para hacerlos permanentes; agregalos en el archivo /rc/bin/termrc

ip/ipconfig -g 192.94.73.1 ether /net/ether0 YOUR_IP 255.255.255.0
echo 'key proto=p9sk1 dom=plan9 user=glenda !password=YOUR_PASSWORD' >/mnt/factotum/ctl
aux/listen1 -t tcp!*!ncpu /bin/cpu -R &

Configuración DNS

echo 'ip=<YOUR_IP> sys=<YOUR_SYSNAME> dom=<YOUR_FQDN> dns=<DNS_IP>' >> /lib/ndb/local

ndb/cs es un servidor utilizado por para traducir nombres de red. Se inicia junto con el sistema.

ndb/dns le sirve a ndb/cs y sistemas remotos traduciendo nombres de dominio de Internet. La opción -r indica que actúa solo como resolver: envía consultas recursivas pidiendo a otros servidores completar la búsqueda.

ndb/cs
ndb/dns -r
mkdir /cfg/<sysname>
dircp /cfg/example /cfg/<sysname>
chmod 750 /cfg/<sysname>/*rc
ip/ipconfig -g <YOUR_GATEWAY> ether /net/ether0 <YOUR_IP> <YOUR_NETMASK>
ndb/cs
ndb/dns -r

echo 'key proto=p9sk1 dom=valhala user=ecelis !password=<SOMEPASSWD>' > /mnt/factotum/ctl
echo 'key proto=pass server=mx.sdf.org service=imap user=ecelis !password=<SOMEPASSWD>' >> /mnt/factotum/ctl
aux/listen1 -t tcp!*!ncpu /bin/cpu -R &

echo 'hwaccel off' > /dev/vgactl

Configuración IP

database=
	file=/lib/ndb/local
	file=/lib/ndb/common

auth=sources.cs.bell-labs.com authdom=outside.plan9.bell-labs.com

ip=127.0.0.1 sys=localhost dom=localhost
ip=<YOUR_IP> sys=<YOUR_SYSNAME> dom=<YOUR_FQDN> dns=<DNS_IP>

Agregar nuevo usuario

Firmado como glenda ejecuta los comandos siguientes para crear un usuario del sistema.

con -l /srv/fscons
uname <usuario> <usuario>
uname sys +<usuario>

Para salir de fscons presiona CTRL+** y escribe q en el indicador >>>

La primera vez que el usuario accede al sistema, ejecuta el siguiente comando para poblar su directorio.

/sys/lib/newuser

Crear mailbox

upas/nedmail -c

Copiar directorio de glenda

dircp /usr/glenda /usr/newuser

Hacer usuario administrador

con -l /srv/fscons
prompt: uname sys +<usuario>

IMAPS e-mail

upas/fs -f/<proto>/<mail.server.address>/<username>
upas/fs impas: server certificate 22471E10D5C1E41768048EF5567B27F532F33 not recognized
upas/fs: opening mailbox: bad server certificate
echo 'x509 sha1=22471E10D5C1E41768048EF5567B27F532F33' > /sys/lib/tls/mail

Actualiza Plan 9

-c previene que la actualización modificque cambios locales.


9fs sources
pull -c /rc/bin/termrc

Para instalar contrib

9fs sources
/n/sources/contrib/fgb/root/rc/bin/contrib/install fgb/contrib

Software marcado con fbg's contrib se instala:

contrib/install <user>/<package>

Dependencias básicas

contrib/install fgb/z
contrib/install fgb/bz2
contrib/install fgb/openssl

mercurial y ptyon

contrib/install bichued/python
contrib/install bichued/hg

Utilerias

lsrupd Script para hacer copia de /n/sources, no disponible donde la wiki deice que debe estar.

switch($#*) {
	case 2
		basehier=$1^/;
		basedort=$2^/;
	case *
		echo usage: lsrupd to from >[1=2]
		exit
}

ramfs;


begin=`{date};
echo $begin;
cd $basehier;
lsr -dt > /tmp/lsr;
if(! test -e $basedort^lsr) {
	echo -n creating other lsr ...;
	cd $basedort;
	lsr -dt > /tmp/lsr.dort;
	echo done;
}
if not {
	cp $basedort^lsr /tmp/lsr.dort;
}
comm -3 /tmp/lsr /tmp/lsr.dort | @{
	while() {
		next=`{awk '{print $1; exit;}'};
		if(~ $next './') {
			next=`{awk '{print $1; exit;}'};
		}
		if(~ $next `) {
			exit
		}

		echo -n trying: $next ...;

		hier=$basehier^$next;
		dort=$basedort^$next;

		hasfiles=0;
		isdirectory=0;
		hierexist=0;
		if( test -e $hier) {
			hierexist=1;
			if( test -d $hier) {
				hasfiles=1;
				dirfiles=`{ls $hier};
				if(~ $dirfiles `)
					hasfiles=0;
			}
		}
		dortexist=1;
		if( ! test -e $dort)
			dortexist=0;
		if( ~ $hierexist 1 && ~ $dortexist 0) {
			if(! ~ $hasfiles 1) {
				echo rm $hasfiles : $next;
				rm -rf $hier;
			}
		}
		if not {
			if( ~ $dortexist 1) {
				dortnewer=0;
				if( test $dort -nt $hier) {
					dortnewer=1;
					if(! ~ $hasfiles 1) {
						echo rm $hasfiles : $next;
						rm -rf $hier;
					}
				}
				if( test -d $dort) {
					if( ~ $dortnewer 1 || ~ $hierexist 0) {
						mkdir -p $hier;
						echo mkdir: $next;
					}
				}
				if not {
					if( ~ $dortnewer 1 || ~ $hierexist 0) {
						base=`{basename -d $hier};
						if( ! test -e $base) {
							mkdir -p $base;
							echo mkdir: $next;
						}
						if( ! test -r $dort) {
							echo touch: $next;
							touch $hier;
						}
						if not {
							echo fcp $dortnewer $hierexist : $next;
							fcp -x $dort $hier;
						}
					}
				}
			}
		}
		echo done;
	}
}
echo started: $begin;
echo ended: `{date};

unmount /tmp;

Drawterm

Autenticación

echo 'key proto=p9sk1 dom=plan9me user=glenda !password=secret' >/mnt/factotum/ctl
aux/listen1 -t tcp!*!ncpu /bin/cpu -R &

Conexión remota

drawterm -c 192.168.0.10 -a 192.168.0.10 -u glenda

Misc

Mounting local disk when booted off of file server

mount /srv/kfs /ncpu/kfs

Mounting local disk on a machine not running kfs

disk/kfs -f /diskev/sd00/fs mount /srv/kfs /n/kfs

Mount fileserver when booted off of local disk

srv il!vampira mount -c /srv/il!vampira /n/vampira

Getting access to 9fat partition on a remote machine

cpu -h bela -a netkey ( login as bootes, you will need to use netkey on your host to complete the challenge response) bind -b ‘#S’ /dev rm /srv/dos dossrv modificqueunt -c /srv/dos /n/9fat /dev/sd00/9fat

Getting access to floppy on a remote machine

cpu -h bela -a netkey ( login as bootes, you will need to use netkey on YOUR_FQDNur host to complete the challenge response) bind -b ‘#f’ /dev rm /srv/dos dossrv a:

Getting access to local floppy on a remote machine

  cpu -h bela 
  a:

  Clear a hung up channel

  assuming il!vampira is hung   up, to fix:

  rm /srv/il!vampira
  srv il!vampira
  mount -c /srv/il!vampiraira /n/vampira

  Mount an iso9660 cdrom

  9660srv
  mount /srv/9660 /n/tappefs /dev/sdD0/data

  Chords in acme/rio

  select w/ 1, use 2 to cut 3 to paste, 2,3 to snarf.
  login from non-acl(home) plan9 machine use netkey

  cpu -a netkey   -h plan9.acl.lanl.gov

  aliases?
  rc does not have aliases, but you can use functions in your
  lib/profile much the same way:

  fn vi { sam $* }

  fn acme { builtin acme -f $font $* }

  setting prompt to sysname

  prompt=($sysnamename%'      ')
          fn $sysname%{ $* }

          Saving your acme config
          rather than seting up acme each time you start it running
          stuff like /acme/mail/Mail can be done automatically if
          you make a dump file. Just setup acme the way you like it,
          then click on the "dump" tag, this makes the file
          acme.dump copy this file to another location like
          acmemail.dump. Now starting acme like:

          acme -l acmemail.dumpump

          will load your configuration.
          starting a second (independent) acme
          Starting 2 copies of acme will cause new acme "windows" to
          appear in both copies of acme. If this in not what you
          want just run a new copy of the plumber first, e.g.

          plumber
          acme

          login from non-plan9 makeachine

          drawterm -a plan9 -c plan9 -n

          adding your own personal "faces"

          mkdir $home/lib/face
          mkdir $home/lib/face/48x48x1
          cp /lib/face/48x48x1x48x1/.dict $home/lib/face/48x48x1/

          modify $home/lib/face/48x48x1/.dict, and add a line to
          your $home/lib/profile like:

          bind -b $home/lib/face/48x48x1 /lib/facee/48x48x1

          Replying to selected text in acme mail

          Note: in the 4th Ed. the "Q" command in acme replaces this
          functionality

          Sometimes it is nice to reply to just a selected part of a
          message rather than using acme's Include: feature. To do
          this I use a small script call ireply:

          #!/bin/rc
          awk '{ print "> " $0}'

          then to reply so some selected text:

          1) select text to include in reply w/ button 1

          2) type "|ireply" in message tag and run w/ button 2

          3) run "reply" in message tag w/ button 2

          4) use the button 1,3 chord to paste text into reply

          5) remove Include: line from message and type your reply.
          Script to start inferno

          #!/bin/rc

          bind -ca $home /usr/inferno/$home
          EMU='-g900x900 -c1'
          emu /dis/wm/logon.dis -u $user

          setting up Charon
          Make sure /usr/inferno/$home/charon exists, run charon and
          it will create /usr/inferno/$home/charon/config which you
          can edit to change the default size and enable cookies.
          running Charon without starting wm
          here is the charon script we use:

          #!/bin/rc

          EMU='-g900x900 -c1'
          emu /dis/charon.dis

          NOTE: this script is for an older version of charon. For
          the latest inferno add these changes to
          /appl/charon/charon.b:

          plan9% diff charon.b charon.b.old
          35,38d34
          < include "tk.m";
          <   tk: Tk;
          < include "tkclient.m";
          <   tkclient: Tkclient;
          147,151d142
          <   tk = load Tk Tk->PATH;
          <   tkclient = load Tkclient Tkclient->PATH;
          <   tkclient->init();
          <   if (ctxt == nil)
          <       ctxt = tkclient->makedrawcontext();
          plan9% 

          Making the gateway /net.alt the primary interface for a
          terminal

          interfacemport plan9 /net.alt
          import plan9 /net.alt /netor bind /net.alt /netkey

          Importing alternate network devices into inferno
          before starting inferno import the the networks needed
          e.g.

          import plan9 /net.alt
          import plan9 /net.alt /net
              
          Once inside inferno make sure /net.alt exists and then:

          bind /net /netet.alt

          Applications such as charon will now have access to the
          external network inferface on plan9.
          Tips for remote terminals
          To import your homedir:

                  import -C plan9.acl.lanl.gov /usr

                  (-C is so it will use the cfs cache filesystem) To
                  get access to machines behind the gateway:

                          import plan9.acl.lanl.gov /net

                          Run faces:

                                  fn rfaces { import
                                  plan9.acl.lanl.gov /net; cpu -h
                                  bela -c faces -i }

                                  To run acmemail we use the
                                  function:

                                          fn racmemail { import
                                          plan9.acl.lanl.gov /net;
                                          cpu -h bela -c acmemail }

                                          which calls the function:

                                                  fn acmemail {
                                                  import plan9
                                                  /net.alt; acme -f
                                                  $font -l
                                                  acmemail.dump }

                                                  set default
                                                  username on
                                                  terminal

                                                  user=<username;>

                                                  in plan9.ini
                                                  cut/paste between
                                                  sam and rio
                                                  Sam uses it own
                                                  cut/paste buffer
                                                  but you can
                                                  exchange it with
                                                  rio's by using the
                                                  <rio;> option in
                                                  the button 2 menu
                                                  of sam, thereby
                                                  enabling cut/paste
                                                  between rio and
                                                  sam.
                                                  Using CVS
                                                  pick a window and
                                                  connect it to the
                                                  external net:

                                                  import plan9
                                                  /net.alt
                                                  import plan9
                                                  /net.alt /net

                                                  add these to your
                                                  lib/profile:

                                                  CVSROOT=:pserver:ddd@cvs.acl.lanl.gov:/n/father/p0/plan9/repository
                                                  CVSEDITOR=sam

                                                  Now you can use
                                                  CVS:

                                                  cvs login
                                                  cvs checkout mp

                                                  Using Dump

                                                  9fs dump
                                                  cd /n/dump/

                                                  Using vncs
                                                  The 4th Ed. has a
                                                  vnc server. To use
                                                  this to connect to
                                                  plan9 from a unix
                                                  machine, you must
                                                  first start the
                                                  server on plan9:

                                                  bind /net.alt /net
                                                  vncs

                                                  vncs will return a
                                                  connection number,
                                                  for this example
                                                  we will assume
                                                  that is :X

                                                  Note: because you
                                                  need to bind
                                                  /net.alt on to
                                                  /net to have vncs
                                                  talk to the
                                                  external network
                                                  you will need
                                                  access to a plan9
                                                  machine or
                                                  drawterm.

                                                  on unix:

                                                  vncviewer
                                                  plan9.acl.lanl.gov:govX

                                                  where is X is the
                                                  connection number
                                                  you got from vncs.

                                                  at this point you
                                                  will have a plan9
                                                  console, now issue
                                                  the commands:

                                                  bind '#l0' /net
                                                  bind '#I0' /net
                                                  ndb/cs
                                                  rio

                                                  at which point you
                                                  should have a
                                                  functional plan9
                                                  desktop.
                                                  setup secstore
                                                  on auth server:

                                                  auth/secstored
                                                  mkdir
                                                  /adm/servercstore
                                                  mkdir
                                                  /adm/secstore/store
                                                  mkdir
                                                  /adm/secstore/who
                                                  auth/secuser dpx

                                                  on terminal:

                                                  touch
                                                  /tmp/factotum
                                                  auth/secstore -p
                                                  /tmp/factotum
                                                    ramfs -p; cd
                                                    /tmp
                                                    auth/secstore -g
                                                    factotum
                                                    secstore
                                                    password:
                                                          echo 'key
                                                          proto=apop
                                                          dom=x.com
                                                          user=dpx
                                                          !password=y~1'
                                                          >> factotum
                                                          automaticallyth/secstore
                                                          -p
                                                          factotum
                                                          secstore
                                                          password:
                                                          cat
                                                          factotum >
                                                          /mnt/factotum/ctl

                                                          and delete
                                                          the
                                                          window.
                                                          Rebuilding
                                                          9load

                                                          cd
                                                          /sys/src/boot/pc
                                                              mk
                                                              9fat:
                                                              cp
                                                              9load
                                                              /n/9fat/

                                                              Generate
                                                              ssh
                                                              keys

                                                                      disk/kfscmd
                                                                      alternatelow
                                                                              aux/ssh_genkey
                                                                                      chgrp
                                                                                      -u
                                                                                      bootes
                                                                                      /sys/lib/ssh/hostkey*
                                                                                              disk/kfscmd
                                                                                              disallow
                                                                                                      disk/kfscmd
                                                                                                      sync

                                                                                                      display
                                                                                                      machine
                                                                                                      load

                                                                                                      awk
                                                                                                      '{print
                                                                                                      $1,$8/10000.0}'
                                                                                                      /dev/sysstat

                                                                                                      display
                                                                                                      machine
                                                                                                      total
                                                                                                      memory

                                                                                                      awk
                                                                                                      -F/
                                                                                                      '{print
                                                                                                      $2}'print
                                                                                                      /dev/swap
                                                                                                      |
                                                                                                      awk
                                                                                                      '{print
                                                                                                      $1*4/1024,"MB"}'

                                                                                                      display
                                                                                                      machine
                                                                                                      used
                                                                                                      memory

                                                                                                      awk
                                                                                                      -F/
                                                                                                      '{print
                                                                                                      $1}'
                                                                                                      /dev/swap
                                                                                                      |
                                                                                                      awk
                                                                                                      '{print
                                                                                                      $1*4/1024,"MB"}'

                                                                                                      display
                                                                                                      machine
                                                                                                      printercent
                                                                                                      used
                                                                                                      memory

                                                                                                      awk
                                                                                                      -F/
                                                                                                      '{print
                                                                                                      100*$1/$2}'
                                                                                                      /dev/swap

                                                                                                      starting
                                                                                                      a
                                                                                                      program
                                                                                                      in
                                                                                                      the
                                                                                                      background

                                                                                                      <program;>
                                                                                                      &

                                                                                                      for
                                                                                                      example:
                                                                                                      charon
                                                                                                      &
                                                                                                      find
                                                                                                      outsidet
                                                                                                      what
                                                                                                      procs
                                                                                                      are
                                                                                                      accessing
                                                                                                      a
                                                                                                      file
                                                                                                      (like
                                                                                                      fuser
                                                                                                      on
                                                                                                      unix)

                                                                                                      grep
                                                                                                      filename
                                                                                                      /proc/*/fd

                                                                                                      convert
                                                                                                      txt
                                                                                                      to
                                                                                                      ps

                                                                                                      lp
                                                                                                      -dstdout
                                                                                                      file.txt
                                                                                                      >file.ps

                                                                                                      convert
                                                                                                      html
                                                                                                      to
                                                                                                      ps

                                                                                                      htmlfmt
                                                                                                      file.html
                                                                                                      |
                                                                                                      lp
                                                                                                      -dstdout
                                                                                                      >file.ps

                                                                                                      changing
                                                                                                      authdom

                                                                                                        FIX...

Referencias