Merge lp:~ubuntu-branches/ubuntu/quantal/lxc/quantal-201208251712 into lp:ubuntu/quantal/lxc

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/quantal/lxc reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/quantal/lxc/quantal-201208251712. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

146. By Stéphane Graber on 2012-08-25

Get rid of debian/local/lxc-wait

145. By Stéphane Graber on 2012-08-25

releasing version 0.8.0~rc1-4ubuntu29

144. By Stéphane Graber on 2012-08-25

Fix get_ips() timeout and add import time warning

143. By Serge Hallyn on 2012-08-24

move fn up before use.

142. By Serge Hallyn on 2012-08-24

add needed fn prototype before use.

141. By Serge Hallyn on 2012-08-24

0202-make-api-start-reliable: have daemonized start through the api
wait until the container is RUNNING before returning true. If a 5
second timeout is hit before the container is RUNNING, return false.

140. By Serge Hallyn on 2012-08-24

rename 201-fix-mkdir-race to 0201-fix-mkdir-race

139. By Serge Hallyn on 2012-08-24

add missing directories for new patch.
reset pocket to unreleased for push to parent

138. By Serge Hallyn on 2012-08-24

set version and release pocket for ppa build.

137. By Serge Hallyn on 2012-08-24

201-fix-mkdir-race: don't raise error if mkdir fails with EEXIST.

