diff --git a/Dockerfile.dapper b/Dockerfile.dapper
index d11cb5daa..236117e9e 100644
--- a/Dockerfile.dapper
+++ b/Dockerfile.dapper
@@ -10,6 +10,7 @@ RUN apt-get update && \
         dosfstools \
         gccgo \
         genisoimage \
+        gettext \
         git \
         isolinux \
         less \
@@ -34,7 +35,7 @@ RUN apt-get update && \
 ENV DAPPER_ENV VERSION DEV_BUILD RUNTEST
 ENV DAPPER_DOCKER_SOCKET true
 ENV DAPPER_SOURCE /go/src/github.com/rancher/os
-ENV DAPPER_OUTPUT ./bin ./dist ./build/initrd
+ENV DAPPER_OUTPUT ./bin ./dist ./build/initrd ./build/kernel
 ENV DAPPER_RUN_ARGS --privileged
 ENV TRASH_CACHE ${DAPPER_SOURCE}/.trash-cache
 ENV SHELL /bin/bash
@@ -55,7 +56,8 @@ ARG DOCKER_BUILD_VERSION=1.10.3
 ARG DOCKER_BUILD_PATCH_VERSION=v${DOCKER_BUILD_VERSION}-ros1
 ARG SELINUX_POLICY_URL=https://github.com/rancher/refpolicy/releases/download/v0.0.3/policy.29
 
-ARG KERNEL_URL_amd64=https://github.com/rancher/os-kernel/releases/download/v4.9-rancher2/linux-4.9-rancher2-x86.tar.gz
+ARG KERNEL_VERSION_amd64=4.9.3-rancher
+ARG KERNEL_URL_amd64=https://github.com/rancher/os-kernel/releases/download/v${KERNEL_VERSION_amd64}/linux-${KERNEL_VERSION_amd64}-x86.tar.gz
 ARG KERNEL_URL_arm64=https://github.com/imikushin/os-kernel/releases/download/Estuary-4.4.0-arm64.8/linux-4.4.0-rancher-arm64.tar.gz
 
 ARG DOCKER_URL_amd64=https://get.docker.com/builds/Linux/x86_64/docker-${DOCKER_VERSION}.tgz
@@ -100,6 +102,7 @@ ENV BUILD_DOCKER_URL=BUILD_DOCKER_URL_${ARCH} \
     GOARCH=$ARCH \
     HOSTNAME_DEFAULT=${HOSTNAME_DEFAULT} \
     IMAGE_NAME=${IMAGE_NAME} \
+    KERNEL_VERSION=${KERNEL_VERSION_amd64} \
     KERNEL_URL=KERNEL_URL_${ARCH} \
     KERNEL_URL_amd64=${KERNEL_URL_amd64} \
     KERNEL_URL_arm64=${KERNEL_URL_arm64} \
@@ -119,7 +122,8 @@ RUN mkdir -p ${DOWNLOADS}
 
 # Download kernel
 RUN rm /bin/sh && ln -s /bin/bash /bin/sh
-RUN if [ -n "${!KERNEL_URL}" ]; then \
+RUN echo "... Downloading  ${!KERNEL_URL}"; \
+    if [ -n "${!KERNEL_URL}" ]; then \
         curl -fL ${!KERNEL_URL} > ${DOWNLOADS}/kernel.tar.gz \
     ;fi
 
diff --git a/cmd/control/install.go b/cmd/control/install.go
index 4e6b6cd0d..31435838c 100755
--- a/cmd/control/install.go
+++ b/cmd/control/install.go
@@ -1,16 +1,24 @@
 package control
 
 import (
+	"bufio"
+	"bytes"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"os"
 	"os/exec"
+	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/rancher/os/log"
 
 	"github.com/codegangsta/cli"
+	"github.com/rancher/os/cmd/control/install"
 	"github.com/rancher/os/cmd/power"
 	"github.com/rancher/os/config"
+	"github.com/rancher/os/dfs" // TODO: move CopyFile into util or something.
 	"github.com/rancher/os/util"
 )
 
