@@ -4,8 +4,8 @@

 #### Notable features since 0.6.0

-* Storage drivers: choose from aufs, device mapper, vfs or btrfs.

-* Standard Linux support: docker now runs on unmodified linux kernels and all major distributions.

+* Storage drivers: choose from aufs, device-mapper, or vfs.

+* Standard Linux support: docker now runs on unmodified Linux kernels and all major distributions.

 * Links: compose complex software stacks by connecting containers to each other.

 * Container naming: organize your containers by giving them memorable names.

 * Advanced port redirects: specify port redirects per interface, or keep sensitive ports private.

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

 	"mime"

 	"net"

 	"net/http"

+	"net/http/pprof"

 	"os"

 	"os/exec"

 	"regexp"

@@ -1037,9 +1038,21 @@ func makeHttpHandler(srv *Server, logging bool, localMethod string, localRoute s

 	}

 }

+func AttachProfiler(router *mux.Router) {

+	router.HandleFunc("/debug/pprof/", pprof.Index)

+	router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)

+	router.HandleFunc("/debug/pprof/profile", pprof.Profile)

+	router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)

+	router.HandleFunc("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)

+	router.HandleFunc("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)

+	router.HandleFunc("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)

+}

+

 func createRouter(srv *Server, logging bool) (*mux.Router, error) {

 	r := mux.NewRouter()

-

+	if os.Getenv("DEBUG") != "" {

+		AttachProfiler(r)

+	}

 	m := map[string]map[string]HttpApiFunc{

 		"GET": {

 			"/events":                         getEvents,

@@ -288,7 +288,7 @@ func (b *buildFile) addContext(container *Container, orig, dest string) error {

 		destPath = destPath + "/"

 	}

 	if !strings.HasPrefix(origPath, b.context) {

-		return fmt.Errorf("Forbidden path: %s", origPath)

+		return fmt.Errorf("Forbidden path outside the build context: %s (%s)", orig, origPath)

 	}

 	fi, err := os.Stat(origPath)

 	if err != nil {

@@ -1666,8 +1666,11 @@ func (opts PathOpts) String() string { return fmt.Sprintf("%v", map[string]struc

 func (opts PathOpts) Set(val string) error {

 	var containerPath string

-	splited := strings.SplitN(val, ":", 2)

-	if len(splited) == 1 {

+	if strings.Count(val, ":") > 2 {

+		return fmt.Errorf("bad format for volumes: %s", val)

+	}

+

+	if splited := strings.SplitN(val, ":", 2); len(splited) == 1 {

 		containerPath = splited[0]

 		val = filepath.Clean(splited[0])

 	} else {

@@ -1680,6 +1683,7 @@ func (opts PathOpts) Set(val string) error {

 		return fmt.Errorf("%s is not an absolute path", containerPath)

 	}

 	opts[val] = struct{}{}

+

 	return nil

 }

@@ -2195,7 +2199,7 @@ func (cli *DockerCli) CmdCp(args ...string) error {

 }

 func (cli *DockerCli) CmdSave(args ...string) error {

-	cmd := cli.Subcmd("save", "IMAGE DESTINATION", "Save an image to a tar archive")

+	cmd := cli.Subcmd("save", "IMAGE", "Save an image to a tar archive (streamed to stdout)")

 	if err := cmd.Parse(args); err != nil {

 		return err

 	}

new file mode 100644

@@ -0,0 +1,157 @@

+package docker

+

+import (

+	"strings"

+	"testing"

+)

+

+func parse(t *testing.T, args string) (*Config, *HostConfig, error) {

+	config, hostConfig, _, err := ParseRun(strings.Split(args+" ubuntu bash", " "), nil)

+	return config, hostConfig, err

+}

+

+func mustParse(t *testing.T, args string) (*Config, *HostConfig) {

+	config, hostConfig, err := parse(t, args)

+	if err != nil {

+		t.Fatal(err)

+	}

+	return config, hostConfig

+}

+

+func TestParseRunLinks(t *testing.T) {

+	if _, hostConfig := mustParse(t, "-link a:b"); len(hostConfig.Links) == 0 || hostConfig.Links[0] != "a:b" {

+		t.Fatalf("Error parsing links. Expected []string{\"a:b\"}, received: %v", hostConfig.Links)

+	}

+	if _, hostConfig := mustParse(t, "-link a:b -link c:d"); len(hostConfig.Links) < 2 || hostConfig.Links[0] != "a:b" || hostConfig.Links[1] != "c:d" {

+		t.Fatalf("Error parsing links. Expected []string{\"a:b\", \"c:d\"}, received: %v", hostConfig.Links)

+	}

+	if _, hostConfig := mustParse(t, ""); len(hostConfig.Links) != 0 {

+		t.Fatalf("Error parsing links. No link expected, received: %v", hostConfig.Links)

+	}

+

+	if _, _, err := parse(t, "-link a"); err == nil {

+		t.Fatalf("Error parsing links. `-link a` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-link"); err == nil {

+		t.Fatalf("Error parsing links. `-link` should be an error but is not")

+	}

+}

+

+func TestParseRunAttach(t *testing.T) {

+	if config, _ := mustParse(t, "-a stdin"); !config.AttachStdin || config.AttachStdout || config.AttachStderr {

+		t.Fatalf("Error parsing attach flags. Expect only Stdin enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

+	}

+	if config, _ := mustParse(t, "-a stdin -a stdout"); !config.AttachStdin || !config.AttachStdout || config.AttachStderr {

+		t.Fatalf("Error parsing attach flags. Expect only Stdin and Stdout enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

+	}

+	if config, _ := mustParse(t, "-a stdin -a stdout -a stderr"); !config.AttachStdin || !config.AttachStdout || !config.AttachStderr {

+		t.Fatalf("Error parsing attach flags. Expect all attach enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

+	}

+	if config, _ := mustParse(t, ""); config.AttachStdin || !config.AttachStdout || !config.AttachStderr {

+		t.Fatalf("Error parsing attach flags. Expect Stdin disabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

+	}

+

+	if _, _, err := parse(t, "-a"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a invalid"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a invalid` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a invalid -a stdout"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a stdout -a invalid` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a stdout -a stderr -d"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a stdout -a stderr -d` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a stdin -d"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a stdin -d` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a stdout -d"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a stdout -d` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-a stderr -d"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-a stderr -d` should be an error but is not")

+	}

+	if _, _, err := parse(t, "-d -rm"); err == nil {

+		t.Fatalf("Error parsing attach flags, `-d -rm` should be an error but is not")

+	}

+}

+

+func TestParseRunVolumes(t *testing.T) {

+	if config, hostConfig := mustParse(t, "-v /tmp"); hostConfig.Binds != nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp` should not mount-bind anything. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/tmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /tmp` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, "-v /tmp -v /var"); hostConfig.Binds != nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp -v /var` should not mount-bind anything. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/tmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /tmp` is missing from volumes. Recevied %v", config.Volumes)

+	} else if _, exists := config.Volumes["/var"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /var` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, "-v /hostTmp:/containerTmp"); hostConfig.Binds == nil || hostConfig.Binds[0] != "/hostTmp:/containerTmp" {

+		t.Fatalf("Error parsing volume flags, `-v /hostTmp:/containerTmp` should mount-bind /hostTmp into /containeTmp. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/containerTmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /tmp` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, "-v /hostTmp:/containerTmp -v /hostVar:/containerVar"); hostConfig.Binds == nil || hostConfig.Binds[0] != "/hostTmp:/containerTmp" || hostConfig.Binds[1] != "/hostVar:/containerVar" {

+		t.Fatalf("Error parsing volume flags, `-v /hostTmp:/containerTmp -v /hostVar:/containerVar` should mount-bind /hostTmp into /containeTmp and /hostVar into /hostContainer. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/containerTmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerTmp` is missing from volumes. Received %v", config.Volumes)

+	} else if _, exists := config.Volumes["/containerVar"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerVar` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, "-v /hostTmp:/containerTmp:ro -v /hostVar:/containerVar:rw"); hostConfig.Binds == nil || hostConfig.Binds[0] != "/hostTmp:/containerTmp:ro" || hostConfig.Binds[1] != "/hostVar:/containerVar:rw" {

+		t.Fatalf("Error parsing volume flags, `-v /hostTmp:/containerTmp:ro -v /hostVar:/containerVar:rw` should mount-bind /hostTmp into /containeTmp and /hostVar into /hostContainer. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/containerTmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerTmp` is missing from volumes. Received %v", config.Volumes)

+	} else if _, exists := config.Volumes["/containerVar"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerVar` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, "-v /hostTmp:/containerTmp -v /containerVar"); hostConfig.Binds == nil || len(hostConfig.Binds) > 1 || hostConfig.Binds[0] != "/hostTmp:/containerTmp" {

+		t.Fatalf("Error parsing volume flags, `-v /hostTmp:/containerTmp -v /containerVar` should mount-bind only /hostTmp into /containeTmp. Received %v", hostConfig.Binds)

+	} else if _, exists := config.Volumes["/containerTmp"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerTmp` is missing from volumes. Received %v", config.Volumes)

+	} else if _, exists := config.Volumes["/containerVar"]; !exists {

+		t.Fatalf("Error parsing volume flags, `-v /containerVar` is missing from volumes. Received %v", config.Volumes)

+	}

+

+	if config, hostConfig := mustParse(t, ""); hostConfig.Binds != nil {

+		t.Fatalf("Error parsing volume flags, without volume, nothing should be mount-binded. Received %v", hostConfig.Binds)

+	} else if len(config.Volumes) != 0 {

+		t.Fatalf("Error parsing volume flags, without volume, no volume should be present. Received %v", config.Volumes)

+	}

+

+	mustParse(t, "-v /")

+

+	if _, _, err := parse(t, "-v /:/"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v /:/` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v /tmp:"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp:` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v /tmp:ro"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp:ro` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v /tmp::"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp::` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v :"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v :` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v ::"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v ::` should fail but didn't")

+	}

+	if _, _, err := parse(t, "-v /tmp:/tmp:/tmp:/tmp"); err == nil {

+		t.Fatalf("Error parsing volume flags, `-v /tmp:/tmp:/tmp:/tmp` should fail but didn't")

+	}

+}

@@ -17,3 +17,34 @@ meaning you can use Vagrant to control Docker containers.

 * [docker-provider](https://github.com/fgrehm/docker-provider)

 * [vagrant-shell](https://github.com/destructuring/vagrant-shell)

+

+## Setting up Vagrant-docker with the Remote API

+

+The initial Docker upstart script will not work because it runs on `127.0.0.1`, which is not accessible to the host machine. Instead, we need to change the script to connect to `0.0.0.0`. To do this, modify `/etc/init/docker.conf` to look like this:

+

+```

+description     "Docker daemon"

+

+start on filesystem and started lxc-net

+stop on runlevel [!2345]

+

+respawn

+

+script

+    /usr/bin/docker -d -H=tcp://0.0.0.0:4243/

+end script

+```

+

+Once that's done, you need to set up a SSH tunnel between your host machine and the vagrant machine that's running Docker. This can be done by running the following command in a host terminal:

+

+```

+ssh -L 4243:localhost:4243 -p 2222 vagrant@localhost

+```

+

+(The first 4243 is what your host can connect to, the second 4243 is what port Docker is running on in the vagrant machine, and the 2222 is the port Vagrant is providing for SSH. If VirtualBox is the VM you're using, you can see what value "2222" should be by going to: Network > Adapter 1 > Advanced > Port Forwarding in the VirtualBox GUI.)

+

+Note that because the port has been changed, to run docker commands from within the command line you must run them like this:

+

+```

+sudo docker -H 0.0.0.0:4243 < commands for docker >

+```

@@ -797,7 +797,7 @@ Known Issues (kill)

         -link="": Remove the link instead of the actual container

 Known Issues (rm)

-~~~~~~~~~~~~~~~~~~~

+~~~~~~~~~~~~~~~~~

 * :issue:`197` indicates that ``docker kill`` may leave directories

   behind and make it difficult to remove the container.

@@ -881,8 +881,15 @@ containers will not be deleted.

       -name="": Assign the specified name to the container. If no name is specific docker will generate a random name

       -P=false: Publish all exposed ports to the host interfaces

-Examples

+Known Issues (run -volumes-from)

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+* :issue:`2702`: "lxc-start: Permission denied - failed to mount"

+  could indicate a permissions problem with AppArmor. Please see the

+  issue for a workaround.

+

+Examples:

+~~~~~~~~~

 .. code-block:: bash

@@ -974,16 +981,10 @@ id may be optionally suffixed with ``:ro`` or ``:rw`` to mount the volumes in

 read-only or read-write mode, respectively. By default, the volumes are mounted

 in the same mode (rw or ro) as the reference container.

-Known Issues (run -volumes-from)

-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-

-* :issue:`2702`: "lxc-start: Permission denied - failed to mount"

-  could indicate a permissions problem with AppArmor. Please see the

-  issue for a workaround.

-

 .. _cli_save:

 ``save``

+---------

 ::

@@ -131,8 +131,6 @@ Attach to the container to see the results in real-time.

 - **"docker attach**" This will allow us to attach to a background

   process to see what is going on.

-- **"-sig-proxy=true"** Proxify all received signal to the process

-  (even in non-tty mode)

 - **$CONTAINER_ID** The Id of the container we want to attach too.

 Exit from the container attachment by pressing Control-C.

@@ -45,19 +45,21 @@ Install ``python-software-properties``.

     apt-get -y install python-software-properties

     apt-get -y install software-properties-common

-Add Pitti's PostgreSQL repository. It contains the most recent stable release

-of PostgreSQL i.e. ``9.2``.

+Add PostgreSQL's repository. It contains the most recent stable release

+of PostgreSQL i.e. ``9.3``.

 .. code-block:: bash

-    add-apt-repository ppa:pitti/postgresql

+    apt-get -y install wget

+    wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -

+    echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list

     apt-get update

-Finally, install PostgreSQL 9.2

+Finally, install PostgreSQL 9.3

 .. code-block:: bash

-    apt-get -y install postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2

+    apt-get -y install postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3

 Now, create a PostgreSQL superuser role that can create databases and

 other roles.  Following Vagrant's convention the role will be named

@@ -76,14 +78,14 @@ role.

 Adjust PostgreSQL configuration so that remote connections to the

 database are possible. Make sure that inside

-``/etc/postgresql/9.2/main/pg_hba.conf`` you have following line (you will need

+``/etc/postgresql/9.3/main/pg_hba.conf`` you have following line (you will need

 to install an editor, e.g. ``apt-get install vim``):

 .. code-block:: bash

     host    all             all             0.0.0.0/0               md5

-Additionaly, inside ``/etc/postgresql/9.2/main/postgresql.conf``

+Additionaly, inside ``/etc/postgresql/9.3/main/postgresql.conf``

 uncomment ``listen_addresses`` so it is as follows:

 .. code-block:: bash

@@ -115,9 +117,9 @@ Finally, run PostgreSQL server via ``docker``.

     CONTAINER=$(sudo docker run -d -p 5432 \

       -t <your username>/postgresql \

-      /bin/su postgres -c '/usr/lib/postgresql/9.2/bin/postgres \

-        -D /var/lib/postgresql/9.2/main \

-        -c config_file=/etc/postgresql/9.2/main/postgresql.conf')

+      /bin/su postgres -c '/usr/lib/postgresql/9.3/bin/postgres \

+        -D /var/lib/postgresql/9.3/main \

+        -c config_file=/etc/postgresql/9.3/main/postgresql.conf')

 Connect the PostgreSQL server using ``psql`` (You will need postgres installed

 on the machine.  For ubuntu, use something like

@@ -132,7 +134,7 @@ As before, create roles or databases if needed.

 .. code-block:: bash

-    psql (9.2.4)

+    psql (9.3.1)

     Type "help" for help.

     docker=# CREATE DATABASE foo OWNER=docker;

@@ -160,9 +162,9 @@ container starts.

 .. code-block:: bash

     sudo docker commit -run='{"Cmd": \

-      ["/bin/su", "postgres", "-c", "/usr/lib/postgresql/9.2/bin/postgres -D \

-      /var/lib/postgresql/9.2/main -c \

-      config_file=/etc/postgresql/9.2/main/postgresql.conf"], "PortSpecs": ["5432"]}' \

+      ["/bin/su", "postgres", "-c", "/usr/lib/postgresql/9.3/bin/postgres -D \

+      /var/lib/postgresql/9.3/main -c \

+      config_file=/etc/postgresql/9.3/main/postgresql.conf"], "PortSpecs": ["5432"]}' \

       <container_id> <your username>/postgresql

 From now on, just type ``docker run <your username>/postgresql`` and

@@ -12,27 +12,28 @@ Arch Linux

 .. include:: install_unofficial.inc

 Installing on Arch Linux is not officially supported but can be handled via 

-either of the following AUR packages:

+one of the following AUR packages:

 * `lxc-docker <https://aur.archlinux.org/packages/lxc-docker/>`_

 * `lxc-docker-git <https://aur.archlinux.org/packages/lxc-docker-git/>`_

+* `lxc-docker-nightly <https://aur.archlinux.org/packages/lxc-docker-nightly/>`_

 The lxc-docker package will install the latest tagged version of docker. 

 The lxc-docker-git package will build from the current master branch.

+The lxc-docker-nightly package will install the latest build.

 Dependencies

 ------------

 Docker depends on several packages which are specified as dependencies in

-either AUR package.

+the AUR packages. The core dependencies are:

-* aufs3

 * bridge-utils

-* go

+* device-mapper

 * iproute2

-* linux-aufs_friendly

 * lxc

+

 Installation

 ------------

@@ -41,20 +42,14 @@ The instructions here assume **yaourt** is installed.  See

 for information on building and installing packages from the AUR if you have not

 done so before.

-Keep in mind that if **linux-aufs_friendly** is not already installed that a

-new kernel will be compiled and this can take quite a while.

-

 ::

-    yaourt -S lxc-docker-git

+    yaourt -S lxc-docker

 Starting Docker

 ---------------

-Prior to starting docker modify your bootloader to use the 

-**linux-aufs_friendly** kernel and reboot your system.

-

 There is a systemd service unit created for docker.  To start the docker service:

 ::

deleted file mode 100644

@@ -1,126 +0,0 @@

-// +build linux

-

-package devmapper

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/utils"

-)

-

-func stringToLoopName(src string) [LoNameSize]uint8 {

-	var dst [LoNameSize]uint8

-	copy(dst[:], src[:])

-	return dst

-}

-

-func getNextFreeLoopbackIndex() (int, error) {

-	f, err := osOpenFile("/dev/loop-control", osORdOnly, 0644)

-	if err != nil {

-		return 0, err

-	}

-	defer f.Close()

-

-	index, err := ioctlLoopCtlGetFree(f.Fd())

-	if index < 0 {

-		index = 0

-	}

-	return index, err

-}

-

-func openNextAvailableLoopback(index int, sparseFile *osFile) (loopFile *osFile, err error) {

-	// Start looking for a free /dev/loop

-	for {

-		target := fmt.Sprintf("/dev/loop%d", index)

-		index++

-

-		fi, err := osStat(target)

-		if err != nil {

-			if osIsNotExist(err) {

-				utils.Errorf("There are no more loopback device available.")

-			}

-			return nil, ErrAttachLoopbackDevice

-		}

-

-		if fi.Mode()&osModeDevice != osModeDevice {

-			utils.Errorf("Loopback device %s is not a block device.", target)

-			continue

-		}

-

-		// Open the targeted loopback (use OpenFile because Open sets O_CLOEXEC)

-		loopFile, err = osOpenFile(target, osORdWr, 0644)

-		if err != nil {

-			utils.Errorf("Error openning loopback device: %s", err)

-			return nil, ErrAttachLoopbackDevice

-		}

-

-		// Try to attach to the loop file

-		if err := ioctlLoopSetFd(loopFile.Fd(), sparseFile.Fd()); err != nil {

-			loopFile.Close()

-

-			// If the error is EBUSY, then try the next loopback

-			if err != sysEBusy {

-				utils.Errorf("Cannot set up loopback device %s: %s", target, err)

-				return nil, ErrAttachLoopbackDevice

-			}

-

-			// Otherwise, we keep going with the loop

-			continue

-		}

-		// In case of success, we finished. Break the loop.

-		break

-	}

-

-	// This can't happen, but let's be sure

-	if loopFile == nil {

-		utils.Errorf("Unreachable code reached! Error attaching %s to a loopback device.", sparseFile.Name())

-		return nil, ErrAttachLoopbackDevice

-	}

-

-	return loopFile, nil

-}

-

-// attachLoopDevice attaches the given sparse file to the next

-// available loopback device. It returns an opened *osFile.

-func attachLoopDevice(sparseName string) (loop *osFile, err error) {

-

-	// Try to retrieve the next available loopback device via syscall.

-	// If it fails, we discard error and start loopking for a

-	// loopback from index 0.

-	startIndex, err := getNextFreeLoopbackIndex()

-	if err != nil {

-		utils.Debugf("Error retrieving the next available loopback: %s", err)

-	}

-

-	// Open the given sparse file (use OpenFile because Open sets O_CLOEXEC)

-	sparseFile, err := osOpenFile(sparseName, osORdWr, 0644)

-	if err != nil {

-		utils.Errorf("Error openning sparse file %s: %s", sparseName, err)

-		return nil, ErrAttachLoopbackDevice

-	}

-	defer sparseFile.Close()

-

-	loopFile, err := openNextAvailableLoopback(startIndex, sparseFile)

-	if err != nil {

-		return nil, err

-	}

-

-	// Set the status of the loopback device

-	loopInfo := &LoopInfo64{

-		loFileName: stringToLoopName(loopFile.Name()),

-		loOffset:   0,

-		loFlags:    LoFlagsAutoClear,

-	}

-

-	if err := ioctlLoopSetStatus64(loopFile.Fd(), loopInfo); err != nil {

-		utils.Errorf("Cannot set up loopback device info: %s", err)

-

-		// If the call failed, then free the loopback device

-		if err := ioctlLoopClrFd(loopFile.Fd()); err != nil {

-			utils.Errorf("Error while cleaning up the loopback device")

-		}

-		loopFile.Close()

-		return nil, ErrAttachLoopbackDevice

-	}

-

-	return loopFile, nil

-}

new file mode 100644

@@ -0,0 +1,126 @@

+// +build linux

+

+package devmapper

+

+import (

+	"fmt"

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

+)

+

+func stringToLoopName(src string) [LoNameSize]uint8 {

+	var dst [LoNameSize]uint8

+	copy(dst[:], src[:])

+	return dst

+}

+

+func getNextFreeLoopbackIndex() (int, error) {

+	f, err := osOpenFile("/dev/loop-control", osORdOnly, 0644)

+	if err != nil {

+		return 0, err

+	}

+	defer f.Close()

+

+	index, err := ioctlLoopCtlGetFree(f.Fd())

+	if index < 0 {

+		index = 0

+	}

+	return index, err

+}

+

+func openNextAvailableLoopback(index int, sparseFile *osFile) (loopFile *osFile, err error) {

+	// Start looking for a free /dev/loop

+	for {

+		target := fmt.Sprintf("/dev/loop%d", index)

+		index++

+

+		fi, err := osStat(target)

+		if err != nil {

+			if osIsNotExist(err) {

+				utils.Errorf("There are no more loopback device available.")

+			}

+			return nil, ErrAttachLoopbackDevice

+		}

+

+		if fi.Mode()&osModeDevice != osModeDevice {

+			utils.Errorf("Loopback device %s is not a block device.", target)

+			continue

+		}

+

+		// OpenFile adds O_CLOEXEC

+		loopFile, err = osOpenFile(target, osORdWr, 0644)

+		if err != nil {

+			utils.Errorf("Error openning loopback device: %s", err)

+			return nil, ErrAttachLoopbackDevice

+		}

+

+		// Try to attach to the loop file

+		if err := ioctlLoopSetFd(loopFile.Fd(), sparseFile.Fd()); err != nil {

+			loopFile.Close()

+

+			// If the error is EBUSY, then try the next loopback

+			if err != sysEBusy {

+				utils.Errorf("Cannot set up loopback device %s: %s", target, err)

+				return nil, ErrAttachLoopbackDevice

+			}

+

+			// Otherwise, we keep going with the loop

+			continue

+		}

+		// In case of success, we finished. Break the loop.

+		break

+	}

+

+	// This can't happen, but let's be sure

+	if loopFile == nil {

+		utils.Errorf("Unreachable code reached! Error attaching %s to a loopback device.", sparseFile.Name())

+		return nil, ErrAttachLoopbackDevice

+	}

+

+	return loopFile, nil

+}

+

+// attachLoopDevice attaches the given sparse file to the next

+// available loopback device. It returns an opened *osFile.

+func attachLoopDevice(sparseName string) (loop *osFile, err error) {

+

+	// Try to retrieve the next available loopback device via syscall.

+	// If it fails, we discard error and start loopking for a

+	// loopback from index 0.

+	startIndex, err := getNextFreeLoopbackIndex()

+	if err != nil {

+		utils.Debugf("Error retrieving the next available loopback: %s", err)

+	}

+

+	// OpenFile adds O_CLOEXEC

+	sparseFile, err := osOpenFile(sparseName, osORdWr, 0644)

+	if err != nil {

+		utils.Errorf("Error openning sparse file %s: %s", sparseName, err)

+		return nil, ErrAttachLoopbackDevice

+	}

+	defer sparseFile.Close()

+

+	loopFile, err := openNextAvailableLoopback(startIndex, sparseFile)

+	if err != nil {

+		return nil, err

+	}

+

+	// Set the status of the loopback device

+	loopInfo := &LoopInfo64{

+		loFileName: stringToLoopName(loopFile.Name()),

+		loOffset:   0,

+		loFlags:    LoFlagsAutoClear,

+	}

+

+	if err := ioctlLoopSetStatus64(loopFile.Fd(), loopInfo); err != nil {

+		utils.Errorf("Cannot set up loopback device info: %s", err)

+

+		// If the call failed, then free the loopback device

+		if err := ioctlLoopClrFd(loopFile.Fd()); err != nil {

+			utils.Errorf("Error while cleaning up the loopback device")

+		}

+		loopFile.Close()

+		return nil, ErrAttachLoopbackDevice

+	}

+

+	return loopFile, nil

+}

@@ -56,21 +56,24 @@ type (

 )

 // FIXME: Make sure the values are defined in C

+// IOCTL consts

 const (

+	BlkGetSize64 = C.BLKGETSIZE64

+

 	LoopSetFd       = C.LOOP_SET_FD

 	LoopCtlGetFree  = C.LOOP_CTL_GET_FREE

 	LoopGetStatus64 = C.LOOP_GET_STATUS64

 	LoopSetStatus64 = C.LOOP_SET_STATUS64

 	LoopClrFd       = C.LOOP_CLR_FD

 	LoopSetCapacity = C.LOOP_SET_CAPACITY

+)

+const (

 	LoFlagsAutoClear = C.LO_FLAGS_AUTOCLEAR

 	LoFlagsReadOnly  = C.LO_FLAGS_READ_ONLY

 	LoFlagsPartScan  = C.LO_FLAGS_PARTSCAN

 	LoKeySize        = C.LO_KEY_SIZE

 	LoNameSize       = C.LO_NAME_SIZE

-

-	BlkGetSize64 = C.BLKGETSIZE64

 )

 var (

@@ -57,12 +57,6 @@ func denyAllDevmapper() {

 	DmGetNextTarget = func(task *CDmTask, next uintptr, start, length *uint64, target, params *string) uintptr {

 		panic("DmGetNextTarget: this method should not be called here")

 	}

-	DmAttachLoopDevice = func(filename string, fd *int) string {

-		panic("DmAttachLoopDevice: this method should not be called here")

-	}

-	DmGetBlockSize = func(fd uintptr) (int64, sysErrno) {

-		panic("DmGetBlockSize: this method should not be called here")

-	}

 	DmUdevWait = func(cookie uint) int {

 		panic("DmUdevWait: this method should not be called here")

 	}

@@ -78,9 +72,6 @@ func denyAllDevmapper() {

 	DmTaskDestroy = func(task *CDmTask) {

 		panic("DmTaskDestroy: this method should not be called here")

 	}

-	GetBlockSize = func(fd uintptr, size *uint64) sysErrno {

-		panic("GetBlockSize: this method should not be called here")

-	}

 	LogWithErrnoInit = func() {

 		panic("LogWithErrnoInit: this method should not be called here")

 	}

@@ -157,11 +148,10 @@ func (r Set) Assert(t *testing.T, names ...string) {

 func TestInit(t *testing.T) {

 	var (

-		calls           = make(Set)

-		devicesAttached = make(Set)

-		taskMessages    = make(Set)

-		taskTypes       = make(Set)

-		home            = mkTestDirectory(t)

+		calls        = make(Set)

+		taskMessages = make(Set)

+		taskTypes    = make(Set)

+		home         = mkTestDirectory(t)

 	)

 	defer osRemoveAll(home)

@@ -235,29 +225,6 @@ func TestInit(t *testing.T) {

 			taskMessages[message] = true

 			return 1

 		}

-		var (

-			fakeDataLoop       = "/dev/loop42"

-			fakeMetadataLoop   = "/dev/loop43"

-			fakeDataLoopFd     = 42

-			fakeMetadataLoopFd = 43

-		)

-		var attachCount int

-		DmAttachLoopDevice = func(filename string, fd *int) string {

-			calls["DmAttachLoopDevice"] = true

-			if _, exists := devicesAttached[filename]; exists {

-				t.Fatalf("Already attached %s", filename)

-			}

-			devicesAttached[filename] = true

-			// This will crash if fd is not dereferenceable

-			if attachCount == 0 {

-				attachCount++

-				*fd = fakeDataLoopFd

-				return fakeDataLoop

-			} else {

-				*fd = fakeMetadataLoopFd

-				return fakeMetadataLoop

-			}

-		}

 		DmTaskDestroy = func(task *CDmTask) {

 			calls["DmTaskDestroy"] = true

 			expectedTask := &task1

@@ -265,14 +232,6 @@ func TestInit(t *testing.T) {

 				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskDestroy(%v)\nReceived: DmTaskDestroy(%v)\n", expectedTask, task)

 			}

 		}

-		fakeBlockSize := int64(4242 * 512)

-		DmGetBlockSize = func(fd uintptr) (int64, sysErrno) {

-			calls["DmGetBlockSize"] = true

-			if expectedFd := uintptr(42); fd != expectedFd {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmGetBlockSize(%v)\nReceived: DmGetBlockSize(%v)\n", expectedFd, fd)

-			}

-			return fakeBlockSize, 0

-		}

 		DmTaskAddTarget = func(task *CDmTask, start, size uint64, ttype, params string) int {

 			calls["DmTaskSetTarget"] = true

 			expectedTask := &task1

@@ -347,11 +306,9 @@ func TestInit(t *testing.T) {

 		"DmTaskSetName",

 		"DmTaskRun",

 		"DmTaskGetInfo",

-		"DmAttachLoopDevice",

 		"DmTaskDestroy",

 		"execRun",

 		"DmTaskCreate",

-		"DmGetBlockSize",

 		"DmTaskSetTarget",

 		"DmTaskSetCookie",

 		"DmUdevWait",

@@ -359,7 +316,6 @@ func TestInit(t *testing.T) {

 		"DmTaskSetMessage",

 		"DmTaskSetAddNode",

 	)

-	devicesAttached.Assert(t, path.Join(home, "devicemapper", "data"), path.Join(home, "devicemapper", "metadata"))

 	taskTypes.Assert(t, "0", "6", "17")

 	taskMessages.Assert(t, "create_thin 0", "set_transaction_id 0 1")

 }

@@ -410,17 +366,9 @@ func mockAllDevmapper(calls Set) {

 		calls["DmTaskSetMessage"] = true

 		return 1

 	}

-	DmAttachLoopDevice = func(filename string, fd *int) string {

-		calls["DmAttachLoopDevice"] = true

-		return "/dev/loop42"

-	}

 	DmTaskDestroy = func(task *CDmTask) {

 		calls["DmTaskDestroy"] = true

 	}

-	DmGetBlockSize = func(fd uintptr) (int64, sysErrno) {

-		calls["DmGetBlockSize"] = true

-		return int64(4242 * 512), 0

-	}

 	DmTaskAddTarget = func(task *CDmTask, start, size uint64, ttype, params string) int {

 		calls["DmTaskSetTarget"] = true