=== added directory '.pc/0201-fix-mkdir-race'
=== renamed directory '.pc/0201-fix-mkdir-race' => '.pc/0201-fix-mkdir-race.moved'
=== added file '.pc/0201-fix-mkdir-race/.timestamp'
=== added directory '.pc/0201-fix-mkdir-race/src'
=== added directory '.pc/0201-fix-mkdir-race/src/lxc'
=== added file '.pc/0201-fix-mkdir-race/src/lxc/cgroup.c'
--- .pc/0201-fix-mkdir-race/src/lxc/cgroup.c	1970-01-01 00:00:00 +0000
+++ .pc/0201-fix-mkdir-race/src/lxc/cgroup.c	2012-08-25 17:20:25 +0000
@@ -0,0 +1,669 @@
+/*
+ * lxc: linux Container library
+ *
+ * (C) Copyright IBM Corp. 2007, 2008
+ *
+ * Authors:
+ * Daniel Lezcano <dlezcano at fr.ibm.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+#include <stdlib.h>
+#include <errno.h>
+#include <mntent.h>
+#include <unistd.h>
+#include <string.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <sys/inotify.h>
+#include <netinet/in.h>
+#include <net/if.h>
+
+#include "error.h"
+#include "config.h"
+
+#include <lxc/log.h>
+#include <lxc/cgroup.h>
+#include <lxc/start.h>
+
+lxc_log_define(lxc_cgroup, lxc);
+
+#define MTAB "/proc/mounts"
+
+enum {
+	CGROUP_NS_CGROUP = 1,
+	CGROUP_CLONE_CHILDREN,
+};
+
+static char *hasmntopt_multiple(struct mntent *mntent, const char *options)
+{
+	const char *ptr = options;
+	const char *ptr2 = strchr(options, ',');
+	char *result;
+
+	while (ptr2 != NULL) {
+		char *option = strndup(ptr, ptr2 - ptr);
+		if (!option) {
+			SYSERROR("Temporary memory allocation error");
+			return NULL;
+		}
+
+		result = hasmntopt(mntent, option);
+		free(option);
+
+		if (!result) {
+			return NULL;
+		}
+
+		ptr = ptr2 + 1;
+		ptr2 = strchr(ptr, ',');
+	}
+
+	/* for multiple mount options, the return value is basically NULL
+	 * or non-NULL, so this should suffice for our purposes */
+	return hasmntopt(mntent, ptr);
+}
+
+/*
+ * get_init_cgroup: get the cgroup init is in.
+ *  dsg: preallocated buffer to put the output in
+ *  subsystem: the exact cgroup subsystem to look up
+ *  mntent: a mntent (from getmntent) whose mntopts contains the
+ *          subsystem to look up.
+ *
+ * subsystem and mntent can both be NULL, in which case we return
+ * the first entry in /proc/1/cgroup.
+ *
+ * Returns a pointer to the answer, which may be "".
+ */
+static char *get_init_cgroup(const char *subsystem, struct mntent *mntent,
+			     char *dsg)
+{
+	FILE *f;
+	char *c, *c2;
+	char line[MAXPATHLEN];
+
+	*dsg = '\0';
+	f = fopen("/proc/1/cgroup", "r");
+	if (!f)
+		return dsg;
+
+	while (fgets(line, MAXPATHLEN, f)) {
+		c = index(line, ':');
+		if (!c)
+			continue;
+		c++;
+		c2 = index(c, ':');
+		if (!c2)
+			continue;
+		*c2 = '\0';
+		c2++;
+		if (!subsystem && !mntent)
+			goto good;
+		if (subsystem && strcmp(c, subsystem) != 0)
+			continue;
+		if (mntent && !hasmntopt(mntent, c))
+			continue;
+good:
+		DEBUG("get_init_cgroup: found init cgroup for subsys %s at %s\n",
+			subsystem, c2);
+		strncpy(dsg, c2, MAXPATHLEN);
+		c = &dsg[strlen(dsg)-1];
+		if (*c == '\n')
+			*c = '\0';
+		goto found;
+	}
+
+found:
+	fclose(f);
+	return dsg;
+}
+
+static int get_cgroup_mount(const char *subsystem, char *mnt)
+{
+	struct mntent *mntent;
+	char initcgroup[MAXPATHLEN];
+	FILE *file = NULL;
+
+	file = setmntent(MTAB, "r");
+	if (!file) {
+		SYSERROR("failed to open %s", MTAB);
+		return -1;
+	}
+
+	while ((mntent = getmntent(file))) {
+
+		if (strcmp(mntent->mnt_type, "cgroup"))
+			continue;
+		if (!subsystem || hasmntopt_multiple(mntent, subsystem)) {
+			int ret;
+			ret = snprintf(mnt, MAXPATHLEN, "%s%s/lxc",
+				       mntent->mnt_dir,
+				       get_init_cgroup(subsystem, NULL,
+						       initcgroup));
+			if (ret < 0 || ret >= MAXPATHLEN)
+				goto fail;
+			fclose(file);
+			DEBUG("using cgroup mounted at '%s'", mnt);
+			return 0;
+		}
+	};
+
+fail:
+	DEBUG("Failed to find cgroup for %s\n",
+	      subsystem ? subsystem : "(NULL)");
+
+	fclose(file);
+
+	return -1;
+}
+
+int lxc_ns_is_mounted(void)
+{
+	static char        buf[MAXPATHLEN];
+
+	return (get_cgroup_mount("ns", buf) == 0);
+}
+
+static int get_cgroup_flags(struct mntent *mntent)
+{
+	int flags = 0;
+
+
+	if (hasmntopt(mntent, "ns"))
+		flags |= CGROUP_NS_CGROUP;
+
+	if (hasmntopt(mntent, "clone_children"))
+		flags |= CGROUP_CLONE_CHILDREN;
+
+	DEBUG("cgroup %s has flags 0x%x", mntent->mnt_dir, flags);
+	return flags;
+}
+
+static int cgroup_rename_nsgroup(const char *mnt, const char *name, pid_t pid)
+{
+	char oldname[MAXPATHLEN];
+	int ret;
+
+	ret = snprintf(oldname, MAXPATHLEN, "%s/%d", mnt, pid);
+	if (ret < 0 || ret >= MAXPATHLEN) {
+		ERROR("Name too long");
+		return -1;
+	}
+
+	if (rename(oldname, name)) {
+		SYSERROR("failed to rename cgroup %s->%s", oldname, name);
+		return -1;
+	}
+
+	DEBUG("'%s' renamed to '%s'", oldname, name);
+
+	return 0;
+}
+
+static int cgroup_enable_clone_children(const char *path)
+{
+	FILE *f;
+	int ret = 0;
+
+	f = fopen(path, "w");
+	if (!f) {
+		SYSERROR("failed to open '%s'", path);
+		return -1;
+	}
+
+	if (fprintf(f, "1") < 1) {
+		ERROR("failed to write flag to '%s'", path);
+		ret = -1;
+	}
+
+	fclose(f);
+
+	return ret;
+}
+
+int lxc_cgroup_attach(const char *path, pid_t pid)
+{
+	FILE *f;
+	char tasks[MAXPATHLEN];
+	int ret = 0;
+	int rc;
+
+	rc = snprintf(tasks, MAXPATHLEN, "%s/tasks", path);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("pathname too long");
+		return -1;
+	}
+
+	f = fopen(tasks, "w");
+	if (!f) {
+		SYSERROR("failed to open '%s'", tasks);
+		return -1;
+	}
+
+	if (fprintf(f, "%d", pid) <= 0) {
+		SYSERROR("failed to write pid '%d' to '%s'", pid, tasks);
+		ret = -1;
+	}
+
+	fclose(f);
+
+	return ret;
+}
+
+/*
+ * rename cgname, which is under cgparent, to a new name starting
+ * with 'cgparent/dead'.  That way cgname can be reused.  Return
+ * 0 on success, -1 on failure.
+ */
+int try_to_move_cgname(char *cgparent, char *cgname)
+{
+	char *newdir;
+
+	/* tempnam problems don't matter here - cgroupfs will prevent
+	 * duplicates if we race, and we'll just fail at that (unlikely)
+	 * point
+	 */
+
+	newdir = tempnam(cgparent, "dead");
+	if (!newdir)
+		return -1;
+	if (rename(cgname, newdir))
+		return -1;
+	WARN("non-empty cgroup %s renamed to %s, please manually inspect it\n",
+		cgname, newdir);
+
+	return 0;
+}
+
+/*
+ * create a cgroup for the container in a particular subsystem.
+ */
+static int lxc_one_cgroup_create(const char *name,
+				 struct mntent *mntent, pid_t pid)
+{
+	char cginit[MAXPATHLEN], cgname[MAXPATHLEN], cgparent[MAXPATHLEN];
+	char clonechild[MAXPATHLEN];
+	char initcgroup[MAXPATHLEN];
+	int flags, ret;
+
+	/* cgparent is the parent dir, /sys/fs/cgroup/<cgroup>/<init-cgroup>/lxc */
+	/* (remember get_init_cgroup() returns a path starting with '/') */
+	/* cgname is the full name,    /sys/fs/cgroup/</cgroup>/<init-cgroup>/lxc/name */
+	ret = snprintf(cginit, MAXPATHLEN, "%s%s", mntent->mnt_dir,
+		get_init_cgroup(NULL, mntent, initcgroup));
+	if (ret < 0 || ret >= MAXPATHLEN) {
+		SYSERROR("Failed creating pathname for init's cgroup (%d)\n", ret);
+		return -1;
+	}
+
+	ret = snprintf(cgparent, MAXPATHLEN, "%s/lxc", cginit);
+	if (ret < 0 || ret >= MAXPATHLEN) {
+		SYSERROR("Failed creating pathname for cgroup parent (%d)\n", ret);
+		return -1;
+	}
+	ret = snprintf(cgname, MAXPATHLEN, "%s/%s", cgparent, name);
+	if (ret < 0 || ret >= MAXPATHLEN) {
+		SYSERROR("Failed creating pathname for cgroup (%d)\n", ret);
+		return -1;
+	}
+
+	flags = get_cgroup_flags(mntent);
+
+	/* Do we have the deprecated ns_cgroup subsystem? */
+	if (flags & CGROUP_NS_CGROUP) {
+		WARN("using deprecated ns_cgroup");
+		return cgroup_rename_nsgroup(cgparent, cgname, pid);
+	}
+
+	ret = snprintf(clonechild, MAXPATHLEN, "%s/cgroup.clone_children",
+		       cginit);
+	if (ret < 0 || ret >= MAXPATHLEN) {
+		SYSERROR("Failed creating pathname for clone_children (%d)\n", ret);
+		return -1;
+	}
+
+	/* we check if the kernel has clone_children, at this point if there
+	 * no clone_children neither ns_cgroup, that means the cgroup is mounted
+	 * without the ns_cgroup and it has not the compatibility flag
+	 */
+	if (access(clonechild, F_OK)) {
+		ERROR("no ns_cgroup option specified");
+		return -1;
+	}
+
+	/* enable the clone_children flag of the cgroup */
+	if (cgroup_enable_clone_children(clonechild)) {
+		SYSERROR("failed to enable 'clone_children flag");
+		return -1;
+	}
+
+	/* if /sys/fs/cgroup/<cgroup>/<init-cgroup>/lxc does not exist, create it */
+	if (access(cgparent, F_OK) && mkdir(cgparent, 0755)) {
+		SYSERROR("failed to create '%s' directory", cgparent);
+		return -1;
+	}
+
+	/*
+	 * There is a previous cgroup.  Try to delete it.  If that fails
+	 * (i.e. it is not empty) try to move it out of the way.
+	 */
+	if (!access(cgname, F_OK) && rmdir(cgname)) {
+		if (try_to_move_cgname(cgparent, cgname)) {
+			SYSERROR("failed to remove previous cgroup '%s'", cgname);
+			return -1;
+		}
+	}
+
+	/* Let's create the cgroup */
+	if (mkdir(cgname, 0755)) {
+		SYSERROR("failed to create '%s' directory", cgname);
+		return -1;
+	}
+
+	/* Let's add the pid to the 'tasks' file */
+	if (lxc_cgroup_attach(cgname, pid)) {
+		SYSERROR("failed to attach pid '%d' to '%s'", pid, cgname);
+		rmdir(cgname);
+		return -1;
+	}
+
+	INFO("created cgroup '%s'", cgname);
+
+	return 0;
+}
+
+/*
+ * for each mounted cgroup, create a cgroup for the container
+ */
+int lxc_cgroup_create(const char *name, pid_t pid)
+{
+	struct mntent *mntent;
+	FILE *file = NULL;
+	int err = -1;
+	int found = 0;
+
+	file = setmntent(MTAB, "r");
+	if (!file) {
+		SYSERROR("failed to open %s", MTAB);
+		return -1;
+	}
+
+	while ((mntent = getmntent(file))) {
+
+		DEBUG("checking '%s' (%s)", mntent->mnt_dir, mntent->mnt_type);
+
+		if (!strcmp(mntent->mnt_type, "cgroup")) {
+
+			INFO("[%d] found cgroup mounted at '%s',opts='%s'",
+			     ++found, mntent->mnt_dir, mntent->mnt_opts);
+
+			err = lxc_one_cgroup_create(name, mntent, pid);
+			if (err)
+				goto out;
+		}
+	};
+
+	if (!found)
+		ERROR("No cgroup mounted on the system");
+
+out:
+	endmntent(file);
+	return err;
+}
+
+int recursive_rmdir(char *dirname)
+{
+	struct dirent dirent, *direntp;
+	DIR *dir;
+	int ret;
+	char pathname[MAXPATHLEN];
+
+	dir = opendir(dirname);
+	if (!dir) {
+		WARN("failed to open directory: %m");
+		return -1;
+	}
+
+	while (!readdir_r(dir, &dirent, &direntp)) {
+		struct stat mystat;
+		int rc;
+
+		if (!direntp)
+			break;
+
+		if (!strcmp(direntp->d_name, ".") ||
+		    !strcmp(direntp->d_name, ".."))
+			continue;
+
+		rc = snprintf(pathname, MAXPATHLEN, "%s/%s", dirname, direntp->d_name);
+		if (rc < 0 || rc >= MAXPATHLEN) {
+			ERROR("pathname too long");
+			continue;
+		}
+		ret = stat(pathname, &mystat);
+		if (ret)
+			continue;
+		if (S_ISDIR(mystat.st_mode))
+			recursive_rmdir(pathname);
+	}
+
+	ret = rmdir(dirname);
+
+	if (closedir(dir))
+		ERROR("failed to close directory");
+	return ret;
+
+
+}
+
+int lxc_one_cgroup_destroy(struct mntent *mntent, const char *name)
+{
+	char cgname[MAXPATHLEN], initcgroup[MAXPATHLEN];
+	char *cgmnt = mntent->mnt_dir;
+	int rc;
+
+	rc = snprintf(cgname, MAXPATHLEN, "%s%s/lxc/%s", cgmnt,
+		get_init_cgroup(NULL, mntent, initcgroup), name);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("name too long");
+		return -1;
+	}
+	DEBUG("destroying %s\n", cgname);
+	if (recursive_rmdir(cgname)) {
+		SYSERROR("failed to remove cgroup '%s'", cgname);
+		return -1;
+	}
+
+	DEBUG("'%s' unlinked", cgname);
+
+	return 0;
+}
+
+/*
+ * for each mounted cgroup, destroy the cgroup for the container
+ */
+int lxc_cgroup_destroy(const char *name)
+{
+	struct mntent *mntent;
+	FILE *file = NULL;
+	int ret, err = -1;
+
+	file = setmntent(MTAB, "r");
+	if (!file) {
+		SYSERROR("failed to open %s", MTAB);
+		return -1;
+	}
+
+	while ((mntent = getmntent(file))) {
+		if (!strcmp(mntent->mnt_type, "cgroup")) {
+			ret = lxc_one_cgroup_destroy(mntent, name);
+			if (ret) {
+				fclose(file);
+				return ret;
+			}
+			err = 0;
+		}
+	}
+
+	fclose(file);
+
+	return err;
+}
+/*
+ * lxc_cgroup_path_get: put into *path the pathname for
+ * %subsystem and cgroup %name.  If %subsystem is NULL, then
+ * the first mounted cgroup will be used (for nr_tasks)
+ */
+int lxc_cgroup_path_get(char **path, const char *subsystem, const char *name)
+{
+	static char        buf[MAXPATHLEN];
+	static char        retbuf[MAXPATHLEN];
+	int rc;
+
+	/* what lxc_cgroup_set calls subsystem is actually the filename, i.e.
+	   'devices.allow'.  So for our purposee we trim it */
+	if (subsystem) {
+		rc = snprintf(retbuf, MAXPATHLEN, "%s", subsystem);
+		if (rc < 0 || rc >= MAXPATHLEN) {
+			ERROR("subsystem name too long");
+			return -1;
+		}
+		char *s = index(retbuf, '.');
+		if (s)
+			*s = '\0';
+		DEBUG("%s: called for subsys %s name %s\n", __func__, retbuf, name);
+	}
+	if (get_cgroup_mount(subsystem ? retbuf : NULL, buf)) {
+		ERROR("cgroup is not mounted");
+		return -1;
+	}
+
+	rc = snprintf(retbuf, MAXPATHLEN, "%s/%s", buf, name);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("name too long");
+		return -1;
+	}
+
+	DEBUG("%s: returning %s for subsystem %s", __func__, retbuf, subsystem);
+
+	*path = retbuf;
+	return 0;
+}
+
+int lxc_cgroup_set(const char *name, const char *filename, const char *value)
+{
+	int fd, ret;
+	char *dirpath;
+	char path[MAXPATHLEN];
+	int rc;
+
+	ret = lxc_cgroup_path_get(&dirpath, filename, name);
+	if (ret)
+		return -1;
+
+	rc = snprintf(path, MAXPATHLEN, "%s/%s", dirpath, filename);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("pathname too long");
+		return -1;
+	}
+
+	fd = open(path, O_WRONLY);
+	if (fd < 0) {
+		ERROR("open %s : %s", path, strerror(errno));
+		return -1;
+	}
+
+	ret = write(fd, value, strlen(value));
+	if (ret < 0) {
+		ERROR("write %s : %s", path, strerror(errno));
+		goto out;
+	}
+
+	ret = 0;
+out:
+	close(fd);
+	return ret;
+}
+
+int lxc_cgroup_get(const char *name, const char *filename,
+		   char *value, size_t len)
+{
+	int fd, ret = -1;
+	char *dirpath;
+	char path[MAXPATHLEN];
+	int rc;
+
+	ret = lxc_cgroup_path_get(&dirpath, filename, name);
+	if (ret)
+		return -1;
+
+	rc = snprintf(path, MAXPATHLEN, "%s/%s", dirpath, filename);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("pathname too long");
+		return -1;
+	}
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0) {
+		ERROR("open %s : %s", path, strerror(errno));
+		return -1;
+	}
+
+	ret = read(fd, value, len);
+	if (ret < 0)
+		ERROR("read %s : %s", path, strerror(errno));
+
+	close(fd);
+	return ret;
+}
+
+int lxc_cgroup_nrtasks(const char *name)
+{
+	char *dpath;
+	char path[MAXPATHLEN];
+	int pid, ret, count = 0;
+	FILE *file;
+	int rc;
+
+	ret = lxc_cgroup_path_get(&dpath, NULL, name);
+	if (ret)
+		return -1;
+
+	rc = snprintf(path, MAXPATHLEN, "%s/tasks", dpath);
+	if (rc < 0 || rc >= MAXPATHLEN) {
+		ERROR("pathname too long");
+		return -1;
+	}
+
+	file = fopen(path, "r");
+	if (!file) {
+		SYSERROR("fopen '%s' failed", path);
+		return -1;
+	}
+
+	while (fscanf(file, "%d", &pid) != EOF)
+		count++;
+
+	fclose(file);
+
+	return count;
+}