@@ -28,9 +36,8 @@ var installCommand = cli.Command{
 		},
 		cli.StringFlag{
 			Name: "install-type, t",
-			Usage: `generic:    (Default) Creates 1 ext4 partition and installs RancherOS
+			Usage: `generic:    (Default) Creates 1 ext4 partition and installs RancherOS (syslinux)
                         amazon-ebs: Installs RancherOS and sets up PV-GRUB
-                        syslinux: partition and format disk (mbr), then install RancherOS and setup Syslinux
                         gptsyslinux: partition and format disk (gpt), then install RancherOS and setup Syslinux
                         `,
 		},
@@ -54,6 +61,19 @@ var installCommand = cli.Command{
 			Name:  "append, a",
 			Usage: "append additional kernel parameters",
 		},
+		cli.StringFlag{ // TODO: hide..
+			Name:  "rollback, r",
+			Usage: "rollback version",
+		},
+		cli.BoolFlag{ // TODO: this should be hidden and internal only
+			Name:   "isoinstallerloaded",
+			Usage:  "INTERNAL use only: mount the iso to get kernel and initrd",
+			Hidden: true,
+		},
+		cli.BoolFlag{
+			Name:  "kexec",
+			Usage: "reboot using kexec",
+		},
 	},
 }
 
@@ -61,10 +81,11 @@ func installAction(c *cli.Context) error {
 	if c.Args().Present() {
 		log.Fatalf("invalid arguments %v", c.Args())
 	}
-	device := c.String("device")
-	if device == "" {
-		log.Fatal("Can not proceed without -d <dev> specified")
-	}
+	kappend := strings.TrimSpace(c.String("append"))
+	force := c.Bool("force")
+	kexec := c.Bool("kexec")
+	reboot := !c.Bool("no-reboot")
+	isoinstallerloaded := c.Bool("isoinstallerloaded")
 
 	image := c.String("image")
 	cfg := config.LoadConfig()
@@ -77,10 +98,27 @@ func installAction(c *cli.Context) error {
 		log.Info("No install type specified...defaulting to generic")
 		installType = "generic"
 	}
+	if installType == "rancher-upgrade" ||
+		installType == "upgrade" {
+		force = true // the os.go upgrade code already asks
+		reboot = false
+		isoinstallerloaded = true // OMG this flag is aweful - kill it with fire
+	}
+	device := c.String("device")
+	if installType != "noformat" &&
+		installType != "raid" &&
+		installType != "bootstrap" &&
+		installType != "upgrade" &&
+		installType != "rancher-upgrade" {
+		// These can use RANCHER_BOOT or RANCHER_STATE labels..
+		if device == "" {
+			log.Fatal("Can not proceed without -d <dev> specified")
+		}
+	}
 
 	cloudConfig := c.String("cloud-config")
 	if cloudConfig == "" {
-		log.Warn("Cloud-config not provided: you might need to provide cloud-config on boot with ssh_authorized_keys")
+		log.Warn("Cloud-config not provided: you might need to provide cloud-config on bootDir with ssh_authorized_keys")
 	} else {
 		uc := "/opt/user_config.yml"
 		if err := util.FileCopy(cloudConfig, uc); err != nil {
@@ -89,54 +127,853 @@ func installAction(c *cli.Context) error {
 		cloudConfig = uc
 	}
 
-	append := strings.TrimSpace(c.String("append"))
-	force := c.Bool("force")
-	reboot := !c.Bool("no-reboot")
-
-	if err := runInstall(image, installType, cloudConfig, device, append, force, reboot); err != nil {
+	if err := runInstall(image, installType, cloudConfig, device, kappend, force, reboot, kexec, isoinstallerloaded); err != nil {
 		log.WithFields(log.Fields{"err": err}).Fatal("Failed to run install")
 	}
 
 	return nil
 }
 
-func runInstall(image, installType, cloudConfig, device, append string, force, reboot bool) error {
+func runInstall(image, installType, cloudConfig, device, kappend string, force, reboot, kexec, isoinstallerloaded bool) error {
 	fmt.Printf("Installing from %s\n", image)
 
 	if !force {
 		if !yes("Continue") {
+			log.Infof("Not continuing with installation due to user not saying 'yes'")
 			os.Exit(1)
 		}
 	}
 	diskType := "msdos"
+
 	if installType == "gptsyslinux" {
 		diskType = "gpt"
 	}
 
+	// Versions before 0.8.0-rc2 use the old calling convention (from the lay-down-os shell script)
+	imageVersion := strings.TrimPrefix(image, "rancher/os:v")
+	if image != imageVersion {
+		log.Infof("user specified different install image: %s != %s", image, imageVersion)
+		imageVersion = strings.Replace(imageVersion, "-", ".", -1)
+		vArray := strings.Split(imageVersion, ".")
+		v, _ := strconv.ParseFloat(vArray[0]+"."+vArray[1], 32)
+		if v < 0.8 || imageVersion == "0.8.0-rc1" {
+			log.Infof("starting installer container for %s", image)
+			if installType == "generic" ||
+				installType == "syslinux" ||
+				installType == "gptsyslinux" {
+				cmd := exec.Command("system-docker", "run", "--net=host", "--privileged", "--volumes-from=all-volumes",
+					"--entrypoint=/scripts/set-disk-partitions", image, device, diskType)
+				cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+				if err := cmd.Run(); err != nil {
+					return err
+				}
+			}
+			cmd := exec.Command("system-docker", "run", "--net=host", "--privileged", "--volumes-from=user-volumes",
+				"--volumes-from=command-volumes", image, "-d", device, "-t", installType, "-c", cloudConfig,
+				"-a", kappend)
+			cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+			if err := cmd.Run(); err != nil {
+				return err
+			}
+			return nil
+		}
+	}
+
+	if _, err := os.Stat("/usr/bin/system-docker"); os.IsNotExist(err) {
+		if err := os.Symlink("/usr/bin/ros", "/usr/bin/system-docker"); err != nil {
+			log.Errorf("ln error %s", err)
+		}
+	}
+
+	useIso := false
+	// --isoinstallerloaded is used if the ros has created the installer container from and image that was on the booted iso
+	if !isoinstallerloaded {
+		if _, err := os.Stat("/dist/initrd"); os.IsNotExist(err) {
+			if err = mountBootIso(); err != nil {
+				log.Debugf("mountBootIso error %s", err)
+			} else {
+				if _, err := os.Stat("/bootiso/rancheros/"); err == nil {
+					cmd := exec.Command("system-docker", "load", "-i", "/bootiso/rancheros/installer.tar.gz")
+					cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+					if err := cmd.Run(); err != nil {
+						log.Infof("failed to load images from /bootiso/rancheros: %s", err)
+					} else {
+						log.Infof("Loaded images from /bootiso/rancheros/installer.tar.gz")
+
+						//TODO: add if os-installer:latest exists - we might have loaded a full installer?
+						useIso = true
+						// now use the installer image
+						cfg := config.LoadConfig()
+						// TODO: fix the fullinstaller Dockerfile to use the ${VERSION}${SUFFIX}
+						image = cfg.Rancher.Upgrade.Image + "-installer" + ":latest"
+					}
+				}
+				// TODO: also poke around looking for the /boot/vmlinuz and initrd...
+			}
+
+			log.Infof("starting installer container for %s (new)", image)
+			installerCmd := []string{
+				"run", "--rm", "--net=host", "--privileged",
+				// bind mount host fs to access its ros, vmlinuz, initrd and /dev (udev isn't running in container)
+				"-v", "/:/host",
+				"--volumes-from=all-volumes",
+				image,
+				//				"install",
+				"-t", installType,
+				"-d", device,
+			}
+			if force {
+				installerCmd = append(installerCmd, "-f")
+			}
+			if !reboot {
+				installerCmd = append(installerCmd, "--no-reboot")
+			}
+			if cloudConfig != "" {
+				installerCmd = append(installerCmd, "-c", cloudConfig)
+			}
+			if kappend != "" {
+				installerCmd = append(installerCmd, "-a", kappend)
+			}
+			if useIso {
+				installerCmd = append(installerCmd, "--isoinstallerloaded=1")
+			}
+			if kexec {
+				installerCmd = append(installerCmd, "--kexec")
+			}
+
+			cmd := exec.Command("system-docker", installerCmd...)
+			log.Debugf("Run(%v)", cmd)
+			cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+			if err := cmd.Run(); err != nil {
+				if useIso {
+					util.Unmount("/bootiso")
+				}
+				return err
+			}
+			if useIso {
+				util.Unmount("/bootiso")
+			}
+			return nil
+		}
+	}
+
+	// TODO: needs to pass the log level on to the container
+	log.InitLogger()
+	log.SetLevel(log.InfoLevel)
+
+	log.Debugf("running installation")
+
 	if installType == "generic" ||
 		installType == "syslinux" ||
 		installType == "gptsyslinux" {
+		diskType := "msdos"
+		if installType == "gptsyslinux" {
+			diskType = "gpt"
+		}
+		log.Debugf("running setDiskpartitions")
+		err := setDiskpartitions(device, diskType)
+		if err != nil {
+			log.Errorf("error setDiskpartitions %s", err)
+			return err
+		}
+		// use the bind mounted host filesystem to get access to the /dev/vda1 device that udev on the host sets up (TODO: can we run a udevd inside the container? `mknod b 253 1 /dev/vda1` doesn't work)
+		device = "/host" + device
+	}
+
+	if installType == "rancher-upgrade" ||
+		installType == "upgrade" {
+		isoinstallerloaded = false
+	}
+
+	if isoinstallerloaded {
+		log.Debugf("running isoinstallerloaded...")
+		// TODO: I hope to remove this from here later.
+		if err := mountBootIso(); err != nil {
+			log.Errorf("error mountBootIso %s", err)
+			return err
+		}
+	}
+
+	err := layDownOS(image, installType, cloudConfig, device, kappend, kexec)
+	if err != nil {
+		log.Errorf("error layDownOS %s", err)
+		return err
+	}
+
+	if !kexec && reboot && (force || yes("Continue with reboot")) {
+		log.Info("Rebooting")
+		power.Reboot()
+	}
+
+	return nil
+}
+
+func mountBootIso() error {
+	deviceName := "/dev/sr0"
+	deviceType := "iso9660"
+	{ // force the defer
+		mountsFile, err := os.Open("/proc/mounts")
+		if err != nil {
+			log.Errorf("failed to read /proc/mounts %s", err)
+			return err
+		}
+		defer mountsFile.Close()
+
+		if partitionMounted(deviceName, mountsFile) {
+			return nil
+		}
+	}
+
+	os.MkdirAll("/bootiso", 0755)
+
+	// find the installation device
+	cmd := exec.Command("blkid", "-L", "RancherOS")
+	log.Debugf("Run(%v)", cmd)
+	cmd.Stderr = os.Stderr
+	out, err := cmd.Output()
+	if err != nil {
+		log.Errorf("Failed to get RancherOS boot device: %s", err)
+		return err
+	}
+	deviceName = strings.TrimSpace(string(out))
+	log.Debugf("blkid found -L RancherOS: %s", deviceName)
+
+	cmd = exec.Command("blkid", deviceName)
+	log.Debugf("Run(%v)", cmd)
+	cmd.Stderr = os.Stderr
+	if out, err = cmd.Output(); err != nil {
+		log.Errorf("Failed to get RancherOS boot device type: %s", err)
+		return err
+	}
+	deviceType = strings.TrimSpace(string(out))
+	s1 := strings.Split(deviceType, "TYPE=\"")
+	s2 := strings.Split(s1[1], "\"")
+	deviceType = s2[0]
+	log.Debugf("blkid type of %s: %s", deviceName, deviceType)
+
+	cmd = exec.Command("mount", "-t", deviceType, deviceName, "/bootiso")
+	log.Debugf("Run(%v)", cmd)
+
+	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	err = cmd.Run()
+	if err != nil {
+		log.Errorf("tried and failed to mount %s: %s", deviceName, err)
+	} else {
+		log.Debugf("Mounted %s", deviceName)
+	}
+	return err
+}
+
+func layDownOS(image, installType, cloudConfig, device, kappend string, kexec bool) error {
+	// ENV == installType
+	//[[ "$ARCH" == "arm" && "$ENV" != "rancher-upgrade" ]] && ENV=arm
+
+	// image == rancher/os:v0.7.0_arm
+	// TODO: remove the _arm suffix (but watch out, its not always there..)
+	VERSION := image[strings.Index(image, ":")+1:]
+
+	var FILES []string
+	DIST := "/dist" //${DIST:-/dist}
+	//cloudConfig := SCRIPTS_DIR + "/conf/empty.yml" //${cloudConfig:-"${SCRIPTS_DIR}/conf/empty.yml"}
+	CONSOLE := "tty0"
+	baseName := "/mnt/new_img"
+	bootDir := "boot/"
+	//# TODO: Change this to a number so that users can specify.
+	//# Will need to make it so that our builds and packer APIs remain consistent.
+	partition := device + "1"                                                //${partition:=${device}1}
+	kernelArgs := "rancher.state.dev=LABEL=RANCHER_STATE rancher.state.wait" // console="+CONSOLE
+
+	// unmount on trap
+	defer util.Unmount(baseName)
+
+	diskType := "msdos"
+	if installType == "gptsyslinux" {
+		diskType = "gpt"
+	}
+
+	switch installType {
+	case "syslinux":
+		fallthrough
+	case "gptsyslinux":
+		fallthrough
+	case "generic":
+		log.Debugf("formatAndMount")
+		var err error
+		device, partition, err = formatAndMount(baseName, bootDir, device, partition)
+		if err != nil {
+			log.Errorf("formatAndMount %s", err)
+			return err
+		}
+		err = installSyslinux(device, baseName, bootDir, diskType)
+		if err != nil {
+			log.Errorf("installSyslinux %s", err)
+			return err
+		}
+		err = seedData(baseName, cloudConfig, FILES)
+		if err != nil {
+			log.Errorf("seedData %s", err)
+			return err
+		}
+	case "arm":
+		var err error
+		device, partition, err = formatAndMount(baseName, bootDir, device, partition)
+		if err != nil {
+			return err
+		}
+		seedData(baseName, cloudConfig, FILES)
+	case "amazon-ebs-pv":
+		fallthrough
+	case "amazon-ebs-hvm":
+		CONSOLE = "ttyS0"
+		var err error
+		device, partition, err = formatAndMount(baseName, bootDir, device, partition)
+		if err != nil {
+			return err
+		}
+		if installType == "amazon-ebs-hvm" {
+			installSyslinux(device, baseName, bootDir, diskType)
+		}
+		//# AWS Networking recommends disabling.
+		seedData(baseName, cloudConfig, FILES)
+	case "googlecompute":
+		CONSOLE = "ttyS0"
+		var err error
+		device, partition, err = formatAndMount(baseName, bootDir, device, partition)
+		if err != nil {
+			return err
+		}
+		installSyslinux(device, baseName, bootDir, diskType)
+		seedData(baseName, cloudConfig, FILES)
+	case "noformat":
+		var err error
+		device, partition, err = mountdevice(baseName, bootDir, partition, false)
+		if err != nil {
+			return err
+		}
+		installSyslinux(device, baseName, bootDir, diskType)
+	case "raid":
+		var err error
+		device, partition, err = mountdevice(baseName, bootDir, partition, false)
+		if err != nil {
+			return err
+		}
+		installSyslinuxRaid(baseName, bootDir, diskType)
+	case "bootstrap":
+		CONSOLE = "ttyS0"
+		var err error
+		device, partition, err = mountdevice(baseName, bootDir, partition, true)
+		if err != nil {
+			return err
+		}
+		kernelArgs = kernelArgs + " rancher.cloud_init.datasources=[ec2,gce]"
+	case "upgrade":
+		fallthrough
+	case "rancher-upgrade":
+		var err error
+		device, partition, err = mountdevice(baseName, bootDir, partition, false)
+		if err != nil {
+			return err
+		}
+		// TODO: detect pv-grub, and don't kill it with syslinux
+		upgradeBootloader(device, baseName, bootDir, diskType)
+	default:
+		return fmt.Errorf("unexpected install type %s", installType)
+	}
+	kernelArgs = kernelArgs + " console=" + CONSOLE
+
+	if kappend == "" {
+		preservedAppend, _ := ioutil.ReadFile(filepath.Join(baseName, bootDir+"append"))
+		kappend = string(preservedAppend)
+	} else {
+		ioutil.WriteFile(filepath.Join(baseName, bootDir+"append"), []byte(kappend), 0644)
+	}
+
+	if installType == "amazon-ebs-pv" {
+		menu := install.BootVars{
+			BaseName: baseName,
+			BootDir:  bootDir,
+			Timeout:  0,
+			Fallback: 0, // need to be conditional on there being a 'rollback'?
+			Entries: []install.MenuEntry{
+				install.MenuEntry{"RancherOS-current", bootDir, VERSION, kernelArgs, kappend},
+			},
+		}
+		install.PvGrubConfig(menu)
+	}
+	log.Debugf("installRancher")
+	err := installRancher(baseName, bootDir, VERSION, DIST, kernelArgs+" "+kappend)
+	if err != nil {
+		log.Errorf("%s", err)
+		return err
+	}
+	log.Debugf("installRancher done")
+
+	// Used by upgrade
+	if kexec {
+		//    kexec -l ${DIST}/vmlinuz --initrd=${DIST}/initrd --append="${kernelArgs} ${APPEND}" -f
+		cmd := exec.Command("kexec", "-l "+DIST+"/vmlinuz",
+			"--initrd="+DIST+"/initrd",
+			"--append='"+kernelArgs+" "+kappend+"'",
+			"-f")
+		log.Debugf("Run(%v)", cmd)
+		cmd.Stderr = os.Stderr
+		if _, err := cmd.Output(); err != nil {
+			log.Errorf("Failed to kexec: %s", err)
+			return err
+		}
+		log.Infof("kexec'd to new install")
+	}
+
+	return nil
+}
+
+// files is an array of 'sourcefile:destination' - but i've not seen any examples of it being used.
+func seedData(baseName, cloudData string, files []string) error {
+	log.Debugf("seedData")
+	_, err := os.Stat(baseName)
+	if err != nil {
+		return err
+	}
+
+	if err = os.MkdirAll(filepath.Join(baseName, "/var/lib/rancher/conf/cloud-config.d"), 0755); err != nil {
+		return err
+	}
+
+	if !strings.HasSuffix(cloudData, "empty.yml") {
+		if err = dfs.CopyFile(cloudData, baseName+"/var/lib/rancher/conf/cloud-config.d/", filepath.Base(cloudData)); err != nil {
+			return err
+		}
+	}
+
+	for _, f := range files {
+		e := strings.Split(f, ":")
+		if err = dfs.CopyFile(e[0], baseName, e[1]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// set-disk-partitions is called with device ==  **/dev/sda**
+func setDiskpartitions(device, diskType string) error {
+	log.Debugf("setDiskpartitions")
+
+	d := strings.Split(device, "/")
+	if len(d) != 3 {
+		return fmt.Errorf("bad device name (%s)", device)
+	}
+	deviceName := d[2]
+
+	file, err := os.Open("/proc/partitions")
+	if err != nil {
+		log.Debugf("failed to read /proc/partitions %s", err)
+		return err
+	}
+	defer file.Close()
 
-		cmd := exec.Command("system-docker", "run",
-			"--net=host", "--privileged", "--volumes-from=all-volumes",
-			"--entrypoint=/scripts/set-disk-partitions",
-			image, device, diskType)
-		cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	exists := false
+	haspartitions := false
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		str := scanner.Text()
+		last := strings.LastIndex(str, " ")
+
+		if last > -1 {
+			dev := str[last+1:]
+
+			if strings.HasPrefix(dev, deviceName) {
+				if dev == deviceName {
+					exists = true
+				} else {
+					haspartitions = true
+				}
+			}
+		}
+	}
+	if !exists {
+		return fmt.Errorf("disk %s not found: %s", device, err)
+	}
+	if haspartitions {
+		log.Debugf("device %s already partitioned - checking if any are mounted", device)
+		file, err := os.Open("/proc/mounts")
+		if err != nil {
+			log.Errorf("failed to read /proc/mounts %s", err)
+			return err
+		}
+		defer file.Close()
+		if partitionMounted(device, file) {
+			err = fmt.Errorf("partition %s mounted, cannot repartition", device)
+			log.Errorf("%s", err)
+			return err
+		}
+
+		cmd := exec.Command("system-docker", "ps", "-q")
+		var outb bytes.Buffer
+		cmd.Stdout = &outb
 		if err := cmd.Run(); err != nil {
+			log.Printf("ps error: %s", err)
 			return err
 		}
+		for _, image := range strings.Split(outb.String(), "\n") {
+			if image == "" {
+				continue
+			}
+			r, w := io.Pipe()
+			go func() {
+				// TODO: consider a timeout
+				// TODO:some of these containers don't have cat / shell
+				cmd := exec.Command("system-docker", "exec", image, "cat /proc/mount")
+				cmd.Stdout = w
+				if err := cmd.Run(); err != nil {
+					log.Debugf("%s cat %s", image, err)
+				}
+				w.Close()
+			}()
+			if partitionMounted(device, r) {
+				err = fmt.Errorf("partition %s mounted in %s, cannot repartition", device, image)
+				log.Errorf("k? %s", err)
+				return err
+			}
+		}
+	}
+	//do it!
+	log.Debugf("running dd")
+	cmd := exec.Command("dd", "if=/dev/zero", "of="+device, "bs=512", "count=2048")
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	if err := cmd.Run(); err != nil {
+		log.Errorf("dd error %s", err)
+		return err
 	}
-	cmd := exec.Command("system-docker", "run", "--net=host", "--privileged", "--volumes-from=user-volumes",
-		"--volumes-from=command-volumes", image, "-d", device, "-t", installType, "-c", cloudConfig, "-a", append)
+	log.Debugf("running partprobe")
+	cmd = exec.Command("partprobe", device)
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	if err := cmd.Run(); err != nil {
+		log.Errorf("partprobe error %s", err)
+		return err
+	}
+
+	log.Debugf("making single RANCHER_STATE partition")
+	cmd = exec.Command("parted", "-s", "-a", "optimal", device,
+		"mklabel "+diskType, "--",
+		"mkpart primary ext4 1 -1")
 	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
 	if err := cmd.Run(); err != nil {
+		log.Errorf("parted: %s", err)
+		return err
+	}
+	if err := setBootable(device, diskType); err != nil {
 		return err
 	}
 
-	if reboot && (force || yes("Continue with reboot")) {
-		log.Info("Rebooting")
-		power.Reboot()
+	return nil
+}
+
+func partitionMounted(device string, file io.Reader) bool {
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		str := scanner.Text()
+		// /dev/sdb1 /data ext4 rw,relatime,errors=remount-ro,data=ordered 0 0
+		ele := strings.Split(str, " ")
+		if len(ele) > 5 {
+			if strings.HasPrefix(ele[0], device) {
+				return true
+			}
+		}
+		if err := scanner.Err(); err != nil {
+			log.Errorf("scanner %s", err)
+			return false
+		}
+	}
+	return false
+}
+
+func formatdevice(device, partition string) error {
+	log.Debugf("formatdevice %s", partition)
+
+	//mkfs.ext4 -F -i 4096 -L RANCHER_STATE ${partition}
+	// -O ^64bit: for syslinux: http://www.syslinux.org/wiki/index.php?title=Filesystem#ext
+	cmd := exec.Command("mkfs.ext4", "-F", "-i", "4096", "-O", "^64bit", "-L", "RANCHER_STATE", partition)
+	log.Debugf("Run(%v)", cmd)
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	if err := cmd.Run(); err != nil {
+		log.Errorf("mkfs.ext4: %s", err)
+		return err
+	}
+	return nil
+}
+
+func mountdevice(baseName, bootDir, partition string, raw bool) (string, string, error) {
+	log.Debugf("mountdevice %s, raw %v", partition, raw)
+	device := ""
+
+	if raw {
+		log.Debugf("util.Mount (raw) %s, %s", partition, baseName)
+
+		cmd := exec.Command("lsblk", "-no", "pkname", partition)
+		log.Debugf("Run(%v)", cmd)
+		cmd.Stderr = os.Stderr
+		if out, err := cmd.Output(); err == nil {
+			device = "/dev/" + strings.TrimSpace(string(out))
+		}
+
+		return device, partition, util.Mount(partition, baseName, "", "")
+	}
+
+	//rootfs := partition
+	// Don't use ResolveDevice - it can fail, whereas `blkid -L LABEL` works more often
+	//if dev := util.ResolveDevice("LABEL=RANCHER_BOOT"); dev != "" {
+	cmd := exec.Command("blkid", "-L", "RANCHER_BOOT")
+	log.Debugf("Run(%v)", cmd)
+	cmd.Stderr = os.Stderr
+	if out, err := cmd.Output(); err == nil {
+		partition = strings.TrimSpace(string(out))
+	} else {
+		cmd := exec.Command("blkid", "-L", "RANCHER_STATE")
+		log.Debugf("Run(%v)", cmd)
+		cmd.Stderr = os.Stderr
+		if out, err := cmd.Output(); err == nil {
+			partition = strings.TrimSpace(string(out))
+		}
+	}
+	cmd = exec.Command("lsblk", "-no", "pkname", partition)
+	log.Debugf("Run(%v)", cmd)
+	cmd.Stderr = os.Stderr
+	if out, err := cmd.Output(); err == nil {
+		device = "/dev/" + strings.TrimSpace(string(out))
+	}
+
+	log.Debugf("util.Mount %s, %s", partition, baseName)
+	os.MkdirAll(baseName, 0755)
+	cmd = exec.Command("mount", partition, baseName)
+	log.Debugf("Run(%v)", cmd)
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	return device, partition, cmd.Run()
+}
+
+func formatAndMount(baseName, bootDir, device, partition string) (string, string, error) {
+	log.Debugf("formatAndMount")
+
+	err := formatdevice(device, partition)
+	if err != nil {
+		log.Errorf("formatdevice %s", err)
+		return device, partition, err
+	}
+	device, partition, err = mountdevice(baseName, bootDir, partition, false)
+	if err != nil {
+		log.Errorf("mountdevice %s", err)
+		return device, partition, err
+	}
+	//err = createbootDirs(baseName, bootDir)
+	//if err != nil {
+	//	log.Errorf("createbootDirs %s", err)
+	//	return bootDir, err
+	//}
+	return device, partition, nil
+}
+
+func NOPEcreatebootDir(baseName, bootDir string) error {
+	log.Debugf("createbootDirs")
+
+	if err := os.MkdirAll(filepath.Join(baseName, bootDir+"grub"), 0755); err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Join(baseName, bootDir+"syslinux"), 0755); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setBootable(device, diskType string) error {
+	// TODO make conditional - if there is a bootable device already, don't break it
+	// TODO: make RANCHER_BOOT bootable - it might not be device 1
+
+	bootflag := "boot"
+	if diskType == "gpt" {
+		bootflag = "legacy_boot"
+	}
+	log.Debugf("making device 1 on %s bootable as %s", device, diskType)
+	cmd := exec.Command("parted", "-s", "-a", "optimal", device, "set 1 "+bootflag+" on")
+	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	if err := cmd.Run(); err != nil {
+		log.Errorf("parted: %s", err)
+		return err
+	}
+	return nil
+}
+
+func upgradeBootloader(device, baseName, bootDir, diskType string) error {
+	log.Debugf("start upgradeBootloader")
+
+	grubDir := filepath.Join(baseName, bootDir+"grub")
+	if _, err := os.Stat(grubDir); os.IsNotExist(err) {
+		log.Debugf("%s does not exist - no need to upgrade bootloader", grubDir)
+		// we've already upgraded
+		// TODO: in v0.9.0, need to detect what version syslinux we have
+		return nil
+	}
+	if err := setBootable(device, diskType); err != nil {
+		log.Debugf("setBootable(%s, %s): %s", device, diskType, err)
+		//return err
+	}
+	if err := os.Rename(grubDir, filepath.Join(baseName, bootDir+"grub_backup")); err != nil {
+		log.Debugf("Rename(%s): %s", grubDir, err)
+		return err
+	}
+
+	syslinuxDir := filepath.Join(baseName, bootDir+"syslinux")
+	backupSyslinuxDir := filepath.Join(baseName, bootDir+"syslinux_backup")
+	if err := os.Rename(syslinuxDir, backupSyslinuxDir); err != nil {
+		log.Debugf("Rename(%s, %s): %s", syslinuxDir, backupSyslinuxDir, err)
+		return err
+	}
+	//mv the old syslinux into linux-previous.cfg
+	oldSyslinux, err := ioutil.ReadFile(filepath.Join(backupSyslinuxDir, "syslinux.cfg"))
+	if err != nil {
+		log.Debugf("read(%s / syslinux.cfg): %s", backupSyslinuxDir, err)
+
+		return err
+	}
+	cfg := string(oldSyslinux)
+	//DEFAULT RancherOS-current
+	//
+	//LABEL RancherOS-current
+	//    LINUX ../vmlinuz-v0.7.1-rancheros
+	//    APPEND rancher.state.dev=LABEL=RANCHER_STATE rancher.state.wait console=tty0 rancher.password=rancher
+	//    INITRD ../initrd-v0.7.1-rancheros
+	cfg = strings.Replace(cfg, "current", "previous", -1)
+	cfg = strings.Replace(cfg, "../", "/boot/", -1)
+	// TODO consider removing the APPEND line - as the global.cfg should have the same result
+	ioutil.WriteFile(filepath.Join(baseName, bootDir, "linux-current.cfg"), []byte(cfg), 0644)
+
+	return installSyslinux(device, baseName, bootDir, diskType)
+}
+
+func installSyslinux(device, baseName, bootDir, diskType string) error {
+	log.Debugf("installSyslinux")
+
+	mbrFile := "mbr.bin"
+	if diskType == "gpt" {
+		mbrFile = "gptmbr.bin"
 	}
 
+	//dd bs=440 count=1 if=/usr/lib/syslinux/mbr/mbr.bin of=${device}
+	// ubuntu: /usr/lib/syslinux/mbr/mbr.bin
+	// alpine: /usr/share/syslinux/mbr.bin
+	cmd := exec.Command("dd", "bs=440", "count=1", "if=/usr/share/syslinux/"+mbrFile, "of="+device)
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	log.Debugf("Run(%v)", cmd)
+	if err := cmd.Run(); err != nil {
+		log.Errorf("dd: %s", err)
+		return err
+	}
+	if err := os.MkdirAll(filepath.Join(baseName, bootDir+"syslinux"), 0755); err != nil {
+		return err
+	}
+
+	//cp /usr/lib/syslinux/modules/bios/* ${baseName}/${bootDir}syslinux
+	files, _ := ioutil.ReadDir("/usr/share/syslinux/")
+	for _, file := range files {
+		if file.IsDir() {
+			continue
+		}
+		if err := dfs.CopyFile(filepath.Join("/usr/share/syslinux/", file.Name()), filepath.Join(baseName, bootDir, "syslinux"), file.Name()); err != nil {
+			log.Errorf("copy syslinux: %s", err)
+			return err
+		}
+	}
+
+	//extlinux --install ${baseName}/${bootDir}syslinux
+	cmd = exec.Command("extlinux", "--install", filepath.Join(baseName, bootDir+"syslinux"))
+	//cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	log.Debugf("Run(%v)", cmd)
+	if err := cmd.Run(); err != nil {
+		log.Errorf("extlinuux: %s", err)
+		return err
+	}
+	return nil
+}
+
+func installSyslinuxRaid(baseName, bootDir, diskType string) error {
+	log.Debugf("installSyslinuxRaid")
+
+	mbrFile := "mbr.bin"
+	if diskType == "gpt" {
+		mbrFile = "gptmbr.bin"
+	}
+
+	//dd bs=440 count=1 if=/usr/lib/syslinux/mbr/mbr.bin of=/dev/sda
+	//dd bs=440 count=1 if=/usr/lib/syslinux/mbr/mbr.bin of=/dev/sdb
+	//cp /usr/lib/syslinux/modules/bios/* ${baseName}/${bootDir}syslinux
+	//extlinux --install --raid ${baseName}/${bootDir}syslinux
+	cmd := exec.Command("dd", "bs=440", "count=1", "if=/usr/share/syslinux/"+mbrFile, "of=/dev/sda")
+	if err := cmd.Run(); err != nil {
+		log.Errorf("%s", err)
+		return err
+	}
+	cmd = exec.Command("dd", "bs=440", "count=1", "if=/usr/share/syslinux/"+mbrFile, "of=/dev/sdb")
+	if err := cmd.Run(); err != nil {
+		log.Errorf("%s", err)
+		return err
+	}
+	if err := os.MkdirAll(filepath.Join(baseName, bootDir+"syslinux"), 0755); err != nil {
+		return err
+	}
+	//cp /usr/lib/syslinux/modules/bios/* ${baseName}/${bootDir}syslinux
+	files, _ := ioutil.ReadDir("/usr/share/syslinux/")
+	for _, file := range files {
+		if file.IsDir() {
+			continue
+		}
+		if err := dfs.CopyFile(filepath.Join("/usr/share/syslinux/", file.Name()), filepath.Join(baseName, bootDir, "syslinux"), file.Name()); err != nil {
+			log.Errorf("copy syslinux: %s", err)
+			return err
+		}
+	}
+	cmd = exec.Command("extlinux", "--install", "--raid", filepath.Join(baseName, bootDir+"syslinux"))
+	if err := cmd.Run(); err != nil {
+		log.Errorf("%s", err)
+		return err
+	}
+	return nil
+}
+
+func installRancher(baseName, bootDir, VERSION, DIST, kappend string) error {
+	log.Debugf("installRancher")
+
+	// detect if there already is a linux-current.cfg, if so, move it to linux-previous.cfg,
+	currentCfg := filepath.Join(baseName, bootDir, "linux-current.cfg")
+	if _, err := os.Stat(currentCfg); !os.IsNotExist(err) {
+		previousCfg := filepath.Join(baseName, bootDir, "linux-previous.cfg")
+		if _, err := os.Stat(previousCfg); !os.IsNotExist(err) {
+			if err := os.Remove(previousCfg); err != nil {
+				return err
+			}
+		}
+		os.Rename(currentCfg, previousCfg)
+	}
+
+	// The image/ISO have all the files in it - the syslinux cfg's and the kernel&initrd, so we can copy them all from there
+	files, _ := ioutil.ReadDir(DIST)
+	for _, file := range files {
+		if file.IsDir() {
+			continue
+		}
+		if err := dfs.CopyFile(filepath.Join(DIST, file.Name()), filepath.Join(baseName, bootDir), file.Name()); err != nil {
+			log.Errorf("copy %s: %s", file.Name(), err)
+			return err
+		}
+	}
+	// the general INCLUDE syslinuxcfg
+	if err := dfs.CopyFile(filepath.Join(DIST, "isolinux", "isolinux.cfg"), filepath.Join(baseName, bootDir, "syslinux"), "syslinux.cfg"); err != nil {
+		log.Errorf("copy %s: %s", "syslinux.cfg", err)
+		return err
+	}
+
+	// The global.cfg INCLUDE - useful for over-riding the APPEND line
+	err := ioutil.WriteFile(filepath.Join(filepath.Join(baseName, bootDir), "global.cfg"), []byte("APPEND "+kappend), 0644)
+	if err != nil {
+		log.Errorf("write (%s) %s", "global.cfg", err)
+		return err
+	}
 	return nil
 }
diff --git a/cmd/control/install/grub.go b/cmd/control/install/grub.go
new file mode 100644
index 000000000..79ffbc582
--- /dev/null
+++ b/cmd/control/install/grub.go
@@ -0,0 +1,102 @@
+package install
+
+import (
+	"html/template"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/rancher/os/log"
+)
+
+func RunGrub(baseName, device string) error {
+	log.Debugf("installGrub")
+
+	//grub-install --boot-directory=${baseName}/boot ${device}
+	cmd := exec.Command("grub-install", "--boot-directory="+baseName+"/boot", device)
+	if err := cmd.Run(); err != nil {
+		log.Errorf("%s", err)
+		return err
+	}
+	return nil
+}
+
+func grubConfig(menu BootVars) error {
+	log.Debugf("grubConfig")
+
+	filetmpl, err := template.New("grub2config").Parse(`{{define "grub2menu"}}menuentry "{{.Name}}" {
+  set root=(hd0,msdos1)
+  linux /{{.bootDir}}vmlinuz-{{.Version}}-rancheros {{.KernelArgs}} {{.Append}}
+  initrd /{{.bootDir}}initrd-{{.Version}}-rancheros
+}
+
+{{end}}
+set default="0"
+set timeout="{{.Timeout}}"
+{{if .Fallback}}set fallback={{.Fallback}}{{end}}
+
+{{- range .Entries}}
+{{template "grub2menu" .}}
+{{- end}}
+
+`)
+	if err != nil {
+		log.Errorf("grub2config %s", err)
+		return err
+	}
+
+	cfgFile := filepath.Join(menu.BaseName, menu.BootDir+"grub/grub.cfg")
+	log.Debugf("grubConfig written to %s", cfgFile)
+
+	f, err := os.Create(cfgFile)
+	if err != nil {
+		return err
+	}
+	err = filetmpl.Execute(f, menu)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func PvGrubConfig(menu BootVars) error {
+	log.Debugf("pvGrubConfig")
+
+	filetmpl, err := template.New("grublst").Parse(`{{define "grubmenu"}}
+title RancherOS {{.Version}}-({{.Name}})
+root (hd0)
+kernel /${bootDir}vmlinuz-{{.Version}}-rancheros {{.KernelArgs}} {{.Append}}
+initrd /${bootDir}initrd-{{.Version}}-rancheros
+
+{{end}}
+default 0
+timeout {{.Timeout}}
+{{if .Fallback}}fallback {{.Fallback}}{{end}}
+hiddenmenu
+
+{{- range .Entries}}
+{{template "grubmenu" .}}
+{{- end}}
+
+`)
+	if err != nil {
+		log.Errorf("pv grublst: %s", err)
+
+		return err
+	}
+
+	cfgFile := filepath.Join(menu.BaseName, menu.BootDir+"grub/menu.lst")
+	log.Debugf("grubMenu written to %s", cfgFile)
+	f, err := os.Create(cfgFile)
+	if err != nil {
+		log.Errorf("Create(%s) %s", cfgFile, err)
+
+		return err
+	}
+	err = filetmpl.Execute(f, menu)
+	if err != nil {
+		log.Errorf("execute %s", err)
+		return err
+	}
+	return nil
+}
diff --git a/cmd/control/install/install.go b/cmd/control/install/install.go
new file mode 100644
index 000000000..0cb50e29d
--- /dev/null
+++ b/cmd/control/install/install.go
@@ -0,0 +1,11 @@
+package install
+
+type MenuEntry struct {
+	Name, BootDir, Version, KernelArgs, Append string
+}
+type BootVars struct {
+	BaseName, BootDir string
+	Timeout           uint
+	Fallback          int
+	Entries           []MenuEntry
+}
diff --git a/cmd/control/install/syslinux.go b/cmd/control/install/syslinux.go
new file mode 100644
index 000000000..9895a7021
--- /dev/null
+++ b/cmd/control/install/syslinux.go
@@ -0,0 +1,45 @@
+package install
+
+import (
+	"html/template"
+	"os"
+	"path/filepath"
+
+	"github.com/rancher/os/log"
+)
+
+func syslinuxConfig(menu BootVars) error {
+	log.Debugf("syslinuxConfig")
+
+	filetmpl, err := template.New("syslinuxconfig").Parse(`{{define "syslinuxmenu"}}
+LABEL {{.Name}}
+    LINUX ../vmlinuz-{{.Version}}-rancheros
+    APPEND {{.KernelArgs}} {{.Append}}
+    INITRD ../initrd-{{.Version}}-rancheros
+{{end}}
+TIMEOUT 20   #2 seconds
+DEFAULT RancherOS-current
+
+{{- range .Entries}}
+{{template "syslinuxmenu" .}}
+{{- end}}
+
+`)
+	if err != nil {
+		log.Errorf("syslinuxconfig %s", err)
+		return err
+	}
+
+	cfgFile := filepath.Join(menu.BaseName, menu.BootDir+"syslinux/syslinux.cfg")
+	log.Debugf("syslinuxConfig written to %s", cfgFile)
+	f, err := os.Create(cfgFile)
+	if err != nil {
+		log.Errorf("Create(%s) %s", cfgFile, err)
+		return err
+	}
+	err = filetmpl.Execute(f, menu)
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/config/config_test.go b/config/config_test.go
index 227396642..2d03f6939 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -148,15 +148,15 @@ func TestParseCmdline(t *testing.T) {
 
 	assert.Equal(map[interface{}]interface{}{
 		"rancher": map[interface{}]interface{}{
-			"strArray": []interface{}{"url:http://192.168.1.100/cloud-config"},
+			"strArray": []interface{}{"url:http://192.168.1.100/cloud-config?a=b"},
 		},
-	}, parseCmdline("rancher.strArray=[\"url:http://192.168.1.100/cloud-config\"]"))
+	}, parseCmdline("rancher.strArray=[\"url:http://192.168.1.100/cloud-config?a=b\"]"))
 
 	assert.Equal(map[interface{}]interface{}{
 		"rancher": map[interface{}]interface{}{
-			"strArray": []interface{}{"url:http://192.168.1.100/cloud-config"},
+			"strArray": []interface{}{"url:http://192.168.1.100/cloud-config?a=b"},
 		},
-	}, parseCmdline("rancher.strArray=[url:http://192.168.1.100/cloud-config]"))
+	}, parseCmdline("rancher.strArray=[url:http://192.168.1.100/cloud-config?a=b]"))
 }
 
 func TestGet(t *testing.T) {
diff --git a/config/data_funcs.go b/config/data_funcs.go
index b036858fb..5ace560ba 100644
--- a/config/data_funcs.go
+++ b/config/data_funcs.go
@@ -116,11 +116,12 @@ func getOrSetVal(args string, data map[interface{}]interface{}, value interface{
 	return "", tData
 }
 
-// Replace newlines and colons with random strings
+// Replace newlines, colons, and question marks with random strings
 // This is done to avoid YAML treating these as special characters
 var (
-	newlineMagicString = "9XsJcx6dR5EERYCC"
-	colonMagicString   = "V0Rc21pIVknMm2rr"
+	newlineMagicString      = "9XsJcx6dR5EERYCC"
+	colonMagicString        = "V0Rc21pIVknMm2rr"
+	questionMarkMagicString = "FoPL6JLMAaJqKMJT"
 )
 
 func reverseReplacement(result interface{}) interface{} {
@@ -138,6 +139,7 @@ func reverseReplacement(result interface{}) interface{} {
 	case string:
 		val = strings.Replace(val, newlineMagicString, "\n", -1)
 		val = strings.Replace(val, colonMagicString, ":", -1)
+		val = strings.Replace(val, questionMarkMagicString, "?", -1)
 		return val
 	}
 
@@ -147,6 +149,7 @@ func reverseReplacement(result interface{}) interface{} {
 func unmarshalOrReturnString(value string) (result interface{}) {
 	value = strings.Replace(value, "\n", newlineMagicString, -1)
 	value = strings.Replace(value, ":", colonMagicString, -1)
+	value = strings.Replace(value, "?", questionMarkMagicString, -1)
 	if err := yaml.Unmarshal([]byte(value), &result); err != nil {
 		result = value
 	}
diff --git a/init/bootstrap.go b/init/bootstrap.go
index d5142e797..1c5a0e4a9 100644
--- a/init/bootstrap.go
+++ b/init/bootstrap.go
@@ -11,7 +11,7 @@ import (
 )
 
 func bootstrapServices(cfg *config.CloudConfig) (*config.CloudConfig, error) {
-	if (len(cfg.Rancher.State.Autoformat) == 0 || util.ResolveDevice(cfg.Rancher.State.Dev) != "") && len(cfg.Bootcmd) == 0 {
+	if util.ResolveDevice(cfg.Rancher.State.Dev) != "" && len(cfg.Bootcmd) == 0 {
 		return cfg, nil
 	}
 	log.Info("Running Bootstrap")
diff --git a/log/log.go b/log/log.go
index 04c0a2d06..aea5108e6 100644
--- a/log/log.go
+++ b/log/log.go
@@ -109,29 +109,30 @@ func InitLogger() {
 	}
 	thisLog := logrus.New()
 
-	filename := "/dev/kmsg"
-	f, err := os.OpenFile(filename, os.O_WRONLY, 0644)
-	if err != nil {
-		logrus.Debugf("error opening /dev/kmsg %s", err)
-	}
-
 	// Filter what the user sees (info level, unless they set --debug)
 	stdLogger := logrus.StandardLogger()
 	showuserHook, err := NewShowuserlogHook(stdLogger.Level)
 	if err != nil {
-		f.Close()
 		logrus.Errorf("hook failure %s", err)
+		return
 	}
 
-	// We're all set up, now we can make it global
-	appLog = thisLog
-	userHook = showuserHook
+	filename := "/dev/kmsg"
+	f, err := os.OpenFile(filename, os.O_WRONLY, 0644)
+	if err != nil {
+		logrus.Debugf("error opening %s: %s", filename, err)
+	} else {
+		// We're all set up, now we can make it global
+		appLog = thisLog
+		userHook = showuserHook
 
-	thisLog.Hooks.Add(showuserHook)
-	logrus.StandardLogger().Hooks.Add(showuserHook)
-	thisLog.Out = f
-	logrus.SetOutput(f)
-	thisLog.Level = logrus.DebugLevel
+		thisLog.Hooks.Add(showuserHook)
+		logrus.StandardLogger().Hooks.Add(showuserHook)
+
+		thisLog.Out = f
+		logrus.SetOutput(f)
+		thisLog.Level = logrus.DebugLevel
+	}
 
 	pwd, err := os.Getwd()
 	if err != nil {
diff --git a/scripts/create-installed b/scripts/create-installed
index 9390c47b3..cff9dc706 100755
--- a/scripts/create-installed
+++ b/scripts/create-installed
@@ -1,12 +1,10 @@
 #!/bin/bash
-set -e
+set -ex
 
 cd $(dirname $0)/..
 
 source ./scripts/run-common
 
-INSTALLER=${BASE}/dist/artifacts/installer.tar
-
 if [ ! -e ${INITRD} ]; then
     cp bin/ros ${INITRD_SRC}/usr/bin/ros
     ./scripts/hash-initrd
@@ -25,26 +23,24 @@ trap "poweroff" EXIT
 
 sleep 5
 
-mount -t 9p -o trans=virtio,version=9p2000.L config-2 /mnt
-
 touch log
 openvt -s -- tail -f log &
-cat /mnt/installer.tar | system-docker load
-ros install -d /dev/vda -f --no-reboot >log 2>&1
+
+mount -t 9p -o trans=virtio,version=9p2000.L config-2 /mnt
+
+# use the install tarball in the iso
+ros install -d /dev/vda -f --no-reboot --append "console=ttyS0 rancher.autologin=ttyS0" >> /mnt/log 2>&1
 
 touch /mnt/success
 EOF
 
 rm -f build/{success,hd.img}
 qemu-img create -f qcow2 build/hd.img 8G
-cp ${INSTALLER} build/installer.tar
 qemu-system-${QEMUARCH} -serial stdio \
     -enable-kvm \
     -drive if=virtio,file=build/hd.img \
-    -kernel ${KERNEL} \
-    -initrd ${INITRD} \
+    -boot d -cdrom ./dist/artifacts/rancheros.iso \
     -m 2048 \
-    -append "${DEFAULT_KERNEL_ARGS}" \
     -smp 1 \
     -nographic \
     -display none \
@@ -55,3 +51,4 @@ qemu-system-${QEMUARCH} -serial stdio \
 
 mkdir -p state
 cp build/hd.img state/hd.img
+echo "------------------------ RancherOS installed to hd.img."
\ No newline at end of file
diff --git a/scripts/hosting/packet/packet.sh b/scripts/hosting/packet/packet.sh
index 4802e1eab..3f55900ee 100644
--- a/scripts/hosting/packet/packet.sh
+++ b/scripts/hosting/packet/packet.sh
@@ -92,6 +92,8 @@ partprobe || true
 echo -e "a\n1\nw" | fdisk ${DEV_PREFIX}a || true
 partprobe || true
 
+wait_for_dev ${DEV_PREFIX}a1 ${DEV_PREFIX}a5 ${DEV_PREFIX}a6 ${DEV_PREFIX}a7
+
 if [ "$RAID" = "true" ]; then
     sfdisk --dump ${DEV_PREFIX}a | sfdisk --no-reread ${DEV_PREFIX}b
 
diff --git a/scripts/hosting/packet/test.expect b/scripts/hosting/packet/test.expect
new file mode 100755
index 000000000..04beb9607
--- /dev/null
+++ b/scripts/hosting/packet/test.expect
@@ -0,0 +1,64 @@
+#!/usr/bin/expect -f
+
+# set Variables
+# /home/sven/.docker/machine/machines/sven-test/id_rsa
+set sshkey [lrange $argv 0 0]
+# 718feb0e-1517-4f92-a6fa-2ee089cf12e4@sos.ewr1.packet.net
+set sshurl [lrange $argv 1 1] 
+
+set username [lrange $argv 2 2] 
+set password [lrange $argv 3 3]
+set command ""
+append command [lrange $argv 4 end]
+
+
+set timeout -1
+
+proc runcmd { username password cmd } {
+	send_user "<< username: $username"
+	send_user "<< password: $password"
+	send_user "<< cmd: $cmd"
+
+	set done 0;
+	while {$done == 0} {
+		expect  {
+			"*?login:" {
+				send -- "$username\r"
+			}
+			"*?assword:" {
+				send -- "$password\r"
+				#send -- "\r"
+			}
+			"*?:~#" {
+				send -- "$cmd\r"
+				set done 1
+			}
+			"*?Reached target Shutdown." {
+				set done 1
+			}
+		}
+	}
+}
+
+
+spawn ssh -F /dev/null -o PasswordAuthentication=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=quiet -o ConnectionAttempts=3 -o ConnectTimeout=10 -o ControlMaster=no -o ControlPath=none -i $sshkey $sshurl
+match_max 100000
+send -- "\r"
+
+set running [ runcmd $username $password $command ]
+
+expect {
+	"*? (yes/no)?" {
+		send -- "no\r"
+		expect "# "
+	}
+	"# " {
+	}
+	"*?Restarting system" {
+	}
+	"*?kexec_core: Starting new kernel" {
+	}
+}
+
+send_user "<< DONE expect"
+send_user "<<"
diff --git a/scripts/hosting/packet/test.sh b/scripts/hosting/packet/test.sh
new file mode 100755
index 000000000..50713cfe6
--- /dev/null
+++ b/scripts/hosting/packet/test.sh
@@ -0,0 +1,130 @@
+#!/bin/bash
+
+set -ex
+
+# https://www.packet.net/help/kb/how-to-provision-a-host-with-docker-machine/
+
+# needs both docker-machine and the docker-machine packet.net driver
+# https://github.com/packethost/docker-machine-driver-packet/releases
+
+if [ "${PACKET_API_KEY}" == "" ]; then
+	echo "need to set the PACKET_API_KEY"
+	exit
+fi
+if [ "${PACKET_PROJECT_ID}" == "" ]; then
+	echo "need to set the PACKET_PROJECT_ID"
+	exit
+fi
+
+# facilities
+#   New York Metro (EWR1) </span>
+#   Silicon Valley (SJC1) </span>
+#   Amsterdam, NL (AMS1) </span>
+#   Tokyo, JP (NRT1) </span>
+FACILITY=sjc1
+
+# plan - the server types
+PLAN=baremetal_0
+
+# randomizing the hostname makes debugging things harder atm
+#HOSTHASH=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 6 | head -n 1)
+HOST=sven-${FACILITY}-${PLAN/_/-}
+
+if ! docker-machine inspect $HOST ; then
+	docker-machine create -d packet \
+		--packet-api-key=${PACKET_API_KEY} --packet-project-id=${PACKET_PROJECT_ID} \
+		--packet-facility-code ${FACILITY} \
+		--packet-plan ${PLAN} \
+		--packet-os=ubuntu_16_04 \
+		${HOST}
+fi
+
+SSH="docker-machine ssh $HOST"
+SCP="docker-machine scp"
+
+echo "- setup.."
+
+#Spin up an Ubuntu 16.04 Packet instance. There are two different categories: Type-0 and the other types. We'll need to test one from each category.
+#SSH into the instance and change the root password.
+
+USER="root"
+PASS=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)
+
+echo "echo '$USER:$PASS' | chpasswd"
+echo "echo '$USER:$PASS' | chpasswd" > /tmp/pass
+chmod 755 /tmp/pass
+$SCP /tmp/pass $HOST:~/pass
+$SSH ./pass
+
+#$SSH echo "root:$HOST" | chpasswd
+
+#Download the initrd and vmlinuz for the RC.
+$SCP ./scripts/hosting/packet/packet.sh $HOST:~/
+
+#$SCP ./dist/artifacts/initrd $HOST:~/
+#$SCP ./dist/artifacts/vmlinuz-4.9-rancher2 $HOST:~/vmlinuz
+
+$SSH wget -c https://github.com/rancher/os/releases/download/v0.7.1/vmlinuz
+$SSH wget -c https://github.com/rancher/os/releases/download/v0.7.1/initrd
+
+#Install the kexec-tools package.
+
+$SSH sudo apt-get update 
+
+#SSH into the SOS shell for the instance. There's a button labelled "Console" on the page for the instance. If you click on that it'll give you an SSH command to paste into your terminal.
+
+FACILITY=$(docker-machine inspect ${HOST} | grep Facility | sed 's/.*Facility": "\(.*\)".*/\1/')
+DEVICEID=$(docker-machine inspect ${HOST} | grep DeviceID | sed 's/.*DeviceID": "\(.*\)".*/\1/')
+SSHKEYPATH=$(docker-machine inspect ${HOST} | grep SSHKeyPath | sed 's/.*SSHKeyPath": "\(.*\)".*/\1/')
+
+SSHSOS="./scripts/hosting/packet/test.expect $SSHKEYPATH $DEVICEID@sos.$FACILITY.packet.net $USER $PASS"
+
+echo "--------------------------------------------------------------------------"
+$SSHSOS uname -a 
+
+#$SSH DEBIAN_FRONTEND=noninteractive sudo apt-get -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" install -yqq kexec-tools
+#USING the SOSSSH expect script to get past the "Should kexec-tools handle reboots? [yes/no]"
+$SSHSOS sudo DEBIAN_FRONTEND=noninteractive apt-get install -yqq kexec-tools
+
+
+$SSHSOS reboot
+
+echo "- kexecing"
+
+$SSHSOS sudo kexec -f -l vmlinuz --initrd=initrd --append "rancher.password=${PASS} tinkerbell=http://bdba494d.ngrok.io console=ttyS1,115200n8 rancher.network.interfaces.eth0.dhcp=true rancher.network.interfaces.eth2.dhcp=true"
+
+#The server will restart and then you should be running RancherOS from memory.
+$SSHSOS reboot
+
+## need to change the user for the exepct script
+USER="rancher"
+SSHSOS="./scripts/hosting/packet/test.expect $SSHKEYPATH $DEVICEID@sos.$FACILITY.packet.net $USER $PASS"
+
+echo "--------------------------------------------------------------------------"
+$SSHSOS uname -a 
+
+# need to retrieve the packet.sh, vmlinuz and initrd from the disk
+# TODO: this makes sense on type-0 - dunno about raid
+# TODO: don't use dev, use LABEL - if&when we switch to running this on RancherOS
+$SSHSOS sudo mount /dev/sda3 /mnt
+$SSHSOS cp /mnt/root/* .
+exit
+
+#Clear the disk(s).
+
+$SSHSOS sudo dd if=/dev/zero of=/dev/sda count=4 bs=1024
+
+#If you're not running a type-0, also run the following command: 
+if [ "$PLAN" != "baremetal_0" ]; then
+	$SSHSOS sudo dd if=/dev/zero of=/dev/sdb count=4 bs=1024
+fi
+
+#Both of these will hang after you run them. Just let them run for a second or two and then hit ctrl+c.
+#Download and run the Packet install script.
+
+$SSHSOS bash ./packet.sh
+
+#Reboot and then RancherOS should be fully installed.
+#$SSHSOS reboot
+
+#$SSH uname -a 
diff --git a/scripts/installer/BaseDockerfile.amd64 b/scripts/installer/BaseDockerfile.amd64
new file mode 100644
index 000000000..2bfd7198b
--- /dev/null
+++ b/scripts/installer/BaseDockerfile.amd64
@@ -0,0 +1,23 @@
+FROM alpine
+# TODO: redo as cross platform, and without git etc :)
+
+ARG VERSION
+ARG KERNEL_VERSION
+ENV VERSION=${VERSION}
+ENV KERNEL_VERSION=${KERNEL_VERSION}
+
+# not installed atm udev, grub2, kexe-tools
+# parted: partprobe, e2fsprogs: mkfs.ext4, syslinux: extlinux&syslinux
+RUN apk --no-cache add syslinux parted e2fsprogs util-linux
+
+COPY conf /scripts/
+COPY ./build/ros /bin/
+#RUN cd /bin && ln -s ./ros ./system-docker
+#OR softlink in the host one - this image should only be used when installing from ISO..
+# (except its useful for testing)
+# && ln -s /host/usr/bin/ros /bin/
+
+RUN ln -s /bootiso/boot/ /dist
+
+ENTRYPOINT ["/bin/ros", "install"]
+
diff --git a/scripts/installer/Dockerfile.amd64 b/scripts/installer/Dockerfile.amd64
old mode 100644
new mode 100755
index 2e74add16..ddd1fbfaa
--- a/scripts/installer/Dockerfile.amd64
+++ b/scripts/installer/Dockerfile.amd64
@@ -1,13 +1,9 @@
-FROM ubuntu:16.04
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && \
-    apt-get install --no-install-recommends -y udev grub2 parted kexec-tools extlinux syslinux-common && \
-    rm -rf /var/lib/apt/*
+FROM rancher/os-installer
 
-COPY ./build/vmlinuz ./build/initrd /dist/
-COPY conf lay-down-os seed-data set-disk-partitions /scripts/
+# TODO: separate out the elements below - so we can mix and match updates
+RUN rm /dist/ \
+    && mkdir -p /dist/
 
-ARG VERSION
-ENV VERSION=${VERSION}
+#COPY ./ros /bin/
+COPY ./boot/ /dist/
 
-ENTRYPOINT ["/scripts/lay-down-os"]
diff --git a/scripts/installer/lay-down-os b/scripts/installer/lay-down-os
index b3cfc69a1..40ef566cc 100755
--- a/scripts/installer/lay-down-os
+++ b/scripts/installer/lay-down-os
@@ -10,17 +10,21 @@ MBR_FILE=mbr.bin
 while getopts "i:f:c:d:t:r:o:p:ka:g" OPTION
 do
     case ${OPTION} in
-        i) DIST="$OPTARG" ;;
-        f) FILES="$OPTARG" ;;
-        c) CLOUD_CONFIG="$OPTARG" ;;
+        # used by `ros install`
         d) DEVICE="$OPTARG" ;;
-        o) OEM="$OPTARG" ;;
-        p) PARTITION="$OPTARG" ;;
-        r) ROLLBACK_VERSION="$OPTARG" ;;
-        k) KEXEC=y ;;
+        t) ENV="$OPTARG" ;;     # install type
+        c) CLOUD_CONFIG="$OPTARG" ;;
         a) APPEND="$OPTARG" ;;
-        t) ENV="$OPTARG" ;;
         g) MBR_FILE=gptmbr.bin ;;
+	# upgrade!
+        r) ROLLBACK_VERSION="$OPTARG" ;;
+        k) KEXEC=y ;;
+        # used for testing?
+        p) PARTITION="$OPTARG" ;;
+        # notused?
+        i) DIST="$OPTARG" ;;
+        f) FILES="$OPTARG" ;;
+        o) OEM="$OPTARG" ;;
         *) exit 1 ;;
     esac
 done
diff --git a/scripts/isolinux.cfg b/scripts/isolinux.cfg
index a20d57ff4..20e683ed3 100644
--- a/scripts/isolinux.cfg
+++ b/scripts/isolinux.cfg
@@ -1,5 +1,9 @@
-default rancheros
-label rancheros
-    kernel /boot/vmlinuz
-    initrd /boot/initrd
-    append quiet rancher.autologin=tty1 rancher.autologin=ttyS0
+TIMEOUT 20  #2s
+#PROMPT 1
+
+# doesn't appear to work here?
+INCLUDE ../global.cfg
+
+# each INCLUDEd file has a `DEFAULT mylabel` in it, and the last one wins
+INCLUDE ../linux-previous.cfg
+INCLUDE ../linux-current.cfg
diff --git a/scripts/isolinux_label.cfg b/scripts/isolinux_label.cfg
new file mode 100644
index 000000000..00d56b986
--- /dev/null
+++ b/scripts/isolinux_label.cfg
@@ -0,0 +1,11 @@
+
+# TODO: should add ros-version to label and initrd
+DEFAULT rancheros-${LABEL}
+LABEL rancheros-${LABEL}
+    SAY rancheros-${LABEL}: RancherOS ${VERSION} ${KERNEL_VERSION}
+    KERNEL /boot/vmlinuz-${KERNEL_VERSION}
+    INITRD /boot/initrd
+    #TODO - once we work out how to append it for qemu-dev,/boot/linuxmods-${KERNEL_VERSION}
+    #APPEND quiet rancher.autologin=tty1 rancher.autologin=ttyS0 ${APPEND}
+    #INCLUDE global.cfg
+
diff --git a/scripts/layout b/scripts/layout
index 9c058f863..451d382eb 100755
--- a/scripts/layout
+++ b/scripts/layout
@@ -4,6 +4,7 @@ set -e
 source $(dirname $0)/version
 cd $(dirname $0)/..
 
+ARTIFACTS=$(pwd)/dist/artifacts
 BUILD=build
 INITRD_DIR=${BUILD}/initrd
 
@@ -43,17 +44,51 @@ if [ -e ${DOWNLOADS}/kernel.tar.gz ]; then
 
     for i in vmlinuz vmlinux; do
         if [ -e ${BUILD}/kernel/boot/${i}-* ]; then
-            mkdir -p dist/artifacts
-            cp ${BUILD}/kernel/boot/${i}-* dist/artifacts/vmlinuz
+            mkdir -p ${ARTIFACTS}
+            # frustratingly, the vmlinuz versioned filename != the tag name, so we need to do some guessing
+            # for eg, 4.9-rc8-rancher2 is called vmlinuz-4.9.0-rc8-rancher
+            echo "Copy ${BUILD}/kernel/boot/${i}-* to ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION}"
+            cp ${BUILD}/kernel/boot/${i}-* ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION}
+            # use an unversioned filename for `scripts/run`
+            cp ${BUILD}/kernel/boot/${i}-* ${BUILD}/kernel/vmlinuz
             break
         fi
     done
 
+    # TODO: move these into a separate tar.gz and add to the syslinux initrd line
     if [ -d ${BUILD}/kernel/lib ]; then
         rm -rf ${INITRD_DIR}/usr/lib
         cp -rf ${BUILD}/kernel/lib ${INITRD_DIR}/usr/
         depmod -b ${INITRD_DIR}/usr $(basename ${INITRD_DIR}/usr/lib/modules/*)
+
+        #TODO:
+        # new: put the kernel modules into their own initrd file
+        #mkdir -p ${BUILD}/kernel-fs/usr/
+        #pushd .
+        #cp -rf ${BUILD}/kernel/lib ${BUILD}/kernel-fs/usr/
+        #depmod -b ${BUILD}/kernel-fs/usr $(basename ${BUILD}/kernel-fs/usr/lib/modules/*)
+        ## and then package it up cpio
+        #cd ${BUILD}/kernel-fs/
+        #echo Creating kernel ${ARTIFACTS}/linuxmods-${KERNEL_VERSION}
+        
+        #if [ "$COMPRESS" == "" ]; then
+        #    COMPRESS="gzip -1"
+        #fi
+        #find | cpio -H newc -o | ${COMPRESS} > ${ARTIFACTS}/linuxmods-${KERNEL_VERSION}
+        #popd
+        #echo Done creating kernel ${ARTIFACTS}/linuxmods-${KERNEL_VERSION}
+        ## use an unversioned filename for `scripts/run`
+        #cp ${ARTIFACTS}/linuxmods-${KERNEL_VERSION} ${BUILD}/kernel/linuxmods
     fi
+else
+	echo "no ${DOWNLOADS}/kernel.tar.gz found"
+	exit 1
+fi
+
+ls -lah ${ARTIFACTS}/vmlinuz-*
+if [ ! -e "${ARTIFACTS}/vmlinuz-${KERNEL_VERSION}" ]; then
+	echo "Can't find ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION}"
+	exit -1
 fi
 
 if [ -e ${DOWNLOADS}/policy.29 ]; then
diff --git a/scripts/package b/scripts/package
index 22ce0c768..989491163 100755
--- a/scripts/package
+++ b/scripts/package
@@ -7,7 +7,6 @@ if [ "$ROOTFS" != "0" ]; then
     ./package-rootfs
 fi
 ./package-initrd
+./package-installer
 ./package-iso
-if [ "$INSTALLER" != "0" ]; then
-    ./package-installer
-fi
+
diff --git a/scripts/package-initrd b/scripts/package-initrd
index 7c984e342..3213e22fc 100755
--- a/scripts/package-initrd
+++ b/scripts/package-initrd
@@ -10,7 +10,7 @@ INITRD=${ARTIFACTS}/initrd
 
 mkdir -p ${ARTIFACTS}
 
-if [ ! -f ${ARTIFACTS}/vmlinuz ]; then
+if [ ! -f ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION} ]; then
     exit 0
 fi
 
diff --git a/scripts/package-installer b/scripts/package-installer
index 25a85c08d..9f9ad7856 100755
--- a/scripts/package-installer
+++ b/scripts/package-installer
@@ -5,17 +5,45 @@ cd $(dirname $0)/..
 
 source ./scripts/version
 
+BASEDOCKERFILE=./scripts/installer/BaseDockerfile.${ARCH}
 DOCKERFILE=./scripts/installer/Dockerfile.${ARCH}
 
-if [ ! -f $DOCKERFILE ] || [ ! -f dist/artifacts/vmlinuz ] || [ ! -f dist/artifacts/initrd ]; then
+if [ ! -f $DOCKERFILE ] || [ ! -f dist/artifacts/vmlinuz-${KERNEL_VERSION} ] || [ ! -f dist/artifacts/initrd ]; then
     exit 0
 fi
 
-mkdir -p ./scripts/installer/build
-cp ./dist/artifacts/{initrd,vmlinuz} ./scripts/installer/build
+# TODO maybe extract the creation of the syslinux cfg files
+mkdir -p ${DIST}/boot/isolinux/
+cat scripts/isolinux.cfg | envsubst >         ${DIST}/boot/isolinux/isolinux.cfg
+cat scripts/isolinux_label.cfg | LABEL=${VERSION} envsubst >   ${DIST}/boot/linux-current.cfg
+#cat scripts/isolinux_label.cfg | LABEL=debug APPEND="rancher.debug=true" envsubst >   ${DIST}/boot/linux-previous.cfg
+cat scripts/global.cfg | LABEL=${VERSION} envsubst >   ${DIST}/boot/global.cfg
+
+
+mkdir -p ./scripts/installer/build/boot
+cp ./bin/ros ./scripts/installer/build
 trap "rm -rf ./scripts/installer/build" EXIT
 
-docker build -t ${OS_REPO}/os:${VERSION}${SUFFIX} --build-arg VERSION=${VERSION} -f $DOCKERFILE ./scripts/installer
-docker save -o dist/artifacts/installer.tar ${OS_REPO}/os:${VERSION}${SUFFIX}
+# installer base image - can be included in iso
+# TODO: fix the fullinstaller Dockerfile to use the ${VERSION}${SUFFIX}
+docker build \
+    -t ${OS_REPO}/os-installer \
+    --build-arg VERSION=${VERSION} \
+    --build-arg KERNEL_VERSION=${KERNEL_VERSION} \
+    -f $BASEDOCKERFILE \
+    ./scripts/installer
+docker save -o dist/artifacts/installer.tar ${OS_REPO}/os-installer
+cp $DOCKERFILE dist/artifacts/
+
+cp ./dist/artifacts/initrd ./scripts/installer/build/boot
+cp ./dist/artifacts/vmlinuz-${KERNEL_VERSION} ./scripts/installer/build/boot
+cp -r ${DIST}/boot/* ./scripts/installer/build/boot
+cp $DOCKERFILE ./scripts/installer/build/Dockerfile
+# Full installer image with initrd - used for pulling from network
+docker build \
+    -t ${OS_REPO}/os:${VERSION}${SUFFIX} \
+    ./scripts/installer/build
+
+docker save -o dist/artifacts/fullinstaller.tar ${OS_REPO}/os:${VERSION}${SUFFIX}
 echo ${OS_REPO}/os:${VERSION}${SUFFIX} >> dist/images
 echo Built ${OS_REPO}/os:${VERSION}${SUFFIX}
diff --git a/scripts/package-iso b/scripts/package-iso
index 4048eb2ac..c549eb240 100755
--- a/scripts/package-iso
+++ b/scripts/package-iso
@@ -1,5 +1,6 @@
 #!/bin/bash
 set -e
+set -x
 
 source $(dirname $0)/version
 cd $(dirname $0)/..
@@ -10,16 +11,29 @@ ISO=${ARTIFACTS}/$(echo ${DISTRIB_ID} | tr '[:upper:]' '[:lower:]').iso
 CHECKSUM=iso-checksums.txt
 
 mkdir -p ${CD}/boot/isolinux
+mkdir -p ${CD}/rancheros
 
-if [ ! -f ${ARTIFACTS}/vmlinuz ] || [ ! -f ${ARTIFACTS}/initrd ]; then
+if [ ! -f ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION} ] || [ ! -f ${ARTIFACTS}/initrd ]; then
     exit 0
 fi
 
 cp ${ARTIFACTS}/initrd                        ${CD}/boot
-cp ${ARTIFACTS}/vmlinuz                       ${CD}/boot
-cp scripts/isolinux.cfg                       ${CD}/boot/isolinux
-cp /usr/lib/ISOLINUX/isolinux.bin             ${CD}/boot/isolinux
-cp /usr/lib/syslinux/modules/bios/ldlinux.c32 ${CD}/boot/isolinux
+
+# TODO: these move to os-kernel
+pwd
+ls dist/artifacts/vmlinuz-${KERNEL_VERSION}
+cp ${ARTIFACTS}/vmlinuz-${KERNEL_VERSION}     ${CD}/boot/
+#TODO cp ${ARTIFACTS}/linuxmods-${KERNEL_VERSION}   ${CD}/boot/
+
+# cfg files creation moved to package-installer
+cp -r ${DIST}/boot/* ${CD}/boot/
+
+cp /usr/lib/ISOLINUX/isolinux.bin             ${CD}/boot/isolinux/
+cp /usr/lib/syslinux/modules/bios/ldlinux.c32 ${CD}/boot/isolinux/
+# add the installer image to the iso for non-network / dev/test
+cp ${ARTIFACTS}/installer.tar                 ${CD}/rancheros/
+cp ${ARTIFACTS}/Dockerfile.amd64              ${CD}/rancheros/
+gzip ${CD}/rancheros/installer.tar
 cd ${CD} && xorriso \
     -as mkisofs \
     -l -J -R -V "${DISTRIB_ID}" \
diff --git a/scripts/package-rootfs b/scripts/package-rootfs
index aa5325248..3671c3c3b 100755
--- a/scripts/package-rootfs
+++ b/scripts/package-rootfs
@@ -37,6 +37,7 @@ BUILD_ID=
 HERE
 
 # need to make relative links to the os-release file
+mkdir -p ${INITRD_DIR}/usr/lib
 cd ${INITRD_DIR}/usr/lib
 ln -s ../share/rancher/os-release os-release
 cd $(dirname $0)/..
diff --git a/scripts/run b/scripts/run
index a1d7c3e5a..0497c61d9 100755
--- a/scripts/run
+++ b/scripts/run
@@ -12,6 +12,13 @@ while [ "$#" -gt 0 ]; do
             BOOT_ISO=1
             QEMU=0
             QIND=0
+            REBUILD=0
+            ;;
+        --boothd)
+            BOOT_HD=1
+            QEMU=0
+            QIND=0
+            REBUILD=0
             ;;
         --append)
             shift 1
@@ -58,6 +65,10 @@ while [ "$#" -gt 0 ]; do
         --fresh)
             FRESH=1
             ;;
+        --console)
+	    # use the bios console, not serial (lets you see syslinux)
+            CONSOLEDISPLAY=1
+            ;;
         --installed)
             ./scripts/create-installed
             INSTALLED=1
@@ -99,30 +110,36 @@ fi
 if [ "$KVM" == "" ] && [ -c /dev/kvm ] && [ -r /dev/kvm ] && [ -w /dev/kvm ]; then
     KVM=1
 fi
-
-if [ "$QEMU" == "1" ] || [ "$BOOT_ISO" == "1" ]; then
+set -x
+if [ "$QEMU" == "1" ] || [ "$BOOT_ISO" == "1" ] || [ "$BOOT_HD" == "1" ]; then
     HD=${BASE}/state/hd.img
     HD2=${BASE}/state/hd2.img
     [ "$FRESH" == "1" ] && rm -f ${HD} ${HD2} >/dev/null 2>&1 || :
 
     if [ ! -e ${HD} ]; then
         mkdir -p $(dirname ${HD})
-        qemu-img create -f qcow2 -o size=10G ${HD}
+        if [ ¨$INSTALLED¨ == ¨1¨ ]; then
+            ./scripts/create-installed
+        else
+        	qemu-img create -f qcow2 -o size=10G ${HD}
+        fi
     fi
 
     if [ "$SECOND_DRIVE" == "1" ]; then
-        qemu-img create -f qcow2 -o size=10G ${HD2}
+        if [ "$FRESH" == "1" ]; then
+            qemu-img create -f qcow2 -o size=10G ${HD2}
+        fi
         SECOND_DRIVE_ENABLE=$(eval "${hd["$ARCH"]} ${HD2}")
     fi
+fi
+
+if [ "$QIND" != "1" ]; then
     CPU=${cpu["$ARCH"]}
     if [ "$KVM" == "1" ] && [ "$ARCH" == "$HOST_ARCH" ]; then
         KVM_ENABLE="-enable-kvm"
         CPU="-cpu host"
     fi
-fi
 
-
-if [ "$QEMU" == "1" ]; then
     CCROOT=${BUILD}/cloud-config
     rm -rf ${CCROOT}
     mkdir -p ${CCROOT}
@@ -139,6 +156,17 @@ if [ "$QEMU" == "1" ]; then
     fi
 
     HOME=${HOME:-/}
+fi
+
+if [ "$CONSOLEDISPLAY" == "1" ]; then
+    DISPLAY_OPTS="-curses"
+else
+    # default
+    DISPLAY_OPTS="-nographic -serial stdio -display none"
+fi
+
+if [ "$QEMU" == "1" ]; then
+
     if [ "$INSTALLED" == "1" ]; then
         # kernel args only works when using -kernel
         KERNEL_ARGS=""
@@ -147,7 +175,7 @@ if [ "$QEMU" == "1" ]; then
     fi
     set -x
     exec qemu-system-${QEMUARCH} \
-            -serial stdio \
+            ${DISPLAY_OPTS} \
             -rtc base=utc,clock=host \
             ${INSTALLED_ARGS} \
             -append "${KERNEL_ARGS}" \
@@ -159,8 +187,6 @@ if [ "$QEMU" == "1" ]; then
             $(eval "${hd["$ARCH"]} ${HD}") \
             ${SECOND_DRIVE_ENABLE} \
             -smp 1 \
-            -nographic \
-            -display none \
             -fsdev local,security_model=passthrough,readonly,id=fsdev0,path=${CCROOT} \
             -device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=config-2 \
             -fsdev local,security_model=none,id=fsdev1,path=${HOME} \
@@ -168,10 +194,19 @@ if [ "$QEMU" == "1" ]; then
             ${QEMU_ARGS} \
             "${@}"
 
-elif [ "$BOOT_ISO" == "1" ]; then
+elif [ "$BOOT_ISO" == "1" ] ||
+            [ "$BOOT_HD" == "1" ]; then
+    if [ "$BOOT_ISO" == "1" ]; then
+        ISO_OPTS="-boot d -cdrom ./dist/artifacts/rancheros.iso \
+            -fsdev local,security_model=passthrough,readonly,id=fsdev0,path=${CCROOT} \
+            -device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=config-2 \
+            -fsdev local,security_model=none,id=fsdev1,path=${HOME} \
+            -device virtio-9p-pci,id=fs1,fsdev=fsdev1,mount_tag=home "
+            echo "----- $ISO_OPTS"
+    fi
     set -x
     exec qemu-system-${QEMUARCH} \
-            -curses \
+            ${DISPLAY_OPTS} \
             -rtc base=utc,clock=host \
             ${KVM_ENABLE} \
             ${CPU} \
@@ -181,8 +216,7 @@ elif [ "$BOOT_ISO" == "1" ]; then
             $(eval "${hd["$ARCH"]} ${HD}") \
             ${SECOND_DRIVE_ENABLE} \
             -smp 1 \
-            -boot d \
-            -cdrom ./dist/artifacts/rancheros.iso
+            ${ISO_OPTS}
 elif [ "$QIND" == "1" ]; then
 
     NAME=${NAME:-ros-qind}
diff --git a/scripts/run-common b/scripts/run-common
index 8f75097ee..79fb0af08 100755
--- a/scripts/run-common
+++ b/scripts/run-common
@@ -34,9 +34,11 @@ BUILD=build
 BASE=$(pwd)
 UNAME=$(uname)
 
-KERNEL=${BASE}/dist/artifacts/vmlinuz
+KERNEL=${BASE}/build/kernel/vmlinuz
 INITRD_SRC=${BASE}/build/initrd
 INITRD=${BASE}/build/initrd.tmp
+#LINUXMOD=${BASE}/build/kernel/linuxmods
+
 
 QEMU=1
 FORMAT=1
@@ -46,4 +48,4 @@ REBUILD=1
 QEMUARCH=${qemuarch["${ARCH}"]}
 TTYCONS=${ttycons["${ARCH}"]}
 
-DEFAULT_KERNEL_ARGS="quiet rancher.password=rancher console=${TTYCONS} rancher.autologin=${TTYCONS}"
+DEFAULT_KERNEL_ARGS="rancher.debug=false rancher.password=rancher console=${TTYCONS} rancher.autologin=${TTYCONS}"
diff --git a/tests/common_test.go b/tests/common_test.go
index b58c34044..cb7e7e109 100644
--- a/tests/common_test.go
+++ b/tests/common_test.go
@@ -17,6 +17,7 @@ func init() {
 	Suite(&QemuSuite{
 		runCommand: "../scripts/run",
 		sshCommand: "../scripts/ssh",
+		qemuCmd:    nil,
 	})
 }
 
@@ -42,11 +43,20 @@ type QemuSuite struct {
 }
 
 func (s *QemuSuite) TearDownTest(c *C) {
-	c.Assert(s.qemuCmd.Process.Kill(), IsNil)
-	time.Sleep(time.Millisecond * 1000)
+	if s.qemuCmd != nil {
+		s.Stop(c)
+	}
+}
+
+// RunQemuWith requires user to specify all the `scripts/run` arguments
+func (s *QemuSuite) RunQemuWith(c *C, additionalArgs ...string) error {
+
+	err := s.runQemu(c, additionalArgs...)
+	c.Assert(err, IsNil)
+	return err
 }
 
-func (s *QemuSuite) RunQemu(c *C, additionalArgs ...string) {
+func (s *QemuSuite) RunQemu(c *C, additionalArgs ...string) error {
 	runArgs := []string{
 		"--qemu",
 		"--no-rebuild",
@@ -55,28 +65,31 @@ func (s *QemuSuite) RunQemu(c *C, additionalArgs ...string) {
 	}
 	runArgs = append(runArgs, additionalArgs...)
 
-	c.Assert(s.runQemu(runArgs...), IsNil)
+	err := s.RunQemuWith(c, runArgs...)
+	c.Assert(err, IsNil)
+	return err
 }
 
-func (s *QemuSuite) RunQemuInstalled(c *C, additionalArgs ...string) {
+func (s *QemuSuite) RunQemuInstalled(c *C, additionalArgs ...string) error {
 	runArgs := []string{
-		"--qemu",
-		"--no-rebuild",
-		"--no-rm-usr",
-		"--installed",
+		"--fresh",
 	}
 	runArgs = append(runArgs, additionalArgs...)
 
-	c.Assert(s.runQemu(runArgs...), IsNil)
+	err := s.RunQemu(c, runArgs...)
+	c.Assert(err, IsNil)
+	return err
 }
 
-func (s *QemuSuite) runQemu(args ...string) error {
+func (s *QemuSuite) runQemu(c *C, args ...string) error {
+	c.Assert(s.qemuCmd, IsNil) // can't run 2 qemu's at once (yet)
 	s.qemuCmd = exec.Command(s.runCommand, args...)
-	s.qemuCmd.Stdout = os.Stdout
+	//s.qemuCmd.Stdout = os.Stdout
 	s.qemuCmd.Stderr = os.Stderr
 	if err := s.qemuCmd.Start(); err != nil {
 		return err
 	}
+	fmt.Printf("--- %s: starting qemu %s, %v\n", c.TestName(), s.runCommand, args)
 
 	return s.WaitForSSH()
 }
@@ -119,23 +132,47 @@ func (s *QemuSuite) WaitForSSH() error {
 	return fmt.Errorf("Failed to check Docker version: %v", err)
 }
 
-func (s *QemuSuite) MakeCall(additionalArgs ...string) error {
+func (s *QemuSuite) MakeCall(additionalArgs ...string) (string, error) {
 	sshArgs := []string{
 		"--qemu",
 	}
 	sshArgs = append(sshArgs, additionalArgs...)
 
 	cmd := exec.Command(s.sshCommand, sshArgs...)
-	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	return cmd.Run()
+	out, err := cmd.Output()
+	str := string(out)
+	fmt.Println(str)
+	return str, err
 }
 
 func (s *QemuSuite) CheckCall(c *C, additionalArgs ...string) {
-	c.Assert(s.MakeCall(additionalArgs...), IsNil)
+	_, err := s.MakeCall(additionalArgs...)
+	c.Assert(err, IsNil)
+}
+
+func (s *QemuSuite) CheckOutput(c *C, result string, check Checker, additionalArgs ...string) string {
+	out, err := s.MakeCall(additionalArgs...)
+	c.Assert(err, IsNil)
+	c.Assert(out, check, result)
+	return out
+}
+
+func (s *QemuSuite) Stop(c *C) {
+	//s.MakeCall("sudo halt")
+	//time.Sleep(2000 * time.Millisecond)
+	//c.Assert(s.WaitForSSH(), IsNil)
+
+	//fmt.Println("%s: stopping qemu", c.TestName())
+	c.Assert(s.qemuCmd.Process.Kill(), IsNil)
+	s.qemuCmd.Process.Wait()
+	//time.Sleep(time.Millisecond * 1000)
+	s.qemuCmd = nil
+	fmt.Printf("--- %s: qemu stopped", c.TestName())
 }
 
 func (s *QemuSuite) Reboot(c *C) {
+	fmt.Printf("--- %s: qemu reboot", c.TestName())
 	s.MakeCall("sudo reboot")
 	time.Sleep(3000 * time.Millisecond)
 	c.Assert(s.WaitForSSH(), IsNil)
diff --git a/tests/installer_test.go b/tests/installer_test.go
new file mode 100644
index 000000000..81b765e64
--- /dev/null
+++ b/tests/installer_test.go
@@ -0,0 +1,150 @@
+package integration
+
+import (
+	"fmt"
+	"time"
+
+	. "gopkg.in/check.v1"
+)
+
+func (s *QemuSuite) TestInstallMsDosMbr(c *C) {
+	// ./scripts/run --no-format --append "rancher.debug=true"  --iso --fresh
+	runArgs := []string{
+		"--iso",
+		"--fresh",
+	}
+	version := ""
+	{
+		s.RunQemuWith(c, runArgs...)
+		version = s.CheckOutput(c, version, Not(Equals), "sudo ros -v")
+		fmt.Printf("installing %s", version)
+
+		s.CheckCall(c, `
+echo "---------------------------------- generic"
+set -ex
+sudo parted /dev/vda print
+echo "ssh_authorized_keys:" > config.yml
+echo "  - $(cat /home/rancher/.ssh/authorized_keys)" >> config.yml
+sudo ros install --force --no-reboot --device /dev/vda -c config.yml --append rancher.password=rancher
+sync
+`)
+		time.Sleep(500 * time.Millisecond)
+		s.Stop(c)
+	}
+
+	// ./scripts/run --no-format --append "rancher.debug=true"
+	runArgs = []string{
+		"--boothd",
+	}
+	s.RunQemuWith(c, runArgs...)
+
+	s.CheckOutput(c, version, Equals, "sudo ros -v")
+	s.Stop(c)
+}
+
+func (s *QemuSuite) TestInstallGptMbr(c *C) {
+	// ./scripts/run --no-format --append "rancher.debug=true"  --iso --fresh
+	runArgs := []string{
+		"--iso",
+		"--fresh",
+	}
+	version := ""
+	{
+		s.RunQemuWith(c, runArgs...)
+
+		version = s.CheckOutput(c, version, Not(Equals), "sudo ros -v")
+		fmt.Printf("installing %s", version)
+
+		s.CheckCall(c, `
+echo "---------------------------------- gptsyslinux"
+set -ex
+sudo parted /dev/vda print
+echo "ssh_authorized_keys:" > config.yml
+echo "  - $(cat /home/rancher/.ssh/authorized_keys)" >> config.yml
+sudo ros install --force --no-reboot --device /dev/vda -t gptsyslinux -c config.yml
+sync
+`)
+		time.Sleep(500 * time.Millisecond)
+		s.Stop(c)
+	}
+
+	// ./scripts/run --no-format --append "rancher.debug=true"
+	runArgs = []string{
+		"--boothd",
+	}
+	s.RunQemuWith(c, runArgs...)
+
+	s.CheckOutput(c, version, Equals, "sudo ros -v")
+	// TEST parted output? (gpt non-uefi == legacy_boot)
+	s.Stop(c)
+}
+
+func (s *QemuSuite) TestUpgradeFromImage(c *C) {
+	// ./scripts/run --no-format --append "rancher.debug=true"  --iso --fresh
+
+	//TODO: --fresh isn't giving us a new disk why? (that's what the parted print is for atm)
+	runArgs := []string{
+		"--iso",
+		"--fresh",
+	}
+	version := ""
+	{
+		s.RunQemuWith(c, runArgs...)
+
+		version = s.CheckOutput(c, version, Not(Equals), "sudo ros -v")
+		fmt.Printf("running %s", version)
+		s.CheckCall(c, "sudo uname -a")
+		//TODO: detect "last release, and install that
+		s.CheckCall(c, `
+echo "---------------------------------- generic"
+set -ex
+sudo parted /dev/vda print
+echo "ssh_authorized_keys:" > config.yml
+echo "  - $(cat /home/rancher/.ssh/authorized_keys)" >> config.yml
+sudo ros install --force --no-reboot --device /dev/vda -c config.yml -i rancher/os:v0.7.1 --append "console=ttyS0 rancher.password=rancher"
+#TODO copy installer image, new ros, and new kernel to HD, so we can fake things up next time? (or have next boot from HD, but have the iso available..)
+sudo mkdir -p /bootiso
+sudo mount -t iso9660 /dev/sr0 /bootiso/
+sudo mount /dev/vda1 /mnt/
+sudo mkdir -p /mnt/rancher-installer/build/ 
+sudo cp /bootiso/rancheros/installer.tar.gz /mnt/rancher-installer/build/
+sudo cp /bootiso/rancheros/Dockerfile.amd64 /mnt/rancher-installer/build/
+sudo cp -r /bootiso/boot /mnt/rancher-installer/build/
+sudo cp /bin/ros /mnt/rancher-installer/build/
+sync
+`)
+		time.Sleep(500 * time.Millisecond)
+		s.Stop(c)
+	}
+
+	{
+		runArgs = []string{
+			"--boothd",
+		}
+		s.RunQemuWith(c, runArgs...)
+
+		s.CheckOutput(c, "ros version v0.7.1\n", Equals, "sudo ros -v")
+		s.CheckCall(c, "sudo uname -a")
+
+		// load the installer.tar.gz, get the other install files into an image, and runit.
+		s.CheckCall(c, `sudo system-docker run --name builder -dt --volumes-from system-volumes -v /:/host alpine sh
+	sudo system-docker exec -t builder ln -s /host/rancher-installer/build/ros /bin/system-docker
+	sudo system-docker exec -t builder system-docker load -i /host/rancher-installer/build/installer.tar.gz
+	sudo system-docker exec -t builder system-docker build -t qwer -f /host/rancher-installer/build/Dockerfile.amd64 /host/rancher-installer/build
+	sudo ros os upgrade -i qwer --no-reboot -f --append "console=tty0 console=ttyS0 rancher.password=rancher"
+	sync
+	`)
+		time.Sleep(500 * time.Millisecond)
+		s.Stop(c)
+	}
+
+	// ./scripts/run --no-format --append "rancher.debug=true"
+	runArgs = []string{
+		"--boothd",
+	}
+	s.RunQemuWith(c, runArgs...)
+
+	s.CheckOutput(c, version, Equals, "sudo ros -v")
+	s.CheckCall(c, "sudo uname -a")
+	s.Stop(c)
+}
diff --git a/tests/upgrade_test.go b/tests/upgrade_test.go
index 6167bd226..b589b2f57 100644
--- a/tests/upgrade_test.go
+++ b/tests/upgrade_test.go
@@ -6,7 +6,11 @@ import (
 	. "gopkg.in/check.v1"
 )
 
-func (s *QemuSuite) TestUpgrade(c *C) {
+// DisabledTestUpgrade, The new go based installer code breaks downgrading from itself to a previous version
+// because 0.8.0 now uses syslinx and a set of syslinux.cfg files, whereas before that , we used grub and
+// assumed that there was only one kernel&initrd
+//      see installer_test.go for more tests
+func (s *QemuSuite) DisabledTestUpgrade(c *C) {
 	s.RunQemuInstalled(c)
 
 	s.CheckCall(c, `
diff --git a/util/cutil.go b/util/cutil.go
old mode 100644
new mode 100755
index 07d58b6f9..afea273bf
--- a/util/cutil.go
+++ b/util/cutil.go
@@ -15,6 +15,7 @@ import (
 	"errors"
 )
 
+// ResolveDevice this isn't reliable - blkid -L LABEL works more often :(
 func ResolveDevice(spec string) string {
 	cSpec := C.CString(spec)
 	defer C.free(unsafe.Pointer(cSpec))
diff --git a/util/util_linux.go b/util/util_linux.go
old mode 100644
new mode 100755
index e33d458c5..cb9596fa5
--- a/util/util_linux.go
+++ b/util/util_linux.go
@@ -39,3 +39,7 @@ func Mount(device, directory, fsType, options string) error {
 
 	return mount.Mount(device, directory, fsType, options)
 }
+
+func Unmount(target string) error {
+	return mount.Unmount(target)
+}