CSE 451 - Recitation 2: VMWare, Linux, Project 1

Project 1 has been released -- it's due a week from Friday.
This project has three components:

Create a ``shell'' like bash
Implement a system call to keep some statistics on program execution
A short write-up.

Goals of today's section:

How to get Linux to compile
How to get VMWare player running, using your Linux image
Some advice and hints on starting the project.

Downloading and Compiling Linux:

You'll want to be compiling Linux, on Linux. Since we're going to be running it inside an x86 emulator, you also want to be compiling from an x86 host. (You can "cross-compile" Linux if you want, but it's considerably more tricky.) You can do it under Cygwin, too, but the same rule applies.

We've provided a machine named forkbomb which can do your compiling for you. You can either ssh in to this machine, do your editing on your files there, and then compile, or you can edit local copies of your files, scp them up, and then compile. The choice is yours; either works equally well. Alternatively, if you have your own x86 Linux machine, you can do your editing & compiling there, too.

(Explain /homes/iws/username vs. /cse451/username)

A copy of the Linux kernel is stored in /cse451/projects/linux-2.6.13.2.tar.bz2. This is not necessarily the most recent version of Linux, but that's OK. This is the official version for the course -- it's what we're going to use. You should make a copy of this file into your compile directory, and unzip it:

cd /cse451/your_username
cp /cse451/projects/linux-2.6.13.2.tar.bz2 .
tar vjxf linux-2.6.13.2.tar.bz2
Feel free to explore the subdirectories that came out of this.
To compile:
cd linux-2.6.13.2/
make bzImage

Usually when compiling Linux, there are several more steps, like ``make menuconfig'', if you've done this before. Don't worry about this -- the tarball that we provided is pre-configured to run just fine in the VMWare environment. We've turned on/off everything how it should be. (Change these settings at your own risk.) You may also be used to modules. Don't worry about these, we're not building any modules.

The ``make'' process will take several minutes (maybe 5-10, depends on how many of you are doing this at once). The result will be a file ./arch/i386/boot/bzImage.

Subsequent compilation of the kernel will run much faster, unless you modify a .h file, in which case it'll need to do the full rebuild. But for a single-file modification, it'll compile in less than a minute.

Running VMWare

VMWare, unfortunately, does not run on the Linux machines in the school. (This is because VMWare needs to install its own kernel-modules to natively support some interaction between VM images and USB devices, and UWCSE support isn't willing to run crazy tricked-out kernels natively.)

Terminology:

image -- means "a snapshot of bits." This can be a ``picture'' of what some of the memory should look like, as in the case of bzImage: it loads this ``image'' of bits directly into RAM and runs it as the operating system. It can also mean the ``picture'' of a harddrive -- VMWare takes a file called a "VMware Image" and pretends that this massive file (over a gigabyte) is an entire harddrive, with its own file system, partition tables, files, operating system, etc. spread through out. VMWare then simulates a computer, booting from this harddrive.
host -- the physical machine running VMWare
virtual machine -- the ``imaginary'' computer that VMWare is simulating.

For you to run the Linux kernel image that you just compiled, you're going to have to do it within VMWare. This is actually advantageous for several reasons:

You can't possibly actually hose the computer you're working on (whereas if the kernel were connected to a real file system, for example, and a memory leak overwrote part of the file system table, you could definitely destroy the harddrive's contents.)
It's faster to reboot VMWare than a real computer
You don't need your own Linux computer

Computers in the computer lab with Windows XP are set up with VMWare already. These computers also contain a VMWare image that will boot a copy of Linux. Only students in CSE 451 can access this. Important: Do not mess with the VMWare settings on these machines. They're set up precisely.

You can download VMWare and install it on your computer at home too. You'll also need to download the VMware Linux image from forkbomb. Instructions are online.

An important note about VMWare: It's a non-persistent image. That means that any changes you make are lost when you close VMWare. (This is actually good, regarding the "you can hose the machine" point above)

To run your own kernel:

on forkbomb: make bzImage. this creates arch/i386/boot/bzImage.
scp that file to your WinXP machine, where you're doing your testing.
Start VMWare. It will ask for a file to run: navigate to the FC4-451 directory, and select Other Linux 2.6.x kernel.vmx
This will boot Linux. Log in with root/rootpassword
VMWare will expose a network adaptor. It thinks its a computer at 192.168.93.2.
Only the host computer can connect to this (this is good, given the weakness of the root password above).
From the host machine, scp your bzImage to /boot/bzImage on the virtual machine.
shutdown -r 0
In the boot-up menu, select "bzImage", not "Fedora Core"
It will now boot your kernel image that you built.

Advice for the project:

Start now (duh)
Don't just divide the project into shell | kernel. Most of the kernel project is a scavenger hunt. More eyes = faster.
Use the linux source browser online (see the web page). Figure out where the bodies of syscalls seem to live. Figure out what's actually doing the forking.
The directory names are there for a reason. Don't forget, analogues to them also all exist under /arch/i386. (and /arch/* as well)
Use CVS or other version control
Keep a file listing which kernel files you read through, what you saw in each of them, and (more importantly), what files you modified
Check out the previous semester's web site -- it's got some information on it that's a bit more thorough about some of these topics.