=== added directory '.pc/0202-make-api-start-reliable'
=== renamed directory '.pc/0202-make-api-start-reliable' => '.pc/0202-make-api-start-reliable.moved'
=== added file '.pc/0202-make-api-start-reliable/.timestamp'
=== added directory '.pc/0202-make-api-start-reliable/src'
=== added directory '.pc/0202-make-api-start-reliable/src/lxc'
=== added file '.pc/0202-make-api-start-reliable/src/lxc/lxccontainer.c'
--- .pc/0202-make-api-start-reliable/src/lxc/lxccontainer.c	1970-01-01 00:00:00 +0000
+++ .pc/0202-make-api-start-reliable/src/lxc/lxccontainer.c	2012-08-25 17:20:25 +0000
@@ -0,0 +1,905 @@
+/* liblxcapi
+ *
+ * Copyright © 2012 Serge Hallyn <[e-mail]>.
+ * Copyright © 2012 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "lxc.h"
+#include "state.h"
+#include "lxccontainer.h"
+#include "conf.h"
+#include "config.h"
+#include "confile.h"
+#include "cgroup.h"
+#include "commands.h"
+#include "log.h"
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+lxc_log_define(lxc_container, lxc);
+
+/* LOCKING
+ * c->privlock protects the struct lxc_container from multiple threads.
+ * c->slock protects the on-disk container data
+ * NOTHING mutexes two independent programs with their own struct
+ * lxc_container for the same c->name, between API calls.  For instance,
+ * c->config_read(); c->start();  Between those calls, data on disk
+ * could change (which shouldn't bother the caller unless for instance
+ * the rootfs get moved).  c->config_read(); update; c->config_write();
+ * Two such updaters could race.  The callers should therefore check their
+ * results.  Trying to prevent that would necessarily expose us to deadlocks
+ * due to hung callers.  So I prefer to keep the locks only within our own
+ * functions, not across functions.
+ *
+ * If you're going to fork while holding a lxccontainer, increment
+ * c->numthreads (under privlock) before forking.  When deleting,
+ * decrement numthreads under privlock, then if it hits 0 you can delete.
+ * Do not ever use a lxccontainer whose numthreads you did not bump.
+ */
+
+static void lxc_container_free(struct lxc_container *c)
+{
+	if (!c)
+		return;
+
+	if (c->configfile) {
+		free(c->configfile);
+		c->configfile = NULL;
+	}
+	if (c->error_string) {
+		free(c->error_string);
+		c->error_string = NULL;
+	}
+	if (c->privlock) {
+		sem_destroy(c->privlock);
+		free(c->privlock);
+		c->privlock = NULL;
+	}
+	if (c->name) {
+		free(c->name);
+		c->name = NULL;
+	}
+	/*
+	 * XXX TODO
+	 * note, c->lxc_conf is going to have to be freed, but the fn
+	 * to do that hasn't been written yet near as I can tell
+	 */
+	free(c);
+}
+
+int lxc_container_get(struct lxc_container *c)
+{
+	if (!c)
+		return 0;
+
+	if (lxclock(c->privlock, 0))
+		return 0;
+	if (c->numthreads < 1) {
+		// bail without trying to unlock, bc the privlock is now probably
+		// in freed memory
+		return 0;
+	}
+	c->numthreads++;
+	lxcunlock(c->privlock);
+	return 1;
+}
+
+int lxc_container_put(struct lxc_container *c)
+{
+	if (!c)
+		return -1;
+	if (lxclock(c->privlock, 0))
+		return -1;
+	if (--c->numthreads < 1) {
+		lxcunlock(c->privlock);
+		lxc_container_free(c);
+		return 1;
+	}
+	lxcunlock(c->privlock);
+	return 0;
+}
+
+static bool file_exists(char *f)
+{
+	struct stat statbuf;
+
+	return stat(f, &statbuf) == 0;
+}
+
+static bool lxcapi_is_defined(struct lxc_container *c)
+{
+	struct stat statbuf;
+	bool ret = false;
+	int statret;
+
+	if (!c)
+		return false;
+
+	if (lxclock(c->privlock, 0))
+		return false;
+	if (!c->configfile)
+		goto out;
+	statret = stat(c->configfile, &statbuf);
+	if (statret != 0)
+		goto out;
+	ret = true;
+
+out:
+	lxcunlock(c->privlock);
+	return ret;
+}
+
+static const char *lxcapi_state(struct lxc_container *c)
+{
+	const char *ret;
+	lxc_state_t s;
+
+	if (!c)
+		return NULL;
+	if (lxclock(c->slock, 0))
+		return NULL;
+	s = lxc_getstate(c->name);
+	ret = lxc_state2str(s);
+	lxcunlock(c->slock);
+
+	return ret;
+}
+
+static bool lxcapi_is_running(struct lxc_container *c)
+{
+	const char *s;
+
+	if (!c)
+		return false;
+	s = lxcapi_state(c);
+	if (!s || strcmp(s, "STOPPED") == 0)
+		return false;
+	return true;
+}
+
+static bool lxcapi_freeze(struct lxc_container *c)
+{
+	int ret;
+	if (!c)
+		return false;
+
+	if (lxclock(c->slock, 0))
+		return false;
+	ret = lxc_freeze(c->name);
+	lxcunlock(c->slock);
+	if (ret)
+		return false;
+	return true;
+}
+
+static bool lxcapi_unfreeze(struct lxc_container *c)
+{
+	int ret;
+	if (!c)
+		return false;
+
+	if (lxclock(c->slock, 0))
+		return false;
+	ret = lxc_unfreeze(c->name);
+	lxcunlock(c->slock);
+	if (ret)
+		return false;
+	return true;
+}
+
+static pid_t lxcapi_init_pid(struct lxc_container *c)
+{
+	pid_t ret;
+	if (!c)
+		return -1;
+
+	if (lxclock(c->slock, 0))
+		return -1;
+	ret = get_init_pid(c->name);
+	lxcunlock(c->slock);
+	return ret;
+}
+
+static bool lxcapi_load_config(struct lxc_container *c, char *alt_file)
+{
+	bool ret = false;
+	char *fname;
+	if (!c)
+		return false;
+
+	fname = c->configfile;
+	if (alt_file)
+		fname = alt_file;
+	if (!fname)
+		return false;
+	if (lxclock(c->slock, 0))
+		return false;
+	if (!c->lxc_conf)
+		c->lxc_conf = lxc_conf_init();
+	if (c->lxc_conf && !lxc_config_read(fname, c->lxc_conf))
+		ret = true;
+	lxcunlock(c->slock);
+	return ret;
+}
+
+static void lxcapi_want_daemonize(struct lxc_container *c)
+{
+	if (!c)
+		return;
+	c->daemonize = 1;
+}
+
+/*
+ * I can't decide if it'd be more convenient for callers if we accept '...',
+ * or a null-terminated array (i.e. execl vs execv)
+ */
+static bool lxcapi_start(struct lxc_container *c, int useinit, char ** argv)
+{
+	int ret;
+	struct lxc_conf *conf;
+	int daemonize = 0;
+	char *default_args[] = {
+		"/sbin/init",
+		'\0',
+	};
+
+	/* container exists */
+	if (!c)
+		return false;
+	/* container has been setup */
+	if (!c->lxc_conf)
+		return false;
+
+	/* is this app meant to be run through lxcinit, as in lxc-execute? */
+	if (useinit && !argv)
+		return false;
+
+	if (lxclock(c->privlock, 0))
+		return false;
+	conf = c->lxc_conf;
+	daemonize = c->daemonize;
+	lxcunlock(c->privlock);
+
+	if (useinit) {
+		ret = lxc_execute(c->name, argv, 1, conf);
+		return ret == 0 ? true : false;
+	}
+
+	if (!argv)
+		argv = default_args;
+
+	/*
+	* say, I'm not sure - what locks do we want here?  Any?
+	* Is liblxc's locking enough here to protect the on disk
+	* container?  We don't want to exclude things like lxc_info
+	* while container is running...
+	*/
+	if (daemonize) {
+		if (!lxc_container_get(c))
+			return false;
+		pid_t pid = fork();
+		if (pid < 0) {
+			lxc_container_put(c);
+			return false;
+		}
+		if (pid != 0)
+			return true;
+		/* like daemon(), chdir to / and redirect 0,1,2 to /dev/null */
+		chdir("/");
+		close(0);
+		close(1);
+		close(2);
+		open("/dev/null", O_RDONLY);
+		open("/dev/null", O_RDWR);
+		open("/dev/null", O_RDWR);
+		setsid();
+	}
+
+	if (putenv("container=lxc")) {
+		fprintf(stderr, "failed to set environment variable");
+		if (daemonize) {
+			lxc_container_put(c);
+			exit(1);
+		} else {
+			return false;
+		}
+	}
+
+reboot:
+	conf->reboot = 0;
+	ret = lxc_start(c->name, argv, conf);
+
+	if (conf->reboot) {
+		INFO("container requested reboot");
+		conf->reboot = 0;
+		if (conf->maincmd_fd)
+			close(conf->maincmd_fd);
+		conf->maincmd_fd = 0;
+		goto reboot;
+	}
+
+	if (daemonize) {
+		lxc_container_put(c);
+		exit (ret == 0 ? true : false);
+	} else {
+		return (ret == 0 ? true : false);
+	}
+}
+
+/*
+ * note there MUST be an ending NULL
+ */
+static bool lxcapi_startl(struct lxc_container *c, int useinit, ...)
+{
+	va_list ap;
+	char **inargs = NULL, **temp;
+	int n_inargs = 0;
+	bool bret = false;
+
+	/* container exists */
+	if (!c)
+		return false;
+
+	/* build array of arguments if any */
+	va_start(ap, useinit);
+	while (1) {
+		char *arg;
+		arg = va_arg(ap, char *);
+		if (!arg)
+			break;
+		n_inargs++;
+		temp = realloc(inargs, n_inargs * sizeof(*inargs));
+		if (!temp)
+			goto out;
+		inargs = temp;
+		inargs[n_inargs - 1] = strdup(arg);  // not sure if it's safe not to copy
+	}
+	va_end(ap);
+
+	/* add trailing NULL */
+	if (n_inargs) {
+		n_inargs++;
+		temp = realloc(inargs, n_inargs * sizeof(*inargs));
+		if (!temp)
+			goto out;
+		inargs = temp;
+		inargs[n_inargs - 1] = NULL;
+	}
+
+	bret = lxcapi_start(c, useinit, inargs);
+
+out:
+	if (inargs) {
+		int i;
+		for (i = 0; i < n_inargs; i++) {
+			if (inargs[i])
+				free(inargs[i]);
+		}
+		free(inargs);
+	}
+
+	return bret;
+}
+
+static bool lxcapi_stop(struct lxc_container *c)
+{
+	int ret;
+
+	if (!c)
+		return false;
+
+	ret = lxc_stop(c->name);
+
+	return ret == 0;
+}
+
+static bool lxcapi_wait(struct lxc_container *c, char *state, int timeout)
+{
+	int ret;
+
+	if (!c)
+		return false;
+
+	ret = lxc_wait(c->name, state, timeout);
+	return ret == 0;
+}
+
+static bool valid_template(char *t)
+{
+	struct stat statbuf;
+	int statret;
+
+	statret = stat(t, &statbuf);
+	if (statret == 0)
+		return true;
+	return false;
+}
+
+/*
+ * create the standard expected container dir
+ */
+static bool create_container_dir(struct lxc_container *c)
+{
+	char *s;
+	int len, ret;
+
+	len = strlen(LXCPATH) + strlen(c->name) + 2;
+	s = malloc(len);
+	if (!s)
+		return false;
+	ret = snprintf(s, len, "%s/%s", LXCPATH, c->name);
+	if (ret < 0 || ret >= len) {
+		free(s);
+		return false;
+	}
+	ret = mkdir(s, 0755);
+	if (ret) {
+		if (errno == EEXIST)
+			ret = 0;
+		else
+			SYSERROR("failed to create container path for %s\n", c->name);
+	}
+	free(s);
+	return ret == 0;
+}
+
+/*
+ * backing stores not (yet) supported
+ * for ->create, argv contains the arguments to pass to the template,
+ * terminated by NULL.  If no arguments, you can just pass NULL.
+ */
+static bool lxcapi_create(struct lxc_container *c, char *t, char **argv)
+{
+	bool bret = false;
+	pid_t pid;
+	int ret, status;
+	char *tpath = NULL;
+	int len, nargs = 0;
+	char **newargv;
+
+	if (!c)
+		return false;
+
+	len = strlen(LXCTEMPLATEDIR) + strlen(t) + strlen("/lxc-") + 1;
+	tpath = malloc(len);
+	if (!tpath)
+		return false;
+	ret = snprintf(tpath, len, "%s/lxc-%s", LXCTEMPLATEDIR, t);
+	if (ret < 0 || ret >= len)
+		goto out;
+	if (!valid_template(tpath)) {
+		ERROR("bad template: %s\n", t);
+		goto out;
+	}
+
+	if (!create_container_dir(c))
+		goto out;
+
+	if (!c->save_config(c, NULL)) {
+		ERROR("failed to save starting configuration for %s\n", c->name);
+		goto out;
+	}
+
+	/* we're going to fork.  but since we'll wait for our child, we
+	   don't need to lxc_container_get */
+
+	if (lxclock(c->slock, 0)) {
+		ERROR("failed to grab global container lock for %s\n", c->name);
+		goto out;
+	}
+
+	pid = fork();
+	if (pid < 0) {
+		SYSERROR("failed to fork task for container creation template\n");
+		goto out_unlock;
+	}
+
+	if (pid == 0) { // child
+		char *patharg, *namearg;
+		int i;
+
+		close(0);
+		close(1);
+		close(2);
+		open("/dev/null", O_RDONLY);
+		open("/dev/null", O_RDWR);
+		open("/dev/null", O_RDWR);
+
+		/*
+		 * create our new array, pre-pend the template name and
+		 * base args
+		 */
+		if (argv)
+			for (; argv[nargs]; nargs++) ;
+		nargs += 3;  // template, path and name args
+		newargv = malloc(nargs * sizeof(*newargv));
+		if (!newargv)
+			exit(1);
+		newargv[0] = t;
+
+		len = strlen(LXCPATH) + strlen(c->name) + strlen("--path=") + 2;
+		patharg = malloc(len);
+		if (!patharg)
+			exit(1);
+		ret = snprintf(patharg, len, "--path=%s/%s", LXCPATH, c->name);
+		if (ret < 0 || ret >= len)
+			exit(1);
+		newargv[1] = patharg;
+		len = strlen("--name=") + strlen(c->name) + 1;
+		namearg = malloc(len);
+		if (!namearg)
+			exit(1);
+		ret = snprintf(namearg, len, "--name=%s", c->name);
+		if (ret < 0 || ret >= len)
+			exit(1);
+		newargv[2] = namearg;
+
+		/* add passed-in args */
+		if (argv)
+			for (i = 3; i < nargs; i++)
+				newargv[i] = argv[i-3];
+
+		/* add trailing NULL */
+		nargs++;
+		newargv = realloc(newargv, nargs * sizeof(*newargv));
+		if (!newargv)
+			exit(1);
+		newargv[nargs - 1] = NULL;
+
+		/* execute */
+		ret = execv(tpath, newargv);
+		SYSERROR("failed to execute template %s", tpath);
+		exit(1);
+	}
+
+again:
+	ret = waitpid(pid, &status, 0);
+	if (ret == -1) {
+		if (errno == -EINTR)
+			goto again;
+		SYSERROR("waitpid failed");
+		goto out_unlock;
+	}
+	if (ret != pid)
+		goto again;
+	if (!WIFEXITED(status))  { // did not exit normally
+		// we could set an error code and string inside the
+		// container_struct here if we like
+		ERROR("container creation template exited abnormally\n");
+		goto out_unlock;
+	}
+
+	if (WEXITSTATUS(status) != 0)
+		ERROR("container creation template for %s exited with %d\n",
+		      c->name, WEXITSTATUS(status));
+	else
+		bret = true;
+
+out_unlock:
+	lxcunlock(c->slock);
+out:
+	if (tpath)
+		free(tpath);
+	return bret;
+}
+
+static bool lxcapi_shutdown(struct lxc_container *c, int timeout)
+{
+	bool retv;
+	pid_t pid;
+
+	if (!c)
+		return false;
+
+	if (!timeout)
+		timeout = -1;
+	if (!c->is_running(c))
+		return true;
+	pid = c->init_pid(c);
+	if (pid <= 0)
+		return true;
+	kill(pid, SIGPWR);
+	retv = c->wait(c, "STOPPED", timeout);
+	if (timeout > 0) {
+		c->stop(c);
+		retv = c->wait(c, "STOPPED", 0); // 0 means don't wait
+	}
+	return retv;
+}
+
+static bool lxcapi_createl(struct lxc_container *c, char *t, ...)
+{
+	bool bret = false;
+	char **args = NULL, **temp;
+	va_list ap;
+	int nargs = 0;
+
+	if (!c)
+		return false;
+
+	/*
+	 * since we're going to wait for create to finish, I don't think we
+	 * need to get a copy of the arguments.
+	 */
+	va_start(ap, t);
+	while (1) {
+		char *arg;
+		arg = va_arg(ap, char *);
+		if (!arg)
+			break;
+		nargs++;
+		temp = realloc(args, nargs * sizeof(*args));
+		if (!temp)
+			goto out;
+		args = temp;
+		args[nargs - 1] = arg;
+	}
+	va_end(ap);
+
+	bret = c->create(c, t, args);
+
+out:
+	if (args)
+		free(args);
+	return bret;
+}
+
+static bool lxcapi_clear_config_item(struct lxc_container *c, char *key)
+{
+	int ret;
+
+	if (!c || !c->lxc_conf)
+		return false;
+	if (lxclock(c->privlock, 0)) {
+		return false;
+	}
+	ret = lxc_clear_config_item(c->lxc_conf, key);
+	lxcunlock(c->privlock);
+	return ret == 0;
+}
+
+static int lxcapi_get_config_item(struct lxc_container *c, char *key, char *retv, int inlen)
+{
+	int ret;
+
+	if (!c || !c->lxc_conf)
+		return -1;
+	if (lxclock(c->privlock, 0)) {
+		return -1;
+	}
+	ret = lxc_get_config_item(c->lxc_conf, key, retv, inlen);
+	lxcunlock(c->privlock);
+	return ret;
+}
+
+static int lxcapi_get_keys(struct lxc_container *c, char *key, char *retv, int inlen)
+{
+	if (!key)
+		return lxc_listconfigs(retv, inlen);
+	/*
+	 * Support 'lxc.network.<idx>', i.e. 'lxc.network.0'
+	 * This is an intelligent result to show which keys are valid given
+	 * the type of nic it is
+	 */
+	if (!c || !c->lxc_conf)
+		return -1;
+	if (lxclock(c->privlock, 0))
+		return -1;
+	int ret = -1;
+	if (strncmp(key, "lxc.network.", 12) == 0)
+		ret =  lxc_list_nicconfigs(c->lxc_conf, key, retv, inlen);
+	lxcunlock(c->privlock);
+	return ret;
+}
+
+
+/* default config file - should probably come through autoconf */
+#define LXC_DEFAULT_CONFIG "/etc/lxc/lxc.conf"
+static bool lxcapi_save_config(struct lxc_container *c, char *alt_file)
+{
+	if (!alt_file)
+		alt_file = c->configfile;
+	if (!alt_file)
+		return false;  // should we write to stdout if no file is specified?
+	if (!c->lxc_conf)
+		if (!c->load_config(c, LXC_DEFAULT_CONFIG)) {
+			ERROR("Error loading default configuration file %s while saving %s\n", LXC_DEFAULT_CONFIG, c->name);
+			return false;
+		}
+
+	FILE *fout = fopen(alt_file, "w");
+	if (!fout)
+		return false;
+	if (lxclock(c->privlock, 0)) {
+		fclose(fout);
+		return false;
+	}
+	write_config(fout, c->lxc_conf);
+	fclose(fout);
+	lxcunlock(c->privlock);
+	return true;
+}
+
+static bool lxcapi_destroy(struct lxc_container *c)
+{
+	pid_t pid;
+	int ret, status;
+
+	if (!c)
+		return false;
+
+	pid = fork();
+	if (pid < 0)
+		return false;
+	if (pid == 0) { // child
+		ret = execlp("lxc-destroy", "lxc-destroy", "-n", c->name, NULL);
+		perror("execl");
+		exit(1);
+	}
+
+again:
+	ret = waitpid(pid, &status, 0);
+	if (ret == -1) {
+		if (errno == -EINTR)
+			goto again;
+		perror("waitpid");
+		return false;
+	}
+	if (ret != pid)
+		goto again;
+	if (!WIFEXITED(status))  { // did not exit normally
+		// we could set an error code and string inside the
+		// container_struct here if we like
+		return false;
+	}
+
+	return WEXITSTATUS(status) == 0;
+}
+
+static bool lxcapi_set_config_item(struct lxc_container *c, char *key, char *v)
+{
+	int ret;
+	bool b = false;
+	struct lxc_config_t *config;
+
+	if (!c)
+		return false;
+
+	if (lxclock(c->privlock, 0))
+		return false;
+
+	if (!c->lxc_conf)
+		c->lxc_conf = lxc_conf_init();
+	if (!c->lxc_conf)
+		goto err;
+	config = lxc_getconfig(key);
+	if (!config)
+		goto err;
+	ret = config->cb(key, v, c->lxc_conf);
+	if (!ret)
+		b = true;
+
+err:
+	lxcunlock(c->privlock);
+	return b;
+}
+
+static char *lxcapi_config_file_name(struct lxc_container *c)
+{
+	if (!c || !c->configfile)
+		return NULL;
+	return strdup(c->configfile);
+}
+
+struct lxc_container *lxc_container_new(char *name)
+{
+	struct lxc_container *c;
+	int ret, len;
+
+	c = malloc(sizeof(*c));
+	if (!c) {
+		fprintf(stderr, "failed to malloc lxc_container\n");
+		return NULL;
+	}
+	memset(c, 0, sizeof(*c));
+
+	c->name = malloc(strlen(name)+1);
+	if (!c->name) {
+		fprintf(stderr, "Error allocating lxc_container name\n");
+		goto err;
+	}
+	strcpy(c->name, name);
+
+	c->numthreads = 1;
+	c->slock = lxc_newlock(name);
+	if (!c->slock) {
+		fprintf(stderr, "failed to create lock\n");
+		goto err;
+	}
+
+	c->privlock = lxc_newlock(NULL);
+	if (!c->privlock) {
+		fprintf(stderr, "failed to alloc privlock\n");
+		goto err;
+	}
+
+	len = strlen(LXCDIR)+strlen(c->name)+strlen("/config")+2;
+	c->configfile = malloc(len);
+	if (!c->configfile) {
+		fprintf(stderr, "Error allocating config file pathname\n");
+		goto err;
+	}
+	ret = snprintf(c->configfile, len, "%s/%s/config", LXCDIR, c->name);
+	if (ret < 0 || ret >= len) {
+		fprintf(stderr, "Error printing out config file name\n");
+		goto err;
+	}
+
+	if (file_exists(c->configfile))
+		lxcapi_load_config(c, NULL);
+
+	// assign the member functions
+	c->is_defined = lxcapi_is_defined;
+	c->state = lxcapi_state;
+	c->is_running = lxcapi_is_running;
+	c->freeze = lxcapi_freeze;
+	c->unfreeze = lxcapi_unfreeze;
+	c->init_pid = lxcapi_init_pid;
+	c->load_config = lxcapi_load_config;
+	c->want_daemonize = lxcapi_want_daemonize;
+	c->start = lxcapi_start;
+	c->startl = lxcapi_startl;
+	c->stop = lxcapi_stop;
+	c->config_file_name = lxcapi_config_file_name;
+	c->wait = lxcapi_wait;
+	c->set_config_item = lxcapi_set_config_item;
+	c->destroy = lxcapi_destroy;
+	c->save_config = lxcapi_save_config;
+	c->get_keys = lxcapi_get_keys;
+	c->create = lxcapi_create;
+	c->createl = lxcapi_createl;
+	c->shutdown = lxcapi_shutdown;
+	c->clear_config_item = lxcapi_clear_config_item;
+	c->get_config_item = lxcapi_get_config_item;
+
+	/* we'll allow the caller to update these later */
+	if (lxc_log_init("/var/log/lxccontainer.log", "trace", "lxc_container", 0)) {
+		fprintf(stderr, "failed to open log\n");
+		goto err;
+	}
+
+	/*
+	 * default configuration file is $LXCDIR/$NAME/config
+	 */
+
+	return c;
+
+err:
+	lxc_container_free(c);
+	return NULL;
+}
+
+int lxc_get_wait_states(char **states)
+{
+	int i;
+
+	if (states)
+		for (i=0; i<MAX_STATE; i++)
+			states[i] = lxc_state2str(i);
+	return MAX_STATE;
+}

