Running Open Genera 2.0 on Linux

VLM should run on any modern amd64-bit Linux variant. These instructions specifically target Ubuntu. I’ve tested on Ubuntu 15.10 through Ubuntu 18.04 LTS.

Ubuntu was only chosen because I have the most familiarity with it. These instructions should also work on Debian, with only minor variation (if any). They could similarly be adapted to work on CentOS or Fedora, but that is beyond the scope of this document.

You need curl to easily download the required packages, so let’s install that first.

$ sudo apt-get install curl

Really, this could be anywhere. I just put it in my home directory for ease of use.

$ mkdir $HOME/genera

The VLM is actally just a single binary named genera. It’s the entire virtual Lisp Machine emulator in one file. While you can compile from source code (available several places online, including here on GitHub), I don’t recommend it. Just grab the binary.

There are two binaries to choose from. You only need one of them. The genera binary was built on an Intel Core-i7 system. The genera-i5 binary was built on an Intel Core-i5. Some users have reported that the Core i7 binary does not work on older i5’s, so if it causes an illegal instruction error, please try the Core i5 binary instead.

Genera itself is distributed as two components:

1. A “world” file, which contains the entire running state of a Lisp machine serialized to disk. This file is named Genera-8-5-xlib-patched.vlod (but may be renamed anything)
2. Files on the local UNIX filesystem exported via NFS. These files live under /var/lib/symbolics

This procedure will grab the required files and put them in the right place.

$ cd $HOME/genera/
$ curl -L -O https://archives.loomcom.com/genera/worlds/Genera-8-5-xlib-patched.vlod
$ curl -L -O https://archives.loomcom.com/genera/worlds/VLM_debugger
$ curl -L -O https://archives.loomcom.com/genera/worlds/dot.VLM
$ mv dot.VLM .VLM
$ cd /var/lib
$ sudo curl -L -O https://archives.loomcom.com/genera/var_lib_symbolics.tar.gz
$ sudo tar xvf var_lib_symbolics.tar.gz

Next, we want the symbolics directory to be owned by the user that’s going to run genera. In a typical Ubuntu installation, this will be UID 1000 and GID 1000, but please be sure to use the correct values here. Also note that this should match the UID and GID used in setting up NFS below.

$ sudo chown -R <user>:<group> symbolics

Finally, edit the .VLM file. Change the line

genera.worldSearchPath: /home/seth/genera

to match the actual directory where you placed the genera files.

NOTE: If you’ve decided to go with non-standard IP addresses, make sure to also change the line:

genera.network: tap0:INTERNET|192.168.2.2;gateway=192.168.2.1

to match!

Edit /etc/hosts to match the internal network you’re going to put the VLM on. These IP addresses can be changed to anything you like, and in fact some pretty advanced networking is possible, but for simplicity I recommend sticking with these IP addresses. If you use different IP addresses, at the very least you’ll need to edit your .VLM file.

You may choose to name genera-vlm and genera anything you like. The names are not that important, but you MUST remember to use the right names later on when setting up your Lisp Machine!

The VLM’s Genera software will use 192.168.2.2, and the UNIX host will create a tun0 interface bound to 192.168.2.1.

192.168.2.1    genera-vlm
192.168.2.2    genera

Genera synchronizes its clock with the UNIX host by using the old-school time and daytime UNIX facilities. These are turned off (not even installed!) by default on modern Linux, so you’ll need to get them and enable them.

sudo apt-get install inetutils-inetd

Then edit the file /etc/inetd.conf

sudo vi /etc/inetd.conf

Replace with the contents:

time      stream  tcp  nowait root internal
time      dgram   udp  wait   root internal
daytime   stream  tcp  nowait root internal
daytime   dgram   udp  wait   root internal

Then restart the service.

$ sudo systemctl restart inetutils-inetd.service

Verify that it’s working by telnet localhost 37 and telnet localhost 13

Genera accesses files on the local host via NFS.

First we install NFS with:

$ sudo apt-get install nfs-common nfs-kernel-server

Then configure. You should replace the values forq anonuid and anongid here with the actual user’s UID and GID that you are going to use to run the genera binary. On a typical Ubuntu installation, the primary user is UID 1000 and GID 1000, but don’t count on that. Verify it.

Edit /etc/exports

/       genera(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)

Restart NFS

$ sudo systemctl restart nfs-kernel-server

Then, to verify that the filesystem has been exported properly, type

$ sudo exportfs -rav

We’re going to let Genera access the host’s NFS export through an address assigned to a TUN/TAP interface.

On Linux this is pretty simple.

# sudo ip tuntap add dev tap0 mode tap
# sudo ip addr add 192.168.2.1/24 dev tap0
# sudo ip link set dev tap0 up

Genera will assign itself the address 192.168.2.2, and expect to find NFS files on 192.168.2.1.

REMEMBER! You’ll need to do this EACH TIME you reboot. There are ways to make this permanent, but I’ll leave that as an exercise to the reader.

