@@ -678,18 +678,19 @@ func (container *Container) Start() (err error) {

 	}

 	container.process = &execdriver.Process{

-		ID:         container.ID,

-		Privileged: container.hostConfig.Privileged,

-		Rootfs:     root,

-		InitPath:   "/.dockerinit",

-		Entrypoint: container.Path,

-		Arguments:  container.Args,

-		WorkingDir: workingDir,

-		ConfigPath: container.lxcConfigPath(),

-		Network:    en,

-		Tty:        container.Config.Tty,

-		User:       container.Config.User,

-		WaitLock:   make(chan struct{}),

+		ID:          container.ID,

+		Privileged:  container.hostConfig.Privileged,

+		Rootfs:      root,

+		InitPath:    "/.dockerinit",

+		Entrypoint:  container.Path,

+		Arguments:   container.Args,

+		WorkingDir:  workingDir,

+		ConfigPath:  container.lxcConfigPath(),

+		Network:     en,

+		Tty:         container.Config.Tty,

+		User:        container.Config.User,

+		WaitLock:    make(chan struct{}),

+		SysInitPath: runtime.sysInitPath,

 	}

 	container.process.SysProcAttr = &syscall.SysProcAttr{Setsid: true}

new file mode 100644

@@ -0,0 +1,66 @@

+package chroot

+

+import (

+	"fmt"

+	"github.com/dotcloud/docker/execdriver"

+	"io/ioutil"

+	"os/exec"

+	"path"

+	"time"

+)

+

+type driver struct {

+}

+

+func NewDriver() (execdriver.Driver, error) {

+	return &driver{}, nil

+}

+

+func (d *driver) Start(c *execdriver.Process) error {

+	data, _ := ioutil.ReadFile(c.SysInitPath)

+	ioutil.WriteFile(path.Join(c.Rootfs, ".dockerinit"), data, 0644)

+	params := []string{

+		"chroot",

+		c.Rootfs,

+		"/.dockerinit",

+	}

+	// need to mount proc

+	params = append(params, c.Entrypoint)

+	params = append(params, c.Arguments...)

+

+	var (

+		name = params[0]

+		arg  = params[1:]

+	)

+	aname, err := exec.LookPath(name)

+	if err != nil {

+		aname = name

+	}

+	c.Path = aname

+	c.Args = append([]string{name}, arg...)

+

+	if err := c.Start(); err != nil {

+		return err

+	}

+

+	go func() {

+		if err := c.Wait(); err != nil {

+			c.WaitError = err

+		}

+		close(c.WaitLock)

+	}()

+

+	return nil

+}

+

+func (d *driver) Kill(p *execdriver.Process, sig int) error {

+	return p.Process.Kill()

+}

+

+func (d *driver) Wait(id string, duration time.Duration) error {

+	panic("No Implemented")

+}

+

+func (d *driver) Version() string {

+	return "0.1"

+}

@@ -25,19 +25,20 @@ type Network struct {

 type Process struct {

 	exec.Cmd

-	ID         string

-	Privileged bool

-	User       string

-	Rootfs     string // root fs of the container

-	InitPath   string // dockerinit

-	Entrypoint string

-	Arguments  []string

-	WorkingDir string

-	ConfigPath string

-	Tty        bool

-	Network    *Network // if network is nil then networking is disabled

-	WaitLock   chan struct{}

-	WaitError  error

+	ID          string

+	Privileged  bool

+	User        string

+	Rootfs      string // root fs of the container

+	InitPath    string // dockerinit

+	Entrypoint  string

+	Arguments   []string

+	WorkingDir  string

+	ConfigPath  string

+	Tty         bool

+	Network     *Network // if network is nil then networking is disabled

+	SysInitPath string

+	WaitLock    chan struct{}

+	WaitError   error

 }

 func (c *Process) Pid() int {

@@ -88,7 +88,6 @@ func (d *driver) Start(c *execdriver.Process) error {

 		params = []string{

 			"unshare", "-m", "--", "/bin/sh", "-c", shellString,

 		}

-

 	}

 	params = append(params, "--", c.Entrypoint)

@@ -6,6 +6,7 @@ import (

 	"github.com/dotcloud/docker/archive"

 	"github.com/dotcloud/docker/cgroups"

 	"github.com/dotcloud/docker/execdriver"

+	"github.com/dotcloud/docker/execdriver/chroot"

 	"github.com/dotcloud/docker/execdriver/lxc"

 	"github.com/dotcloud/docker/graphdriver"

 	"github.com/dotcloud/docker/graphdriver/aufs"

@@ -735,7 +736,12 @@ func NewRuntimeFromDirectory(config *DaemonConfig) (*Runtime, error) {

 	}

 	capabilities := NewRuntimeCapabilities(false)

-	ed, err := lxc.NewDriver(config.Root, capabilities.AppArmor)

+	var ed execdriver.Driver

+	if driver := os.Getenv("EXEC_DRIVER"); driver == "lxc" {

+		ed, err = lxc.NewDriver(config.Root, capabilities.AppArmor)

+	} else {

+		ed, err = chroot.NewDriver()

+	}

 	if err != nil {

 		return nil, err

 	}

@@ -182,24 +182,25 @@ func getEnv(args *DockerInitArgs, key string) string {

 func executeProgram(args *DockerInitArgs) error {

 	setupEnv(args)

-	if err := setupHostname(args); err != nil {

-		return err

-	}

-

-	if err := setupNetworking(args); err != nil {

-		return err

-	}

+	if false {

+		if err := setupHostname(args); err != nil {

+			return err

+		}

-	if err := setupCapabilities(args); err != nil {

-		return err

-	}

+		if err := setupNetworking(args); err != nil {

+			return err

+		}

-	if err := setupWorkingDirectory(args); err != nil {

-		return err

-	}

+		if err := setupCapabilities(args); err != nil {

+			return err

+		}

+		if err := setupWorkingDirectory(args); err != nil {

+			return err

+		}

-	if err := changeUser(args); err != nil {

-		return err

+		if err := changeUser(args); err != nil {

+			return err

+		}

 	}

 	path, err := exec.LookPath(args.args[0])