=== modified file 'debian/changelog'
--- debian/changelog	2012-08-25 12:44:17 +0000
+++ debian/changelog	2012-08-25 17:20:25 +0000
@@ -1,20 +1,47 @@
-lxc (0.8.0~rc1-4ubuntu29) quantal; urgency=low
-
-  [ Serge Hallyn ]
-  * fix lxcapi_start to not return true when it container failed to start.
-  * 0201-fix-mkdir-race: don't raise error if mkdir fails with EEXIST.
-  * 0202-make-api-start-reliable: have daemonized start through the api
-    wait until the container is RUNNING before returning true.  If a 5
-    second timeout is hit before the container is RUNNING, return false.
-
-  [ Stéphane Graber ]
-  * python-lxc: in get_ips() if timeout is 1 don't wait one second before
-    returning.
-  * python-lxc: Add import time warning that the API isn't yet stable and
-    so may change at any point in the future.
-
- -- Stéphane Graber <[e-mail]>  Sat, 25 Aug 2012 12:44:17 -0400
-
+<<<<<<< TREE
+lxc (0.8.0~rc1-4ubuntu29) quantal; urgency=low
+
+  [ Serge Hallyn ]
+  * fix lxcapi_start to not return true when it container failed to start.
+  * 0201-fix-mkdir-race: don't raise error if mkdir fails with EEXIST.
+  * 0202-make-api-start-reliable: have daemonized start through the api
+    wait until the container is RUNNING before returning true.  If a 5
+    second timeout is hit before the container is RUNNING, return false.
+
+  [ Stéphane Graber ]
+  * python-lxc: in get_ips() if timeout is 1 don't wait one second before
+    returning.
+  * python-lxc: Add import time warning that the API isn't yet stable and
+    so may change at any point in the future.
+
+ -- Stéphane Graber <[e-mail]>  Sat, 25 Aug 2012 12:44:17 -0400
+
+=======
+lxc (0.8.0~rc1-4ubuntu30) UNRELEASED; urgency=low
+
+  * Remove debian/local/lxc-wait in favor of upstream's implementation.
+    This actually fixes (LP: #1020179)
+
+ -- Stéphane Graber <[e-mail]>  Sat, 25 Aug 2012 13:01:02 -0400
+
+lxc (0.8.0~rc1-4ubuntu29) quantal; urgency=low
+
+  [ Serge Hallyn ]
+  * fix lxcapi_start to not return true when it container failed to start.
+  * 0201-fix-mkdir-race: don't raise error if mkdir fails with EEXIST.
+  * 0202-make-api-start-reliable: have daemonized start through the api
+    wait until the container is RUNNING before returning true.  If a 5
+    second timeout is hit before the container is RUNNING, return false.
+
+  [ Stéphane Graber ]
+  * python-lxc: in get_ips() if timeout is 1 don't wait one second before
+    returning.
+  * python-lxc: Add import time warning that the API isn't yet stable and
+    so may change at any point in the future.
+
+ -- Stéphane Graber <[e-mail]>  Sat, 25 Aug 2012 12:44:17 -0400
+
+>>>>>>> MERGE-SOURCE
 lxc (0.8.0~rc1-4ubuntu28) quantal; urgency=low
 
   [ Stéphane Graber ]

=== removed file 'debian/local/lxc-wait'
--- debian/local/lxc-wait	2012-03-21 08:20:06 +0000
+++ debian/local/lxc-wait	1970-01-01 00:00:00 +0000
@@ -1,171 +0,0 @@
-#!/bin/bash
-
-# (C) Copyright Canonical 2011,2012
-
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-usage() {
-    echo "Usage: lxc-wait --name=NAME --state=STATE"
-}
-
-help() {
-    usage
-    echo
-    echo "lxc-wait waits for NAME container state to reach STATE"
-    echo
-    echo "Options :"
-    echo "   -n, --name=NAME   NAME for name of the container"
-    echo "   -s, --state=STATE ORed states to wait for"
-    echo "                     STOPPED, STARTING, RUNNING, STOPPING,"
-    echo "                     ABORTING, FREEZING, FROZEN"
-}
-
-set -e
-
-valid_states=("STOPPED" "STARTING" "RUNNING" "STOPPING"
-"ABORTING" "FREEZING" "FROZEN" "THAWED" "MAX_STATE")
-
-container_exists() {
-    local c=$1
-    local list=`lxc-ls -1`
-    local name
-
-    for name in $list; do
-        if [ "$c" = "$name" ]; then
-            echo "yes"
-        fi
-        echo "no"
-    done
-}
-
-verify_state() {
-    local s="$1"
-    local i
-
-    for((i=0;i<${#valid_states[@]};i++)); do
-        if [ "$s" = "${valid_states[$i]}" ]; then
-            echo "ok"; return;
-        fi
-    done
-    echo "bad"; return;
-}
-        
-badstate=""
-verify_states() {
-    local states=$1
-    local s
-    local v
-
-    for s in $states; do
-        echo "verifying $s"
-        v=$(verify_state "$s")
-        if [ $v = "bad" ]; then
-            echo "bad";
-            badstate="$s"
-            return;
-        fi
-    done
-    echo "ok";
-}
-
-state_is_in() {
-    local state=$1
-    local states=$2
-    local s
-
-    for s in $states; do
-        if [ "$state" = "$s" ]; then
-            echo "yes"; return;
-        fi
-    done
-    echo "no"
-}
-
-shortoptions='hn:s:'
-longoptions='help,name:,states:'
-
-getopt=$(getopt -o $shortoptions --longoptions  $longoptions -- "$@")
-if [ $? != 0 ]; then
-    usage
-    exit 1;
-fi
-
-eval set -- "$getopt"
-
-states="RUNNING"
-
-while true; do
-    case "$1" in
-    -h|--help)
-        help
-        exit 1
-        ;;
-    -n|--name)
-        shift
-        lxc_name=$1
-        shift
-        ;;
-    -s|--states)
-        shift
-        states=$1
-        shift
-        ;;
-    --)
-        shift
-        break;;
-    *)
-        echo $1
-        usage
-        exit 1
-        ;;
-    esac
-done
-
-if [ -z "$lxc_name" ]; then
-    echo "no container name specified"
-    usage
-    exit 1
-fi
-
-if [ "$(id -u)" != "0" ]; then
-   echo "This command has to be run as root"
-   exit 1
-fi
-
-type lxc-info > /dev/null || { echo "lxc-info not found."; exit 1; }
-
-v=$(container_exists $lxc_name)
-if [ "$v" = "no" ]; then
-    echo "Container $lxc_name does not exist"
-    exit 1
-fi
-states2="`echo $states | sed -e 's/|/ /g'`"
-v=$(verify_states "${states2}")
-if [ "$v" = "bad" ]; then
-   echo "invalid state $badstate in provided set"
-   exit 1
-fi
-	
-
-while [ 1 ]; do
-    o=`lxc-info -s -n $lxc_name`
-    s=`echo $o | awk '{ print $2 }'`
-    if [ $(state_is_in "$s" "${states2}") = "yes" ]; then
-        break;
-    fi
-    sleep 1
-done
-
-exit 0

