path: root/distrib/notes/sun3/install

dnl	$OpenBSD: install,v 1.20 2002/06/09 05:53:55 todd Exp $
OpenBSDInstallPrelude

There are several ways to install OpenBSD onto a disk. The easiest way
in terms of preliminary setup is to use the OpenBSD miniroot that can
be booted off a tape.

If your MACHINE is hooked up in a network and you can find a server to
arrange for a diskless setup, which is a convenient way to install on a
machine whose disk does not currently hold a usable operating system.
This is difficult to get set up correctly the first time, but easy to
use afterwards.  (see ``Installing using a diskless setup'' below).

It is also possible to install OpenBSD "manually" from a running SunOS
system, using the system tools, as well as gnu tar and gunzip (see
``Installing from SunOS'' below).


Booting from the Installation Media:

Prior to attempting an installation, you should make sure that everything
of value on the target system has been backed up.  While installing OpenBSD
does not necessarily wipe out all the partitions on the hard disk, errors
during the install process can have unforeseen consequences and you will
probably render the system unbootable if you start, but do not complete
the installation.  Have the installation media for the prior installation,
be it a SunOS or OpenBSD tape is good insurance if you want to be able to
"go back" for some reason.

After taking care of all that, bring your system down gracefully using
the shutdown(8) and/or halt(8) commands.  This will get you to the monitor
prompt.


Booting from SCSI tape:

Boot the miniroot by typing the appropriate command at the PROM:

	> b st()
	
The above instructions assume your tape drive is the default tape drive
using SCSI id 4. If your drive uses id 5, modify the boot command
accordingly:

	> b st(,28,)
	
This will cause the kernel contained in the miniroot to be booted.


Installing using a diskless setup:

First, you must setup a diskless client configuration on a server. If
you are using a OpenBSD system as the boot-server, have a look at the
diskless(8) manual page for guidelines on how to proceed with this.
If the server runs another operating system, you'll have to consult
documentation that came with it (on SunOS systems, add_client(8) and
the Sun System/Networks administrators guide constitute a good start;
on Solaris systems, share(1M) is a good starting point as well).

Boot your workstation from the server by entering the appropriate `boot'
command at the monitor prompt. Depending on the ethernet chip in your
machine, this command takes one of the following forms:

	> b le()bsd.rd		# for sun pizza boxes (3/50, 3/60)
	> b ie()bsd.rd		# for other MACHINE

In order to have a MACHINE machine boot diskless by default, you need to
do some nvram wizardry:

	> q 18
	12
then, if your machine is a model 3/50 or 3/60, continue with:
	6c
	65
	00
	00
	00
or, for other MACHINE machines:
	69
	65
	00
	00
	00
and return to the prom prompt with:
	q
	>

The above set of commands has changed the boot path strategy to the
network interface, thus a diskless boot.
To change the strategy in diagnostic mode (when the "Diag/Norm" switch
is set to "Diag"), enter the same set of data after a "q 22" command
instead of "q 18".
Remember that the prom having a limited number of write cycles, you
shouldn't abuse this feature.

Installing using the Tape or netboot procedure:

OpenBSDInstallPart2

	Boot your machine from the installation media as described above.

	It will take a while to load the kernel especially from a
	slow network connection, most likely more than a minute.  If
	some action doesn't eventually happen, or the spinning cursor has
	stopped and nothing further has happened, either your boot medias
	is probably bad, your diskless setup isn't correct or you may have
	a hardware or configuration problem.

OpenBSDBootMsgs

	You will next be asked for your terminal type.  If you are
	installing from a keyboard/monitor console, the default of
	"sun" if correct.  If you are installing from a serial console
	you should choose the terminal type from amongst those listed.
	(If your terminal type is xterm, just use vt100).

OpenBSDInstallPart3

OpenBSDInstallPart4

OpenBSDInstallPart5(sd0)

OpenBSDInstallNet({:-CD-ROM, NFS, -:})

OpenBSDFTPInstall

OpenBSDHTTPInstall

OpenBSDCDROMInstall

OpenBSDTAPEInstall(3)

OpenBSDNFSInstall

OpenBSDDISKInstall({:-"xdN" or -:},{:-only -:})

OpenBSDCommonFS
		
OpenBSDCommonURL

OpenBSDCongratulations

If you will be running your OpenBSD system from a serial console, you may
need to edit /etc/ttys and change the terminal type, and getty method from
"sun" and "console" to "vt100" and "std.9600" or something similar.

In order to use 'tip' on OpenBSD/MACHINE, you'll need to edit /etc/ttys
and add "local" to the end of the tty configuration line, and run
'ttyflags -a' to put your changes into effect.



Installing from SunOS:

You need a SunOS machine to install OpenBSD.  You also need at
least the following pieces:

  - the *.tgz files you want to install (as a minimum, base{:--:}OSrev.tgz and
    etc{:--:}OSrev.tgz)
  - gunzip (GNU gzip) SunOS binary
  - gtar (GNU tar) SunOS binary
  - a "/boot" file from a SunOS MACHINE machine (not sun3x!)
  - an OpenBSD kernel

All these pieces, except "/boot" and the GNU utilities are supplied in
the OpenBSD/MACHINE distribution.

You need to format and partition the disk using SunOS (since
OpenBSD/MACHINE uses SunOS disk labels.)  Give yourself adequate
partition sizes.  Here is an example layout:

    partition    size   offset	  will be..
    sd0a        80000        0	  /
    sd0b       256000    80000	  swap
    sd0c      4165271        0	  `whole disk'
    sd0d       100000   436000    /var
    sd0f       100000   336000    /tmp
    sd0g      3229271   936000    /usr
    sd0h       400000   536000    /var/tmp

