Gavare's eXperimental Emulator: Installing and running "guest OSes"

Back to the index

## Installing and running "guest OSes"

- General notes on running "guest OSes"
- NetBSD/pmax
- NetBSD/arc
- NetBSD/hpcmips
- NetBSD/cobalt
- NetBSD/evbmips
- NetBSD/sgimips
- NetBSD/cats
- NetBSD/evbarm
- NetBSD/prep
- OpenBSD/pmax
- OpenBSD/cats
- Ultrix/RISC
- Sprite for DECstation
- Debian GNU/Linux for DECstation
- Redhat Linux for DECstation

In addition to the "working" guest operating systems listed above, you might find the following information interesting:

- Mach/PMAX
- OpenBSD/sgi
- OpenBSD/arc
- Debian GNU/Linux for CATS
- NetBSD/netwinder

### General notes on running "guest OSes":

The emulator works well enough to run complete operating systems. These are often refered to as "guest" operating systems.

Although it is possible to let a guest OS access real hardware, such as harddisks, it is much more flexible and attractive to simulate harddisks using files residing in the host's filesystem. On Unix-like systems, files may contain holes, which makes this really simple. To the guest operating system, the harddisk image looks and acts like a real disk.

### NetBSD/pmax:

To install NetBSD/pmax onto a harddisk image in the emulator, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that NetBSD installs itself onto:

       	dd if=/dev/zero of=nbsd_pmax.img bs=1 count=512 seek=1900000000

From this point, there are two separate ways to continue the installation. You can either download a CD-ROM iso image (and let the installation program copy files from the CD-ROM image to the harddisk image), or you can install via ftp. For an installation from a CD-ROM image, follow these steps:

2. Download a NetBSD CD-ROM iso image:

       	ftp://ftp.netbsd.org/pub/NetBSD/iso/1.6.2/pmaxcd.iso
       	or
       	ftp://ftp.netbsd.org/pub/NetBSD/iso/3.0/pmaxcd-3.0.iso

3. Start the emulator like this:

       	gxemul -e 3max -A -d nbsd_pmax.img -d bc:pmaxcd-3.0.iso
       	(or pmaxcd.iso)

   and proceed like you would do if you were installing NetBSD on a real DECstation. Remember to choose `vt100` as your terminal type, and not `rcons`.

For an ftp install, substitute steps 2 and 3 above with these:

2. Download a NetBSD pmax INSTALL kernel:

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-1.6.2/pmax/binary/kernel/netbsd-INSTALL.gz
       	or
       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-3.0/pmax/binary/kernel/netbsd-INSTALL.gz

3. Start the emulator like this:

       	gxemul -e 3max -A -d nbsd_pmax.img -O netbsd-INSTALL.gz

   and proceed like you would do if you were installing NetBSD on a real DECstation. Remember to choose `vt100` as your terminal type, and not `rcons`. Suitable networking parameters are as follows:

       	Which device shall I use? [le0]: le0
       	..
       	Your DNS domain: mydomain.com
       	Your host name: foo
       	Your IPv4 number: 10.0.0.1
       	IPv4 Netmask [0xff000000]: 0xff000000
       	IPv4 gateway: 10.0.0.254
       	IPv4 name server: 10.0.0.254

   (If using 10.0.0.254 as the nameserver fails, then try entering the IP number of a real-world nameserver instead.)

If you want to use a graphical framebuffer during the install, you can add `-X -Y2` to the command line, and choose `rcons` instead of `vt100` when prompted with which terminal type to use. (By just using `-X`, you will get a full-size framebuffer window.)

When the installation is finished, the following command should start NetBSD from the harddisk image:

    	gxemul -e 3max -d nbsd_pmax.img

NOTE: For some reason, NetBSD 2.x and 3.x do not work with X out-of-the-box on pmax. It seems that this has to do with NetBSD switching console system to "WSCONS" somewhere between 1.6.2 and 2.0. For now, if you want X, then try NetBSD 1.6.2.

With NetBSD/pmax 1.6.2, try the following to start with a framebuffer:

    	gxemul -X -e 3max -d nbsd_pmax.img

and log in as `root` and type `startx` to start X windows.

### NetBSD/arc:

It is possible to install and run NetBSD/arc on an emulated Acer PICA-61 in the emulator.

To install NetBSD/arc from a CDROM image onto an emulated harddisk image, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that NetBSD installs itself onto:

       	dd if=/dev/zero of=nbsd_arc.img bs=1024 count=1 seek=900000

2. Download a NetBSD/arc 1.6.2 CDROM image, and a generic NetBSD/arc kernel:

       	ftp://ftp.netbsd.org/pub/NetBSD/iso/1.6.2/arccd.iso
       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-1.6.2/arc/binary/kernel/netbsd-GENERIC.gz

3. Start the emulator using this command line:

       	gxemul -e pica -x -d nbsd_arc.img -d bc:arccd.iso \
       	  -j arc/binary/kernel/netbsd.RAMDISK.gz

   (Try removing `-x` if you have problems with the xterm.)

