Merge remote-tracking branch 'linus/master' into x86/urgent

34 files changed, 3486 insertions, 315 deletions

diff --git a/tools/lguest/.gitignore b/tools/lguest/.gitignore
new file mode 100644
index 000000000000..115587fd5f65
--- /dev/null
+++ b/tools/lguest/.gitignore
@@ -0,0 +1 @@
+lguest
diff --git a/tools/lguest/Makefile b/tools/lguest/Makefile
new file mode 100644
index 000000000000..0ac34206f7a7
--- /dev/null
+++ b/tools/lguest/Makefile
@@ -0,0 +1,8 @@
+# This creates the demonstration utility "lguest" which runs a Linux guest.
+# Missing headers?  Add "-I../../../include -I../../../arch/x86/include"
+CFLAGS:=-m32 -Wall -Wmissing-declarations -Wmissing-prototypes -O3 -U_FORTIFY_SOURCE
+
+all: lguest
+
+clean:
+        rm -f lguest
diff --git a/tools/lguest/extract b/tools/lguest/extract
new file mode 100644
index 000000000000..7730bb6e4b94
--- /dev/null
+++ b/tools/lguest/extract
@@ -0,0 +1,58 @@
+#! /bin/sh
+
+set -e
+
+PREFIX=$1
+shift
+
+trap 'rm -r $TMPDIR' 0
+TMPDIR=`mktemp -d`
+
+exec 3>/dev/null
+for f; do
+    while IFS="
+" read -r LINE; do
+        case "$LINE" in
+            *$PREFIX:[0-9]*:\**)
+                NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"`
+                if [ -f $TMPDIR/$NUM ]; then
+                    echo "$TMPDIR/$NUM already exits prior to $f"
+                    exit 1
+                fi
+                exec 3>>$TMPDIR/$NUM
+                echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM
+                /bin/echo "$LINE" | sed -e "s/$PREFIX:[0-9]*//" -e "s/:\*/*/" >&3
+                ;;
+            *$PREFIX:[0-9]*)
+                NUM=`echo "$LINE" | sed "s/.*$PREFIX:\([0-9]*\).*/\1/"`
+                if [ -f $TMPDIR/$NUM ]; then
+                    echo "$TMPDIR/$NUM already exits prior to $f"
+                    exit 1
+                fi
+                exec 3>>$TMPDIR/$NUM
+                echo $f | sed 's,\.\./,,g' > $TMPDIR/.$NUM
+                /bin/echo "$LINE" | sed "s/$PREFIX:[0-9]*//" >&3
+                ;;
+            *:\**)
+                /bin/echo "$LINE" | sed -e "s/:\*/*/" -e "s,/\*\*/,," >&3
+                echo >&3
+                exec 3>/dev/null
+                ;;
+            *)
+                /bin/echo "$LINE" >&3
+                ;;
+        esac
+    done < $f
+    echo >&3
+    exec 3>/dev/null
+done
+
+LASTFILE=""
+for f in $TMPDIR/*; do
+    if [ "$LASTFILE" != $(cat $TMPDIR/.$(basename $f) ) ]; then
+        LASTFILE=$(cat $TMPDIR/.$(basename $f) )
+        echo "[ $LASTFILE ]"
+    fi
+    cat $f
+done
+
diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
new file mode 100644
index 000000000000..f759f4f097c7
--- /dev/null
+++ b/tools/lguest/lguest.c
@@ -0,0 +1,2065 @@
+/*P:100
+ * This is the Launcher code, a simple program which lays out the "physical"
+ * memory for the new Guest by mapping the kernel image and the virtual
+ * devices, then opens /dev/lguest to tell the kernel about the Guest and
+ * control it.
+:*/
+#define _LARGEFILE64_SOURCE
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <err.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <elf.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/eventfd.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ctype.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <time.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#include <linux/sockios.h>
+#include <linux/if_tun.h>
+#include <sys/uio.h>
+#include <termios.h>
+#include <getopt.h>
+#include <assert.h>
+#include <sched.h>
+#include <limits.h>
+#include <stddef.h>
+#include <signal.h>
+#include <pwd.h>
+#include <grp.h>
+
+#include <linux/virtio_config.h>
+#include <linux/virtio_net.h>
+#include <linux/virtio_blk.h>
+#include <linux/virtio_console.h>
+#include <linux/virtio_rng.h>
+#include <linux/virtio_ring.h>
+#include <asm/bootparam.h>
+#include "../../include/linux/lguest_launcher.h"
+/*L:110
+ * We can ignore the 43 include files we need for this program, but I do want
+ * to draw attention to the use of kernel-style types.
+ *
+ * As Linus said, "C is a Spartan language, and so should your naming be."  I
+ * like these abbreviations, so we define them here.  Note that u64 is always
+ * unsigned long long, which works on all Linux systems: this means that we can
+ * use %llu in printf for any u64.
+ */
+typedef unsigned long long u64;
+typedef uint32_t u32;
+typedef uint16_t u16;
+typedef uint8_t u8;
+/*:*/
+
+#define BRIDGE_PFX "bridge:"
+#ifndef SIOCBRADDIF
+#define SIOCBRADDIF     0x89a2          /* add interface to bridge      */
+#endif
+/* We can have up to 256 pages for devices. */
+#define DEVICE_PAGES 256
+/* This will occupy 3 pages: it must be a power of 2. */
+#define VIRTQUEUE_NUM 256
+
+/*L:120
+ * verbose is both a global flag and a macro.  The C preprocessor allows
+ * this, and although I wouldn't recommend it, it works quite nicely here.
+ */
+static bool verbose;
+#define verbose(args...) \
+        do { if (verbose) printf(args); } while(0)
+/*:*/
+
+/* The pointer to the start of guest memory. */
+static void *guest_base;
+/* The maximum guest physical address allowed, and maximum possible. */
+static unsigned long guest_limit, guest_max;
+/* The /dev/lguest file descriptor. */
+static int lguest_fd;
+
+/* a per-cpu variable indicating whose vcpu is currently running */
+static unsigned int __thread cpu_id;
+
+/* This is our list of devices. */
+struct device_list {
+        /* Counter to assign interrupt numbers. */
+        unsigned int next_irq;
+
+        /* Counter to print out convenient device numbers. */
+        unsigned int device_num;
+
+        /* The descriptor page for the devices. */
+        u8 *descpage;
+
+        /* A single linked list of devices. */
+        struct device *dev;
+        /* And a pointer to the last device for easy append. */
+        struct device *lastdev;
+};
+
+/* The list of Guest devices, based on command line arguments. */
+static struct device_list devices;
+
+/* The device structure describes a single device. */
+struct device {
+        /* The linked-list pointer. */
+        struct device *next;
+
+        /* The device's descriptor, as mapped into the Guest. */
+        struct lguest_device_desc *desc;
+
+        /* We can't trust desc values once Guest has booted: we use these. */
+        unsigned int feature_len;
+        unsigned int num_vq;
+
+        /* The name of this device, for --verbose. */
+        const char *name;
+
+        /* Any queues attached to this device */
+        struct virtqueue *vq;
+
+        /* Is it operational */
+        bool running;
+
+        /* Device-specific data. */
+        void *priv;
+};
+
+/* The virtqueue structure describes a queue attached to a device. */
+struct virtqueue {
+        struct virtqueue *next;
+
+        /* Which device owns me. */
+        struct device *dev;
+
+        /* The configuration for this queue. */
+        struct lguest_vqconfig config;
+
+        /* The actual ring of buffers. */
+        struct vring vring;
+
+        /* Last available index we saw. */
+        u16 last_avail_idx;
+
+        /* How many are used since we sent last irq? */
+        unsigned int pending_used;
+
+        /* Eventfd where Guest notifications arrive. */
+        int eventfd;
+
+        /* Function for the thread which is servicing this virtqueue. */
+        void (*service)(struct virtqueue *vq);
+        pid_t thread;
+};
+
+/* Remember the arguments to the program so we can "reboot" */
+static char **main_args;
+
+/* The original tty settings to restore on exit. */
+static struct termios orig_term;
+
+/*
+ * We have to be careful with barriers: our devices are all run in separate
+ * threads and so we need to make sure that changes visible to the Guest happen
+ * in precise order.
+ */
+#define wmb() __asm__ __volatile__("" : : : "memory")
+#define mb() __asm__ __volatile__("" : : : "memory")
+
+/*
+ * Convert an iovec element to the given type.
+ *
+ * This is a fairly ugly trick: we need to know the size of the type and
+ * alignment requirement to check the pointer is kosher.  It's also nice to
+ * have the name of the type in case we report failure.
+ *
+ * Typing those three things all the time is cumbersome and error prone, so we
+ * have a macro which sets them all up and passes to the real function.
+ */
+#define convert(iov, type) \
+        ((type *)_convert((iov), sizeof(type), __alignof__(type), #type))
+
+static void *_convert(struct iovec *iov, size_t size, size_t align,
+                      const char *name)
+{
+        if (iov->iov_len != size)
+                errx(1, "Bad iovec size %zu for %s", iov->iov_len, name);
+        if ((unsigned long)iov->iov_base % align != 0)
+                errx(1, "Bad alignment %p for %s", iov->iov_base, name);
+        return iov->iov_base;
+}
+
+/* Wrapper for the last available index.  Makes it easier to change. */
+#define lg_last_avail(vq)       ((vq)->last_avail_idx)
+
+/*
+ * The virtio configuration space is defined to be little-endian.  x86 is
+ * little-endian too, but it's nice to be explicit so we have these helpers.
+ */
+#define cpu_to_le16(v16) (v16)
+#define cpu_to_le32(v32) (v32)
+#define cpu_to_le64(v64) (v64)
+#define le16_to_cpu(v16) (v16)
+#define le32_to_cpu(v32) (v32)
+#define le64_to_cpu(v64) (v64)
+
+/* Is this iovec empty? */
+static bool iov_empty(const struct iovec iov[], unsigned int num_iov)
+{
+        unsigned int i;
+
+        for (i = 0; i < num_iov; i++)
+                if (iov[i].iov_len)
+                        return false;
+        return true;
+}
+
+/* Take len bytes from the front of this iovec. */
+static void iov_consume(struct iovec iov[], unsigned num_iov, unsigned len)
+{
+        unsigned int i;
+
+        for (i = 0; i < num_iov; i++) {
+                unsigned int used;
+
+                used = iov[i].iov_len < len ? iov[i].iov_len : len;
+                iov[i].iov_base += used;
+                iov[i].iov_len -= used;
+                len -= used;
+        }
+        assert(len == 0);
+}
+
+/* The device virtqueue descriptors are followed by feature bitmasks. */
+static u8 *get_feature_bits(struct device *dev)
+{
+        return (u8 *)(dev->desc + 1)
+                + dev->num_vq * sizeof(struct lguest_vqconfig);
+}
+
+/*L:100
+ * The Launcher code itself takes us out into userspace, that scary place where
+ * pointers run wild and free!  Unfortunately, like most userspace programs,
+ * it's quite boring (which is why everyone likes to hack on the kernel!).
+ * Perhaps if you make up an Lguest Drinking Game at this point, it will get
+ * you through this section.  Or, maybe not.
+ *
+ * The Launcher sets up a big chunk of memory to be the Guest's "physical"
+ * memory and stores it in "guest_base".  In other words, Guest physical ==
+ * Launcher virtual with an offset.
+ *
+ * This can be tough to get your head around, but usually it just means that we
+ * use these trivial conversion functions when the Guest gives us its
+ * "physical" addresses:
+ */
+static void *from_guest_phys(unsigned long addr)
+{
+        return guest_base + addr;
+}
+
+static unsigned long to_guest_phys(const void *addr)
+{
+        return (addr - guest_base);
+}
+
+/*L:130
+ * Loading the Kernel.
+ *
+ * We start with couple of simple helper routines.  open_or_die() avoids
+ * error-checking code cluttering the callers:
+ */
+static int open_or_die(const char *name, int flags)
+{
+        int fd = open(name, flags);
+        if (fd < 0)
+                err(1, "Failed to open %s", name);
+        return fd;
+}
+
+/* map_zeroed_pages() takes a number of pages. */
+static void *map_zeroed_pages(unsigned int num)
+{
+        int fd = open_or_die("/dev/zero", O_RDONLY);
+        void *addr;
+
+        /*
+         * We use a private mapping (ie. if we write to the page, it will be
+         * copied). We allocate an extra two pages PROT_NONE to act as guard
+         * pages against read/write attempts that exceed allocated space.
+         */
+        addr = mmap(NULL, getpagesize() * (num+2),
+                    PROT_NONE, MAP_PRIVATE, fd, 0);
+
+        if (addr == MAP_FAILED)
+                err(1, "Mmapping %u pages of /dev/zero", num);
+
+        if (mprotect(addr + getpagesize(), getpagesize() * num,
+                     PROT_READ|PROT_WRITE) == -1)
+                err(1, "mprotect rw %u pages failed", num);
+
+        /*
+         * One neat mmap feature is that you can close the fd, and it
+         * stays mapped.
+         */
+        close(fd);
+
+        /* Return address after PROT_NONE page */
+        return addr + getpagesize();
+}
+
+/* Get some more pages for a device. */
+static void *get_pages(unsigned int num)
+{
+        void *addr = from_guest_phys(guest_limit);
+
+        guest_limit += num * getpagesize();
+        if (guest_limit > guest_max)
+                errx(1, "Not enough memory for devices");
+        return addr;
+}
+
+/*
+ * This routine is used to load the kernel or initrd.  It tries mmap, but if
+ * that fails (Plan 9's kernel file isn't nicely aligned on page boundaries),
+ * it falls back to reading the memory in.
+ */
+static void map_at(int fd, void *addr, unsigned long offset, unsigned long len)
+{
+        ssize_t r;
+
+        /*
+         * We map writable even though for some segments are marked read-only.
+         * The kernel really wants to be writable: it patches its own
+         * instructions.
+         *
+         * MAP_PRIVATE means that the page won't be copied until a write is
+         * done to it.  This allows us to share untouched memory between
+         * Guests.
+         */
+        if (mmap(addr, len, PROT_READ|PROT_WRITE,
+                 MAP_FIXED|MAP_PRIVATE, fd, offset) != MAP_FAILED)
+                return;
+
+        /* pread does a seek and a read in one shot: saves a few lines. */
+        r = pread(fd, addr, len, offset);
+        if (r != len)
+                err(1, "Reading offset %lu len %lu gave %zi", offset, len, r);
+}
+
+/*
+ * This routine takes an open vmlinux image, which is in ELF, and maps it into
+ * the Guest memory.  ELF = Embedded Linking Format, which is the format used
+ * by all modern binaries on Linux including the kernel.
+ *
+ * The ELF headers give *two* addresses: a physical address, and a virtual
+ * address.  We use the physical address; the Guest will map itself to the
+ * virtual address.
+ *
+ * We return the starting address.
+ */
+static unsigned long map_elf(int elf_fd, const Elf32_Ehdr *ehdr)
+{
+        Elf32_Phdr phdr[ehdr->e_phnum];
+        unsigned int i;
+
+        /*
+         * Sanity checks on the main ELF header: an x86 executable with a
+         * reasonable number of correctly-sized program headers.
+         */
+        if (ehdr->e_type != ET_EXEC
+            || ehdr->e_machine != EM_386
+            || ehdr->e_phentsize != sizeof(Elf32_Phdr)
+            || ehdr->e_phnum < 1 || ehdr->e_phnum > 65536U/sizeof(Elf32_Phdr))
+                errx(1, "Malformed elf header");
+
+        /*
+         * An ELF executable contains an ELF header and a number of "program"
+         * headers which indicate which parts ("segments") of the program to
+         * load where.
+         */
+
+        /* We read in all the program headers at once: */
+        if (lseek(elf_fd, ehdr->e_phoff, SEEK_SET) < 0)
+                err(1, "Seeking to program headers");
+        if (read(elf_fd, phdr, sizeof(phdr)) != sizeof(phdr))
+                err(1, "Reading program headers");
+
+        /*
+         * Try all the headers: there are usually only three.  A read-only one,
+         * a read-write one, and a "note" section which we don't load.
+         */
+        for (i = 0; i < ehdr->e_phnum; i++) {
+                /* If this isn't a loadable segment, we ignore it */
+                if (phdr[i].p_type != PT_LOAD)
+                        continue;
+
+                verbose("Section %i: size %i addr %p\n",
+                        i, phdr[i].p_memsz, (void *)phdr[i].p_paddr);
+
+                /* We map this section of the file at its physical address. */
+                map_at(elf_fd, from_guest_phys(phdr[i].p_paddr),
+                       phdr[i].p_offset, phdr[i].p_filesz);
+        }
+
+        /* The entry point is given in the ELF header. */
+        return ehdr->e_entry;
+}
+
+/*L:150
+ * A bzImage, unlike an ELF file, is not meant to be loaded.  You're supposed
+ * to jump into it and it will unpack itself.  We used to have to perform some
+ * hairy magic because the unpacking code scared me.
+ *
+ * Fortunately, Jeremy Fitzhardinge convinced me it wasn't that hard and wrote
+ * a small patch to jump over the tricky bits in the Guest, so now we just read
+ * the funky header so we know where in the file to load, and away we go!
+ */
+static unsigned long load_bzimage(int fd)
+{
+        struct boot_params boot;
+        int r;
+        /* Modern bzImages get loaded at 1M. */
+        void *p = from_guest_phys(0x100000);
+
+        /*
+         * Go back to the start of the file and read the header.  It should be
+         * a Linux boot header (see Documentation/x86/boot.txt)
+         */
+        lseek(fd, 0, SEEK_SET);
+        read(fd, &boot, sizeof(boot));
+
+        /* Inside the setup_hdr, we expect the magic "HdrS" */
+        if (memcmp(&boot.hdr.header, "HdrS", 4) != 0)
+                errx(1, "This doesn't look like a bzImage to me");
+
+        /* Skip over the extra sectors of the header. */
+        lseek(fd, (boot.hdr.setup_sects+1) * 512, SEEK_SET);
+
+        /* Now read everything into memory. in nice big chunks. */
+        while ((r = read(fd, p, 65536)) > 0)
+                p += r;
+
+        /* Finally, code32_start tells us where to enter the kernel. */
+        return boot.hdr.code32_start;
+}
+
+/*L:140
+ * Loading the kernel is easy when it's a "vmlinux", but most kernels
+ * come wrapped up in the self-decompressing "bzImage" format.  With a little
+ * work, we can load those, too.
+ */
+static unsigned long load_kernel(int fd)
+{
+        Elf32_Ehdr hdr;
+
+        /* Read in the first few bytes. */
+        if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
+                err(1, "Reading kernel");
+
+        /* If it's an ELF file, it starts with "\177ELF" */
+        if (memcmp(hdr.e_ident, ELFMAG, SELFMAG) == 0)
+                return map_elf(fd, &hdr);
+
+        /* Otherwise we assume it's a bzImage, and try to load it. */
+        return load_bzimage(fd);
+}
+
+/*
+ * This is a trivial little helper to align pages.  Andi Kleen hated it because
+ * it calls getpagesize() twice: "it's dumb code."
+ *
+ * Kernel guys get really het up about optimization, even when it's not
+ * necessary.  I leave this code as a reaction against that.
+ */
+static inline unsigned long page_align(unsigned long addr)
+{
+        /* Add upwards and truncate downwards. */
+        return ((addr + getpagesize()-1) & ~(getpagesize()-1));
+}
+
+/*L:180
+ * An "initial ram disk" is a disk image loaded into memory along with the
+ * kernel which the kernel can use to boot from without needing any drivers.
+ * Most distributions now use this as standard: the initrd contains the code to
+ * load the appropriate driver modules for the current machine.
+ *
+ * Importantly, James Morris works for RedHat, and Fedora uses initrds for its
+ * kernels.  He sent me this (and tells me when I break it).
+ */
+static unsigned long load_initrd(const char *name, unsigned long mem)
+{
+        int ifd;
+        struct stat st;
+        unsigned long len;
+
+        ifd = open_or_die(name, O_RDONLY);
+        /* fstat() is needed to get the file size. */
+        if (fstat(ifd, &st) < 0)
+                err(1, "fstat() on initrd '%s'", name);
+
+        /*
+         * We map the initrd at the top of memory, but mmap wants it to be
+         * page-aligned, so we round the size up for that.
+         */
+        len = page_align(st.st_size);
+        map_at(ifd, from_guest_phys(mem - len), 0, st.st_size);
+        /*
+         * Once a file is mapped, you can close the file descriptor.  It's a
+         * little odd, but quite useful.
+         */
+        close(ifd);
+        verbose("mapped initrd %s size=%lu @ %p\n", name, len, (void*)mem-len);
+
+        /* We return the initrd size. */
+        return len;
+}
+/*:*/
+
+/*
+ * Simple routine to roll all the commandline arguments together with spaces
+ * between them.
+ */
+static void concat(char *dst, char *args[])
+{
+        unsigned int i, len = 0;
+
+        for (i = 0; args[i]; i++) {
+                if (i) {
+                        strcat(dst+len, " ");
+                        len++;
+                }
+                strcpy(dst+len, args[i]);
+                len += strlen(args[i]);
+        }
+        /* In case it's empty. */
+        dst[len] = '\0';
+}
+
+/*L:185
+ * This is where we actually tell the kernel to initialize the Guest.  We
+ * saw the arguments it expects when we looked at initialize() in lguest_user.c:
+ * the base of Guest "physical" memory, the top physical page to allow and the
+ * entry point for the Guest.
+ */
+static void tell_kernel(unsigned long start)
+{
+        unsigned long args[] = { LHREQ_INITIALIZE,
+                                 (unsigned long)guest_base,
+                                 guest_limit / getpagesize(), start };
+        verbose("Guest: %p - %p (%#lx)\n",
+                guest_base, guest_base + guest_limit, guest_limit);
+        lguest_fd = open_or_die("/dev/lguest", O_RDWR);
+        if (write(lguest_fd, args, sizeof(args)) < 0)
+                err(1, "Writing to /dev/lguest");
+}
+/*:*/
+
+/*L:200
+ * Device Handling.
+ *
+ * When the Guest gives us a buffer, it sends an array of addresses and sizes.
+ * We need to make sure it's not trying to reach into the Launcher itself, so
+ * we have a convenient routine which checks it and exits with an error message
+ * if something funny is going on:
+ */
+static void *_check_pointer(unsigned long addr, unsigned int size,
+                            unsigned int line)
+{
+        /*
+         * Check if the requested address and size exceeds the allocated memory,
+         * or addr + size wraps around.
+         */
+        if ((addr + size) > guest_limit || (addr + size) < addr)
+                errx(1, "%s:%i: Invalid address %#lx", __FILE__, line, addr);
+        /*
+         * We return a pointer for the caller's convenience, now we know it's
+         * safe to use.
+         */
+        return from_guest_phys(addr);
+}
+/* A macro which transparently hands the line number to the real function. */
+#define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)
+
+/*
+ * Each buffer in the virtqueues is actually a chain of descriptors.  This
+ * function returns the next descriptor in the chain, or vq->vring.num if we're
+ * at the end.
+ */
+static unsigned next_desc(struct vring_desc *desc,
+                          unsigned int i, unsigned int max)
+{
+        unsigned int next;
+
+        /* If this descriptor says it doesn't chain, we're done. */
+        if (!(desc[i].flags & VRING_DESC_F_NEXT))
+                return max;
+
+        /* Check they're not leading us off end of descriptors. */
+        next = desc[i].next;
+        /* Make sure compiler knows to grab that: we don't want it changing! */
+        wmb();
+
+        if (next >= max)
+                errx(1, "Desc next is %u", next);
+
+        return next;
+}
+
+/*
+ * This actually sends the interrupt for this virtqueue, if we've used a
+ * buffer.
+ */
+static void trigger_irq(struct virtqueue *vq)
+{
+        unsigned long buf[] = { LHREQ_IRQ, vq->config.irq };
+
+        /* Don't inform them if nothing used. */
+        if (!vq->pending_used)
+                return;
+        vq->pending_used = 0;
+
+        /* If they don't want an interrupt, don't send one... */
+        if (vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT) {
+                return;
+        }
+
+        /* Send the Guest an interrupt tell them we used something up. */
+        if (write(lguest_fd, buf, sizeof(buf)) != 0)
+                err(1, "Triggering irq %i", vq->config.irq);
+}
+
+/*
+ * This looks in the virtqueue for the first available buffer, and converts
+ * it to an iovec for convenient access.  Since descriptors consist of some
+ * number of output then some number of input descriptors, it's actually two
+ * iovecs, but we pack them into one and note how many of each there were.
+ *
+ * This function waits if necessary, and returns the descriptor number found.
+ */
+static unsigned wait_for_vq_desc(struct virtqueue *vq,
+                                 struct iovec iov[],
+                                 unsigned int *out_num, unsigned int *in_num)
+{
+        unsigned int i, head, max;
+        struct vring_desc *desc;
+        u16 last_avail = lg_last_avail(vq);
+
+        /* There's nothing available? */
+        while (last_avail == vq->vring.avail->idx) {
+                u64 event;
+
+                /*
+                 * Since we're about to sleep, now is a good time to tell the
+                 * Guest about what we've used up to now.
+                 */
+                trigger_irq(vq);
+
+                /* OK, now we need to know about added descriptors. */
+                vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
+
+                /*
+                 * They could have slipped one in as we were doing that: make
+                 * sure it's written, then check again.
+                 */
+                mb();
+                if (last_avail != vq->vring.avail->idx) {
+                        vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
+                        break;
+                }
+
+                /* Nothing new?  Wait for eventfd to tell us they refilled. */
+                if (read(vq->eventfd, &event, sizeof(event)) != sizeof(event))
+                        errx(1, "Event read failed?");
+
+                /* We don't need to be notified again. */
+                vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
+        }
+
+        /* Check it isn't doing very strange things with descriptor numbers. */
+        if ((u16)(vq->vring.avail->idx - last_avail) > vq->vring.num)
+                errx(1, "Guest moved used index from %u to %u",
+                     last_avail, vq->vring.avail->idx);
+
+        /*
+         * Grab the next descriptor number they're advertising, and increment
+         * the index we've seen.
+         */
+        head = vq->vring.avail->ring[last_avail % vq->vring.num];
+        lg_last_avail(vq)++;
+
+        /* If their number is silly, that's a fatal mistake. */
+        if (head >= vq->vring.num)
+                errx(1, "Guest says index %u is available", head);
+
+        /* When we start there are none of either input nor output. */
+        *out_num = *in_num = 0;
+
+        max = vq->vring.num;
+        desc = vq->vring.desc;
+        i = head;
+
+        /*
+         * If this is an indirect entry, then this buffer contains a descriptor
+         * table which we handle as if it's any normal descriptor chain.
+         */
+        if (desc[i].flags & VRING_DESC_F_INDIRECT) {
+                if (desc[i].len % sizeof(struct vring_desc))
+                        errx(1, "Invalid size for indirect buffer table");
+
+                max = desc[i].len / sizeof(struct vring_desc);
+                desc = check_pointer(desc[i].addr, desc[i].len);
+                i = 0;
+        }
+
+        do {
+                /* Grab the first descriptor, and check it's OK. */
+                iov[*out_num + *in_num].iov_len = desc[i].len;
+                iov[*out_num + *in_num].iov_base
+                        = check_pointer(desc[i].addr, desc[i].len);
+                /* If this is an input descriptor, increment that count. */
+                if (desc[i].flags & VRING_DESC_F_WRITE)
+                        (*in_num)++;
+                else {
+                        /*
+                         * If it's an output descriptor, they're all supposed
+                         * to come before any input descriptors.
+                         */
+                        if (*in_num)
+                                errx(1, "Descriptor has out after in");
+                        (*out_num)++;
+                }
+
+                /* If we've got too many, that implies a descriptor loop. */
+                if (*out_num + *in_num > max)
+                        errx(1, "Looped descriptor");
+        } while ((i = next_desc(desc, i, max)) != max);
+
+        return head;
+}
+
+/*
+ * After we've used one of their buffers, we tell the Guest about it.  Sometime
+ * later we'll want to send them an interrupt using trigger_irq(); note that
+ * wait_for_vq_desc() does that for us if it has to wait.
+ */
+static void add_used(struct virtqueue *vq, unsigned int head, int len)
+{
+        struct vring_used_elem *used;
+
+        /*
+         * The virtqueue contains a ring of used buffers.  Get a pointer to the
+         * next entry in that used ring.
+         */
+        used = &vq->vring.used->ring[vq->vring.used->idx % vq->vring.num];
+        used->id = head;
+        used->len = len;
+        /* Make sure buffer is written before we update index. */
+        wmb();
+        vq->vring.used->idx++;
+        vq->pending_used++;
+}
+
+/* And here's the combo meal deal.  Supersize me! */
+static void add_used_and_trigger(struct virtqueue *vq, unsigned head, int len)
+{
+        add_used(vq, head, len);
+        trigger_irq(vq);
+}
+
+/*
+ * The Console
+ *
+ * We associate some data with the console for our exit hack.
+ */
+struct console_abort {
+        /* How many times have they hit ^C? */
+        int count;
+        /* When did they start? */
+        struct timeval start;
+};
+
+/* This is the routine which handles console input (ie. stdin). */
+static void console_input(struct virtqueue *vq)
+{
+        int len;
+        unsigned int head, in_num, out_num;
+        struct console_abort *abort = vq->dev->priv;
+        struct iovec iov[vq->vring.num];
+
+        /* Make sure there's a descriptor available. */
+        head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
+        if (out_num)
+                errx(1, "Output buffers in console in queue?");
+
+        /* Read into it.  This is where we usually wait. */
+        len = readv(STDIN_FILENO, iov, in_num);
+        if (len <= 0) {
+                /* Ran out of input? */
+                warnx("Failed to get console input, ignoring console.");
+                /*
+                 * For simplicity, dying threads kill the whole Launcher.  So
+                 * just nap here.
+                 */
+                for (;;)
+                        pause();
+        }
+
+        /* Tell the Guest we used a buffer. */
+        add_used_and_trigger(vq, head, len);
+
+        /*
+         * Three ^C within one second?  Exit.
+         *
+         * This is such a hack, but works surprisingly well.  Each ^C has to
+         * be in a buffer by itself, so they can't be too fast.  But we check
+         * that we get three within about a second, so they can't be too
+         * slow.
+         */
+        if (len != 1 || ((char *)iov[0].iov_base)[0] != 3) {
+                abort->count = 0;
+                return;
+        }
+
+        abort->count++;
+        if (abort->count == 1)
+                gettimeofday(&abort->start, NULL);
+        else if (abort->count == 3) {
+                struct timeval now;
+                gettimeofday(&now, NULL);
+                /* Kill all Launcher processes with SIGINT, like normal ^C */
+                if (now.tv_sec <= abort->start.tv_sec+1)
+                        kill(0, SIGINT);
+                abort->count = 0;
+        }
+}
+
+/* This is the routine which handles console output (ie. stdout). */
+static void console_output(struct virtqueue *vq)
+{
+        unsigned int head, out, in;
+        struct iovec iov[vq->vring.num];
+
+        /* We usually wait in here, for the Guest to give us something. */
+        head = wait_for_vq_desc(vq, iov, &out, &in);
+        if (in)
+                errx(1, "Input buffers in console output queue?");
+
+        /* writev can return a partial write, so we loop here. */
+        while (!iov_empty(iov, out)) {
+                int len = writev(STDOUT_FILENO, iov, out);
+                if (len <= 0) {
+                        warn("Write to stdout gave %i (%d)", len, errno);
+                        break;
+                }
+                iov_consume(iov, out, len);
+        }
+
+        /*
+         * We're finished with that buffer: if we're going to sleep,
+         * wait_for_vq_desc() will prod the Guest with an interrupt.
+         */
+        add_used(vq, head, 0);
+}
+
+/*
+ * The Network
+ *
+ * Handling output for network is also simple: we get all the output buffers
+ * and write them to /dev/net/tun.
+ */
+struct net_info {
+        int tunfd;
+};
+
+static void net_output(struct virtqueue *vq)
+{
+        struct net_info *net_info = vq->dev->priv;
+        unsigned int head, out, in;
+        struct iovec iov[vq->vring.num];
+
+        /* We usually wait in here for the Guest to give us a packet. */
+        head = wait_for_vq_desc(vq, iov, &out, &in);
+        if (in)
+                errx(1, "Input buffers in net output queue?");
+        /*
+         * Send the whole thing through to /dev/net/tun.  It expects the exact
+         * same format: what a coincidence!
+         */
+        if (writev(net_info->tunfd, iov, out) < 0)
+                warnx("Write to tun failed (%d)?", errno);
+
+        /*
+         * Done with that one; wait_for_vq_desc() will send the interrupt if
+         * all packets are processed.
+         */
+        add_used(vq, head, 0);
+}
+
+/*
+ * Handling network input is a bit trickier, because I've tried to optimize it.
+ *
+ * First we have a helper routine which tells is if from this file descriptor
+ * (ie. the /dev/net/tun device) will block:
+ */
+static bool will_block(int fd)
+{
+        fd_set fdset;
+        struct timeval zero = { 0, 0 };
+        FD_ZERO(&fdset);
+        FD_SET(fd, &fdset);
+        return select(fd+1, &fdset, NULL, NULL, &zero) != 1;
+}
+
+/*
+ * This handles packets coming in from the tun device to our Guest.  Like all
+ * service routines, it gets called again as soon as it returns, so you don't
+ * see a while(1) loop here.
+ */
+static void net_input(struct virtqueue *vq)
+{
+        int len;
+        unsigned int head, out, in;
+        struct iovec iov[vq->vring.num];
+        struct net_info *net_info = vq->dev->priv;
+
+        /*
+         * Get a descriptor to write an incoming packet into.  This will also
+         * send an interrupt if they're out of descriptors.
+         */
+        head = wait_for_vq_desc(vq, iov, &out, &in);
+        if (out)
+                errx(1, "Output buffers in net input queue?");
+
+        /*
+         * If it looks like we'll block reading from the tun device, send them
+         * an interrupt.
+         */
+        if (vq->pending_used && will_block(net_info->tunfd))
+                trigger_irq(vq);
+
+        /*
+         * Read in the packet.  This is where we normally wait (when there's no
+         * incoming network traffic).
+         */
+        len = readv(net_info->tunfd, iov, in);
+        if (len <= 0)
+                warn("Failed to read from tun (%d).", errno);
+
+        /*
+         * Mark that packet buffer as used, but don't interrupt here.  We want
+         * to wait until we've done as much work as we can.
+         */
+        add_used(vq, head, len);
+}
+/*:*/
+
+/* This is the helper to create threads: run the service routine in a loop. */
+static int do_thread(void *_vq)
+{
+        struct virtqueue *vq = _vq;
+
+        for (;;)
+                vq->service(vq);
+        return 0;
+}
+
+/*
+ * When a child dies, we kill our entire process group with SIGTERM.  This
+ * also has the side effect that the shell restores the console for us!
+ */
+static void kill_launcher(int signal)
+{
+        kill(0, SIGTERM);
+}
+
+static void reset_device(struct device *dev)
+{
+        struct virtqueue *vq;
+
+        verbose("Resetting device %s\n", dev->name);
+
+        /* Clear any features they've acked. */
+        memset(get_feature_bits(dev) + dev->feature_len, 0, dev->feature_len);
+
+        /* We're going to be explicitly killing threads, so ignore them. */
+        signal(SIGCHLD, SIG_IGN);
+
+        /* Zero out the virtqueues, get rid of their threads */
+        for (vq = dev->vq; vq; vq = vq->next) {
+                if (vq->thread != (pid_t)-1) {
+                        kill(vq->thread, SIGTERM);
+                        waitpid(vq->thread, NULL, 0);
+                        vq->thread = (pid_t)-1;
+                }
+                memset(vq->vring.desc, 0,
+                       vring_size(vq->config.num, LGUEST_VRING_ALIGN));
+                lg_last_avail(vq) = 0;
+        }
+        dev->running = false;
+
+        /* Now we care if threads die. */
+        signal(SIGCHLD, (void *)kill_launcher);
+}
+
+/*L:216
+ * This actually creates the thread which services the virtqueue for a device.
+ */
+static void create_thread(struct virtqueue *vq)
+{
+        /*
+         * Create stack for thread.  Since the stack grows upwards, we point
+         * the stack pointer to the end of this region.
+         */
+        char *stack = malloc(32768);
+        unsigned long args[] = { LHREQ_EVENTFD,
+                                 vq->config.pfn*getpagesize(), 0 };
+
+        /* Create a zero-initialized eventfd. */
+        vq->eventfd = eventfd(0, 0);
+        if (vq->eventfd < 0)
+                err(1, "Creating eventfd");
+        args[2] = vq->eventfd;
+
+        /*
+         * Attach an eventfd to this virtqueue: it will go off when the Guest
+         * does an LHCALL_NOTIFY for this vq.
+         */
+        if (write(lguest_fd, &args, sizeof(args)) != 0)
+                err(1, "Attaching eventfd");
+
+        /*
+         * CLONE_VM: because it has to access the Guest memory, and SIGCHLD so
+         * we get a signal if it dies.
+         */
+        vq->thread = clone(do_thread, stack + 32768, CLONE_VM | SIGCHLD, vq);
+        if (vq->thread == (pid_t)-1)
+                err(1, "Creating clone");
+
+        /* We close our local copy now the child has it. */
+        close(vq->eventfd);
+}
+
+static void start_device(struct device *dev)
+{
+        unsigned int i;
+        struct virtqueue *vq;
+
+        verbose("Device %s OK: offered", dev->name);
+        for (i = 0; i < dev->feature_len; i++)
+                verbose(" %02x", get_feature_bits(dev)[i]);
+        verbose(", accepted");
+        for (i = 0; i < dev->feature_len; i++)
+                verbose(" %02x", get_feature_bits(dev)
+                        [dev->feature_len+i]);
+
+        for (vq = dev->vq; vq; vq = vq->next) {
+                if (vq->service)
+                        create_thread(vq);
+        }
+        dev->running = true;
+}
+
+static void cleanup_devices(void)
+{
+        struct device *dev;
+
+        for (dev = devices.dev; dev; dev = dev->next)
+                reset_device(dev);
+
+        /* If we saved off the original terminal settings, restore them now. */
+        if (orig_term.c_lflag & (ISIG|ICANON|ECHO))
+                tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
+}
+
+/* When the Guest tells us they updated the status field, we handle it. */
+static void update_device_status(struct device *dev)
+{
+        /* A zero status is a reset, otherwise it's a set of flags. */
+        if (dev->desc->status == 0)
+                reset_device(dev);
+        else if (dev->desc->status & VIRTIO_CONFIG_S_FAILED) {
+                warnx("Device %s configuration FAILED", dev->name);
+                if (dev->running)
+                        reset_device(dev);
+        } else {
+                if (dev->running)
+                        err(1, "Device %s features finalized twice", dev->name);
+                start_device(dev);
+        }
+}
+
+/*L:215
+ * This is the generic routine we call when the Guest uses LHCALL_NOTIFY.  In
+ * particular, it's used to notify us of device status changes during boot.
+ */
+static void handle_output(unsigned long addr)
+{
+        struct device *i;
+
+        /* Check each device. */
+        for (i = devices.dev; i; i = i->next) {
+                struct virtqueue *vq;
+
+                /*
+                 * Notifications to device descriptors mean they updated the
+                 * device status.
+                 */
+                if (from_guest_phys(addr) == i->desc) {
+                        update_device_status(i);
+                        return;
+                }
+
+                /* Devices should not be used before features are finalized. */
+                for (vq = i->vq; vq; vq = vq->next) {
+                        if (addr != vq->config.pfn*getpagesize())
+                                continue;
+                        errx(1, "Notification on %s before setup!", i->name);
+                }
+        }
+
+        /*
+         * Early console write is done using notify on a nul-terminated string
+         * in Guest memory.  It's also great for hacking debugging messages
+         * into a Guest.
+         */
+        if (addr >= guest_limit)
+                errx(1, "Bad NOTIFY %#lx", addr);
+
+        write(STDOUT_FILENO, from_guest_phys(addr),
+              strnlen(from_guest_phys(addr), guest_limit - addr));
+}
+
+/*L:190
+ * Device Setup
+ *
+ * All devices need a descriptor so the Guest knows it exists, and a "struct
+ * device" so the Launcher can keep track of it.  We have common helper
+ * routines to allocate and manage them.
+ */
+
+/*
+ * The layout of the device page is a "struct lguest_device_desc" followed by a
+ * number of virtqueue descriptors, then two sets of feature bits, then an
+ * array of configuration bytes.  This routine returns the configuration
+ * pointer.
+ */
+static u8 *device_config(const struct device *dev)
+{
+        return (void *)(dev->desc + 1)
+                + dev->num_vq * sizeof(struct lguest_vqconfig)
+                + dev->feature_len * 2;
+}
+
+/*
+ * This routine allocates a new "struct lguest_device_desc" from descriptor
+ * table page just above the Guest's normal memory.  It returns a pointer to
+ * that descriptor.
+ */
+static struct lguest_device_desc *new_dev_desc(u16 type)
+{
+        struct lguest_device_desc d = { .type = type };
+        void *p;
+
+        /* Figure out where the next device config is, based on the last one. */
+        if (devices.lastdev)
+                p = device_config(devices.lastdev)
+                        + devices.lastdev->desc->config_len;
+        else
+                p = devices.descpage;
+
+        /* We only have one page for all the descriptors. */
+        if (p + sizeof(d) > (void *)devices.descpage + getpagesize())
+                errx(1, "Too many devices");
+
+        /* p might not be aligned, so we memcpy in. */
+        return memcpy(p, &d, sizeof(d));
+}
+
+/*
+ * Each device descriptor is followed by the description of its virtqueues.  We
+ * specify how many descriptors the virtqueue is to have.
+ */
+static void add_virtqueue(struct device *dev, unsigned int num_descs,
+                          void (*service)(struct virtqueue *))
+{
+        unsigned int pages;
+        struct virtqueue **i, *vq = malloc(sizeof(*vq));
+        void *p;
+
+        /* First we need some memory for this virtqueue. */
+        pages = (vring_size(num_descs, LGUEST_VRING_ALIGN) + getpagesize() - 1)
+                / getpagesize();
+        p = get_pages(pages);
+
+        /* Initialize the virtqueue */
+        vq->next = NULL;
+        vq->last_avail_idx = 0;
+        vq->dev = dev;
+
+        /*
+         * This is the routine the service thread will run, and its Process ID
+         * once it's running.
+         */
+        vq->service = service;
+        vq->thread = (pid_t)-1;
+
+        /* Initialize the configuration. */
+        vq->config.num = num_descs;
+        vq->config.irq = devices.next_irq++;
+        vq->config.pfn = to_guest_phys(p) / getpagesize();
+
+        /* Initialize the vring. */
+        vring_init(&vq->vring, num_descs, p, LGUEST_VRING_ALIGN);
+
+        /*
+         * Append virtqueue to this device's descriptor.  We use
+         * device_config() to get the end of the device's current virtqueues;
+         * we check that we haven't added any config or feature information
+         * yet, otherwise we'd be overwriting them.
+         */
+        assert(dev->desc->config_len == 0 && dev->desc->feature_len == 0);
+        memcpy(device_config(dev), &vq->config, sizeof(vq->config));
+        dev->num_vq++;
+        dev->desc->num_vq++;
+
+        verbose("Virtqueue page %#lx\n", to_guest_phys(p));
+
+        /*
+         * Add to tail of list, so dev->vq is first vq, dev->vq->next is
+         * second.
+         */
+        for (i = &dev->vq; *i; i = &(*i)->next);
+        *i = vq;
+}
+
+/*
+ * The first half of the feature bitmask is for us to advertise features.  The
+ * second half is for the Guest to accept features.
+ */
+static void add_feature(struct device *dev, unsigned bit)
+{
+        u8 *features = get_feature_bits(dev);
+
+        /* We can't extend the feature bits once we've added config bytes */
+        if (dev->desc->feature_len <= bit / CHAR_BIT) {
+                assert(dev->desc->config_len == 0);
+                dev->feature_len = dev->desc->feature_len = (bit/CHAR_BIT) + 1;
+        }
+
+        features[bit / CHAR_BIT] |= (1 << (bit % CHAR_BIT));
+}
+
+/*
+ * This routine sets the configuration fields for an existing device's
+ * descriptor.  It only works for the last device, but that's OK because that's
+ * how we use it.
+ */
+static void set_config(struct device *dev, unsigned len, const void *conf)
+{
+        /* Check we haven't overflowed our single page. */
+        if (device_config(dev) + len > devices.descpage + getpagesize())
+                errx(1, "Too many devices");
+
+        /* Copy in the config information, and store the length. */
+        memcpy(device_config(dev), conf, len);
+        dev->desc->config_len = len;
+
+        /* Size must fit in config_len field (8 bits)! */
+        assert(dev->desc->config_len == len);
+}
+
+/*
+ * This routine does all the creation and setup of a new device, including
+ * calling new_dev_desc() to allocate the descriptor and device memory.  We
+ * don't actually start the service threads until later.
+ *
+ * See what I mean about userspace being boring?
+ */
+static struct device *new_device(const char *name, u16 type)
+{
+        struct device *dev = malloc(sizeof(*dev));
+
+        /* Now we populate the fields one at a time. */
+        dev->desc = new_dev_desc(type);
+        dev->name = name;
+        dev->vq = NULL;
+        dev->feature_len = 0;
+        dev->num_vq = 0;
+        dev->running = false;
+
+        /*
+         * Append to device list.  Prepending to a single-linked list is
+         * easier, but the user expects the devices to be arranged on the bus
+         * in command-line order.  The first network device on the command line
+         * is eth0, the first block device /dev/vda, etc.
+         */
+        if (devices.lastdev)
+                devices.lastdev->next = dev;
+        else
+                devices.dev = dev;
+        devices.lastdev = dev;
+
+        return dev;
+}
+
+/*
+ * Our first setup routine is the console.  It's a fairly simple device, but
+ * UNIX tty handling makes it uglier than it could be.
+ */
+static void setup_console(void)
+{
+        struct device *dev;
+
+        /* If we can save the initial standard input settings... */
+        if (tcgetattr(STDIN_FILENO, &orig_term) == 0) {
+                struct termios term = orig_term;
+                /*
+                 * Then we turn off echo, line buffering and ^C etc: We want a
+                 * raw input stream to the Guest.
+                 */
+                term.c_lflag &= ~(ISIG|ICANON|ECHO);
+                tcsetattr(STDIN_FILENO, TCSANOW, &term);
+        }
+
+        dev = new_device("console", VIRTIO_ID_CONSOLE);
+
+        /* We store the console state in dev->priv, and initialize it. */
+        dev->priv = malloc(sizeof(struct console_abort));
+        ((struct console_abort *)dev->priv)->count = 0;
+
+        /*
+         * The console needs two virtqueues: the input then the output.  When
+         * they put something the input queue, we make sure we're listening to
+         * stdin.  When they put something in the output queue, we write it to
+         * stdout.
+         */
+        add_virtqueue(dev, VIRTQUEUE_NUM, console_input);
+        add_virtqueue(dev, VIRTQUEUE_NUM, console_output);
+
+        verbose("device %u: console\n", ++devices.device_num);
+}
+/*:*/
+
+/*M:010
+ * Inter-guest networking is an interesting area.  Simplest is to have a
+ * --sharenet=<name> option which opens or creates a named pipe.  This can be
+ * used to send packets to another guest in a 1:1 manner.
+ *
+ * More sophisticated is to use one of the tools developed for project like UML
+ * to do networking.
+ *
+ * Faster is to do virtio bonding in kernel.  Doing this 1:1 would be
+ * completely generic ("here's my vring, attach to your vring") and would work
+ * for any traffic.  Of course, namespace and permissions issues need to be
+ * dealt with.  A more sophisticated "multi-channel" virtio_net.c could hide
+ * multiple inter-guest channels behind one interface, although it would
+ * require some manner of hotplugging new virtio channels.
+ *
+ * Finally, we could use a virtio network switch in the kernel, ie. vhost.
+:*/
+
+static u32 str2ip(const char *ipaddr)
+{
+        unsigned int b[4];
+
+        if (sscanf(ipaddr, "%u.%u.%u.%u", &b[0], &b[1], &b[2], &b[3]) != 4)
+                errx(1, "Failed to parse IP address '%s'", ipaddr);
+        return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
+}
+
+static void str2mac(const char *macaddr, unsigned char mac[6])
+{
+        unsigned int m[6];
+        if (sscanf(macaddr, "%02x:%02x:%02x:%02x:%02x:%02x",
+                   &m[0], &m[1], &m[2], &m[3], &m[4], &m[5]) != 6)
+                errx(1, "Failed to parse mac address '%s'", macaddr);
+        mac[0] = m[0];
+        mac[1] = m[1];
+        mac[2] = m[2];
+        mac[3] = m[3];
+        mac[4] = m[4];
+        mac[5] = m[5];
+}
+
+/*
+ * This code is "adapted" from libbridge: it attaches the Host end of the
+ * network device to the bridge device specified by the command line.
+ *
+ * This is yet another James Morris contribution (I'm an IP-level guy, so I
+ * dislike bridging), and I just try not to break it.
+ */
+static void add_to_bridge(int fd, const char *if_name, const char *br_name)
+{
+        int ifidx;
+        struct ifreq ifr;
+
+        if (!*br_name)
+                errx(1, "must specify bridge name");
+
+        ifidx = if_nametoindex(if_name);
+        if (!ifidx)
+                errx(1, "interface %s does not exist!", if_name);
+
+        strncpy(ifr.ifr_name, br_name, IFNAMSIZ);
+        ifr.ifr_name[IFNAMSIZ-1] = '\0';
+        ifr.ifr_ifindex = ifidx;
+        if (ioctl(fd, SIOCBRADDIF, &ifr) < 0)
+                err(1, "can't add %s to bridge %s", if_name, br_name);
+}
+
+/*
+ * This sets up the Host end of the network device with an IP address, brings
+ * it up so packets will flow, the copies the MAC address into the hwaddr
+ * pointer.
+ */
+static void configure_device(int fd, const char *tapif, u32 ipaddr)
+{
+        struct ifreq ifr;
+        struct sockaddr_in sin;
+
+        memset(&ifr, 0, sizeof(ifr));
+        strcpy(ifr.ifr_name, tapif);
+
+        /* Don't read these incantations.  Just cut & paste them like I did! */
+        sin.sin_family = AF_INET;
+        sin.sin_addr.s_addr = htonl(ipaddr);
+        memcpy(&ifr.ifr_addr, &sin, sizeof(sin));
+        if (ioctl(fd, SIOCSIFADDR, &ifr) != 0)
+                err(1, "Setting %s interface address", tapif);
+        ifr.ifr_flags = IFF_UP;
+        if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0)
+                err(1, "Bringing interface %s up", tapif);
+}
+
+static int get_tun_device(char tapif[IFNAMSIZ])
+{
+        struct ifreq ifr;
+        int netfd;
+
+        /* Start with this zeroed.  Messy but sure. */
+        memset(&ifr, 0, sizeof(ifr));
+
+        /*
+         * We open the /dev/net/tun device and tell it we want a tap device.  A
+         * tap device is like a tun device, only somehow different.  To tell
+         * the truth, I completely blundered my way through this code, but it
+         * works now!
+         */
+        netfd = open_or_die("/dev/net/tun", O_RDWR);
+        ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR;
+        strcpy(ifr.ifr_name, "tap%d");
+        if (ioctl(netfd, TUNSETIFF, &ifr) != 0)
+                err(1, "configuring /dev/net/tun");
+
+        if (ioctl(netfd, TUNSETOFFLOAD,
+                  TUN_F_CSUM|TUN_F_TSO4|TUN_F_TSO6|TUN_F_TSO_ECN) != 0)
+                err(1, "Could not set features for tun device");
+
+        /*
+         * We don't need checksums calculated for packets coming in this
+         * device: trust us!
+         */
+        ioctl(netfd, TUNSETNOCSUM, 1);
+
+        memcpy(tapif, ifr.ifr_name, IFNAMSIZ);
+        return netfd;
+}
+
+/*L:195
+ * Our network is a Host<->Guest network.  This can either use bridging or
+ * routing, but the principle is the same: it uses the "tun" device to inject
+ * packets into the Host as if they came in from a normal network card.  We
+ * just shunt packets between the Guest and the tun device.
+ */
+static void setup_tun_net(char *arg)
+{
+        struct device *dev;
+        struct net_info *net_info = malloc(sizeof(*net_info));
+        int ipfd;
+        u32 ip = INADDR_ANY;
+        bool bridging = false;
+        char tapif[IFNAMSIZ], *p;
+        struct virtio_net_config conf;
+
+        net_info->tunfd = get_tun_device(tapif);
+
+        /* First we create a new network device. */
+        dev = new_device("net", VIRTIO_ID_NET);
+        dev->priv = net_info;
+
+        /* Network devices need a recv and a send queue, just like console. */
+        add_virtqueue(dev, VIRTQUEUE_NUM, net_input);
+        add_virtqueue(dev, VIRTQUEUE_NUM, net_output);
+
+        /*
+         * We need a socket to perform the magic network ioctls to bring up the
+         * tap interface, connect to the bridge etc.  Any socket will do!
+         */
+        ipfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
+        if (ipfd < 0)
+                err(1, "opening IP socket");
+
+        /* If the command line was --tunnet=bridge:<name> do bridging. */
+        if (!strncmp(BRIDGE_PFX, arg, strlen(BRIDGE_PFX))) {
+                arg += strlen(BRIDGE_PFX);
+                bridging = true;
+        }
+
+        /* A mac address may follow the bridge name or IP address */
+        p = strchr(arg, ':');
+        if (p) {
+                str2mac(p+1, conf.mac);
+                add_feature(dev, VIRTIO_NET_F_MAC);
+                *p = '\0';
+        }
+
+        /* arg is now either an IP address or a bridge name */
+        if (bridging)
+                add_to_bridge(ipfd, tapif, arg);
+        else
+                ip = str2ip(arg);
+
+        /* Set up the tun device. */
+        configure_device(ipfd, tapif, ip);
+
+        /* Expect Guest to handle everything except UFO */
+        add_feature(dev, VIRTIO_NET_F_CSUM);
+        add_feature(dev, VIRTIO_NET_F_GUEST_CSUM);
+        add_feature(dev, VIRTIO_NET_F_GUEST_TSO4);
+        add_feature(dev, VIRTIO_NET_F_GUEST_TSO6);
+        add_feature(dev, VIRTIO_NET_F_GUEST_ECN);
+        add_feature(dev, VIRTIO_NET_F_HOST_TSO4);
+        add_feature(dev, VIRTIO_NET_F_HOST_TSO6);
+        add_feature(dev, VIRTIO_NET_F_HOST_ECN);
+        /* We handle indirect ring entries */
+        add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC);
+        set_config(dev, sizeof(conf), &conf);
+
+        /* We don't need the socket any more; setup is done. */
+        close(ipfd);
+
+        devices.device_num++;
+
+        if (bridging)
+                verbose("device %u: tun %s attached to bridge: %s\n",
+                        devices.device_num, tapif, arg);
+        else
+                verbose("device %u: tun %s: %s\n",
+                        devices.device_num, tapif, arg);
+}
+/*:*/
+
+/* This hangs off device->priv. */
+struct vblk_info {
+        /* The size of the file. */
+        off64_t len;
+
+        /* The file descriptor for the file. */
+        int fd;
+
+};
+
+/*L:210
+ * The Disk
+ *
+ * The disk only has one virtqueue, so it only has one thread.  It is really
+ * simple: the Guest asks for a block number and we read or write that position
+ * in the file.
+ *
+ * Before we serviced each virtqueue in a separate thread, that was unacceptably
+ * slow: the Guest waits until the read is finished before running anything
+ * else, even if it could have been doing useful work.
+ *
+ * We could have used async I/O, except it's reputed to suck so hard that
+ * characters actually go missing from your code when you try to use it.
+ */
+static void blk_request(struct virtqueue *vq)
+{
+        struct vblk_info *vblk = vq->dev->priv;
+        unsigned int head, out_num, in_num, wlen;
+        int ret;
+        u8 *in;
+        struct virtio_blk_outhdr *out;
+        struct iovec iov[vq->vring.num];
+        off64_t off;
+
+        /*
+         * Get the next request, where we normally wait.  It triggers the
+         * interrupt to acknowledge previously serviced requests (if any).
+         */
+        head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
+
+        /*
+         * Every block request should contain at least one output buffer
+         * (detailing the location on disk and the type of request) and one
+         * input buffer (to hold the result).
+         */
+        if (out_num == 0 || in_num == 0)
+                errx(1, "Bad virtblk cmd %u out=%u in=%u",
+                     head, out_num, in_num);
+
+        out = convert(&iov[0], struct virtio_blk_outhdr);
+        in = convert(&iov[out_num+in_num-1], u8);
+        /*
+         * For historical reasons, block operations are expressed in 512 byte
+         * "sectors".
+         */
+        off = out->sector * 512;
+
+        /*
+         * In general the virtio block driver is allowed to try SCSI commands.
+         * It'd be nice if we supported eject, for example, but we don't.
+         */
+        if (out->type & VIRTIO_BLK_T_SCSI_CMD) {
+                fprintf(stderr, "Scsi commands unsupported\n");
+                *in = VIRTIO_BLK_S_UNSUPP;
+                wlen = sizeof(*in);
+        } else if (out->type & VIRTIO_BLK_T_OUT) {
+                /*
+                 * Write
+                 *
+                 * Move to the right location in the block file.  This can fail
+                 * if they try to write past end.
+                 */
+                if (lseek64(vblk->fd, off, SEEK_SET) != off)
+                        err(1, "Bad seek to sector %llu", out->sector);
+
+                ret = writev(vblk->fd, iov+1, out_num-1);
+                verbose("WRITE to sector %llu: %i\n", out->sector, ret);
+
+                /*
+                 * Grr... Now we know how long the descriptor they sent was, we
+                 * make sure they didn't try to write over the end of the block
+                 * file (possibly extending it).
+                 */
+                if (ret > 0 && off + ret > vblk->len) {
+                        /* Trim it back to the correct length */
+                        ftruncate64(vblk->fd, vblk->len);
+                        /* Die, bad Guest, die. */
+                        errx(1, "Write past end %llu+%u", off, ret);
+                }
+
+                wlen = sizeof(*in);
+                *in = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
+        } else if (out->type & VIRTIO_BLK_T_FLUSH) {
+                /* Flush */
+                ret = fdatasync(vblk->fd);
+                verbose("FLUSH fdatasync: %i\n", ret);
+                wlen = sizeof(*in);
+                *in = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
+        } else {
+                /*
+                 * Read
+                 *
+                 * Move to the right location in the block file.  This can fail
+                 * if they try to read past end.
+                 */
+                if (lseek64(vblk->fd, off, SEEK_SET) != off)
+                        err(1, "Bad seek to sector %llu", out->sector);
+
+                ret = readv(vblk->fd, iov+1, in_num-1);
+                verbose("READ from sector %llu: %i\n", out->sector, ret);
+                if (ret >= 0) {
+                        wlen = sizeof(*in) + ret;
+                        *in = VIRTIO_BLK_S_OK;
+                } else {
+                        wlen = sizeof(*in);
+                        *in = VIRTIO_BLK_S_IOERR;
+                }
+        }
+
+        /* Finished that request. */
+        add_used(vq, head, wlen);
+}
+
+/*L:198 This actually sets up a virtual block device. */
+static void setup_block_file(const char *filename)
+{
+        struct device *dev;
+        struct vblk_info *vblk;
+        struct virtio_blk_config conf;
+
+        /* Creat the device. */
+        dev = new_device("block", VIRTIO_ID_BLOCK);
+
+        /* The device has one virtqueue, where the Guest places requests. */
+        add_virtqueue(dev, VIRTQUEUE_NUM, blk_request);
+
+        /* Allocate the room for our own bookkeeping */
+        vblk = dev->priv = malloc(sizeof(*vblk));
+
+        /* First we open the file and store the length. */
+        vblk->fd = open_or_die(filename, O_RDWR|O_LARGEFILE);
+        vblk->len = lseek64(vblk->fd, 0, SEEK_END);
+
+        /* We support FLUSH. */
+        add_feature(dev, VIRTIO_BLK_F_FLUSH);
+
+        /* Tell Guest how many sectors this device has. */
+        conf.capacity = cpu_to_le64(vblk->len / 512);
+
+        /*
+         * Tell Guest not to put in too many descriptors at once: two are used
+         * for the in and out elements.
+         */
+        add_feature(dev, VIRTIO_BLK_F_SEG_MAX);
+        conf.seg_max = cpu_to_le32(VIRTQUEUE_NUM - 2);
+
+        /* Don't try to put whole struct: we have 8 bit limit. */
+        set_config(dev, offsetof(struct virtio_blk_config, geometry), &conf);
+
+        verbose("device %u: virtblock %llu sectors\n",
+                ++devices.device_num, le64_to_cpu(conf.capacity));
+}
+
+/*L:211
+ * Our random number generator device reads from /dev/random into the Guest's
+ * input buffers.  The usual case is that the Guest doesn't want random numbers
+ * and so has no buffers although /dev/random is still readable, whereas
+ * console is the reverse.
+ *
+ * The same logic applies, however.
+ */
+struct rng_info {
+        int rfd;
+};
+
+static void rng_input(struct virtqueue *vq)
+{
+        int len;
+        unsigned int head, in_num, out_num, totlen = 0;
+        struct rng_info *rng_info = vq->dev->priv;
+        struct iovec iov[vq->vring.num];
+
+        /* First we need a buffer from the Guests's virtqueue. */
+        head = wait_for_vq_desc(vq, iov, &out_num, &in_num);
+        if (out_num)
+                errx(1, "Output buffers in rng?");
+
+        /*
+         * Just like the console write, we loop to cover the whole iovec.
+         * In this case, short reads actually happen quite a bit.
+         */
+        while (!iov_empty(iov, in_num)) {
+                len = readv(rng_info->rfd, iov, in_num);
+                if (len <= 0)
+                        err(1, "Read from /dev/random gave %i", len);
+                iov_consume(iov, in_num, len);
+                totlen += len;
+        }
+
+        /* Tell the Guest about the new input. */
+        add_used(vq, head, totlen);
+}
+
+/*L:199
+ * This creates a "hardware" random number device for the Guest.
+ */
+static void setup_rng(void)
+{
+        struct device *dev;
+        struct rng_info *rng_info = malloc(sizeof(*rng_info));
+
+        /* Our device's privat info simply contains the /dev/random fd. */
+        rng_info->rfd = open_or_die("/dev/random", O_RDONLY);
+
+        /* Create the new device. */
+        dev = new_device("rng", VIRTIO_ID_RNG);
+        dev->priv = rng_info;
+
+        /* The device has one virtqueue, where the Guest places inbufs. */
+        add_virtqueue(dev, VIRTQUEUE_NUM, rng_input);
+
+        verbose("device %u: rng\n", devices.device_num++);
+}
+/* That's the end of device setup. */
+
+/*L:230 Reboot is pretty easy: clean up and exec() the Launcher afresh. */
+static void __attribute__((noreturn)) restart_guest(void)
+{
+        unsigned int i;
+
+        /*
+         * Since we don't track all open fds, we simply close everything beyond
+         * stderr.
+         */
+        for (i = 3; i < FD_SETSIZE; i++)
+                close(i);
+
+        /* Reset all the devices (kills all threads). */
+        cleanup_devices();
+
+        execv(main_args[0], main_args);
+        err(1, "Could not exec %s", main_args[0]);
+}
+
+/*L:220
+ * Finally we reach the core of the Launcher which runs the Guest, serves
+ * its input and output, and finally, lays it to rest.
+ */
+static void __attribute__((noreturn)) run_guest(void)
+{
+        for (;;) {
+                unsigned long notify_addr;
+                int readval;
+
+                /* We read from the /dev/lguest device to run the Guest. */
+                readval = pread(lguest_fd, &notify_addr,
+                                sizeof(notify_addr), cpu_id);
+
+                /* One unsigned long means the Guest did HCALL_NOTIFY */
+                if (readval == sizeof(notify_addr)) {
+                        verbose("Notify on address %#lx\n", notify_addr);
+                        handle_output(notify_addr);
+                /* ENOENT means the Guest died.  Reading tells us why. */
+                } else if (errno == ENOENT) {
+                        char reason[1024] = { 0 };
+                        pread(lguest_fd, reason, sizeof(reason)-1, cpu_id);
+                        errx(1, "%s", reason);
+                /* ERESTART means that we need to reboot the guest */
+                } else if (errno == ERESTART) {
+                        restart_guest();
+                /* Anything else means a bug or incompatible change. */
+                } else
+                        err(1, "Running guest failed");
+        }
+}
+/*L:240
+ * This is the end of the Launcher.  The good news: we are over halfway
+ * through!  The bad news: the most fiendish part of the code still lies ahead
+ * of us.
+ *
+ * Are you ready?  Take a deep breath and join me in the core of the Host, in
+ * "make Host".
+:*/
+
+static struct option opts[] = {
+        { "verbose", 0, NULL, 'v' },
+        { "tunnet", 1, NULL, 't' },
+        { "block", 1, NULL, 'b' },
+        { "rng", 0, NULL, 'r' },
+        { "initrd", 1, NULL, 'i' },
+        { "username", 1, NULL, 'u' },
+        { "chroot", 1, NULL, 'c' },
+        { NULL },
+};
+static void usage(void)
+{
+        errx(1, "Usage: lguest [--verbose] "
+             "[--tunnet=(<ipaddr>:<macaddr>|bridge:<bridgename>:<macaddr>)\n"
+             "|--block=<filename>|--initrd=<filename>]...\n"
+             "<mem-in-mb> vmlinux [args...]");
+}
+
+/*L:105 The main routine is where the real work begins: */
+int main(int argc, char *argv[])
+{
+        /* Memory, code startpoint and size of the (optional) initrd. */
+        unsigned long mem = 0, start, initrd_size = 0;
+        /* Two temporaries. */
+        int i, c;
+        /* The boot information for the Guest. */
+        struct boot_params *boot;
+        /* If they specify an initrd file to load. */
+        const char *initrd_name = NULL;
+
+        /* Password structure for initgroups/setres[gu]id */
+        struct passwd *user_details = NULL;
+
+        /* Directory to chroot to */
+        char *chroot_path = NULL;
+
+        /* Save the args: we "reboot" by execing ourselves again. */
+        main_args = argv;
+
+        /*
+         * First we initialize the device list.  We keep a pointer to the last
+         * device, and the next interrupt number to use for devices (1:
+         * remember that 0 is used by the timer).
+         */
+        devices.lastdev = NULL;
+        devices.next_irq = 1;
+
+        /* We're CPU 0.  In fact, that's the only CPU possible right now. */
+        cpu_id = 0;
+
+        /*
+         * We need to know how much memory so we can set up the device
+         * descriptor and memory pages for the devices as we parse the command
+         * line.  So we quickly look through the arguments to find the amount
+         * of memory now.
+         */
+        for (i = 1; i < argc; i++) {
+                if (argv[i][0] != '-') {
+                        mem = atoi(argv[i]) * 1024 * 1024;
+                        /*
+                         * We start by mapping anonymous pages over all of
+                         * guest-physical memory range.  This fills it with 0,
+                         * and ensures that the Guest won't be killed when it
+                         * tries to access it.
+                         */
+                        guest_base = map_zeroed_pages(mem / getpagesize()
+                                                      + DEVICE_PAGES);
+                        guest_limit = mem;
+                        guest_max = mem + DEVICE_PAGES*getpagesize();
+                        devices.descpage = get_pages(1);
+                        break;
+                }
+        }
+
+        /* The options are fairly straight-forward */
+        while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) {
+                switch (c) {
+                case 'v':
+                        verbose = true;
+                        break;
+                case 't':
+                        setup_tun_net(optarg);
+                        break;
+                case 'b':
+                        setup_block_file(optarg);
+                        break;
+                case 'r':
+                        setup_rng();
+                        break;
+                case 'i':
+                        initrd_name = optarg;
+                        break;
+                case 'u':
+                        user_details = getpwnam(optarg);
+                        if (!user_details)
+                                err(1, "getpwnam failed, incorrect username?");
+                        break;
+                case 'c':
+                        chroot_path = optarg;
+                        break;
+                default:
+                        warnx("Unknown argument %s", argv[optind]);
+                        usage();
+                }
+        }
+        /*
+         * After the other arguments we expect memory and kernel image name,
+         * followed by command line arguments for the kernel.
+         */
+        if (optind + 2 > argc)
+                usage();
+
+        verbose("Guest base is at %p\n", guest_base);
+
+        /* We always have a console device */
+        setup_console();
+
+        /* Now we load the kernel */
+        start = load_kernel(open_or_die(argv[optind+1], O_RDONLY));
+
+        /* Boot information is stashed at physical address 0 */
+        boot = from_guest_phys(0);
+
+        /* Map the initrd image if requested (at top of physical memory) */
+        if (initrd_name) {
+                initrd_size = load_initrd(initrd_name, mem);
+                /*
+                 * These are the location in the Linux boot header where the
+                 * start and size of the initrd are expected to be found.
+                 */
+                boot->hdr.ramdisk_image = mem - initrd_size;
+                boot->hdr.ramdisk_size = initrd_size;
+                /* The bootloader type 0xFF means "unknown"; that's OK. */
+                boot->hdr.type_of_loader = 0xFF;
+        }
+
+        /*
+         * The Linux boot header contains an "E820" memory map: ours is a
+         * simple, single region.
+         */
+        boot->e820_entries = 1;
+        boot->e820_map[0] = ((struct e820entry) { 0, mem, E820_RAM });
+        /*
+         * The boot header contains a command line pointer: we put the command
+         * line after the boot header.
+         */
+        boot->hdr.cmd_line_ptr = to_guest_phys(boot + 1);
+        /* We use a simple helper to copy the arguments separated by spaces. */
+        concat((char *)(boot + 1), argv+optind+2);
+
+        /* Set kernel alignment to 16M (CONFIG_PHYSICAL_ALIGN) */
+        boot->hdr.kernel_alignment = 0x1000000;
+
+        /* Boot protocol version: 2.07 supports the fields for lguest. */
+        boot->hdr.version = 0x207;
+
+        /* The hardware_subarch value of "1" tells the Guest it's an lguest. */
+        boot->hdr.hardware_subarch = 1;
+
+        /* Tell the entry path not to try to reload segment registers. */
+        boot->hdr.loadflags |= KEEP_SEGMENTS;
+
+        /* We tell the kernel to initialize the Guest. */
+        tell_kernel(start);
+
+        /* Ensure that we terminate if a device-servicing child dies. */
+        signal(SIGCHLD, kill_launcher);
+
+        /* If we exit via err(), this kills all the threads, restores tty. */
+        atexit(cleanup_devices);
+
+        /* If requested, chroot to a directory */
+        if (chroot_path) {
+                if (chroot(chroot_path) != 0)
+                        err(1, "chroot(\"%s\") failed", chroot_path);
+
+                if (chdir("/") != 0)
+                        err(1, "chdir(\"/\") failed");
+
+                verbose("chroot done\n");
+        }
+
+        /* If requested, drop privileges */
+        if (user_details) {
+                uid_t u;
+                gid_t g;
+
+                u = user_details->pw_uid;
+                g = user_details->pw_gid;
+
+                if (initgroups(user_details->pw_name, g) != 0)
+                        err(1, "initgroups failed");
+
+                if (setresgid(g, g, g) != 0)
+                        err(1, "setresgid failed");
+
+                if (setresuid(u, u, u) != 0)
+                        err(1, "setresuid failed");
+
+                verbose("Dropping privileges completed\n");
+        }
+
+        /* Finally, run the Guest.  This doesn't return. */
+        run_guest();
+}
+/*:*/
+
+/*M:999
+ * Mastery is done: you now know everything I do.
+ *
+ * But surely you have seen code, features and bugs in your wanderings which
+ * you now yearn to attack?  That is the real game, and I look forward to you
+ * patching and forking lguest into the Your-Name-Here-visor.
+ *
+ * Farewell, and good coding!
+ * Rusty Russell.
+ */
diff --git a/tools/lguest/lguest.txt b/tools/lguest/lguest.txt
new file mode 100644
index 000000000000..bff0c554485d
--- /dev/null
+++ b/tools/lguest/lguest.txt
@@ -0,0 +1,129 @@
+      __
+ (___()'`;  Rusty's Remarkably Unreliable Guide to Lguest
+ /,    /`      - or, A Young Coder's Illustrated Hypervisor
+ \\"--\\    http://lguest.ozlabs.org
+
+Lguest is designed to be a minimal 32-bit x86 hypervisor for the Linux kernel,
+for Linux developers and users to experiment with virtualization with the
+minimum of complexity.  Nonetheless, it should have sufficient features to
+make it useful for specific tasks, and, of course, you are encouraged to fork
+and enhance it (see drivers/lguest/README).
+
+Features:
+
+- Kernel module which runs in a normal kernel.
+- Simple I/O model for communication.
+- Simple program to create new guests.
+- Logo contains cute puppies: http://lguest.ozlabs.org
+
+Developer features:
+
+- Fun to hack on.
+- No ABI: being tied to a specific kernel anyway, you can change anything.
+- Many opportunities for improvement or feature implementation.
+
+Running Lguest:
+
+- The easiest way to run lguest is to use same kernel as guest and host.
+  You can configure them differently, but usually it's easiest not to.
+
+  You will need to configure your kernel with the following options:
+
+  "General setup":
+     "Prompt for development and/or incomplete code/drivers" = Y
+        (CONFIG_EXPERIMENTAL=y)
+
+  "Processor type and features":
+     "Paravirtualized guest support" = Y
+        "Lguest guest support" = Y
+     "High Memory Support" = off/4GB
+     "Alignment value to which kernel should be aligned" = 0x100000
+        (CONFIG_PARAVIRT=y, CONFIG_LGUEST_GUEST=y, CONFIG_HIGHMEM64G=n and
+         CONFIG_PHYSICAL_ALIGN=0x100000)
+
+  "Device Drivers":
+     "Block devices"
+        "Virtio block driver (EXPERIMENTAL)" = M/Y
+     "Network device support"
+        "Universal TUN/TAP device driver support" = M/Y
+        "Virtio network driver (EXPERIMENTAL)" = M/Y
+           (CONFIG_VIRTIO_BLK=m, CONFIG_VIRTIO_NET=m and CONFIG_TUN=m)
+
+  "Virtualization"
+     "Linux hypervisor example code" = M/Y
+        (CONFIG_LGUEST=m)
+
+- A tool called "lguest" is available in this directory: type "make"
+  to build it.  If you didn't build your kernel in-tree, use "make
+  O=<builddir>".
+
+- Create or find a root disk image.  There are several useful ones
+  around, such as the xm-test tiny root image at
+          http://xm-test.xensource.com/ramdisks/initrd-1.1-i386.img
+
+  For more serious work, I usually use a distribution ISO image and
+  install it under qemu, then make multiple copies:
+
+          dd if=/dev/zero of=rootfile bs=1M count=2048
+          qemu -cdrom image.iso -hda rootfile -net user -net nic -boot d
+
+  Make sure that you install a getty on /dev/hvc0 if you want to log in on the
+  console!
+
+- "modprobe lg" if you built it as a module.
+
+- Run an lguest as root:
+
+      Documentation/virtual/lguest/lguest 64 vmlinux --tunnet=192.168.19.1 \
+        --block=rootfile root=/dev/vda
+
+   Explanation:
+    64: the amount of memory to use, in MB.
+
+    vmlinux: the kernel image found in the top of your build directory.  You
+       can also use a standard bzImage.
+
+    --tunnet=192.168.19.1: configures a "tap" device for networking with this
+       IP address.
+
+    --block=rootfile: a file or block device which becomes /dev/vda
+       inside the guest.
+
+    root=/dev/vda: this (and anything else on the command line) are
+       kernel boot parameters.
+
+- Configuring networking.  I usually have the host masquerade, using
+  "iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE" and "echo 1 >
+  /proc/sys/net/ipv4/ip_forward".  In this example, I would configure
+  eth0 inside the guest at 192.168.19.2.
+
+  Another method is to bridge the tap device to an external interface
+  using --tunnet=bridge:<bridgename>, and perhaps run dhcp on the guest
+  to obtain an IP address.  The bridge needs to be configured first:
+  this option simply adds the tap interface to it.
+
+  A simple example on my system:
+
+    ifconfig eth0 0.0.0.0
+    brctl addbr lg0
+    ifconfig lg0 up
+    brctl addif lg0 eth0
+    dhclient lg0
+
+  Then use --tunnet=bridge:lg0 when launching the guest.
+
+  See:
+  
+    http://www.linuxfoundation.org/collaborate/workgroups/networking/bridge
+    
+  for general information on how to get bridging to work.
+
+- Random number generation. Using the --rng option will provide a
+  /dev/hwrng in the guest that will read from the host's /dev/random.
+  Use this option in conjunction with rng-tools (see ../hw_random.txt)
+  to provide entropy to the guest kernel's /dev/random.
+
+There is a helpful mailing list at http://ozlabs.org/mailman/listinfo/lguest
+
+Good luck!
+Rusty Russell rusty@rustcorp.com.au.
diff --git a/tools/nfsd/inject_fault.sh b/tools/nfsd/inject_fault.sh
new file mode 100755
index 000000000000..06a399ac8b2f
--- /dev/null
+++ b/tools/nfsd/inject_fault.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+#
+# Copyright (c) 2011 Bryan Schumaker <bjschuma@netapp.com>
+#
+# Script for easier NFSD fault injection
+
+# Check that debugfs has been mounted
+DEBUGFS=`cat /proc/mounts | grep debugfs`
+if [ "$DEBUGFS" == "" ]; then
+        echo "debugfs does not appear to be mounted!"
+        echo "Please mount debugfs and try again"
+        exit 1
+fi
+
+# Check that the fault injection directory exists
+DEBUGDIR=`echo $DEBUGFS | awk '{print $2}'`/nfsd
+if [ ! -d "$DEBUGDIR" ]; then
+        echo "$DEBUGDIR does not exist"
+        echo "Check that your .config selects CONFIG_NFSD_FAULT_INJECTION"
+        exit 1
+fi
+
+function help()
+{
+        echo "Usage $0 injection_type [count]"
+        echo ""
+        echo "Injection types are:"
+        ls $DEBUGDIR
+        exit 1
+}
+
+if [ $# == 0 ]; then
+        help
+elif [ ! -f $DEBUGDIR/$1 ]; then
+        help
+elif [ $# != 2 ]; then
+        COUNT=0
+else
+        COUNT=$2
+fi
+
+BEFORE=`mktemp`
+AFTER=`mktemp`
+dmesg > $BEFORE
+echo $COUNT > $DEBUGDIR/$1
+dmesg > $AFTER
+# Capture lines that only exist in the $AFTER file
+diff $BEFORE $AFTER | grep ">"
+rm -f $BEFORE $AFTER
diff --git a/tools/perf/Documentation/examples.txt b/tools/perf/Documentation/examples.txt
index 8eb6c489fb15..77f952762426 100644
--- a/tools/perf/Documentation/examples.txt
+++ b/tools/perf/Documentation/examples.txt
@@ -17,8 +17,8 @@ titan:~> perf list
   kmem:kmem_cache_alloc_node               [Tracepoint event]
   kmem:kfree                               [Tracepoint event]
   kmem:kmem_cache_free                     [Tracepoint event]
-  kmem:mm_page_free_direct                 [Tracepoint event]
-  kmem:mm_pagevec_free                     [Tracepoint event]
+  kmem:mm_page_free                        [Tracepoint event]
+  kmem:mm_page_free_batched                [Tracepoint event]
   kmem:mm_page_alloc                       [Tracepoint event]
   kmem:mm_page_alloc_zone_locked           [Tracepoint event]
   kmem:mm_page_pcpu_drain                  [Tracepoint event]
@@ -29,15 +29,15 @@ measured. For example the page alloc/free properties of a 'hackbench
 run' are:
 
  titan:~> perf stat -e kmem:mm_page_pcpu_drain -e kmem:mm_page_alloc
- -e kmem:mm_pagevec_free -e kmem:mm_page_free_direct ./hackbench 10
+ -e kmem:mm_page_free_batched -e kmem:mm_page_free ./hackbench 10
  Time: 0.575
 
  Performance counter stats for './hackbench 10':
 
           13857  kmem:mm_page_pcpu_drain
           27576  kmem:mm_page_alloc
-           6025  kmem:mm_pagevec_free
-          20934  kmem:mm_page_free_direct
+           6025  kmem:mm_page_free_batched
+          20934  kmem:mm_page_free
 
     0.613972165  seconds time elapsed
 
@@ -45,8 +45,8 @@ You can observe the statistical properties as well, by using the
 'repeat the workload N times' feature of perf stat:
 
  titan:~> perf stat --repeat 5 -e kmem:mm_page_pcpu_drain -e
-   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-   kmem:mm_page_free_direct ./hackbench 10
+   kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+   kmem:mm_page_free ./hackbench 10
  Time: 0.627
  Time: 0.644
  Time: 0.564
@@ -57,8 +57,8 @@ You can observe the statistical properties as well, by using the
 
           12920  kmem:mm_page_pcpu_drain    ( +-   3.359% )
           25035  kmem:mm_page_alloc         ( +-   3.783% )
-           6104  kmem:mm_pagevec_free       ( +-   0.934% )
-          18376  kmem:mm_page_free_direct   ( +-   4.941% )
+           6104  kmem:mm_page_free_batched  ( +-   0.934% )
+          18376  kmem:mm_page_free          ( +-   4.941% )
 
     0.643954516  seconds time elapsed   ( +-   2.363% )
 
@@ -158,15 +158,15 @@ Or you can observe the whole system's page allocations for 10
 seconds:
 
 titan:~/git> perf stat -a -e kmem:mm_page_pcpu_drain -e
-kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-kmem:mm_page_free_direct sleep 10
+kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+kmem:mm_page_free sleep 10
 
  Performance counter stats for 'sleep 10':
 
          171585  kmem:mm_page_pcpu_drain
          322114  kmem:mm_page_alloc
-          73623  kmem:mm_pagevec_free
-         254115  kmem:mm_page_free_direct
+          73623  kmem:mm_page_free_batched
+         254115  kmem:mm_page_free
 
    10.000591410  seconds time elapsed
 
@@ -174,15 +174,15 @@ Or observe how fluctuating the page allocations are, via statistical
 analysis done over ten 1-second intervals:
 
  titan:~/git> perf stat --repeat 10 -a -e kmem:mm_page_pcpu_drain -e
-   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-   kmem:mm_page_free_direct sleep 1
+   kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+   kmem:mm_page_free sleep 1
 
  Performance counter stats for 'sleep 1' (10 runs):
 
           17254  kmem:mm_page_pcpu_drain    ( +-   3.709% )
           34394  kmem:mm_page_alloc         ( +-   4.617% )
-           7509  kmem:mm_pagevec_free       ( +-   4.820% )
-          25653  kmem:mm_page_free_direct   ( +-   3.672% )
+           7509  kmem:mm_page_free_batched  ( +-   4.820% )
+          25653  kmem:mm_page_free          ( +-   3.672% )
 
     1.058135029  seconds time elapsed   ( +-   3.089% )
 
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index 7a527f7e9da9..ddc22525228d 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -21,6 +21,8 @@ EVENT MODIFIERS
 Events can optionally have a modifer by appending a colon and one or
 more modifiers.  Modifiers allow the user to restrict when events are
 counted with 'u' for user-space, 'k' for kernel, 'h' for hypervisor.
+Additional modifiers are 'G' for guest counting (in KVM guests) and 'H'
+for host counting (not in KVM guests).
 
 The 'p' modifier can be used for specifying how precise the instruction
 address should be. The 'p' modifier is currently only implemented for
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index c12659d8cb26..1078c5fadd5b 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -1,4 +1,5 @@
 tools/perf
+include/linux/const.h
 include/linux/perf_event.h
 include/linux/rbtree.h
 include/linux/list.h
diff --git a/tools/perf/arch/powerpc/util/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
index 48ae0c5e3f73..7cdd61d0e27c 100644
--- a/tools/perf/arch/powerpc/util/dwarf-regs.c
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -9,7 +9,10 @@
  * 2 of the License, or (at your option) any later version.
  */
 
+#include <stdlib.h>
+#ifndef __UCLIBC__
 #include <libio.h>
+#endif
 #include <dwarf-regs.h>
 
 
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 214ba7f9f577..806e0a286634 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -235,7 +235,7 @@ out_delete:
 }
 
 static const char * const annotate_usage[] = {
-        "perf annotate [<options>] <command>",
+        "perf annotate [<options>]",
         NULL
 };
 
@@ -313,10 +313,5 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 annotate.sym_hist_filter = argv[0];
         }
 
-        if (field_sep && *field_sep == '.') {
-                pr_err("'.' is the only non valid --field-separator argument\n");
-                return -1;
-        }
-
         return __cmd_annotate(&annotate);
 }
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index fe1ad8f21961..39104c0beea3 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -108,7 +108,9 @@ static void setup_cpunode_map(void)
                                 continue;
                         cpunode_map[cpu] = mem;
                 }
+                closedir(dir2);
         }
+        closedir(dir1);
 }
 
 static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
@@ -645,6 +647,7 @@ static int setup_sorting(struct list_head *sort_list, const char *arg)
                         break;
                 if (sort_dimension__add(tok, sort_list) < 0) {
                         error("Unknown --sort key: '%s'", tok);
+                        free(str);
                         return -1;
                 }
         }
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 032324a76b87..9fc6e0fa3dce 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -22,9 +22,6 @@
 static const char               *file_name;
 static char                     name_buffer[256];
 
-bool                            perf_host = 1;
-bool                            perf_guest;
-
 static const char * const kvm_usage[] = {
         "perf kvm [<options>] {top|record|report|diff|buildid-list}",
         NULL
@@ -107,7 +104,8 @@ static int __cmd_buildid_list(int argc, const char **argv)
 
 int cmd_kvm(int argc, const char **argv, const char *prefix __used)
 {
-        perf_host = perf_guest = 0;
+        perf_host  = 0;
+        perf_guest = 1;
 
         argc = parse_options(argc, argv, kvm_options, kvm_usage,
                         PARSE_OPT_STOP_AT_NON_OPTION);
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index fd1909afcfd6..bb68ddf257b7 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -1018,13 +1018,17 @@ static char *get_script_path(const char *script_root, const char *suffix)
                         __script_root = get_script_root(&script_dirent, suffix);
                         if (__script_root && !strcmp(script_root, __script_root)) {
                                 free(__script_root);
+                                closedir(lang_dir);
+                                closedir(scripts_dir);
                                 snprintf(script_path, MAXPATHLEN, "%s/%s",
                                          lang_path, script_dirent.d_name);
                                 return strdup(script_path);
                         }
                         free(__script_root);
                 }
+                closedir(lang_dir);
         }
+        closedir(scripts_dir);
 
         return NULL;
 }
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 2b9a7f497a20..3854e869dce1 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -1396,7 +1396,7 @@ int cmd_test(int argc, const char **argv, const char *prefix __used)
         NULL,
         };
         const struct option test_options[] = {
-        OPT_INTEGER('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_END()
         };
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 4f81eeb99875..8f80df896038 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -235,7 +235,6 @@ static struct hist_entry *perf_evsel__add_hist_entry(struct perf_evsel *evsel,
         if (he == NULL)
                 return NULL;
 
-        evsel->hists.stats.total_period += sample->period;
         hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
         return he;
 }
@@ -889,6 +888,10 @@ try_again:
                                 ui__warning("The %s event is not supported.\n",
                                             event_name(counter));
                                 goto out_err;
+                        } else if (err == EMFILE) {
+                                ui__warning("Too many events are opened.\n"
+                                            "Try again after reducing the number of events\n");
+                                goto out_err;
                         }
 
                         ui__warning("The sys_perf_event_open() syscall "
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index fa1837088ca8..3f16e08a5c8d 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -111,8 +111,11 @@ int perf_evlist__add_default(struct perf_evlist *evlist)
                 .type = PERF_TYPE_HARDWARE,
                 .config = PERF_COUNT_HW_CPU_CYCLES,
         };
-        struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
+        struct perf_evsel *evsel;
+
+        event_attr_init(&attr);
 
+        evsel = perf_evsel__new(&attr, 0);
         if (evsel == NULL)
                 goto error;
 
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index abef2703cd24..6f505d1abac7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -76,21 +76,21 @@ static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         }
 }
 
-static void hist_entry__add_cpumode_period(struct hist_entry *self,
+static void hist_entry__add_cpumode_period(struct hist_entry *he,
                                            unsigned int cpumode, u64 period)
 {
         switch (cpumode) {
         case PERF_RECORD_MISC_KERNEL:
-                self->period_sys += period;
+                he->period_sys += period;
                 break;
         case PERF_RECORD_MISC_USER:
-                self->period_us += period;
+                he->period_us += period;
                 break;
         case PERF_RECORD_MISC_GUEST_KERNEL:
-                self->period_guest_sys += period;
+                he->period_guest_sys += period;
                 break;
         case PERF_RECORD_MISC_GUEST_USER:
-                self->period_guest_us += period;
+                he->period_guest_us += period;
                 break;
         default:
                 break;
@@ -165,18 +165,18 @@ void hists__decay_entries_threaded(struct hists *hists,
 static struct hist_entry *hist_entry__new(struct hist_entry *template)
 {
         size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
-        struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
+        struct hist_entry *he = malloc(sizeof(*he) + callchain_size);
 
-        if (self != NULL) {
-                *self = *template;
-                self->nr_events = 1;
-                if (self->ms.map)
-                        self->ms.map->referenced = true;
+        if (he != NULL) {
+                *he = *template;
+                he->nr_events = 1;
+                if (he->ms.map)
+                        he->ms.map->referenced = true;
                 if (symbol_conf.use_callchain)
-                        callchain_init(self->callchain);
+                        callchain_init(he->callchain);
         }
 
-        return self;
+        return he;
 }
 
 static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
@@ -677,15 +677,16 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
         return ret;
 }
 
-static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
-                                            u64 total_samples, int left_margin)
+static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
+                                            u64 total_samples, int left_margin,
+                                            FILE *fp)
 {
         struct rb_node *rb_node;
         struct callchain_node *chain;
         size_t ret = 0;
         u32 entries_printed = 0;
 
-        rb_node = rb_first(&self->sorted_chain);
+        rb_node = rb_first(&he->sorted_chain);
         while (rb_node) {
                 double percent;
 
@@ -730,35 +731,35 @@ void hists__output_recalc_col_len(struct hists *hists, int max_rows)
         }
 }
 
-static int hist_entry__pcnt_snprintf(struct hist_entry *self, char *s,
+static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
                                      size_t size, struct hists *pair_hists,
                                      bool show_displacement, long displacement,
-                                     bool color, u64 session_total)
+                                     bool color, u64 total_period)
 {
         u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
         u64 nr_events;
         const char *sep = symbol_conf.field_sep;
         int ret;
 
-        if (symbol_conf.exclude_other && !self->parent)
+        if (symbol_conf.exclude_other && !he->parent)
                 return 0;
 
         if (pair_hists) {
-                period = self->pair ? self->pair->period : 0;
-                nr_events = self->pair ? self->pair->nr_events : 0;
+                period = he->pair ? he->pair->period : 0;
+                nr_events = he->pair ? he->pair->nr_events : 0;
                 total = pair_hists->stats.total_period;
-                period_sys = self->pair ? self->pair->period_sys : 0;
-                period_us = self->pair ? self->pair->period_us : 0;
-                period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
-                period_guest_us = self->pair ? self->pair->period_guest_us : 0;
+                period_sys = he->pair ? he->pair->period_sys : 0;
+                period_us = he->pair ? he->pair->period_us : 0;
+                period_guest_sys = he->pair ? he->pair->period_guest_sys : 0;
+                period_guest_us = he->pair ? he->pair->period_guest_us : 0;
         } else {
-                period = self->period;
-                nr_events = self->nr_events;
-                total = session_total;
-                period_sys = self->period_sys;
-                period_us = self->period_us;
-                period_guest_sys = self->period_guest_sys;
-                period_guest_us = self->period_guest_us;
+                period = he->period;
+                nr_events = he->nr_events;
+                total = total_period;
+                period_sys = he->period_sys;
+                period_us = he->period_us;
+                period_guest_sys = he->period_guest_sys;
+                period_guest_us = he->period_guest_us;
         }
 
         if (total) {
@@ -812,8 +813,8 @@ static int hist_entry__pcnt_snprintf(struct hist_entry *self, char *s,
 
                 if (total > 0)
                         old_percent = (period * 100.0) / total;
-                if (session_total > 0)
-                        new_percent = (self->period * 100.0) / session_total;
+                if (total_period > 0)
+                        new_percent = (he->period * 100.0) / total_period;
 
                 diff = new_percent - old_percent;
 
@@ -862,9 +863,10 @@ int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
         return ret;
 }
 
-int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
-                        struct hists *pair_hists, bool show_displacement,
-                        long displacement, FILE *fp, u64 session_total)
+static int hist_entry__fprintf(struct hist_entry *he, size_t size,
+                               struct hists *hists, struct hists *pair_hists,
+                               bool show_displacement, long displacement,
+                               u64 total_period, FILE *fp)
 {
         char bf[512];
         int ret;
@@ -874,14 +876,14 @@ int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
 
         ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
                                         show_displacement, displacement,
-                                        true, session_total);
+                                        true, total_period);
         hist_entry__snprintf(he, bf + ret, size - ret, hists);
         return fprintf(fp, "%s\n", bf);
 }
 
-static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
-                                            struct hists *hists, FILE *fp,
-                                            u64 session_total)
+static size_t hist_entry__fprintf_callchain(struct hist_entry *he,
+                                            struct hists *hists,
+                                            u64 total_period, FILE *fp)
 {
         int left_margin = 0;
 
@@ -889,11 +891,10 @@ static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
                 struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
                                                          typeof(*se), list);
                 left_margin = hists__col_len(hists, se->se_width_idx);
-                left_margin -= thread__comm_len(self->thread);
+                left_margin -= thread__comm_len(he->thread);
         }
 
-        return hist_entry_callchain__fprintf(fp, self, session_total,
-                                             left_margin);
+        return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
 }
 
 size_t hists__fprintf(struct hists *hists, struct hists *pair,
@@ -903,6 +904,7 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
         struct sort_entry *se;
         struct rb_node *nd;
         size_t ret = 0;
+        u64 total_period;
         unsigned long position = 1;
         long displacement = 0;
         unsigned int width;
@@ -917,20 +919,6 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
 
         fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
 
-        if (symbol_conf.show_nr_samples) {
-                if (sep)
-                        fprintf(fp, "%cSamples", *sep);
-                else
-                        fputs("  Samples  ", fp);
-        }
-
-        if (symbol_conf.show_total_period) {
-                if (sep)
-                        ret += fprintf(fp, "%cPeriod", *sep);
-                else
-                        ret += fprintf(fp, "   Period    ");
-        }
-
         if (symbol_conf.show_cpu_utilization) {
                 if (sep) {
                         ret += fprintf(fp, "%csys", *sep);
@@ -940,8 +928,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                                 ret += fprintf(fp, "%cguest us", *sep);
                         }
                 } else {
-                        ret += fprintf(fp, "  sys  ");
-                        ret += fprintf(fp, "  us  ");
+                        ret += fprintf(fp, "     sys  ");
+                        ret += fprintf(fp, "      us  ");
                         if (perf_guest) {
                                 ret += fprintf(fp, "  guest sys  ");
                                 ret += fprintf(fp, "  guest us  ");
@@ -949,6 +937,20 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 }
         }
 
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%cSamples", *sep);
+                else
+                        fputs("  Samples  ", fp);
+        }
+
+        if (symbol_conf.show_total_period) {
+                if (sep)
+                        ret += fprintf(fp, "%cPeriod", *sep);
+                else
+                        ret += fprintf(fp, "   Period    ");
+        }
+
         if (pair) {
                 if (sep)
                         ret += fprintf(fp, "%cDelta", *sep);
@@ -993,6 +995,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 goto print_entries;
 
         fprintf(fp, "# ........");
+        if (symbol_conf.show_cpu_utilization)
+                fprintf(fp, "   .......   .......");
         if (symbol_conf.show_nr_samples)
                 fprintf(fp, " ..........");
         if (symbol_conf.show_total_period)
@@ -1025,6 +1029,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 goto out;
 
 print_entries:
+        total_period = hists->stats.total_period;
+
         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
@@ -1040,11 +1046,10 @@ print_entries:
                         ++position;
                 }
                 ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
-                                           displacement, fp, hists->stats.total_period);
+                                           displacement, total_period, fp);
 
                 if (symbol_conf.use_callchain)
-                        ret += hist_entry__fprintf_callchain(h, hists, fp,
-                                                             hists->stats.total_period);
+                        ret += hist_entry__fprintf_callchain(h, hists, total_period, fp);
                 if (max_rows && ++nr_rows >= max_rows)
                         goto out;
 
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index ff6f9d56ea41..f55f0a8d1f81 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -66,11 +66,8 @@ struct hists {
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
                                       struct symbol *parent, u64 period);
-extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
-extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
-int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
-                        struct hists *pair_hists, bool show_displacement,
-                        long displacement, FILE *fp, u64 session_total);
+int64_t hist_entry__cmp(struct hist_entry *left, struct hist_entry *right);
+int64_t hist_entry__collapse(struct hist_entry *left, struct hist_entry *right);
 int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
                          struct hists *hists);
 void hist_entry__free(struct hist_entry *);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 531c283fc0c5..b029296d20d9 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -735,8 +735,8 @@ static int
 parse_event_modifier(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
-        int exclude = 0;
-        int eu = 0, ek = 0, eh = 0, precise = 0;
+        int exclude = 0, exclude_GH = 0;
+        int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
 
         if (!*str)
                 return 0;
@@ -760,6 +760,14 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
                         if (!exclude)
                                 exclude = eu = ek = eh = 1;
                         eh = 0;
+                } else if (*str == 'G') {
+                        if (!exclude_GH)
+                                exclude_GH = eG = eH = 1;
+                        eG = 0;
+                } else if (*str == 'H') {
+                        if (!exclude_GH)
+                                exclude_GH = eG = eH = 1;
+                        eH = 0;
                 } else if (*str == 'p') {
                         precise++;
                 } else
@@ -776,6 +784,8 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
         attr->exclude_kernel = ek;
         attr->exclude_hv     = eh;
         attr->precise_ip     = precise;
+        attr->exclude_host   = eH;
+        attr->exclude_guest  = eG;
 
         return 0;
 }
@@ -838,6 +848,7 @@ int parse_events(struct perf_evlist *evlist , const char *str, int unset __used)
         for (;;) {
                 ostr = str;
                 memset(&attr, 0, sizeof(attr));
+                event_attr_init(&attr);
                 ret = parse_event_symbols(evlist, &str, &attr);
                 if (ret == EVT_FAILED)
                         return -1;
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index ac6830d8292b..fc22cf5c605f 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -18,7 +18,6 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#include <ctype.h>
 #include "util.h"
 #include <dirent.h>
 #include <mntent.h>
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 5b3ea49aa63e..813141047fc2 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -1,6 +1,21 @@
+#include "../perf.h"
 #include "util.h"
 #include <sys/mman.h>
 
+/*
+ * XXX We need to find a better place for these things...
+ */
+bool perf_host  = true;
+bool perf_guest = true;
+
+void event_attr_init(struct perf_event_attr *attr)
+{
+        if (!perf_host)
+                attr->exclude_host  = 1;
+        if (!perf_guest)
+                attr->exclude_guest = 1;
+}
+
 int mkdir_p(char *path, mode_t mode)
 {
         struct stat st;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 37be34dff798..b9c530cce79a 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -242,6 +242,10 @@ int strtailcmp(const char *s1, const char *s2);
 unsigned long convert_unit(unsigned long value, char *unit);
 int readn(int fd, void *buf, size_t size);
 
+struct perf_event_attr;
+
+void event_attr_init(struct perf_event_attr *attr);
+
 #define _STR(x) #x
 #define STR(x) _STR(x)
 
diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8
index ff75125deed0..555c69a5592a 100644
--- a/tools/power/x86/turbostat/turbostat.8
+++ b/tools/power/x86/turbostat/turbostat.8
@@ -38,8 +38,8 @@ displays the statistics gathered since it was forked.
 .PP
 .SH FIELD DESCRIPTIONS
 .nf
-\fBpkg\fP processor package number.
-\fBcore\fP processor core number.
+\fBpk\fP processor package number.
+\fBcr\fP processor core number.
 \fBCPU\fP Linux CPU (logical processor) number.
 \fB%c0\fP percent of the interval that the CPU retired instructions.
 \fBGHz\fP average clock rate while the CPU was in c0 state.
@@ -58,7 +58,7 @@ Subsequent rows show per-CPU statistics.
 
 .nf
 [root@x980]# ./turbostat
-core CPU   %c0   GHz  TSC   %c1    %c3    %c6   %pc3   %pc6
+cr   CPU   %c0   GHz  TSC   %c1    %c3    %c6   %pc3   %pc6
           0.04 1.62 3.38   0.11   0.00  99.85   0.00  95.07
   0   0   0.04 1.62 3.38   0.06   0.00  99.90   0.00  95.07
   0   6   0.02 1.62 3.38   0.08   0.00  99.90   0.00  95.07
@@ -102,7 +102,7 @@ until ^C while the other CPUs are mostly idle:
 .nf
 [root@x980 lenb]# ./turbostat cat /dev/zero > /dev/null
 
-^Ccore CPU   %c0   GHz  TSC   %c1    %c3    %c6   %pc3   %pc6
+^Ccr   CPU   %c0   GHz  TSC   %c1    %c3    %c6   %pc3   %pc6
            8.49 3.63 3.38  16.23   0.66  74.63   0.00   0.00
    0   0   1.22 3.62 3.38  32.18   0.00  66.60   0.00   0.00
    0   6   0.40 3.61 3.38  33.00   0.00  66.60   0.00   0.00
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 3c6f7808efae..310d3dd5e547 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -811,6 +811,8 @@ int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model)
         case 0x2C:      /* Westmere EP - Gulftown */
         case 0x2A:      /* SNB */
         case 0x2D:      /* SNB Xeon */
+        case 0x3A:      /* IVB */
+        case 0x3D:      /* IVB Xeon */
                 return 1;
         case 0x2E:      /* Nehalem-EX Xeon - Beckton */
         case 0x2F:      /* Westmere-EX Xeon - Eagleton */
diff --git a/tools/testing/ktest/compare-ktest-sample.pl b/tools/testing/ktest/compare-ktest-sample.pl
index 9a571e71683c..a373a5bfff68 100755
--- a/tools/testing/ktest/compare-ktest-sample.pl
+++ b/tools/testing/ktest/compare-ktest-sample.pl
@@ -2,7 +2,9 @@
 
 open (IN,"ktest.pl");
 while (<IN>) {
+    # hashes are now used
     if (/\$opt\{"?([A-Z].*?)(\[.*\])?"?\}/ ||
+        /^\s*"?([A-Z].*?)"?\s*=>\s*/ ||
         /set_test_option\("(.*?)"/) {
         $opt{$1} = 1;
     }
@@ -11,7 +13,7 @@ close IN;
 
 open (IN, "sample.conf");
 while (<IN>) {
-    if (/^\s*#?\s*(\S+)\s*=/) {
+    if (/^\s*#?\s*([A-Z]\S*)\s*=/) {
         $samp{$1} = 1;
     }
 }
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 8b4c2535b266..62a134dc421a 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -18,40 +18,50 @@ $| = 1;
 my %opt;
 my %repeat_tests;
 my %repeats;
-my %default;
 
 #default opts
-$default{"NUM_TESTS"}           = 1;
-$default{"REBOOT_TYPE"}         = "grub";
-$default{"TEST_TYPE"}           = "test";
-$default{"BUILD_TYPE"}          = "randconfig";
-$default{"MAKE_CMD"}            = "make";
-$default{"TIMEOUT"}             = 120;
-$default{"TMP_DIR"}             = "/tmp/ktest/\${MACHINE}";
-$default{"SLEEP_TIME"}          = 60;   # sleep time between tests
-$default{"BUILD_NOCLEAN"}       = 0;
-$default{"REBOOT_ON_ERROR"}     = 0;
-$default{"POWEROFF_ON_ERROR"}   = 0;
-$default{"REBOOT_ON_SUCCESS"}   = 1;
-$default{"POWEROFF_ON_SUCCESS"} = 0;
-$default{"BUILD_OPTIONS"}       = "";
-$default{"BISECT_SLEEP_TIME"}   = 60;   # sleep time between bisects
-$default{"PATCHCHECK_SLEEP_TIME"} = 60; # sleep time between patch checks
-$default{"CLEAR_LOG"}           = 0;
-$default{"BISECT_MANUAL"}       = 0;
-$default{"BISECT_SKIP"}         = 1;
-$default{"SUCCESS_LINE"}        = "login:";
-$default{"DETECT_TRIPLE_FAULT"} = 1;
-$default{"NO_INSTALL"}          = 0;
-$default{"BOOTED_TIMEOUT"}      = 1;
-$default{"DIE_ON_FAILURE"}      = 1;
-$default{"SSH_EXEC"}            = "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND";
-$default{"SCP_TO_TARGET"}       = "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE";
-$default{"REBOOT"}              = "ssh \$SSH_USER\@\$MACHINE reboot";
-$default{"STOP_AFTER_SUCCESS"}  = 10;
-$default{"STOP_AFTER_FAILURE"}  = 60;
-$default{"STOP_TEST_AFTER"}     = 600;
-$default{"LOCALVERSION"}        = "-test";
+my %default = (
+    "NUM_TESTS"                 => 1,
+    "TEST_TYPE"                 => "build",
+    "BUILD_TYPE"                => "randconfig",
+    "MAKE_CMD"                  => "make",
+    "TIMEOUT"                   => 120,
+    "TMP_DIR"                   => "/tmp/ktest/\${MACHINE}",
+    "SLEEP_TIME"                => 60,  # sleep time between tests
+    "BUILD_NOCLEAN"             => 0,
+    "REBOOT_ON_ERROR"           => 0,
+    "POWEROFF_ON_ERROR"         => 0,
+    "REBOOT_ON_SUCCESS"         => 1,
+    "POWEROFF_ON_SUCCESS"       => 0,
+    "BUILD_OPTIONS"             => "",
+    "BISECT_SLEEP_TIME"         => 60,   # sleep time between bisects
+    "PATCHCHECK_SLEEP_TIME"     => 60, # sleep time between patch checks
+    "CLEAR_LOG"                 => 0,
+    "BISECT_MANUAL"             => 0,
+    "BISECT_SKIP"               => 1,
+    "SUCCESS_LINE"              => "login:",
+    "DETECT_TRIPLE_FAULT"       => 1,
+    "NO_INSTALL"                => 0,
+    "BOOTED_TIMEOUT"            => 1,
+    "DIE_ON_FAILURE"            => 1,
+    "SSH_EXEC"                  => "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND",
+    "SCP_TO_TARGET"             => "scp \$SRC_FILE \$SSH_USER\@\$MACHINE:\$DST_FILE",
+    "REBOOT"                    => "ssh \$SSH_USER\@\$MACHINE reboot",
+    "STOP_AFTER_SUCCESS"        => 10,
+    "STOP_AFTER_FAILURE"        => 60,
+    "STOP_TEST_AFTER"           => 600,
+
+# required, and we will ask users if they don't have them but we keep the default
+# value something that is common.
+    "REBOOT_TYPE"               => "grub",
+    "LOCALVERSION"              => "-test",
+    "SSH_USER"                  => "root",
+    "BUILD_TARGET"              => "arch/x86/boot/bzImage",
+    "TARGET_IMAGE"              => "/boot/vmlinuz-test",
+
+    "LOG_FILE"                  => undef,
+    "IGNORE_UNUSED"             => 0,
+);
 
 my $ktest_config;
 my $version;
@@ -73,6 +83,8 @@ my $reboot_script;
 my $power_cycle;
 my $reboot;
 my $reboot_on_error;
+my $switch_to_good;
+my $switch_to_test;
 my $poweroff_on_error;
 my $die_on_failure;
 my $powercycle_after_reboot;
@@ -92,17 +104,24 @@ my $start_minconfig;
 my $start_minconfig_defined;
 my $output_minconfig;
 my $ignore_config;
+my $ignore_errors;
 my $addconfig;
 my $in_bisect = 0;
-my $bisect_bad = "";
+my $bisect_bad_commit = "";
 my $reverse_bisect;
 my $bisect_manual;
 my $bisect_skip;
 my $config_bisect_good;
+my $bisect_ret_good;
+my $bisect_ret_bad;
+my $bisect_ret_skip;
+my $bisect_ret_abort;
+my $bisect_ret_default;
 my $in_patchcheck = 0;
 my $run_test;
 my $redirect;
 my $buildlog;
+my $testlog;
 my $dmesg;
 my $monitor_fp;
 my $monitor_pid;
@@ -112,6 +131,7 @@ my $bisect_sleep_time;
 my $patchcheck_sleep_time;
 my $ignore_warnings;
 my $store_failures;
+my $store_successes;
 my $test_name;
 my $timeout;
 my $booted_timeout;
@@ -124,10 +144,34 @@ my $stop_after_failure;
 my $stop_test_after;
 my $build_target;
 my $target_image;
+my $checkout;
 my $localversion;
 my $iteration = 0;
 my $successes = 0;
 
+my $bisect_good;
+my $bisect_bad;
+my $bisect_type;
+my $bisect_start;
+my $bisect_replay;
+my $bisect_files;
+my $bisect_reverse;
+my $bisect_check;
+
+my $config_bisect;
+my $config_bisect_type;
+
+my $patchcheck_type;
+my $patchcheck_start;
+my $patchcheck_end;
+
+# set when a test is something other that just building or install
+# which would require more options.
+my $buildonly = 1;
+
+# set when creating a new config
+my $newconfig = 0;
+
 my %entered_configs;
 my %config_help;
 my %variable;
@@ -136,11 +180,99 @@ my %force_config;
 # do not force reboots on config problems
 my $no_reboot = 1;
 
+my %option_map = (
+    "MACHINE"                   => \$machine,
+    "SSH_USER"                  => \$ssh_user,
+    "TMP_DIR"                   => \$tmpdir,
+    "OUTPUT_DIR"                => \$outputdir,
+    "BUILD_DIR"                 => \$builddir,
+    "TEST_TYPE"                 => \$test_type,
+    "BUILD_TYPE"                => \$build_type,
+    "BUILD_OPTIONS"             => \$build_options,
+    "PRE_BUILD"                 => \$pre_build,
+    "POST_BUILD"                => \$post_build,
+    "PRE_BUILD_DIE"             => \$pre_build_die,
+    "POST_BUILD_DIE"            => \$post_build_die,
+    "POWER_CYCLE"               => \$power_cycle,
+    "REBOOT"                    => \$reboot,
+    "BUILD_NOCLEAN"             => \$noclean,
+    "MIN_CONFIG"                => \$minconfig,
+    "OUTPUT_MIN_CONFIG"         => \$output_minconfig,
+    "START_MIN_CONFIG"          => \$start_minconfig,
+    "IGNORE_CONFIG"             => \$ignore_config,
+    "TEST"                      => \$run_test,
+    "ADD_CONFIG"                => \$addconfig,
+    "REBOOT_TYPE"               => \$reboot_type,
+    "GRUB_MENU"                 => \$grub_menu,
+    "POST_INSTALL"              => \$post_install,
+    "NO_INSTALL"                => \$no_install,
+    "REBOOT_SCRIPT"             => \$reboot_script,
+    "REBOOT_ON_ERROR"           => \$reboot_on_error,
+    "SWITCH_TO_GOOD"            => \$switch_to_good,
+    "SWITCH_TO_TEST"            => \$switch_to_test,
+    "POWEROFF_ON_ERROR"         => \$poweroff_on_error,
+    "DIE_ON_FAILURE"            => \$die_on_failure,
+    "POWER_OFF"                 => \$power_off,
+    "POWERCYCLE_AFTER_REBOOT"   => \$powercycle_after_reboot,
+    "POWEROFF_AFTER_HALT"       => \$poweroff_after_halt,
+    "SLEEP_TIME"                => \$sleep_time,
+    "BISECT_SLEEP_TIME"         => \$bisect_sleep_time,
+    "PATCHCHECK_SLEEP_TIME"     => \$patchcheck_sleep_time,
+    "IGNORE_WARNINGS"           => \$ignore_warnings,
+    "IGNORE_ERRORS"             => \$ignore_errors,
+    "BISECT_MANUAL"             => \$bisect_manual,
+    "BISECT_SKIP"               => \$bisect_skip,
+    "CONFIG_BISECT_GOOD"        => \$config_bisect_good,
+    "BISECT_RET_GOOD"           => \$bisect_ret_good,
+    "BISECT_RET_BAD"            => \$bisect_ret_bad,
+    "BISECT_RET_SKIP"           => \$bisect_ret_skip,
+    "BISECT_RET_ABORT"          => \$bisect_ret_abort,
+    "BISECT_RET_DEFAULT"        => \$bisect_ret_default,
+    "STORE_FAILURES"            => \$store_failures,
+    "STORE_SUCCESSES"           => \$store_successes,
+    "TEST_NAME"                 => \$test_name,
+    "TIMEOUT"                   => \$timeout,
+    "BOOTED_TIMEOUT"            => \$booted_timeout,
+    "CONSOLE"                   => \$console,
+    "DETECT_TRIPLE_FAULT"       => \$detect_triplefault,
+    "SUCCESS_LINE"              => \$success_line,
+    "REBOOT_SUCCESS_LINE"       => \$reboot_success_line,
+    "STOP_AFTER_SUCCESS"        => \$stop_after_success,
+    "STOP_AFTER_FAILURE"        => \$stop_after_failure,
+    "STOP_TEST_AFTER"           => \$stop_test_after,
+    "BUILD_TARGET"              => \$build_target,
+    "SSH_EXEC"                  => \$ssh_exec,
+    "SCP_TO_TARGET"             => \$scp_to_target,
+    "CHECKOUT"                  => \$checkout,
+    "TARGET_IMAGE"              => \$target_image,
+    "LOCALVERSION"              => \$localversion,
+
+    "BISECT_GOOD"               => \$bisect_good,
+    "BISECT_BAD"                => \$bisect_bad,
+    "BISECT_TYPE"               => \$bisect_type,
+    "BISECT_START"              => \$bisect_start,
+    "BISECT_REPLAY"             => \$bisect_replay,
+    "BISECT_FILES"              => \$bisect_files,
+    "BISECT_REVERSE"            => \$bisect_reverse,
+    "BISECT_CHECK"              => \$bisect_check,
+
+    "CONFIG_BISECT"             => \$config_bisect,
+    "CONFIG_BISECT_TYPE"        => \$config_bisect_type,
+
+    "PATCHCHECK_TYPE"           => \$patchcheck_type,
+    "PATCHCHECK_START"          => \$patchcheck_start,
+    "PATCHCHECK_END"            => \$patchcheck_end,
+);
+
+# Options may be used by other options, record them.
+my %used_options;
+
 # default variables that can be used
 chomp ($variable{"PWD"} = `pwd`);
 
 $config_help{"MACHINE"} = << "EOF"
  The machine hostname that you will test.
+ For build only tests, it is still needed to differentiate log files.
 EOF
     ;
 $config_help{"SSH_USER"} = << "EOF"
@@ -150,11 +282,15 @@ EOF
     ;
 $config_help{"BUILD_DIR"} = << "EOF"
  The directory that contains the Linux source code (full path).
+ You can use \${PWD} that will be the path where ktest.pl is run, or use
+ \${THIS_DIR} which is assigned \${PWD} but may be changed later.
 EOF
     ;
 $config_help{"OUTPUT_DIR"} = << "EOF"
  The directory that the objects will be built (full path).
  (can not be same as BUILD_DIR)
+ You can use \${PWD} that will be the path where ktest.pl is run, or use
+ \${THIS_DIR} which is assigned \${PWD} but may be changed later.
 EOF
     ;
 $config_help{"BUILD_TARGET"} = << "EOF"
@@ -162,6 +298,11 @@ $config_help{"BUILD_TARGET"} = << "EOF"
  (relative to OUTPUT_DIR)
 EOF
     ;
+$config_help{"BUILD_OPTIONS"} = << "EOF"
+ Options to add to \"make\" when building.
+ i.e.  -j20
+EOF
+    ;
 $config_help{"TARGET_IMAGE"} = << "EOF"
  The place to put your image on the test machine.
 EOF
@@ -227,20 +368,36 @@ $config_help{"REBOOT_SCRIPT"} = << "EOF"
 EOF
     ;
 
-sub read_yn {
-    my ($prompt) = @_;
+sub read_prompt {
+    my ($cancel, $prompt) = @_;
 
     my $ans;
 
     for (;;) {
-        print "$prompt [Y/n] ";
+        if ($cancel) {
+            print "$prompt [y/n/C] ";
+        } else {
+            print "$prompt [Y/n] ";
+        }
         $ans = <STDIN>;
         chomp $ans;
         if ($ans =~ /^\s*$/) {
-            $ans = "y";
+            if ($cancel) {
+                $ans = "c";
+            } else {
+                $ans = "y";
+            }
         }
         last if ($ans =~ /^y$/i || $ans =~ /^n$/i);
-        print "Please answer either 'y' or 'n'.\n";
+        if ($cancel) {
+            last if ($ans =~ /^c$/i);
+            print "Please answer either 'y', 'n' or 'c'.\n";
+        } else {
+            print "Please answer either 'y' or 'n'.\n";
+        }
+    }
+    if ($ans =~ /^c/i) {
+        exit;
     }
     if ($ans !~ /^y$/i) {
         return 0;
@@ -248,6 +405,18 @@ sub read_yn {
     return 1;
 }
 
+sub read_yn {
+    my ($prompt) = @_;
+
+    return read_prompt 0, $prompt;
+}
+
+sub read_ync {
+    my ($prompt) = @_;
+
+    return read_prompt 1, $prompt;
+}
+
 sub get_ktest_config {
     my ($config) = @_;
     my $ans;
@@ -261,7 +430,7 @@ sub get_ktest_config {
 
     for (;;) {
         print "$config = ";
-        if (defined($default{$config})) {
+        if (defined($default{$config}) && length($default{$config})) {
             print "\[$default{$config}\] ";
         }
         $ans = <STDIN>;
@@ -274,22 +443,37 @@ sub get_ktest_config {
                 next;
             }
         }
-        $entered_configs{$config} = process_variables($ans);
+        $entered_configs{$config} = ${ans};
         last;
     }
 }
 
 sub get_ktest_configs {
     get_ktest_config("MACHINE");
-    get_ktest_config("SSH_USER");
     get_ktest_config("BUILD_DIR");
     get_ktest_config("OUTPUT_DIR");
-    get_ktest_config("BUILD_TARGET");
-    get_ktest_config("TARGET_IMAGE");
-    get_ktest_config("POWER_CYCLE");
-    get_ktest_config("CONSOLE");
+
+    if ($newconfig) {
+        get_ktest_config("BUILD_OPTIONS");
+    }
+
+    # options required for other than just building a kernel
+    if (!$buildonly) {
+        get_ktest_config("POWER_CYCLE");
+        get_ktest_config("CONSOLE");
+    }
+
+    # options required for install and more
+    if ($buildonly != 1) {
+        get_ktest_config("SSH_USER");
+        get_ktest_config("BUILD_TARGET");
+        get_ktest_config("TARGET_IMAGE");
+    }
+
     get_ktest_config("LOCALVERSION");
 
+    return if ($buildonly);
+
     my $rtype = $opt{"REBOOT_TYPE"};
 
     if (!defined($rtype)) {
@@ -303,8 +487,6 @@ sub get_ktest_configs {
 
     if ($rtype eq "grub") {
         get_ktest_config("GRUB_MENU");
-    } else {
-        get_ktest_config("REBOOT_SCRIPT");
     }
 }
 
@@ -334,6 +516,10 @@ sub process_variables {
         } else {
             # put back the origin piece.
             $retval = "$retval\$\{$var\}";
+            # This could be an option that is used later, save
+            # it so we don't warn if this option is not one of
+            # ktests options.
+            $used_options{$var} = 1;
         }
         $value = $end;
     }
@@ -348,6 +534,19 @@ sub process_variables {
 sub set_value {
     my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
 
+    my $prvalue = process_variables($rvalue);
+
+    if ($buildonly && $lvalue =~ /^TEST_TYPE(\[.*\])?$/ && $prvalue ne "build") {
+        # Note if a test is something other than build, then we
+        # will need other manditory options.
+        if ($prvalue ne "install") {
+            $buildonly = 0;
+        } else {
+            # install still limits some manditory options.
+            $buildonly = 2;
+        }
+    }
+
     if (defined($opt{$lvalue})) {
         if (!$override || defined(${$overrides}{$lvalue})) {
             my $extra = "";
@@ -356,13 +555,12 @@ sub set_value {
             }
             die "$name: $.: Option $lvalue defined more than once!\n$extra";
         }
-        ${$overrides}{$lvalue} = $rvalue;
+        ${$overrides}{$lvalue} = $prvalue;
     }
     if ($rvalue =~ /^\s*$/) {
         delete $opt{$lvalue};
     } else {
-        $rvalue = process_variables($rvalue);
-        $opt{$lvalue} = $rvalue;
+        $opt{$lvalue} = $prvalue;
     }
 }
 
@@ -712,6 +910,15 @@ sub __read_config {
     return $test_case;
 }
 
+sub get_test_case {
+        print "What test case would you like to run?\n";
+        print " (build, install or boot)\n";
+        print " Other tests are available but require editing the config file\n";
+        my $ans = <STDIN>;
+        chomp $ans;
+        $default{"TEST_TYPE"} = $ans;
+}
+
 sub read_config {
     my ($config) = @_;
 
@@ -726,10 +933,7 @@ sub read_config {
     # was a test specified?
     if (!$test_case) {
         print "No test case specified.\n";
-        print "What test case would you like to run?\n";
-        my $ans = <STDIN>;
-        chomp $ans;
-        $default{"TEST_TYPE"} = $ans;
+        get_test_case;
     }
 
     # set any defaults
@@ -739,6 +943,37 @@ sub read_config {
             $opt{$default} = $default{$default};
         }
     }
+
+    if ($opt{"IGNORE_UNUSED"} == 1) {
+        return;
+    }
+
+    my %not_used;
+
+    # check if there are any stragglers (typos?)
+    foreach my $option (keys %opt) {
+        my $op = $option;
+        # remove per test labels.
+        $op =~ s/\[.*\]//;
+        if (!exists($option_map{$op}) &&
+            !exists($default{$op}) &&
+            !exists($used_options{$op})) {
+            $not_used{$op} = 1;
+        }
+    }
+
+    if (%not_used) {
+        my $s = "s are";
+        $s = " is" if (keys %not_used == 1);
+        print "The following option$s not used; could be a typo:\n";
+        foreach my $option (keys %not_used) {
+            print "$option\n";
+        }
+        print "Set IGRNORE_UNUSED = 1 to have ktest ignore unused variables\n";
+        if (!read_yn "Do you want to continue?") {
+            exit -1;
+        }
+    }
 }
 
 sub __eval_option {
@@ -873,6 +1108,17 @@ sub reboot {
     }
 }
 
+sub reboot_to_good {
+    my ($time) = @_;
+
+    if (defined($switch_to_good)) {
+        run_command $switch_to_good;
+        return;
+    }
+
+    reboot $time;
+}
+
 sub do_not_reboot {
     my $i = $iteration;
 
@@ -889,7 +1135,7 @@ sub dodie {
     if ($reboot_on_error && !do_not_reboot) {
 
         doprint "REBOOTING\n";
-        reboot;
+        reboot_to_good;
 
     } elsif ($poweroff_on_error && defined($power_off)) {
         doprint "POWERING OFF\n";
@@ -975,6 +1221,43 @@ sub wait_for_monitor {
     print "** Monitor flushed **\n";
 }
 
+sub save_logs {
+        my ($result, $basedir) = @_;
+        my @t = localtime;
+        my $date = sprintf "%04d%02d%02d%02d%02d%02d",
+                1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
+
+        my $type = $build_type;
+        if ($type =~ /useconfig/) {
+            $type = "useconfig";
+        }
+
+        my $dir = "$machine-$test_type-$type-$result-$date";
+
+        $dir = "$basedir/$dir";
+
+        if (!-d $dir) {
+            mkpath($dir) or
+                die "can't create $dir";
+        }
+
+        my %files = (
+                "config" => $output_config,
+                "buildlog" => $buildlog,
+                "dmesg" => $dmesg,
+                "testlog" => $testlog,
+        );
+
+        while (my ($name, $source) = each(%files)) {
+                if (-f "$source") {
+                        cp "$source", "$dir/$name" or
+                                die "failed to copy $source";
+                }
+        }
+
+        doprint "*** Saved info to $dir ***\n";
+}
+
 sub fail {
 
         if ($die_on_failure) {
@@ -988,7 +1271,7 @@ sub fail {
         # no need to reboot for just building.
         if (!do_not_reboot) {
             doprint "REBOOTING\n";
-            reboot $sleep_time;
+            reboot_to_good $sleep_time;
         }
 
         my $name = "";
@@ -1003,38 +1286,9 @@ sub fail {
         doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
         doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
 
-        return 1 if (!defined($store_failures));
-
-        my @t = localtime;
-        my $date = sprintf "%04d%02d%02d%02d%02d%02d",
-                1900+$t[5],$t[4],$t[3],$t[2],$t[1],$t[0];
-
-        my $type = $build_type;
-        if ($type =~ /useconfig/) {
-            $type = "useconfig";
-        }
-
-        my $dir = "$machine-$test_type-$type-fail-$date";
-        my $faildir = "$store_failures/$dir";
-
-        if (!-d $faildir) {
-            mkpath($faildir) or
-                die "can't create $faildir";
-        }
-        if (-f "$output_config") {
-            cp "$output_config", "$faildir/config" or
-                die "failed to copy .config";
-        }
-        if (-f $buildlog) {
-            cp $buildlog, "$faildir/buildlog" or
-                die "failed to move $buildlog";
-        }
-        if (-f $dmesg) {
-            cp $dmesg, "$faildir/dmesg" or
-                die "failed to move $dmesg";
-        }
-
-        doprint "*** Saved info to $faildir ***\n";
+        if (defined($store_failures)) {
+            save_logs "fail", $store_failures;
+        }
 
         return 1;
 }
@@ -1170,13 +1424,16 @@ sub wait_for_input
 }
 
 sub reboot_to {
+    if (defined($switch_to_test)) {
+        run_command $switch_to_test;
+    }
+
     if ($reboot_type eq "grub") {
         run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
-        reboot;
-        return;
+    } elsif (defined $reboot_script) {
+        run_command "$reboot_script";
     }
-
-    run_command "$reboot_script";
+    reboot;
 }
 
 sub get_sha1 {
@@ -1274,7 +1531,7 @@ sub monitor {
         }
 
         if ($full_line =~ /call trace:/i) {
-            if (!$bug && !$skip_call_trace) {
+            if (!$ignore_errors && !$bug && !$skip_call_trace) {
                 $bug = 1;
                 $failure_start = time;
             }
@@ -1341,12 +1598,19 @@ sub monitor {
     return 1;
 }
 
+sub eval_kernel_version {
+    my ($option) = @_;
+
+    $option =~ s/\$KERNEL_VERSION/$version/g;
+
+    return $option;
+}
+
 sub do_post_install {
 
     return if (!defined($post_install));
 
-    my $cp_post_install = $post_install;
-    $cp_post_install =~ s/\$KERNEL_VERSION/$version/g;
+    my $cp_post_install = eval_kernel_version $post_install;
     run_command "$cp_post_install" or
         dodie "Failed to run post install";
 }
@@ -1355,7 +1619,9 @@ sub install {
 
     return if ($no_install);
 
-    run_scp "$outputdir/$build_target", "$target_image" or
+    my $cp_target = eval_kernel_version $target_image;
+
+    run_scp "$outputdir/$build_target", "$cp_target" or
         dodie "failed to copy image";
 
     my $install_mods = 0;
@@ -1640,9 +1906,13 @@ sub success {
     doprint     "*******************************************\n";
     doprint     "*******************************************\n";
 
+    if (defined($store_successes)) {
+        save_logs "success", $store_successes;
+    }
+
     if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
         doprint "Reboot and wait $sleep_time seconds\n";
-        reboot $sleep_time;
+        reboot_to_good $sleep_time;
     }
 }
 
@@ -1669,7 +1939,10 @@ sub child_run_test {
     $poweroff_on_error = 0;
     $die_on_failure = 1;
 
+    $redirect = "$testlog";
     run_command $run_test or $failed = 1;
+    undef $redirect;
+
     exit $failed;
 }
 
@@ -1744,6 +2017,43 @@ sub do_run_test {
     waitpid $child_pid, 0;
     $child_exit = $?;
 
+    if (!$bug && $in_bisect) {
+        if (defined($bisect_ret_good)) {
+            if ($child_exit == $bisect_ret_good) {
+                return 1;
+            }
+        }
+        if (defined($bisect_ret_skip)) {
+            if ($child_exit == $bisect_ret_skip) {
+                return -1;
+            }
+        }
+        if (defined($bisect_ret_abort)) {
+            if ($child_exit == $bisect_ret_abort) {
+                fail "test abort" and return -2;
+            }
+        }
+        if (defined($bisect_ret_bad)) {
+            if ($child_exit == $bisect_ret_skip) {
+                return 0;
+            }
+        }
+        if (defined($bisect_ret_default)) {
+            if ($bisect_ret_default eq "good") {
+                return 1;
+            } elsif ($bisect_ret_default eq "bad") {
+                return 0;
+            } elsif ($bisect_ret_default eq "skip") {
+                return -1;
+            } elsif ($bisect_ret_default eq "abort") {
+                return -2;
+            } else {
+                fail "unknown default action: $bisect_ret_default"
+                    and return -2;
+            }
+        }
+    }
+
     if ($bug || $child_exit) {
         return 0 if $in_bisect;
         fail "test failed" and return 0;
@@ -1770,7 +2080,7 @@ sub run_git_bisect {
     if ($output =~ m/^(Bisecting: .*\(roughly \d+ steps?\))\s+\[([[:xdigit:]]+)\]/) {
         doprint "$1 [$2]\n";
     } elsif ($output =~ m/^([[:xdigit:]]+) is the first bad commit/) {
-        $bisect_bad = $1;
+        $bisect_bad_commit = $1;
         doprint "Found bad commit... $1\n";
         return 0;
     } else {
@@ -1783,7 +2093,7 @@ sub run_git_bisect {
 
 sub bisect_reboot {
     doprint "Reboot and sleep $bisect_sleep_time seconds\n";
-    reboot $bisect_sleep_time;
+    reboot_to_good $bisect_sleep_time;
 }
 
 # returns 1 on success, 0 on failure, -1 on skip
@@ -1868,21 +2178,28 @@ sub run_bisect {
     }
 }
 
+sub update_bisect_replay {
+    my $tmp_log = "$tmpdir/ktest_bisect_log";
+    run_command "git bisect log > $tmp_log" or
+        die "can't create bisect log";
+    return $tmp_log;
+}
+
 sub bisect {
     my ($i) = @_;
 
     my $result;
 
-    die "BISECT_GOOD[$i] not defined\n" if (!defined($opt{"BISECT_GOOD[$i]"}));
-    die "BISECT_BAD[$i] not defined\n"  if (!defined($opt{"BISECT_BAD[$i]"}));
-    die "BISECT_TYPE[$i] not defined\n" if (!defined($opt{"BISECT_TYPE[$i]"}));
+    die "BISECT_GOOD[$i] not defined\n" if (!defined($bisect_good));
+    die "BISECT_BAD[$i] not defined\n"  if (!defined($bisect_bad));
+    die "BISECT_TYPE[$i] not defined\n" if (!defined($bisect_type));
 
-    my $good = $opt{"BISECT_GOOD[$i]"};
-    my $bad = $opt{"BISECT_BAD[$i]"};
-    my $type = $opt{"BISECT_TYPE[$i]"};
-    my $start = $opt{"BISECT_START[$i]"};
-    my $replay = $opt{"BISECT_REPLAY[$i]"};
-    my $start_files = $opt{"BISECT_FILES[$i]"};
+    my $good = $bisect_good;
+    my $bad = $bisect_bad;
+    my $type = $bisect_type;
+    my $start = $bisect_start;
+    my $replay = $bisect_replay;
+    my $start_files = $bisect_files;
 
     if (defined($start_files)) {
         $start_files = " -- " . $start_files;
@@ -1894,8 +2211,7 @@ sub bisect {
     $good = get_sha1($good);
     $bad = get_sha1($bad);
 
-    if (defined($opt{"BISECT_REVERSE[$i]"}) &&
-        $opt{"BISECT_REVERSE[$i]"} == 1) {
+    if (defined($bisect_reverse) && $bisect_reverse == 1) {
         doprint "Performing a reverse bisect (bad is good, good is bad!)\n";
         $reverse_bisect = 1;
     } else {
@@ -1907,8 +2223,31 @@ sub bisect {
         $type = "boot";
     }
 
-    my $check = $opt{"BISECT_CHECK[$i]"};
-    if (defined($check) && $check ne "0") {
+    # Check if a bisect was running
+    my $bisect_start_file = "$builddir/.git/BISECT_START";
+
+    my $check = $bisect_check;
+    my $do_check = defined($check) && $check ne "0";
+
+    if ( -f $bisect_start_file ) {
+        print "Bisect in progress found\n";
+        if ($do_check) {
+            print " If you say yes, then no checks of good or bad will be done\n";
+        }
+        if (defined($replay)) {
+            print "** BISECT_REPLAY is defined in config file **";
+            print " Ignore config option and perform new git bisect log?\n";
+            if (read_ync " (yes, no, or cancel) ") {
+                $replay = update_bisect_replay;
+                $do_check = 0;
+            }
+        } elsif (read_yn "read git log and continue?") {
+            $replay = update_bisect_replay;
+            $do_check = 0;
+        }
+    }
+
+    if ($do_check) {
 
         # get current HEAD
         my $head = get_sha1("HEAD");
@@ -1973,7 +2312,7 @@ sub bisect {
     run_command "git bisect reset" or
         dodie "could not reset git bisect";
 
-    doprint "Bad commit was [$bisect_bad]\n";
+    doprint "Bad commit was [$bisect_bad_commit]\n";
 
     success $i;
 }
@@ -2129,7 +2468,7 @@ sub run_config_bisect {
     }
 
     doprint "***** RUN TEST ***\n";
-    my $type = $opt{"CONFIG_BISECT_TYPE[$iteration]"};
+    my $type = $config_bisect_type;
     my $ret;
     my %current_config;
 
@@ -2233,7 +2572,7 @@ sub run_config_bisect {
 sub config_bisect {
     my ($i) = @_;
 
-    my $start_config = $opt{"CONFIG_BISECT[$i]"};
+    my $start_config = $config_bisect;
 
     my $tmpconfig = "$tmpdir/use_config";
 
@@ -2346,29 +2685,29 @@ sub config_bisect {
 
 sub patchcheck_reboot {
     doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
-    reboot $patchcheck_sleep_time;
+    reboot_to_good $patchcheck_sleep_time;
 }
 
 sub patchcheck {
     my ($i) = @_;
 
     die "PATCHCHECK_START[$i] not defined\n"
-        if (!defined($opt{"PATCHCHECK_START[$i]"}));
+        if (!defined($patchcheck_start));
     die "PATCHCHECK_TYPE[$i] not defined\n"
-        if (!defined($opt{"PATCHCHECK_TYPE[$i]"}));
+        if (!defined($patchcheck_type));
 
-    my $start = $opt{"PATCHCHECK_START[$i]"};
+    my $start = $patchcheck_start;
 
     my $end = "HEAD";
-    if (defined($opt{"PATCHCHECK_END[$i]"})) {
-        $end = $opt{"PATCHCHECK_END[$i]"};
+    if (defined($patchcheck_end)) {
+        $end = $patchcheck_end;
     }
 
     # Get the true sha1's since we can use things like HEAD~3
     $start = get_sha1($start);
     $end = get_sha1($end);
 
-    my $type = $opt{"PATCHCHECK_TYPE[$i]"};
+    my $type = $patchcheck_type;
 
     # Can't have a test without having a test to run
     if ($type eq "test" && !defined($run_test)) {
@@ -2963,7 +3302,7 @@ sub make_min_config {
         }
 
         doprint "Reboot and wait $sleep_time seconds\n";
-        reboot $sleep_time;
+        reboot_to_good $sleep_time;
     }
 
     success $i;
@@ -2985,13 +3324,27 @@ if ($#ARGV == 0) {
 }
 
 if (! -f $ktest_config) {
+    $newconfig = 1;
+    get_test_case;
     open(OUT, ">$ktest_config") or die "Can not create $ktest_config";
     print OUT << "EOF"
 # Generated by ktest.pl
 #
+
+# PWD is a ktest.pl variable that will result in the process working
+# directory that ktest.pl is executed in.
+
+# THIS_DIR is automatically assigned the PWD of the path that generated
+# the config file. It is best to use this variable when assigning other
+# directory paths within this directory. This allows you to easily
+# move the test cases to other locations or to other machines.
+#
+THIS_DIR := $variable{"PWD"}
+
 # Define each test with TEST_START
 # The config options below it will override the defaults
 TEST_START
+TEST_TYPE = $default{"TEST_TYPE"}
 
 DEFAULTS
 EOF
@@ -3011,7 +3364,7 @@ if ($#new_configs >= 0) {
     open(OUT, ">>$ktest_config") or die "Can not append to $ktest_config";
     foreach my $config (@new_configs) {
         print OUT "$config = $entered_configs{$config}\n";
-        $opt{$config} = $entered_configs{$config};
+        $opt{$config} = process_variables($entered_configs{$config});
     }
 }
 
@@ -3091,61 +3444,10 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     my $makecmd = set_test_option("MAKE_CMD", $i);
 
-    $machine = set_test_option("MACHINE", $i);
-    $ssh_user = set_test_option("SSH_USER", $i);
-    $tmpdir = set_test_option("TMP_DIR", $i);
-    $outputdir = set_test_option("OUTPUT_DIR", $i);
-    $builddir = set_test_option("BUILD_DIR", $i);
-    $test_type = set_test_option("TEST_TYPE", $i);
-    $build_type = set_test_option("BUILD_TYPE", $i);
-    $build_options = set_test_option("BUILD_OPTIONS", $i);
-    $pre_build = set_test_option("PRE_BUILD", $i);
-    $post_build = set_test_option("POST_BUILD", $i);
-    $pre_build_die = set_test_option("PRE_BUILD_DIE", $i);
-    $post_build_die = set_test_option("POST_BUILD_DIE", $i);
-    $power_cycle = set_test_option("POWER_CYCLE", $i);
-    $reboot = set_test_option("REBOOT", $i);
-    $noclean = set_test_option("BUILD_NOCLEAN", $i);
-    $minconfig = set_test_option("MIN_CONFIG", $i);
-    $output_minconfig = set_test_option("OUTPUT_MIN_CONFIG", $i);
-    $start_minconfig = set_test_option("START_MIN_CONFIG", $i);
-    $ignore_config = set_test_option("IGNORE_CONFIG", $i);
-    $run_test = set_test_option("TEST", $i);
-    $addconfig = set_test_option("ADD_CONFIG", $i);
-    $reboot_type = set_test_option("REBOOT_TYPE", $i);
-    $grub_menu = set_test_option("GRUB_MENU", $i);
-    $post_install = set_test_option("POST_INSTALL", $i);
-    $no_install = set_test_option("NO_INSTALL", $i);
-    $reboot_script = set_test_option("REBOOT_SCRIPT", $i);
-    $reboot_on_error = set_test_option("REBOOT_ON_ERROR", $i);
-    $poweroff_on_error = set_test_option("POWEROFF_ON_ERROR", $i);
-    $die_on_failure = set_test_option("DIE_ON_FAILURE", $i);
-    $power_off = set_test_option("POWER_OFF", $i);
-    $powercycle_after_reboot = set_test_option("POWERCYCLE_AFTER_REBOOT", $i);
-    $poweroff_after_halt = set_test_option("POWEROFF_AFTER_HALT", $i);
-    $sleep_time = set_test_option("SLEEP_TIME", $i);
-    $bisect_sleep_time = set_test_option("BISECT_SLEEP_TIME", $i);
-    $patchcheck_sleep_time = set_test_option("PATCHCHECK_SLEEP_TIME", $i);
-    $ignore_warnings = set_test_option("IGNORE_WARNINGS", $i);
-    $bisect_manual = set_test_option("BISECT_MANUAL", $i);
-    $bisect_skip = set_test_option("BISECT_SKIP", $i);
-    $config_bisect_good = set_test_option("CONFIG_BISECT_GOOD", $i);
-    $store_failures = set_test_option("STORE_FAILURES", $i);
-    $test_name = set_test_option("TEST_NAME", $i);
-    $timeout = set_test_option("TIMEOUT", $i);
-    $booted_timeout = set_test_option("BOOTED_TIMEOUT", $i);
-    $console = set_test_option("CONSOLE", $i);
-    $detect_triplefault = set_test_option("DETECT_TRIPLE_FAULT", $i);
-    $success_line = set_test_option("SUCCESS_LINE", $i);
-    $reboot_success_line = set_test_option("REBOOT_SUCCESS_LINE", $i);
-    $stop_after_success = set_test_option("STOP_AFTER_SUCCESS", $i);
-    $stop_after_failure = set_test_option("STOP_AFTER_FAILURE", $i);
-    $stop_test_after = set_test_option("STOP_TEST_AFTER", $i);
-    $build_target = set_test_option("BUILD_TARGET", $i);
-    $ssh_exec = set_test_option("SSH_EXEC", $i);
-    $scp_to_target = set_test_option("SCP_TO_TARGET", $i);
-    $target_image = set_test_option("TARGET_IMAGE", $i);
-    $localversion = set_test_option("LOCALVERSION", $i);
+    # Load all the options into their mapped variable names
+    foreach my $opt (keys %option_map) {
+        ${$option_map{$opt}} = set_test_option($opt, $i);
+    }
 
     $start_minconfig_defined = 1;
 
@@ -3166,26 +3468,26 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     $ENV{"SSH_USER"} = $ssh_user;
     $ENV{"MACHINE"} = $machine;
 
-    $target = "$ssh_user\@$machine";
-
     $buildlog = "$tmpdir/buildlog-$machine";
+    $testlog = "$tmpdir/testlog-$machine";
     $dmesg = "$tmpdir/dmesg-$machine";
     $make = "$makecmd O=$outputdir";
     $output_config = "$outputdir/.config";
 
-    if ($reboot_type eq "grub") {
-        dodie "GRUB_MENU not defined" if (!defined($grub_menu));
-    } elsif (!defined($reboot_script)) {
-        dodie "REBOOT_SCRIPT not defined"
+    if (!$buildonly) {
+        $target = "$ssh_user\@$machine";
+        if ($reboot_type eq "grub") {
+            dodie "GRUB_MENU not defined" if (!defined($grub_menu));
+        }
     }
 
     my $run_type = $build_type;
     if ($test_type eq "patchcheck") {
-        $run_type = $opt{"PATCHCHECK_TYPE[$i]"};
+        $run_type = $patchcheck_type;
     } elsif ($test_type eq "bisect") {
-        $run_type = $opt{"BISECT_TYPE[$i]"};
+        $run_type = $bisect_type;
     } elsif ($test_type eq "config_bisect") {
-        $run_type = $opt{"CONFIG_BISECT_TYPE[$i]"};
+        $run_type = $config_bisect_type;
     }
 
     if ($test_type eq "make_min_config") {
@@ -3205,6 +3507,7 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     unlink $dmesg;
     unlink $buildlog;
+    unlink $testlog;
 
     if (defined($addconfig)) {
         my $min = $minconfig;
@@ -3216,7 +3519,6 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
         $minconfig = "$tmpdir/add_config";
     }
 
-    my $checkout = $opt{"CHECKOUT[$i]"};
     if (defined($checkout)) {
         run_command "git checkout $checkout" or
             die "failed to checkout $checkout";
@@ -3267,7 +3569,7 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 if ($opt{"POWEROFF_ON_SUCCESS"}) {
     halt;
 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot) {
-    reboot;
+    reboot_to_good;
 }
 
 doprint "\n    $successes of $opt{NUM_TESTS} tests were successful\n\n";
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index dbedfa196727..5ea04c6a71bf 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -346,7 +346,10 @@
 #GRUB_MENU = Test Kernel
 
 # A script to reboot the target into the test kernel
-# (Only mandatory if REBOOT_TYPE = script)
+# This and SWITCH_TO_TEST are about the same, except
+# SWITCH_TO_TEST is run even for REBOOT_TYPE = grub.
+# This may be left undefined.
+# (default undefined)
 #REBOOT_SCRIPT =
 
 #### Optional Config Options (all have defaults) ####
@@ -468,6 +471,27 @@
 # The test will not modify that file.
 #REBOOT_TYPE = grub
 
+# If you are using a machine that doesn't boot with grub, and
+# perhaps gets its kernel from a remote server (tftp), then
+# you can use this option to update the target image with the
+# test image.
+#
+# You could also do the same with POST_INSTALL, but the difference
+# between that option and this option is that POST_INSTALL runs
+# after the install, where this one runs just before a reboot.
+# (default undefined)
+#SWITCH_TO_TEST = cp ${OUTPUT_DIR}/${BUILD_TARGET} ${TARGET_IMAGE}
+
+# If you are using a machine that doesn't boot with grub, and
+# perhaps gets its kernel from a remote server (tftp), then
+# you can use this option to update the target image with the
+# the known good image to reboot safely back into.
+#
+# This option holds a command that will execute before needing
+# to reboot to a good known image.
+# (default undefined)
+#SWITCH_TO_GOOD = ssh ${SSH_USER}/${MACHINE} cp good_image ${TARGET_IMAGE}
+
 # The min config that is needed to build for the machine
 # A nice way to create this is with the following:
 #
@@ -589,6 +613,12 @@
 # (default undefined)
 #STORE_FAILURES = /home/test/failures
 
+# Directory to store success directories on success. If this is not
+# set, the .config, dmesg and bootlog will not be saved if a
+# test succeeds.
+# (default undefined)
+#STORE_SUCCESSES = /home/test/successes
+
 # Build without doing a make mrproper, or removing .config
 # (default 0)
 #BUILD_NOCLEAN = 0
@@ -700,6 +730,25 @@
 # (default 1)
 #DETECT_TRIPLE_FAULT = 0
 
+# All options in the config file should be either used by ktest
+# or could be used within a value of another option. If an option
+# in the config file is not used, ktest will warn about it and ask
+# if you want to continue.
+#
+# If you don't care if there are non-used options, enable this
+# option. Be careful though, a non-used option is usually a sign
+# of an option name being typed incorrectly.
+# (default 0)
+#IGNORE_UNUSED = 1
+
+# When testing a kernel that happens to have WARNINGs, and call
+# traces, ktest.pl will detect these and fail a boot or test run
+# due to warnings. By setting this option, ktest will ignore
+# call traces, and will not fail a test if the kernel produces
+# an oops. Use this option with care.
+# (default 0)
+#IGNORE_ERRORS = 1
+
 #### Per test run options ####
 # The following options are only allowed in TEST_START sections.
 # They are ignored in the DEFAULTS sections.
@@ -862,6 +911,42 @@
 #   BISECT_BAD with BISECT_CHECK = good or
 #   BISECT_CHECK = bad, respectively.
 #
+# BISECT_RET_GOOD = 0 (optional, default undefined)
+#
+#   In case the specificed test returns something other than just
+#   0 for good, and non-zero for bad, you can override 0 being
+#   good by defining BISECT_RET_GOOD.
+#
+# BISECT_RET_BAD = 1 (optional, default undefined)
+#
+#   In case the specificed test returns something other than just
+#   0 for good, and non-zero for bad, you can override non-zero being
+#   bad by defining BISECT_RET_BAD.
+#
+# BISECT_RET_ABORT = 255 (optional, default undefined)
+#
+#   If you need to abort the bisect if the test discovers something
+#   that was wrong, you can define BISECT_RET_ABORT to be the error
+#   code returned by the test in order to abort the bisect.
+#
+# BISECT_RET_SKIP = 2 (optional, default undefined)
+#
+#   If the test detects that the current commit is neither good
+#   nor bad, but something else happened (another bug detected)
+#   you can specify BISECT_RET_SKIP to an error code that the
+#   test returns when it should skip the current commit.
+#
+# BISECT_RET_DEFAULT = good (optional, default undefined)
+#
+#   You can override the default of what to do when the above
+#   options are not hit. This may be one of, "good", "bad",
+#   "abort" or "skip" (without the quotes).
+#
+#   Note, if you do not define any of the previous BISECT_RET_*
+#   and define BISECT_RET_DEFAULT, all bisects results will do
+#   what the BISECT_RET_DEFAULT has.
+#
+#
 # Example:
 #   TEST_START
 #   TEST_TYPE = bisect
@@ -950,7 +1035,7 @@
 #   TEST_START
 #   TEST_TYPE = config_bisect
 #   CONFIG_BISECT_TYPE = build
-#   CONFIG_BISECT = /home/test/¢onfig-bad
+#   CONFIG_BISECT = /home/test/config-bad
 #   MIN_CONFIG = /home/test/config-min
 #   BISECT_MANUAL = 1
 #
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
new file mode 100644
index 000000000000..4ec84018cc13
--- /dev/null
+++ b/tools/testing/selftests/Makefile
@@ -0,0 +1,11 @@
+TARGETS = breakpoints
+
+all:
+        for TARGET in $(TARGETS); do \
+                make -C $$TARGET; \
+        done;
+
+clean:
+        for TARGET in $(TARGETS); do \
+                make -C $$TARGET clean; \
+        done;
diff --git a/tools/testing/selftests/breakpoints/Makefile b/tools/testing/selftests/breakpoints/Makefile
new file mode 100644
index 000000000000..f362722cdce7
--- /dev/null
+++ b/tools/testing/selftests/breakpoints/Makefile
@@ -0,0 +1,20 @@
+# Taken from perf makefile
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
+ifeq ($(ARCH),i386)
+        ARCH := x86
+endif
+ifeq ($(ARCH),x86_64)
+        ARCH := x86
+endif
+
+
+all:
+ifeq ($(ARCH),x86)
+        gcc breakpoint_test.c -o run_test
+else
+        echo "Not an x86 target, can't build breakpoints selftests"
+endif
+
+clean:
+        rm -fr run_test
diff --git a/tools/testing/selftests/breakpoints/breakpoint_test.c b/tools/testing/selftests/breakpoints/breakpoint_test.c
new file mode 100644
index 000000000000..a0743f3b2b57
--- /dev/null
+++ b/tools/testing/selftests/breakpoints/breakpoint_test.c
@@ -0,0 +1,394 @@
+/*
+ * Copyright (C) 2011 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
+ *
+ * Licensed under the terms of the GNU GPL License version 2
+ *
+ * Selftests for breakpoints (and more generally the do_debug() path) in x86.
+ */
+
+
+#include <sys/ptrace.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sys/user.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+
+/* Breakpoint access modes */
+enum {
+        BP_X = 1,
+        BP_RW = 2,
+        BP_W = 4,
+};
+
+static pid_t child_pid;
+
+/*
+ * Ensures the child and parent are always "talking" about
+ * the same test sequence. (ie: that we haven't forgotten
+ * to call check_trapped() somewhere).
+ */
+static int nr_tests;
+
+static void set_breakpoint_addr(void *addr, int n)
+{
+        int ret;
+
+        ret = ptrace(PTRACE_POKEUSER, child_pid,
+                     offsetof(struct user, u_debugreg[n]), addr);
+        if (ret) {
+                perror("Can't set breakpoint addr\n");
+                exit(-1);
+        }
+}
+
+static void toggle_breakpoint(int n, int type, int len,
+                              int local, int global, int set)
+{
+        int ret;
+
+        int xtype, xlen;
+        unsigned long vdr7, dr7;
+
+        switch (type) {
+        case BP_X:
+                xtype = 0;
+                break;
+        case BP_W:
+                xtype = 1;
+                break;
+        case BP_RW:
+                xtype = 3;
+                break;
+        }
+
+        switch (len) {
+        case 1:
+                xlen = 0;
+                break;
+        case 2:
+                xlen = 4;
+                break;
+        case 4:
+                xlen = 0xc;
+                break;
+        case 8:
+                xlen = 8;
+                break;
+        }
+
+        dr7 = ptrace(PTRACE_PEEKUSER, child_pid,
+                     offsetof(struct user, u_debugreg[7]), 0);
+
+        vdr7 = (xlen | xtype) << 16;
+        vdr7 <<= 4 * n;
+
+        if (local) {
+                vdr7 |= 1 << (2 * n);
+                vdr7 |= 1 << 8;
+        }
+        if (global) {
+                vdr7 |= 2 << (2 * n);
+                vdr7 |= 1 << 9;
+        }
+
+        if (set)
+                dr7 |= vdr7;
+        else
+                dr7 &= ~vdr7;
+
+        ret = ptrace(PTRACE_POKEUSER, child_pid,
+                     offsetof(struct user, u_debugreg[7]), dr7);
+        if (ret) {
+                perror("Can't set dr7");
+                exit(-1);
+        }
+}
+
+/* Dummy variables to test read/write accesses */
+static unsigned long long dummy_var[4];
+
+/* Dummy functions to test execution accesses */
+static void dummy_func(void) { }
+static void dummy_func1(void) { }
+static void dummy_func2(void) { }
+static void dummy_func3(void) { }
+
+static void (*dummy_funcs[])(void) = {
+        dummy_func,
+        dummy_func1,
+        dummy_func2,
+        dummy_func3,
+};
+
+static int trapped;
+
+static void check_trapped(void)
+{
+        /*
+         * If we haven't trapped, wake up the parent
+         * so that it notices the failure.
+         */
+        if (!trapped)
+                kill(getpid(), SIGUSR1);
+        trapped = 0;
+
+        nr_tests++;
+}
+
+static void write_var(int len)
+{
+        char *pcval; short *psval; int *pival; long long *plval;
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                switch (len) {
+                case 1:
+                        pcval = (char *)&dummy_var[i];
+                        *pcval = 0xff;
+                        break;
+                case 2:
+                        psval = (short *)&dummy_var[i];
+                        *psval = 0xffff;
+                        break;
+                case 4:
+                        pival = (int *)&dummy_var[i];
+                        *pival = 0xffffffff;
+                        break;
+                case 8:
+                        plval = (long long *)&dummy_var[i];
+                        *plval = 0xffffffffffffffffLL;
+                        break;
+                }
+                check_trapped();
+        }
+}
+
+static void read_var(int len)
+{
+        char cval; short sval; int ival; long long lval;
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                switch (len) {
+                case 1:
+                        cval = *(char *)&dummy_var[i];
+                        break;
+                case 2:
+                        sval = *(short *)&dummy_var[i];
+                        break;
+                case 4:
+                        ival = *(int *)&dummy_var[i];
+                        break;
+                case 8:
+                        lval = *(long long *)&dummy_var[i];
+                        break;
+                }
+                check_trapped();
+        }
+}
+
+/*
+ * Do the r/w/x accesses to trigger the breakpoints. And run
+ * the usual traps.
+ */
+static void trigger_tests(void)
+{
+        int len, local, global, i;
+        char val;
+        int ret;
+
+        ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);
+        if (ret) {
+                perror("Can't be traced?\n");
+                return;
+        }
+
+        /* Wake up father so that it sets up the first test */
+        kill(getpid(), SIGUSR1);
+
+        /* Test instruction breakpoints */
+        for (local = 0; local < 2; local++) {
+                for (global = 0; global < 2; global++) {
+                        if (!local && !global)
+                                continue;
+
+                        for (i = 0; i < 4; i++) {
+                                dummy_funcs[i]();
+                                check_trapped();
+                        }
+                }
+        }
+
+        /* Test write watchpoints */
+        for (len = 1; len <= sizeof(long); len <<= 1) {
+                for (local = 0; local < 2; local++) {
+                        for (global = 0; global < 2; global++) {
+                                if (!local && !global)
+                                        continue;
+                                write_var(len);
+                        }
+                }
+        }
+
+        /* Test read/write watchpoints (on read accesses) */
+        for (len = 1; len <= sizeof(long); len <<= 1) {
+                for (local = 0; local < 2; local++) {
+                        for (global = 0; global < 2; global++) {
+                                if (!local && !global)
+                                        continue;
+                                read_var(len);
+                        }
+                }
+        }
+
+        /* Icebp trap */
+        asm(".byte 0xf1\n");
+        check_trapped();
+
+        /* Int 3 trap */
+        asm("int $3\n");
+        check_trapped();
+
+        kill(getpid(), SIGUSR1);
+}
+
+static void check_success(const char *msg)
+{
+        const char *msg2;
+        int child_nr_tests;
+        int status;
+
+        /* Wait for the child to SIGTRAP */
+        wait(&status);
+
+        msg2 = "Failed";
+
+        if (WSTOPSIG(status) == SIGTRAP) {
+                child_nr_tests = ptrace(PTRACE_PEEKDATA, child_pid,
+                                        &nr_tests, 0);
+                if (child_nr_tests == nr_tests)
+                        msg2 = "Ok";
+                if (ptrace(PTRACE_POKEDATA, child_pid, &trapped, 1)) {
+                        perror("Can't poke\n");
+                        exit(-1);
+                }
+        }
+
+        nr_tests++;
+
+        printf("%s [%s]\n", msg, msg2);
+}
+
+static void launch_instruction_breakpoints(char *buf, int local, int global)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                set_breakpoint_addr(dummy_funcs[i], i);
+                toggle_breakpoint(i, BP_X, 1, local, global, 1);
+                ptrace(PTRACE_CONT, child_pid, NULL, 0);
+                sprintf(buf, "Test breakpoint %d with local: %d global: %d",
+                        i, local, global);
+                check_success(buf);
+                toggle_breakpoint(i, BP_X, 1, local, global, 0);
+        }
+}
+
+static void launch_watchpoints(char *buf, int mode, int len,
+                               int local, int global)
+{
+        const char *mode_str;
+        int i;
+
+        if (mode == BP_W)
+                mode_str = "write";
+        else
+                mode_str = "read";
+
+        for (i = 0; i < 4; i++) {
+                set_breakpoint_addr(&dummy_var[i], i);
+                toggle_breakpoint(i, mode, len, local, global, 1);
+                ptrace(PTRACE_CONT, child_pid, NULL, 0);
+                sprintf(buf, "Test %s watchpoint %d with len: %d local: "
+                        "%d global: %d", mode_str, i, len, local, global);
+                check_success(buf);
+                toggle_breakpoint(i, mode, len, local, global, 0);
+        }
+}
+
+/* Set the breakpoints and check the child successfully trigger them */
+static void launch_tests(void)
+{
+        char buf[1024];
+        int len, local, global, i;
+
+        /* Instruction breakpoints */
+        for (local = 0; local < 2; local++) {
+                for (global = 0; global < 2; global++) {
+                        if (!local && !global)
+                                continue;
+                        launch_instruction_breakpoints(buf, local, global);
+                }
+        }
+
+        /* Write watchpoint */
+        for (len = 1; len <= sizeof(long); len <<= 1) {
+                for (local = 0; local < 2; local++) {
+                        for (global = 0; global < 2; global++) {
+                                if (!local && !global)
+                                        continue;
+                                launch_watchpoints(buf, BP_W, len,
+                                                   local, global);
+                        }
+                }
+        }
+
+        /* Read-Write watchpoint */
+        for (len = 1; len <= sizeof(long); len <<= 1) {
+                for (local = 0; local < 2; local++) {
+                        for (global = 0; global < 2; global++) {
+                                if (!local && !global)
+                                        continue;
+                                launch_watchpoints(buf, BP_RW, len,
+                                                   local, global);
+                        }
+                }
+        }
+
+        /* Icebp traps */
+        ptrace(PTRACE_CONT, child_pid, NULL, 0);
+        check_success("Test icebp");
+
+        /* Int 3 traps */
+        ptrace(PTRACE_CONT, child_pid, NULL, 0);
+        check_success("Test int 3 trap");
+
+        ptrace(PTRACE_CONT, child_pid, NULL, 0);
+}
+
+int main(int argc, char **argv)
+{
+        pid_t pid;
+        int ret;
+
+        pid = fork();
+        if (!pid) {
+                trigger_tests();
+                return 0;
+        }
+
+        child_pid = pid;
+
+        wait(NULL);
+
+        launch_tests();
+
+        wait(NULL);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/run_tests b/tools/testing/selftests/run_tests
new file mode 100644
index 000000000000..320718a4e6bf
--- /dev/null
+++ b/tools/testing/selftests/run_tests
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+TARGETS=breakpoints
+
+for TARGET in $TARGETS
+do
+        $TARGET/run_test
+done
diff --git a/tools/virtio/linux/virtio.h b/tools/virtio/linux/virtio.h
index 669bcdd45805..b4fbc91c41b4 100644
--- a/tools/virtio/linux/virtio.h
+++ b/tools/virtio/linux/virtio.h
@@ -186,21 +186,12 @@ struct virtqueue {
 #endif
 
 /* Interfaces exported by virtio_ring. */
-int virtqueue_add_buf_gfp(struct virtqueue *vq,
-                          struct scatterlist sg[],
-                          unsigned int out_num,
-                          unsigned int in_num,
-                          void *data,
-                          gfp_t gfp);
-
-static inline int virtqueue_add_buf(struct virtqueue *vq,
-                                    struct scatterlist sg[],
-                                    unsigned int out_num,
-                                    unsigned int in_num,
-                                    void *data)
-{
-        return virtqueue_add_buf_gfp(vq, sg, out_num, in_num, data, GFP_ATOMIC);
-}
+int virtqueue_add_buf(struct virtqueue *vq,
+                      struct scatterlist sg[],
+                      unsigned int out_num,
+                      unsigned int in_num,
+                      void *data,
+                      gfp_t gfp);
 
 void virtqueue_kick(struct virtqueue *vq);
 
@@ -214,6 +205,7 @@ void *virtqueue_detach_unused_buf(struct virtqueue *vq);
 struct virtqueue *vring_new_virtqueue(unsigned int num,
                                       unsigned int vring_align,
                                       struct virtio_device *vdev,
+                                      bool weak_barriers,
                                       void *pages,
                                       void (*notify)(struct virtqueue *vq),
                                       void (*callback)(struct virtqueue *vq),
diff --git a/tools/virtio/virtio_test.c b/tools/virtio/virtio_test.c
index 74d3331bdaf9..6bf95f995364 100644
--- a/tools/virtio/virtio_test.c
+++ b/tools/virtio/virtio_test.c
@@ -92,7 +92,8 @@ static void vq_info_add(struct vdev_info *dev, int num)
         assert(r >= 0);
         memset(info->ring, 0, vring_size(num, 4096));
         vring_init(&info->vring, num, info->ring, 4096);
-        info->vq = vring_new_virtqueue(info->vring.num, 4096, &dev->vdev, info->ring,
+        info->vq = vring_new_virtqueue(info->vring.num, 4096, &dev->vdev,
+                                       true, info->ring,
                                        vq_notify, vq_callback, "test");
         assert(info->vq);
         info->vq->priv = info;
@@ -160,7 +161,8 @@ static void run_test(struct vdev_info *dev, struct vq_info *vq, int bufs)
                         if (started < bufs) {
                                 sg_init_one(&sl, dev->buf, dev->buf_size);
                                 r = virtqueue_add_buf(vq->vq, &sl, 1, 0,
-                                                      dev->buf + started);
+                                                      dev->buf + started,
+                                                      GFP_ATOMIC);
                                 if (likely(r >= 0)) {
                                         ++started;
                                         virtqueue_kick(vq->vq);