Use SunOS to newfs the partitions which will have filesystems on them.
(OpenBSD's filesystem format is identical to SunOS).

    sunos# newfs /dev/rsd0a
    [... lots of output]

Repeat for any other partition (in this example, /dev/rsd0d, /dev/rsd0f,
/dev/rsd0g, /dev/rsd0h).

NOTE: If you are able to, there is a performance benefit from
newfs'ing using OpenBSD.  If you newfs using the OpenBSD newfs command,
be sure to use the -O flag for your / partition, so that newfs will
use the 4.3BSD filesystem format, rather than the new 4.4BSD filesystem
format.  If you forget, you will not be able to boot -- the SunOS boot
blocks do not understand the extended 4.4BSD filesystem format.

Mount those partitions in a tree formation, under /mnt; ie:

    sunos# df
    Filesystem            kbytes    used   avail capacity  Mounted on
    [...]
    /dev/sd0a              38427       0   38427     0%    /mnt
    /dev/sd0d              48249       0   48249     0%    /mnt/var
    /dev/sd0f              48249       0   48249     0%    /mnt/tmp
    /dev/sd0g            1564024       0 1564024     0%    /mnt/usr
    /dev/sd0h             193536       0  193536     0%    /mnt/var/tmp

Place a standard SunOS "boot" program in /mnt (your new root
partition), and use the SunOS command "installboot" to make it work.
The installboot man page says to do something like this:

    sunos# cp /usr/mdec/ufsboot /mnt/boot
    sunos# sync; sync
    sunos# /usr/mdec/installboot -vlt /mnt/boot /usr/mdec/bootxx /dev/rsd0a

You can now extract the provided "*.tgz files onto your disk.

    sunos# ls -FC
    base{:--:}OSrev.tgz   comp{:--:}OSrev.tgz   game{:--:}OSrev.tgz   misc{:--:}OSrev.tgz
    bsd          etc{:--:}OSrev.tgz    man{:--:}OSrev.tgz
    sunos{:-#-:} gunzip < base{:--:}OSrev.tgz | (cd /mnt; gtar xvpf -)
    [...] for each set

And finally copy the OpenBSD kernel onto your disk.

    sunos# cp bsd /mnt/bsd

The GNU gunzip and gtar programs are not distributed as part of SunOS,
but may be present in your /usr/local/bin.  If not, you will need to
obtain them from a GNU archive and install before proceeding.  The
OpenBSD tar files are in the "new format" that includes directory
information, and the standard SunOS tar will not extract from them
successfully.

After the files have been extracted, setup /mnt/etc/fstab to match
your actual disk layout.  (Minus the "/mnt" component of each path, of
course :-)

Now proceed to reboot the machine and the customize your installation.



Net Boot or Diskless Setup Information:

The setup is similar to SunOS diskless setup, but not identical, because
the Sun setup assumes that the bootblocks load a kernel image, which then
uses NFS to access the exported root partition, while the OpenBSD bootblocks
use internal NFS routines to load the kernel image directly from the
exported root partition.

Please understand that no one gets this right the first try, since
there is a lot of setup and all the host daemons must be running and
configured correctly.  If you have problems, extract the diskless(8)
manpage, find someone who's been through it before and use the host
syslog and tcpdump(8) to get visibility of what's happening (or not).

Your MACHINE expects to be able to download a second stage bootstrap
program via TFTP after having acquired its IP address through RevARP when
instructed to boot "over the net". It will look for a filename
corresponding to the machine's IP address. For example, a MACHINE machine
which has been assigned IP address 130.115.144.11, will make an TFTP
request for `8273900B'.
Normally, this file is a symbolic link to an appropriate second-stage
boot program, which should be located in a place where the TFTP daemon
can find it (remember, many TFTP daemons run in a chroot'ed environment).

You can find the boot program in `/usr/mdec/netboot' in the OpenBSD/MACHINE
distribution.

Here's an example to illustrate this whole mess:

    server# cd /<client-root-dir>/usr/mdec
    server# cp boot /tftpboot/boot.MACHINE.OpenBSD
    server# cd /tftpboot
    server# ln -s boot.MACHINE.OpenBSD 8273900B


After the boot program has been loaded into memory and given control by
the PROM, it starts locating the machine's remote root directory through
the BOOTPARAM protocol. First a BOOTPARAM WHOAMI request is broadcast
on the local net. The answer to this request (if it comes in) contains
the client's name. This name is used in next step, a BOOTPARAM GETFILE
request -- sent to the server that responded to the WHOAMI request --
requesting the name and address of the machine that will serve the client's
root directory, as well as the path of the client's root on that server.

Finally, this information (if it comes in) is used to issue a REMOTE MOUNT
request to the client's root filesystem server, asking for an NFS file
handle corresponding to the root filesystem. If successful, the boot
program starts reading from the remote root filesystem in search of the
kernel which is then read into memory.

You will want export the miniroot{:--:}OSrev.fs filesystem to the client.  You
can dd this filesystem image to some spare partition, mount and export
that partition or use tar to copy the contents to a more convenient spot.

Alternatively you can build a bootable partition from the distribution sets
as follows:

Unpack `base{:--:}OSrev.tgz' and `etc{:--:}OSrev.tgz' on the server in the root directory
for your target machine. If you elect to use a separately NFS-mounted
filesystem for `/usr' with your diskless setup, make sure the "./usr" base
files in base{:--:}OSrev.tgz end up in the correct location. One way to do this is
to temporarily use a loopback mount on the server, re-routing <root>/usr to
your server's exported OpenBSD "/usr" directory. Also put the kernel and
the install/upgrade scripts into the root directory.

A few configuration files need to be edited:

	<root>/etc/hosts
		Add the IP addresses of both server and client.

	<root>/etc/myname
		This files contains the client's hostname; use the same
		name as in <root>/etc/hosts.

	<root>/etc/fstab
		Enter the entries for the remotely mounted filesystems.
		For example:
			server:/export/root/client       /     nfs  rw 0 0
			server:/export/exec/MACHINE.OpenBSD /usr  nfs  rw 0 0

Now you must populate the the `/dev' directory for your client. For
this, you can simply change your working directory to `<root>/dev'
and run the MAKEDEV script: `sh MAKEDEV all' (this might require the edition
of MAKEDEV to change the PATH for it to work properly).