=== added file 'debian/patches/0201-fix-mkdir-race'
--- debian/patches/0201-fix-mkdir-race	1970-01-01 00:00:00 +0000
+++ debian/patches/0201-fix-mkdir-race	2012-08-25 17:20:25 +0000
@@ -0,0 +1,24 @@
+Description: if mkdir fails with -EEXIST, let it be.
+Author: Serge Hallyn <[e-mail]>
+Forwarded: yes
+
+Index: lxc/src/lxc/cgroup.c
+===================================================================
+--- lxc.orig/src/lxc/cgroup.c	2012-08-24 10:51:33.375144000 -0500
++++ lxc/src/lxc/cgroup.c	2012-08-24 10:59:42.293491913 -0500
+@@ -357,9 +357,12 @@
+ 	}
+ 
+ 	/* if /sys/fs/cgroup/<cgroup>/<init-cgroup>/lxc does not exist, create it */
+-	if (access(cgparent, F_OK) && mkdir(cgparent, 0755)) {
+-		SYSERROR("failed to create '%s' directory", cgparent);
+-		return -1;
++	if (access(cgparent, F_OK)) {
++		ret = mkdir(cgparent, 0755);
++		if (ret == -1 && errno == EEXIST) {
++			SYSERROR("failed to create '%s' directory", cgparent);
++			return -1;
++		}
+ 	}
+ 
+ 	/*

=== renamed file 'debian/patches/0201-fix-mkdir-race' => 'debian/patches/0201-fix-mkdir-race.moved'
=== added file 'debian/patches/0202-make-api-start-reliable'
--- debian/patches/0202-make-api-start-reliable	1970-01-01 00:00:00 +0000
+++ debian/patches/0202-make-api-start-reliable	2012-08-25 17:20:25 +0000
@@ -0,0 +1,58 @@
+Index: lxc/src/lxc/lxccontainer.c
+===================================================================
+--- lxc.orig/src/lxc/lxccontainer.c	2012-08-24 11:46:43.112003985 -0500
++++ lxc/src/lxc/lxccontainer.c	2012-08-24 12:22:40.683925258 -0500
+@@ -244,6 +244,26 @@
+ 	c->daemonize = 1;
+ }
+ 
++static bool lxcapi_wait(struct lxc_container *c, char *state, int timeout)
++{
++	int ret;
++
++	if (!c)
++		return false;
++
++	ret = lxc_wait(c->name, state, timeout);
++	return ret == 0;
++}
++
++
++static bool wait_on_daemonized_start(struct lxc_container *c)
++{
++	/* we'll probably want to make this timeout configurable? */
++	int timeout = 5;
++
++	return lxcapi_wait(c, "RUNNING", timeout);
++}
++
+ /*
+  * I can't decide if it'd be more convenient for callers if we accept '...',
+  * or a null-terminated array (i.e. execl vs execv)
+@@ -298,7 +318,7 @@
+ 			return false;
+ 		}
+ 		if (pid != 0)
+-			return true;
++			return wait_on_daemonized_start(c);
+ 		/* like daemon(), chdir to / and redirect 0,1,2 to /dev/null */
+ 		chdir("/");
+ 		close(0);
+@@ -408,17 +428,6 @@
+ 	return ret == 0;
+ }
+ 
+-static bool lxcapi_wait(struct lxc_container *c, char *state, int timeout)
+-{
+-	int ret;
+-
+-	if (!c)
+-		return false;
+-
+-	ret = lxc_wait(c->name, state, timeout);
+-	return ret == 0;
+-}
+-
+ static bool valid_template(char *t)
+ {
+ 	struct stat statbuf;

=== renamed file 'debian/patches/0202-make-api-start-reliable' => 'debian/patches/0202-make-api-start-reliable.moved'