4. From now on, you have to use your imagination, as there is no automatic installation program for NetBSD/arc. Here are some tips and hints on how you can proceed with the install:

   ``

       mount /dev/cd0a /mnt2
       disklabel -i -I sd0    (for example 'a', '4.2BSD', '1c',
           '700M', 'b', 'swap', '701M', '$', 'P', 'W', 'y', and 'Q')
       newfs /dev/sd0a
       mount /dev/sd0a /mnt
       cd /mnt
       for a in /mnt2/arc/binary/sets/*.tgz; do echo $a; tar xzpf $a; done
       cd dev; sh MAKEDEV all
       cd ../etc; echo "rc_configured=YES" >> rc.conf
       cat > /mnt/etc/fstab
       /dev/sd0a / ffs rw 1 1
       /dev/sd0b none swap sw 0 0
       (press ctrl-d)
       cd /; umount /mnt; umount /mnt2
       halt

You can now use the generic NetBSD/arc kernel to boot from the harddisk image, using the following command:

    	gxemul -e pica -x -d nbsd_arc.img netbsd-GENERIC.gz

When asked for "`root device:` ", enter `sd0`.

### NetBSD/hpcmips:

It is possible to install NetBSD/hpcmips onto a disk image, on an an emulated MobilePro 770, 780, 800, or 880. The emulator treats the different machine models as being almost identical; the most important difference is regarding the framebuffer.

| Model: |  | Framebuffer size/depth: |  | Framebuffer address:
| MobilePro 770 (<super>*2</super>) |  | 640 x 240, 16 bits |  | 0xa000000
| MobilePro 780 |  | 640 x 240, 16 bits |  | 0xa180100 (<super>*</super>)
| MobilePro 800 |  | 800 x 600, 16 bits |  | 0xa000000
| MobilePro 880 |  | 800 x 600, 16 bits |  | 0xa0ea600 (<super>*</super>)

(<super>*</super>) = not aligned at a 4 KB boundary, so it will not work efficiently with the current bintrans system. Using this mode will still work, but each load and store will be emulated much more slowly than is possible with an aligned framebuffer.

(<super>*2</super>) = The MobilePro 770's cursor keys work differently than the other models, for some reason. (This is a known bug.)

These instructions show an example of how to install NetBSD/hpcmips on an emulated MobilePro 770:

1. Create an empty harddisk image, which will be the root disk that you will install NetBSD/hpcmips onto:

       	dd if=/dev/zero of=nbsd_hpcmips.img bs=1024 count=1 seek=1990000

2. Download the NetBSD/hpcmips 3.0 ISO image, and a generic kernel:

       	ftp://ftp.netbsd.org/pub/NetBSD/iso/3.0/hpcmipscd-3.0.iso

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-3.0/hpcmips/binary/kernel/netbsd-GENERIC.gz

3. Start the installation like this:

       	gxemul -e mobilepro770 -X -A -d nbsd_hpcmips.img  \
       	  -d b:hpcmipscd-3.0.iso -j hpcmips/installation/netbsd.gz

   and proceed like you would do if you were installing NetBSD on a real MobilePro 770. (Install onto wd0, choose "Use entire disk" when doing the MBR partitioning, and choose to install from CD-ROM.)

If everything worked, NetBSD should now be installed on the disk image. Use the following command line to boot the emulated hpcmips machine:

    	gxemul -e mobilepro770 -X -d nbsd_hpcmips.img netbsd-GENERIC.gz

If you change your mind at this point regarding which machine type to emulate, you might for example prefer a MobilePro 800, then you can change that at any time. NetBSD/hpcmips is designed to be able to boot on many types, without any need to change the kernel.

When you have logged in as `root`, you can use `startx` to start X Windows, but there is no mouse support yet so only keyboard input is available. This makes it a bit akward to use X.

### NetBSD/cobalt:

NetBSD/cobalt is tricky to install, because the Cobalt machines were designed for Linux, and not very flexible. There is no INSTALL kernel for NetBSD/cobalt. One way to install the NetBSD/cobalt distribution onto a disk image is to do it from another (emulated) machine.

The following instructions will let you install NetBSD/cobalt onto a disk image, from an emulated DECstation 3MAX machine:

1. Create an empty harddisk image, which will be the disk image that you will install NetBSD/cobalt onto:

       	dd if=/dev/zero of=nbsd_cobalt.img bs=1024 count=1 seek=1999000

2. Download the generic kernel for Cobalt and the 2.1 ISO image:

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-2.1/cobalt/binary/kernel/netbsd-GENERIC.gz
       	ftp://ftp.netbsd.org/pub/NetBSD/iso/2.1/cobaltcd.iso

3. Install NetBSD/pmax 3.0 according to instructions further up on this page.

4. Start NetBSD/pmax like this:

       	gxemul -e3max -A -d nbsd_pmax.img -d cobaltcd.iso -d nbsd_cobalt.img

5. Log in as root (on the emulated 3MAX machine), and execute the following commands: (adjust according to taste)

   ``

       newfs /dev/sd1c
       mount /dev/cd0c /mnt
       mkdir /mnt2; mount /dev/sd1c /mnt2
       cd /mnt2; sh
       for a in /mnt/cobalt/binary/sets/*.tgz; do echo $a; tar zxfp $a; done
       exit
       cd dev; sh ./MAKEDEV all; cd ../etc
       echo rc_configured=YES >> rc.conf
       echo "/dev/wd0d / ffs rw 1 1" > fstab
       cd /; umount /mnt; umount /mnt2; halt

You should now be able to boot NetBSD/cobalt like this:

    	gxemul -M128 -E cobalt -d nbsd_cobalt.img netbsd-GENERIC.gz

Note that the installation instructions above create a filesystem without a disklabel, so there is only one ffs partition and no swap. You will need to enter the following things when booting with the generic kernel:

    	root device (default wd0a): wd0d
    	dump device (default wd0b): none
    	file system (default generic): ffs
    	init path (default /sbin/init):     (just press enter here)

### NetBSD/evbmips:

NetBSD/evbmips can run in GXemul on an emulated Malta evaluation board (with a 5Kc or 4Kc CPU).

It is tricky to install, because there is (as far as I know) no INSTALL kernel. One way to install the NetBSD/evbmips distribution onto a disk image is to install the files using another (emulated) machine.

The following instructions will let you install NetBSD/evbmips onto a disk image, from an emulated DECstation 3MAX machine:

1. Install NetBSD/pmax 3.0 according to instructions further up on this page.

2. Create an empty harddisk image, which will be the disk image that you will install NetBSD onto:

       	dd if=/dev/zero of=nbsd_malta.img bs=1024 count=1 seek=999000

3. Download the generic kernel and the 2.1 ISO image:

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-2.1/evbmips-mipsel/binary/kernel/netbsd-MALTA.gz
       	ftp://ftp.netbsd.org/pub/NetBSD/iso/2.1/evbmips-mipselcd.iso

4. Start NetBSD/pmax like this:

       	gxemul -e 3max -A -d nbsd_pmax.img -d nbsd_malta.img -d evbmips-mipselcd.iso

   and execute the following commands as `root`:

   ``

       newfs /dev/sd1c
       mount /dev/cd0c /mnt
       mkdir /mnt2; mount /dev/sd1c /mnt2
       cd /mnt2; sh
       for a in /mnt/evbmips-mipsel/binary/sets/*.tgz; do echo $a; tar zxfp $a; done
       exit
       cd dev; sh ./MAKEDEV all; cd ../etc
       echo rc_configured=YES >> rc.conf
       echo "/dev/wd0c / ffs rw 1 1" > fstab
       cd /; umount /mnt; umount /mnt2; halt

You should now be able to boot NetBSD/evbmips using this command:

    	gxemul -e malta -d nbsd_malta.img netbsd-MALTA.gz

NOTE: To select a 4Kc (MIPS32) CPU instead of the default 5Kc (MIPS64) CPU, add `-C 4Kc` to the command line. With NetBSD 2.1, however, there will be little or no difference in functionality, as NetBSD still runs in 32-bit mode on 64-bit MIPS CPUs. There are two things that differ:

1. GXemul's binary translation subsystem might run a bit faster in 32-bit mode (because there are some optimizations that don't work with 64-bit emulation)
2. 4Kc only has 16 TLB entries, whereas 5Kc has 48. This makes 4Kc slower.

The installation instructions above create a filesystem without a disklabel, so there is only one ffs partition and no swap. You will need to enter the following things when booting with the generic kernel:

    	root device (default wd0a): wd0c
    	dump device (default wd0b): none
    	file system (default generic): ffs
    	init path (default /sbin/init):     (just press enter here)

### NetBSD/sgimips:

NetBSD/sgimips can run in GXemul on an emulated O2 (SGI-IP32). However, GXemul does not yet emulate the AHC PCI SCSI controller in the O2. (I have mailed Adaptec several times, asking for documentation, but never received any reply.) NetBSD can still run in the emulator, as long as it doesn't use SCSI.

For a simple test with the 2.1 ramdisk (install) kernel, try dowloading

    	ftp://ftp.NetBSD.org/pub/NetBSD/NetBSD-2.1/sgimips/binary/kernel/netbsd-INSTALL32_IP3x.gz

and run `gxemul -e o2 netbsd-INSTALL32_IP3x.gz`.

It is possible to set up an environment for netbooting the emulated SGI machine off of another emulated machine. Performing this setup is quite time consuming, but necessary:

1. First of all, the "`nfs server`" machine must be set up. This needs to have a 750 MB `/tftpboot` partition. Install NetBSD/pmax 3.0 from CDROM. (Don't forget to add the extra partition!)

2. Configure the nfs server machine to act as an nfs server. Start up the emulated DECstation:

       	gxemul -e 3max -A -d nbsd_pmax.img

   and enter the following commands as `root` inside the emulator:

   ``

       echo hostname=server >> /etc/rc.conf
       echo ifconfig_le0=\"inet 10.0.0.2\" >> /etc/rc.conf
       echo nameserver 10.0.0.254 >> /etc/resolv.conf
       echo 10.0.0.254 > /etc/mygate
       echo /tftpboot -maproot=root 10.0.0.1 > /etc/exports
       echo rpcbind=YES >> /etc/rc.conf
       echo nfs_server=YES >> /etc/rc.conf
       echo mountd=YES >> /etc/rc.conf
       echo bootparamd=YES >> /etc/rc.conf
       printf "client root=10.0.0.2:/tftpboot \\\n swap=10.0.0.2:/tftpboot/swap\n" > /etc/bootparams
       echo "bootps dgram udp wait root /usr/sbin/bootpd bootpd -d 4 -h 10.0.0.2" >> /etc/inetd.conf
       cat >> /etc/bootptab
       client:\
               :ht=ether:\
               :ha=102030000010:\
               :sm=255.0.0.0:\
               :lg=10.0.0.254:\
               :ip=10.0.0.1:\
               :rp=/tftpboot:
       (press CTRL-D)
       echo "10:20:30:00:00:10 client" > /etc/ethers
       echo 10.0.0.1 client > /etc/hosts
       reboot

3. Start the DECstation emulation again, and download the NetBSD/sgimips distribution sets:
   (NOTE: This takes quite some time, even if you have a fast network connection.)

   ``

       cd /tftpboot; ftp -i ftp.uk.netbsd.org
       (log in as anonymous...)
       cd /pub/NetBSD/NetBSD-2.1/sgimips/binary/sets
       mget base.tgz comp.tgz etc.tgz games.tgz man.tgz misc.tgz text.tgz
       quit
       sh
       for a in *.tgz; do echo $a; tar zxfp $a; rm -f $a; done
       echo 10.0.0.2:/tftpboot / nfs rw 0 0 > /tftpboot/etc/fstab
       echo rc_configured=YES >> /tftpboot/etc/rc.conf
       dd if=/dev/zero of=swap bs=1024 count=32768
       halt

4. Download the NetBSD/sgimips GENERIC and INSTALL kernels:

       	ftp://ftp.NetBSD.org/pub/NetBSD/NetBSD-2.1/sgimips/binary/kernel/netbsd-GENERIC32_IP3x.gz
       	ftp://ftp.NetBSD.org/pub/NetBSD/NetBSD-2.1/sgimips/binary/kernel/netbsd-INSTALL32_IP3x.gz

5. Create a configuration file called `config_client`:

   ``

       !!gxemul
       !
       !  Configuration file for running NetBSD/sgimips diskless with
       !  a NetBSD/pmax machine as the nfs server.

       emul(
           net(
       	add_remote("localhost:12444")   ! the server
       	local_port(12445)               ! the client
           )

           machine(
       	name("client machine")
       	serial_nr(1)

               type("sgi")
               subtype("o2")

               load("netbsd-INSTALL32_IP3x.gz")
               ! load("netbsd-GENERIC32_IP3x.gz")
           )
       )

   ... and another configuration file for the server, `config_server`:

   ``

       !!gxemul
       emul(
           net(
       	local_port(12444)               ! the server
       	add_remote("localhost:12445")   ! the client
           )

           machine(
       	name("nfs server")
       	serial_nr(2)

               type("dec")
               subtype("5000/200")

               disk("nbsd_pmax.img")
           )
       )

6. Boot the "`nfs server`" and the NetBSD/sgimips "`client machine`" as two separate emulator instances:

       	in one xterm:
       	gxemul @config_server

       	and then, in another xterm:
       	gxemul @config_client

7. In the NetBSD/sgimips window, choose "`x: Exit Install System`" in the installer's main menu, and then type:

       	ifconfig mec0 10.0.0.1; route add default 10.0.0.254
       	mount -v 10.0.0.2:/tftpboot /mnt
       	cd /mnt/dev; ./MAKEDEV all; cd /; umount /mnt
       	halt

   Then, once the client machine has halted, log in as `root` on the server machine and type `reboot`.

8. Once everything has been set up correctly, change `netbsd-INSTALL32_IP3x.gz` in `config_client` to `netbsd-GENERIC32_IP3x.gz` (the GENERIC kernel).

You might want to log in as `root` on the server machine, and run `tcpdump -lnvv` or similar, to see that what the client machine actually does on the network.

It should now be possible to boot NetBSD/sgimips using the NetBSD/pmax nfs server, using the following commands: (NOTE! Execute these two commands in separate xterms!)

    	gxemul @config_server
    	gxemul @config_client

When asked for "`root device:`" etc. on the client machine, enter the following values:

    	root device: mec0
    	dump device: 				(leave blank)
    	file system (default generic): 		(leave blank)
    	..
    	init path (default /sbin/init):		(leave blank)
    	Enter pathname of shell or RETURN for /bin/sh:	(leave blank)
    	Terminal type? [unknown] xterm
    	..
    	# exit			(to leave the single-user shell)

Note: Netbooting like this is very slow, so you need a lot of patience. For example, when NetBSD says "`nfs_boot: trying DHCP/BOOTP`", there will be a long pause, even on a very fast host machine. The reason for this is mostly because the emulator doesn't deal with timing issues very well, but also because NetBSD tries IPv6 first, before falling back to IPv4.

### NetBSD/cats:

It is possible to install and run NetBSD/cats in GXemul.

To install NetBSD/cats onto a disk image, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that you will install NetBSD/cats onto:

       	dd if=/dev/zero of=nbsd_cats.img bs=1024 count=1 seek=2000000

2. Download the NetBSD/cats 3.0 ISO image and the generic and install kernels:

       	ftp://ftp.netbsd.org/pub/NetBSD/iso/3.0/catscd-3.0.iso
       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-3.0/cats/binary/kernel/netbsd.aout-GENERIC.gz
       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-3.0/cats/binary/kernel/netbsd.aout-INSTALL.gz

3. Start the installation like this:

       	gxemul -XEcats -d nbsd_cats.img -d catscd-3.0.iso netbsd.aout-INSTALL.gz

   and proceed like you would do if you were installing NetBSD on a real CATS from CDROM.

Alternatively, to install from FTP, you can skip downloading the ISO, and start the install without `-d catscd-3.0.iso`. Suitable network settings are IP 10.0.0.1, gateway/default route 10.0.0.254, netmask 255.0.0.0, nameserver 10.0.0.254.

If everything worked, NetBSD should now be installed on the disk image. Use the following command line to boot the emulated CATS machine:

    	gxemul -XEcats -d nbsd_cats.img netbsd.aout-GENERIC.gz

### NetBSD/evbarm:

NetBSD/evbarm can run in GXemul on an emulated IQ80321 evaluation board.

It is tricky to install, because there is (as far as I know) no INSTALL kernel. One way to install the NetBSD/evbarm distribution onto a disk image is to install the files using another (emulated) machine.

The following instructions will let you install NetBSD/evbarm onto a disk image, from an emulated CATS machine:

1. Install NetBSD/cats 3.0 according to instructions further up on this page.

2. Create an empty harddisk image, which will be the disk image that you will install NetBSD onto:

       	dd if=/dev/zero of=nbsd_iq80321.img bs=1024 count=1 seek=999000

3. Download an IQ80321 kernel with wdc support, and the 2.1 ISO image:

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-2.1/evbarm/binary/kernel/netbsd-wd0-IQ80321.gz
       	ftp://ftp.netbsd.org/pub/NetBSD/iso/2.1/evbarmcd.iso

4. The first step is to copy the .tgz files we want onto the CATS machine's harddisk. Start the CATS machine like this:

       	gxemul -XEcats -d nbsd_cats.img -d evbarmcd.iso netbsd.aout-GENERIC.gz

   and execute the following commands as `root`:

   ``

       mount /dev/cd0a /mnt; cd /root; cp /mnt/evbarm/binary/sets/[bcegmt]* .
       sync; halt

5. Now let's extract the files onto the IQ80321's disk image. Start the CATS machine again, with the following command line:

       	gxemul -XEcats -d nbsd_cats.img -d nbsd_iq80321.img netbsd.aout-GENERIC.gz

   and execute the following commands as `root`:

   ``

       disklabel -I -i wd1
           (enter suitable commands, e.g. a, 4.2BSD, 1c, 750M, b,
            swap, a, 200M, P, W, y, Q)
       newfs /dev/wd1a; mount /dev/wd1a /mnt; cd /mnt; sh
       for a in /root/[bcegmt]*.tgz; do echo $a; tar zxfp $a; done
       exit
       cd dev; sh ./MAKEDEV all; cd ../etc
       echo rc_configured=YES >> rc.conf
       echo "/dev/wd0a / ffs rw 1 1" > fstab
       echo "/dev/wd0b none swap sw 0 0" >> fstab
       cd /; umount /mnt; sync; halt

You should now be able to boot NetBSD/evbarm using this command:

    	gxemul -xEiq80321 -d nbsd_iq80321.img netbsd-wd0-IQ80321.gz

### NetBSD/prep:

It is possible to install and run NetBSD/prep in GXemul on an emulated IBM 6050 (PowerPC) machine.

To install NetBSD/prep onto a disk image, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that you will install NetBSD/prep onto:

           dd if=/dev/zero of=nbsd_prep.img bs=1024 count=1 seek=1000000

2. Download the NetBSD/prep 2.1 ISO image and the generic kernel:

           ftp://ftp.netbsd.org/pub/NetBSD/iso/2.1/prepcd.iso
           ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-2.1/prep/binary/kernel/netbsd-GENERIC.gz

3. Start the installation like this:

           gxemul -x -e ibm6050 -d nbsd_prep.img -d rdb:prepcd.iso -j prep/binary/kernel/netbsd-INSTALL.gz

4. Installation is a bit unsmooth, possibly due to bugs in GXemul, possibly due to bugs in NetBSD itself; others have been having problems on real hardware: http://mail-index.NetBSD.org/port-prep/2005/11/25/0004.html. Creating an MBR slice and a disklabel with sysinst bugs out, so some things have to be done manually:

   At "`(I)nstall, (S)hell, or (H)alt`", choose `s`.
   `# fdisk -u wd0`
   `Do you want to change our idea of what BIOS thinks? [n]` (just press ENTER)
   `Which partition do you want to change?: [none] 0`
   `sysid: ...` (just press ENTER)
   `start: ... 1cyl`
   `size: ...` (just press ENTER)
   `Which partition do you want to change?: [none]` (press ENTER)
   `Should we write new partition table? [n] y`
   `# disklabel -I -i wd0`
   `partition> a`
   `Filesystem type [?] [unused]: 4.2BSD`
   `Start offset ('x' to start after partition 'x') [0c, 0s, 0M]: 1c`
   `Partition size ('$' for all remaining) [0c, 0s, 0M]: 900M`
   `partition> b`
   `Filesystem type [?] [unused]: swap`
   `Start offset ('x' to start after partition 'x') [0c, 0s, 0M]: a`
   `Partition size ('$' for all remaining) [0c, 0s, 0M]: $`
   `partition> W`
   `Label disk [n]? y`
   `partition> Q`
   `# newfs wd0a`
   `# sysinst`
   Choose to install onto wd0. Choose "`a: Edit the MBR partition table`" when presented with that option.
   Choose the 'a' partition/slice, set the 'e' ("active") and 'f' ("install") fields to Yes, and then choose "`x: Partition table OK`".
   Choose "`b: Use existing partition sizes`" in the next menu.
   Select partition 'a' and press ENTER. Set field 'k' (mount point) to '`/`'.
   Get out of the partitioner by selecting "`x: Partition sizes ok`" twice.
   At "`Write outside MBR partition? [n]:`", just press ENTER.
   Install from CD-ROM, device wd1c.

If everything worked, NetBSD should now be installed on the disk image. Use the following command line to boot the emulated machine:

    	gxemul -x -e ibm6050 -d nbsd_prep.img netbsd-GENERIC.gz

When asked which the root device is, type `wd0` and just press ENTER to select the default values for dump device, file system type, and init path.

### OpenBSD/pmax:

Installing OpenBSD/pmax is a bit harder than installing NetBSD/pmax. You should first read the section above on how to install NetBSD/pmax, before continuing here. If you have never installed OpenBSD on any architecture, then you need a great deal of patience to do this. If, on the other hand you are used to installing OpenBSD, then this should be no problem for you.

OpenBSD/pmax died at release 2.8 of OpenBSD, so you should be aware of the fact that this will not give you an up-to-date OpenBSD system.

Following these instructions might work. If not, then use common sense and imagination to modify them as you see fit.

1. Create an empty harddisk image, which will be the root disk that OpenBSD installs itself onto:

       	dd if=/dev/zero of=obsd_pmax.img bs=1 count=512 seek=900000000

2. Download the entire pmax directory from the ftp server: (approx. 99 MB)

       	wget -r ftp://ftp.se.openbsd.org/pub/OpenBSD/2.8/pmax/

3. Execute the following commands:

   ``

       mv ftp.se.openbsd.org/pub/OpenBSD/2.8/pmax/simpleroot28.fs.gz .
       gunzip simpleroot28.fs.gz
       chmod +w simpleroot28.fs		<--- make sure

4. You now need to make an ISO image of the entire directory you downloaded. (I recommend using `mkisofs` for that purpose. If you don't already have `mkisofs` installed on your system, you need to install it in order to do this.)

       	mkisofs -o openbsd_pmax_2.8.iso ftp.se.openbsd.org/pub/OpenBSD/2.8/pmax

5. Start the emulator with all three (!) disk images:

       	gxemul -e 3max -A -d obsd_pmax.img -d b:simpleroot28.fs -j bsd -d c:openbsd_pmax_2.8.iso

   (If you add `-X`, you will run with the graphical framebuffer. This is REALLY slow because the console has to scroll a lot during the install. I don't recommend it.)

6. Go on with the installation as you would do if you were installing on a real machine. If you are not used to the OpenBSD installer, then this will most likely be a very uncomfortable experience. Some important things to keep in mind are:
   - rz0 is the rootdisk you wish to install onto.
   - rz1 is the simpleroot image.
   - rz2 is the CDROM containing the "install sets".
   - When asked for the "root device?", enter rz1.
   - At "Enter pathname of shell or RETURN for sh:", press enter.
   - At the # prompt, do the following:

         	fsck /dev/rz1a        (and mark the filesystem as clean)
         	mount /dev/rz1a /
         	mount -t kernfs kern kern
         	./install

     and proceed with the install. Good luck. :-)
   - Answer "y" when asked if you wish to configure the network. (See the section about installing NetBSD/pmax for suitable network settings.)
   - Install from "c" (cdrom), choose "rz2" as the cdrom device, and "/" as the directory containing the install sets.

7. For some unknown reason, the install script does not set the root password! The first time you boot up OpenBSD after the install, you need to go into single user mode and run passwd root to set the root password, or you will not be able to log in at all!

       	gxemul -e 3max -A -d obsd_pmax.img -d 2c:openbsd_pmax_2.8.iso -j bsd -o '-s'

   While you are at it, you might want to extract the X11 install sets as well, as the installer seems to ignore them too. (Perhaps due to a bug in the installer, perhaps because of the way I used mkisofs.)

   Execute the following commands in the emulator:

   ``

       fsck /dev/rz0a
       mount /
       passwd root

       cd /; mount -t cd9660 /dev/rz2c /mnt; sh
       for a in /mnt/[xX]*; do tar zxvf $a; done
       ln -s /usr/X11R6/bin/Xcfbpmax /usr/X11R6/bin/X
       ln -s /dev/fb0 /dev/mouse
       echo /usr/X11R6/lib >> /etc/ld.so.conf
       ldconfig

       sync
       halt

NOTE: It is also possible to install via ftp instead of using a CDROM image. This is not much less awkward, you still need the simpleroot filesystem image, and you still have to manually add the X11 install sets and set the root password, and so on.

Once you have completed the installation procedure, the following command will let you boot from the new rootdisk image:

    	gxemul -e 3max -X -o '-aN' -d obsd_pmax.img -j bsd

(Normally, you would be asked about which root device to use (`rz0`), but using `-o '-aN'` supresses that.)

When asked for which terminal type to use, when logging in as root, enter `rcons` if you are using the graphical framebuffer, `vt100` for text-mode.
Use `startx` to start X windows.

### OpenBSD/cats:

It is possible to install and run OpenBSD/cats in GXemul.

To install OpenBSD/cats onto an emulated harddisk image, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that OpenBSD installs itself onto:

       	dd if=/dev/zero of=obsd_cats.img bs=1024 count=1 seek=1900000

2. Download the entire cats directory from the ftp server:

       	wget -np -l 0 -r ftp://ftp.openbsd.org/pub/OpenBSD/3.8/cats/
       	cp ftp.openbsd.org/pub/OpenBSD/3.8/cats/bsd .
       	cp ftp.openbsd.org/pub/OpenBSD/3.8/cats/bsd.rd .

3. You now need to make an ISO image of the entire directory you downloaded. (I recommend using `mkisofs` for that purpose. If you don't already have `mkisofs` installed on your system, you need to install it in order to do this.)

       	mkisofs -allow-lowercase -o openbsd_cats_3.8.iso ftp.openbsd.org/pub/OpenBSD/

4. Start the emulator using this command line:

       	gxemul -XEcats -d obsd_cats.img -d openbsd_cats_3.8.iso bsd.rd

   and proceed like you would do if you were installing OpenBSD on a real CATS. (Install onto `wd0`, don't configure the network, install from CD.)

(Although it is possible to configure the network, IPv4 address 10.0.0.1, netmask 255.0.0.0, gateway/default route 10.0.0.254, and nameserver 10.0.0.254, the userland NAT-like networking layer is not stable enough yet to support a full install via ftp.)

NOTE: Make sure that you `sync` and `reboot` correctly once the installation is finished, or the `/dev` nodes may not have been written correctly to disk.

Once the install has finished, the following command should let you boot from the harddisk image:

    	gxemul -XEcats -d obsd_cats.img bsd

### Ultrix/RISC:

Ultrix 4.x can run in GXemul on an emulated DECstation 5000/200. (Ultrix was the native OS for these machines, but NetBSD/pmax is also usable.)

The following instructions should let you install Ultrix onto a disk image:

1. Create an empty harddisk image, which will be the root disk that Ultrix installs itself onto:

               dd if=/dev/zero of=rootdisk.img bs=1024 count=1 seek=800000

2. Place your Ultrix installation media in your CDROM drive. (On FreeBSD and similar systems, it is called `/dev/cd0c`. Replace that with the name of your CDROM drive, or the name of a .iso image file.) Then, start the emulator like this:

               gxemul -X -A -e 3max -d rootdisk.img -d bc:/dev/cd0c -j vmunix

3. Once the first stage of the installation is done (restoring the root filesystem), you need to restart the emulator, booting from the new rootdisk, to continue the installation process. This is done by removing the bootflag ('`b`') from the second diskimage argument:

               gxemul -X -A -e 3max -d rootdisk.img -d c:/dev/cd0c -j vmunix

When the installation is completed, the following command should start Ultrix from the harddisk image:

            gxemul -X -A -e 3max -j vmunix -d rootdisk.img

Ultrix mostly seems to work with dynamic binary translation (which can be disabled by the `-B` command line option). If you have a very fast host machine, and use bintrans, you might experience a weird timer related bug, which makes it impossible to logon to the system. It is triggered when the emulation goes faster than any real DECstation machine was capable of running. A temporary workaround is to add `-I33000000` to fix the emulated clock speed to 33 million instructions per emulated second. (When using `-CR4400`, `-I16000000` should be used instead.)

You can experiment with adding `-Z2` (for emulating a dual-headed workstation) or even `-Z3` (tripple-headed), and also the `-Y2` option for scaling down the framebuffer windows by a factor 2x2. There is also a `-z` option for supplying names of X11 displays to use. The following example starts Ultrix on an emulated tripple-headed workstation, on three different displays (`remote1:0.0`, `localhost:0.0`, and `remote2:0.0`), using no scaledown:

            gxemul -A -N -e 3max -jgenvmunix -d rootdisk.img \
                -XZ3 -z remote1:0.0 -z localhost:0.0 -z remote2:0.0

The photo below shows a single Ultrix session running tripple-headed in GXemul on an Alpha 21164PC, with displays on a Sun Ultra1 (to the left), on the Alpha itself (in the middle), and on an HP700/RX X-terminal (8-bit color depth, running off the Alpha) to the right.

The X11 displays may differ in bit depth and endianness. Unfortunately, there is no way yet to set the scaledown factor on a per-window basis, so the scaledown factor affects all windows.

(If you didn't use `-Zn` during the installation, and compiled your own `/vmunix`, then it will not contain support for multiple graphics cards. To overcome this problem, use the generic kernel, `-j genvmunix`, whenever you are running the emulator with a different setup than the one you used when Ultrix was installed.)

A note for the historically interested: OSF/1 for MIPS was quite similar to Ultrix, so that is possible to run as well. If you are unsuccessful in installing Ultrix or OSF/1 directly in the emulator, you can always install it on your real machine onto a real SCSI disk, and then copy the contents of that SCSI disk into a file (using `dd(1)`), and use that file as a disk image file in the emulator.

### Sprite for DECstation:

Sprite was a research operating system at the University of Berkeley. The Unix Heritage Society (TUHS, www.tuhs.org) has made available a copy of a Sprite harddisk image for a DECstation 5000/200. If you want to find out more about Sprite in general, read http://www.cs.berkeley.edu/projects/sprite/retrospective.html.

The following instructions should let you run Sprite in the emulator:

1. Download the Sprite harddisk image:

       	ftp://ftp.es.embnet.org/pub/misc/TUHS/other_os/Sprite/ds5000.bt
       	83973120 bytes, MD5 = ec84eeeb20fe77b758370d5e312e4a5e

2. Start the emulator with the following command line:

       	gxemul -X -e 3max -M128 -d ds5000.bt -j vmsprite -o ''

The first time you boot up with the disk image, you will be asked a number of questions regarding network settings. If you feel like entering correct values, then you should use the following:

        Your machine's Ethernet address:    10:20:30:00:00:10
        Your machine's IP:                  10.0.0.1
        Subnet mask:                        0xff000000
        Gateway's Ethernet address:         60:50:40:30:20:10
        Gateway's IP:                       10.0.0.254

Unfortunately, at the end of ftp://ftp.es.embnet.org/pub/misc/TUHS/other_os/Sprite/boot.txt, the following sad statement can be found:

        The bootable Sprite image is meant to be a demonstration of Sprite, not
        a robust Sprite system.  There are several missing things, such as
        floating point and network support.

Once you are logged in as root, running `xinit` will start the X11 environment.

### Debian GNU/Linux for DECstation:

It is possible to run Debian GNU/Linux for DECstation in the emulator, on an emulated 5000/200 ("3max"). Although the Debian project has released install ramdisk kernels for this purpose, these do not always work:

- Serial console output doesn't work too well in GXemul. There are random oopses, which may be due to bugs in GXemul, but may also be due to bugs in the serial controller code in Linux. (The speed at which serial interrupts are generated can be lowered with the `-U` command line option, but it only reduces the risk, it doesn't take away the oopses completely.)
- Old install kernels supported the graphical framebuffer on the 3max, but not the keyboard.
- For quite some time, the MIPS linux cvs tree had support for the keyboard, but it did not include Debian's patches for networking. (Perhaps this has been fixed now, I don't know.)

David Muse has made available a precompiled install kernel which has support for framebuffer, keyboard, and networking, which works pretty well. Thanks David. :-)

The following steps should let you install Debian GNU/Linux for DECstation onto a harddisk image:

1. Create an empty harddisk image, which will be the root disk that Debian installs itself onto:

       	dd if=/dev/zero of=debian_pmax.img bs=1024 count=1 seek=3300000

2. Download David Muse' install kernel, and a Debian Netinstall CD-ROM:

       	http://www.firstworks.com/mips-linux-2.4.31/vmlinux-2.4.31
       	http://cdimage.debian.org/debian-cd/3.1_r0a/mipsel/iso-cd/debian-31r0a-mipsel-netinst.iso

3. Start the installation like this:

       	gxemul -XAe3max -d debian_pmax.img -d debian-31r0a-mipsel-netinst.iso vmlinux-2.4.31

   Everything is really slow, for several reasons (framebuffer is always slower than serial console, and Debian's install seems to be made up of scripts that run a lot slower in the emulator than pure C code would).

   There will be a warning about "Select keyboard layout". Don't mind this. Continue by selecting "Detect and mount CD-ROM".

   There will also be a warning about lack of loadable modules. Don't mind this, continue anyway.

   You need to enter some values during the installation procedure, for example network settings. The following should work:

       	DHCP:                       No, choose "Configure network manually"
       	IP address:                 10.0.0.1
       	Netmask:                    255.0.0.0
       	Gateway:                    10.0.0.254
       	Name server addresses:      10.0.0.254

4. Once the first phase of the install has finished, the following command should let you boot into Debian, and perform post-install configuration:

       	gxemul -XAe3max -o 'root=/dev/sda1' -d debian_pmax.img vmlinux-2.4.31

   The post-install step takes quite some time.

Debian GNU/Linux for DECstation should now be installed. Use this command to boot from the installed disk image:

    	gxemul -XAe3max -o 'root=/dev/sda1' -d debian_pmax.img vmlinux-2.4.31

### Redhat Linux for DECstation:

The following steps should let you run Redhat Linux for DECstation in GXemul:

1. Download a kernel. David Muse' Debian-install kernel works fine, also with Redhat:

       	http://www.firstworks.com/mips-linux-2.4.31/vmlinux-2.4.31

2. Download a root filesystem tree:

       	ftp://ftp.uni-wuppertal.de/pub/linux/mips/
       	 mipsel-linux/root/mipsel-root-20011216.tgz
       	19486676 bytes, md5 = 5bcb725c90209479cd7ead8ad0c4a414

3. Create a disk image which will contain the Redhat filesystem:

       	dd if=/dev/zero of=redhat_mips.img bs=1024 count=1 seek=2000000

4. This is the tricky part: on redhat_mips.img, you need to create an MS-DOS (!) partition table, and then an ext2 partition. This is what Linux will then see as /dev/sda1.

   On a Linux host, you could use a loopback mount, or similar. Otherwise, I recommend you run fdisk and mke2fs and untar the archive from within Debian/DECstation or Debian/CATS running inside the emulator. Use your imagination.

   In order to actually boot the system you need to modify /etc/fstab. Change

       	/dev/root               /               nfs     defaults        1 1
       	#/dev/sdc1              /               ext2    defaults        1 1
       	none                    /proc           proc    defaults        0 0
       	none                    /dev/pts        devpts  mode=0622       0 0

   to

       	#/dev/root              /               nfs     defaults        1 1
       	/dev/sda1               /               ext2    defaults        1 1
       	none                    /proc           proc    defaults        0 0
       	none                    /dev/pts        devpts  mode=0622       0 0

   (Note sda1 instead of sdc1.)

To boot Redhat linux from the disk image, use the following command line:

    	gxemul -XAe3max -o "root=/dev/sda1 ro" -d redhat_mips.img vmlinux-2.4.31

If you need to boot into single user mode, change options to `-o "root=/dev/sda1 rw init=/bin/sh"`.

### Mach/PMAX:

Read the following link if you want to know more about Mach in general: http://www-2.cs.cmu.edu/afs/cs/project/mach/public/www/mach.html

NOTE: Mach for DECstation requires some files (called 'startup' and 'emulator') which I haven't been able to find on the web. Without these, Mach will not get very far. These installation instructions are preliminary.

The following steps should let you experiment with running Mach for DECstation in the emulator:

1. Compile gxemul with cache emulation: (NOTE: --enable-caches)

       	./configure --enable-caches; make

2. Download the pmax binary distribution for Mach 3.0:

       	http://lost-contact.mit.edu/afs/athena/user/d/a/
       	    daveg/Info/Links/Mach/src/release/pmax.tar.Z
       	7263343 bytes, md5 = f9d76c240a6e169921a1df99ad560cc0

3. Extract the Mach kernel:

               tar xfvz pmax.tar.Z pmax_mach/special/mach.boot.MK83.STD+ANY

4. Create an empty disk image:

       	dd if=/dev/zero of=disk.img bs=1 count=512 seek=400000000

5. Load the contents of pmax.tar.Z onto the disk image. This is complicated, and should be described in more detail some time. For now, use your imagination. (For example using OpenBSD/pmax: disklabel -E rz1; newfs -O /dev/rz1a; mount /dev/rz1a /mnt; cd /mnt; download pmax.tar.Z using ftp; tar xzvf pmax.tar.Z; mv pmax_mach/* .; rmdir pmax_mach; mkdir mach_servers; cd mach_servers; cp ../etc/mach_init .; cp ../tests/test_service startup; dd if=/dev/zero of=paging_file bs=65536 count=400; cd /; sync; umount /mnt)

6. Start the emulator with the following command:

       	gxemul -e 3max -X -d disk.img \
       	    pmax_mach/special/mach.boot.MK83.STD+ANY

### OpenBSD/sgi:

OpenBSD/sgi can (almost) run in GXemul on an emulated O2 (SGI-IP32) with root on nfs.

NOTE: I haven't succeeded all the way with this yet, and this shows/triggers many bugs in the emulator, but some of it works.

GXemul does not yet emulate the AHC PCI SCSI controller in the O2. (I have mailed Adaptec several times, asking for documentation, but never received any reply.) OpenBSD/sgi can still run in the emulator, as long as it doesn't use SCSI. For a simple test with the ramdisk (install) kernel, try dowloading

    	ftp://ftp.se.openbsd.org/pub/OpenBSD/3.7/sgi/bsd.rd

and run `gxemul -e o2 bsd.rd`.

It might also be possible to netboot. Another emulated machine must then be used as the nfs root server, and the emulated O2 machine must boot as a diskless client. Performing this setup is quite time consuming, but necessary:

1. First of all, the "`nfs server`" machine must be set up. This needs to have a 800 MB `/tftpboot` partition. Install NetBSD/pmax 3.0 from CDROM. (Don't forget to add the extra partition!)

2. Configure the nfs server machine to act as an nfs server. Start up the emulated DECstation:

       	gxemul -e 3max -A -d nbsd_pmax.img

   and enter the following commands as `root` inside the emulator:

   ``

       echo hostname=server >> /etc/rc.conf
       echo ifconfig_le0=\"inet 10.0.0.2\" >> /etc/rc.conf
       echo nameserver 10.0.0.254 >> /etc/resolv.conf
       echo 10.0.0.254 > /etc/mygate
       echo /tftpboot -maproot=root 10.0.0.1 > /etc/exports
       echo rpcbind=YES >> /etc/rc.conf
       echo nfs_server=YES >> /etc/rc.conf
       echo mountd=YES >> /etc/rc.conf
       echo bootparamd=YES >> /etc/rc.conf
       printf "client root=10.0.0.2:/tftpboot \\\n swap=10.0.0.2:/tftpboot/swap\n" > /etc/bootparams
       echo "10:20:30:00:00:10 client" > /etc/ethers
       echo 10.0.0.1 client > /etc/hosts
       reboot

3. Start the DECstation emulation again, and enter the following commands to download the OpenBSD/sgi distribution:
   (NOTE: This takes quite some time, even if you have a fast network connection.)

   ``

       cd /tftpboot; ftp -i ftp.se.openbsd.org
       (log in as anonymous...)
       cd pub/OpenBSD/3.7/sgi
       mget b*tgz c* e* g* m*
       quit
       sh
       for a in *.tgz; do echo $a; tar zxfp $a; done
       echo 10.0.0.2:/tftpboot / nfs rw 0 0 > /tftpboot/etc/fstab
       rm *.tgz
       dd if=/dev/zero of=swap bs=1024 count=32768
       halt

4. Download the OpenBSD/sgi GENERIC and RAMDISK kernels:

       	ftp://ftp.se.openbsd.org/pub/OpenBSD/3.7/sgi/bsd
       	MD5 (bsd) = f16eaf3dcbd51876db7c25f70e6d8a08
       	ftp://ftp.se.openbsd.org/pub/OpenBSD/3.7/sgi/bsd.rd
       	MD5 (bsd.rd) = 4843e6139d8dd04b03d5f0e33e9a4f7b

5. Create a configuration file called `config_client`:

   ``

       !!gxemul
       !
       !  Configuration file for running OpenBSD/sgi diskless with
       !  a NetBSD/pmax machine as the nfs server.
       !
       !  This config file is for the client.

       emul(
           net(
       	add_remote("localhost:12444")   ! the server
       	local_port(12445)               ! the client
           )

           machine(
       	name("client machine")
       	serial_nr(1)

               type("sgi")
               subtype("o2")

               ! load("bsd")
               load("bsd.rd")
           )
       )

   ... and another configuration file for the server, `config_server`:

   ``

       !!gxemul
       emul(
           net(
       	local_port(12444)               ! the server
       	add_remote("localhost:12445")   ! the client
           )

           machine(
       	name("nfs server")
       	serial_nr(2)

               type("dec")
               subtype("5000/200")

               disk("nbsd_pmax.img")
           )
       )

6. Boot the "`nfs server`" and the OpenBSD/sgi "`client machine`" as two separate emulator instances:

       	in one xterm:
       	gxemul @config_server

       	and then, in another xterm:
       	gxemul @config_client

7. In the OpenBSD/sgi window, choose "`s`" (for Shell), and type:

   ``

       ifconfig mec0 10.0.0.1; route add default 10.0.0.254
       mount -v 10.0.0.2:/tftpboot /mnt
       cd /mnt/dev; ./MAKEDEV all; cd /; umount /mnt
       halt

   You might want to log in as `root` on the server machine, and run `tcpdump -lnvv` or similar, to see that what the client machine actually does on the network. The `MAKEDEV` script takes almost forever, so be patient.

NOTE: Everything up to this point should work. However, the next step (in gray) doesn't actually work:

Once everything has been set up correctly, change `bsd.rd` in `config_client` to just `bsd` (the GENERIC kernel). It should now be possible to boot OpenBSD/sgi using the NetBSD/pmax nfs server. (When asked for "`root device :`" on the OpenBSD machine, enter `mec0`.)

But it doesn't work. Probably because GXemul's implementation of the mec (ethernet card used in the O2) is too much of a quick hack. For now, use the `bsd.rd` kernel, and (at every boot) type:

    	s  (for Shell)
    	ifconfig mec0 10.0.0.1; route add default 10.0.0.254
    	mount -v 10.0.0.2:/tftpboot /mnt
    	cd /mnt; usr/sbin/chroot .
    	sh etc/rc

This will not cause OpenBSD to be booted normally, but at least a few basic things will work. By the way, the emulator performs so poorly, that you will have time to fetch several cups of coffee for each of the steps above.

### OpenBSD/arc:

It is (almost) possible to install and run OpenBSD/arc on an emulated Acer PICA-61 in the emulator.

Earlier, I had this guest OS listed as officially working in the emulator, but for several reasons, it has been moved down here to the "informative-but-not-really-working" section.

- The last OpenBSD/arc release was 2.3. This means that it is very old, it would not give a fair picture of what OpenBSD is (if you are just looking to find out what it is like), and it is not worth experimenting with it. See http://www.openbsd.org/arc.html for more information.
- OpenBSD/arc was (if I understood things correctly) never really stable, even on real hardare. Problems with too small an interrupt stack. Bugs are triggered in the emulator that have to do with issues such as this.

Currently, I don't test for every release whether or not OpenBSD/arc can be installed. Releases prior to 0.3.7 (but probably not 0.3.7) should work. Anyway, here are the old installation instructions:

To install OpenBSD/arc onto an emulated harddisk image, follow these instructions:

1. Create an empty harddisk image, which will be the root disk that OpenBSD installs itself onto:

       	dd if=/dev/zero of=obsd_arc.img bs=1024 count=1 seek=700000

2. Download the entire arc directory from the ftp server: (approx. 75 MB)

       	wget -np -l 0 -r ftp://ftp.se.openbsd.org/pub/OpenBSD/2.3/arc/

3. You now need to make an ISO image of the entire directory you downloaded. (I recommend using `mkisofs` for that purpose. If you don't already have `mkisofs` installed on your system, you need to install it in order to do this.)

       	mkisofs -o openbsd_arc_2.3.iso ftp.se.openbsd.org/pub/OpenBSD/

4. Start the emulator using this command line:

       	gxemul -e pica -X -A -d obsd_arc.img -d b:openbsd_arc_2.3.iso -j 2.3/arc/bsd.rd

   and proceed like you would do if you were installing OpenBSD on a real Acer PICA-61. (Answer 'no' when asked if you want to configure networking, and then install from CD-ROM.)

Once the install has finished, the following command should let you boot from the harddisk image:

    	gxemul -X -e pica -d obsd_arc.img ftp.se.openbsd.org/pub/OpenBSD/2.3/arc/bsd

The system is very sensitive to (I think) kernel stack overflow, so it crashes easily. If I remember correctly from mailing lists, this also happened on real hardware.

### Debian GNU/Linux for CATS:

Debian GNU/Linux for CATS (ARM) could theoretically run in GXemul, however:

- The DEC 21143 NIC is not emulated well enough for Linux to accept it.
- Development of Debian for CATS seems to have died? The latest install kernel is quite old.

IT DOES NOT WORK YET!

The following installation instructions would theoretically work:

1. Create an empty harddisk image, which will be the root disk that Debian installs itself onto:

       	dd if=/dev/zero of=debian_cats.img bs=1024 count=1 seek=3300000

2. Download the tftpboot install kernel:

       	http://ftp.debian.org/debian/dists/oldstable/main/disks-arm/current/cats/tftpboot.img

3. Start the installation using the following command line:

       	gxemul -XEcats -d debian_cats.img tftpboot.img

It doesn't work, though, because the NIC isn't working well enough.

The only use of Debian/CATS in the emulator right now is as a way to manipulate Linux disk images, if you are on a non-Linux host. By choosing "Execute a shell" in the installer's menu, you can have access to tools such as fdisk and mke2fs, which are useful for creating Linux paritions on disk images.

### NetBSD/netwinder:

NetBSD/netwinder could possibly run in GXemul. IT DOES NOT WORK YET!

It is tricky to install, because there is (as far as I know) no INSTALL kernel. One way to install the NetBSD/netwinder distribution onto a disk image is to install the files using another (emulated) machine.

The following instructions will let you install the NetBSD/netwinder distribution onto a disk image, from an emulated DECstation 3MAX machine:

1. Install NetBSD/pmax 3.0 according to instructions further up on this page.

2. Create an empty harddisk image, which will be the disk image that you will install NetBSD onto:

       	dd if=/dev/zero of=nbsd_netwinder.img bs=1024 count=1 seek=999000

3. Download the generic kernel and the 2.1 ISO image:

       	ftp://ftp.netbsd.org/pub/NetBSD/NetBSD-2.1/netwinder/binary/kernel/netbsd-GENERIC.gz
       	ftp://ftp.netbsd.org/pub/NetBSD/iso/2.1/netwindercd.iso

4. Start NetBSD/pmax like this:

       	gxemul -e 3max -A -d nbsd_pmax.img -d nbsd_netwinder.img -d netwinder.iso

   and execute the following commands as `root`:

   ``

       newfs /dev/sd1c
       mount /dev/cd0c /mnt
       mkdir /mnt2; mount /dev/sd1c /mnt2
       cd /mnt2; sh
       for a in /mnt/netwinder/binary/sets/*.tgz; do echo $a; tar zxfp $a; done
       exit
       cd dev; sh ./MAKEDEV all; cd ../etc
       echo rc_configured=YES >> rc.conf
       echo "/dev/wd0c / ffs rw 1 1" > fstab
       cd /; umount /mnt; umount /mnt2; halt

NetBSD/netwinder is now installed on the disk image. But actually running it does not work yet. Sorry.

Something like the following command line would be used to start NetBSD, if it worked:

    	gxemul -E netwinder -d nbsd_netwinder.img netbsd-GENERIC.gz

Note: The installation instructions above create a filesystem without a disklabel, so there is only one ffs partition and no swap. You will need to enter the following things when booting with the generic kernel:

    	root device (default wd0a): wd0c
    	dump device (default wd0b): none
    	file system (default generic):    (just press enter)
    	init path (default /sbin/init):   (just press enter)