Now you’re ready to start Genera for the first time!

Unfortunately, there are a few tricks to doing this on Ubutuntu 17.10, specifically, so I’ve broken this into two sections.

You should now be looking at the DISTRIBUTION world. It’ll look like this:

Important!: If you make a mistake while typing, use your DELETE key, not Backspace, to go back up. This is normal for Genera!!

The world you’ve just booted is a distribution world. There’s already a lot you can do with it, but it’s better to define a “Site” and then save a working world. That way you can keep your pristene distribution world as a kind of backup in case you ever want to get started again.

Note that this process writes files to NFS, so it will modify files under genera-vlm:/var/lib/symbolics/sys.sct/. If you really want to start over fresh and clean, you’ll need to delete /var/lib/symbolics and unpack it again from the original tar file.

Type

Halt Genera

at the prompt. You’ll be asked for a couple of confirmations. At this point the debugger window should pop up and ask you for a third confirmation that you really want to exit Lisp (if it doesn’t, find the hidden window and type ’Y’ at it. This behavior depends on your enviornment and window manager.)

You should now be back in Linux. It’s time to edit your .VLM file.

Open your .VLM file, and comment out the line genera.world: Genera-8-5-xlib-patched.vlod. Now add a new line that reads:

genera.world: Genera-8-5-working.vlod

(Or whatever you named your working world VLOD file)

At this point you can restart genera by typing ./genera.

Congratulations! You’re in a working Genera world. It’s time to explore.

To shut down, type

Halt Genera

You’ll be prompted a couple times for confirmation. After the Genera window closes, you’ll have to confirm again in the Cold Load window.

Symbolics Lisp Machines came with really amazing keyboards just covered with modifier keys.

When Symbolics released the VLM, they realized they had a problem. DEC Alpha workstations used PS/2 style keyboards, so they had to somehow map all of their modifer keys to PS/2 keyboard codes, and build a converter box to use their keyboards with the DEC hardware.

Thus, this mapping was born. You can get away with using a regular 101-key or 104-key PC keyboard, as long as you follow this mapping. (N.B.: “KP” means the keys on the number pad)

I always forget how to scroll in a Genera window if I haven’t been using it for a while. It’s pretty simple.

When a site is defined, Genera calls (si:enable-who-calls :new) automatically for you.. But we want to enable who-calls on all functions, not just new functions, so we must manually set that up

(si:enable-who-calls :all)

This takes a few minutes to run.

To search for all functions that have the string “crypt” in their name, one can simply type

(apropos "crypt")

After “Who Calls” has been set up as above, you can find all callers of ’rpc::encrypted-password)

(who-calls 'rpc::encrypted-password)

UNIX authentication seems to be defined in the flavor RPC::UNIX-AUTHENTICATION-MIXIN. Specifically, see the definition of the function RPC::USERNAME-AND-PASSWORD-VALID-P

Here’s the original definition.

(defun-in-flavor (username-and-password-valid-p unix-authentication-mixin)
    (username password)
  (declare (values username-valid-p password-valid-p))
  (if (null username)
      (values nil nil)
      (multiple-value-bind (encrypted-password defaulted-p)
          (let ((*unix-authentication-allow-defaulting* t))
            (username->password (unix-name-lookup-access-path) username))
        (cond ((and defaulted-p
                    (not (string-equal username "anonymous"))
                    (not (string-equal username "lisp-machine"))
                    (not (string-equal username "nobody")))
               (values nil nil))
              ((or (zerop (string-length encrypted-password))
                   (and password
                        (string= (unix-crypt password encrypted-password)
                                 encrypted-password)))
               (values t t))
              (t
               (values t nil))))))

We can hack this function to overcome the need for crypt-style passwords in NIS authentication. We could do a couple of things here:

1. Implement MD5, SHA256, or SHA512 encryption
2. Hack around (unix-crypt) by editing this function definition and adding a no-op of some kind
3. Figure out Genera’s Flavor system and actually implement our own login mixin (probably the right way?)

What I personally have done is to modify the function so that I can log in with the password “xyzzy”. This is very silly, but it works fine. It’s also a good introduction to hacking Genera.

Here’s how I changed mine. Notice the (string= "xyzzy" password).

(defun-in-flavor (username-and-password-valid-p unix-authentication-mixin)
    (username password)
  (declare (values username-valid-p password-valid-p))
  (if (null username)
      (values nil nil)
      (multiple-value-bind (encrypted-password defaulted-p)
          (let ((*unix-authentication-allow-defaulting* t))
            (username->password (unix-name-lookup-access-path) username))
        (cond ((and defaulted-p
                    (not (string-equal username "anonymous"))
                    (not (string-equal username "lisp-machine"))
                    (not (string-equal username "nobody")))
               (values nil nil))
              ((or (zerop (string-length encrypted-password))
                   (string= "xyzzy" password)
                   (and password
                        (string= (unix-crypt password encrypted-password)
                                 encrypted-password)))
               (values t t))
              (t
               (values t nil))))))