Skip to content

L
lxc
Commit 2acf7795 by Dwight Engen Committed by Serge Hallyn
Options

fix memory leaks in cgroup functions

There were several memory leaks in the cgroup functions, notably in the success cases. The cgpath test program was refactored and additional tests added to it. It was used in various modes under valgrind to test that the leaks were fixed. Simplify lxc_cgroup_path_get() and cgroup_path_get by having them return a char * instead of an int and an output char * argument. The only return values ever used were -1 and 0, which are now handled with NULL and non-NULL returns respectively. Use consistent variable names of cgabspath when refering to an absolute path to a cgroup subsystem or file, and cgrelpath when refering to a container "group/name" within the cgroup heirarchy. Remove unused subsystem argument to lxc_cmd_get_cgroup_path(). Remove unused #define MAXPRIOLEN Make template arg to lxcapi_create() const Signed-off-by: 's avatarDwight Engen <dwight.engen@oracle.com> Signed-off-by: 's avatarSerge Hallyn <serge.hallyn@ubuntu.com>
parent 6a44839f
Showing with 463 additions and 276 deletions
src/lxc/cgroup.c
...@@ -147,102 +147,113 @@ out: ...@@ -147,102 +147,113 @@ out:
} }
/* /*
* cgroup_path_get: Calculate the full path for a particular subsystem, plus * cgroup_path_get: Get the absolute path to a particular subsystem,
* a passed-in (to be appended) relative cgpath for a container. * plus a passed-in (to be appended) relative cgpath for a container.
* @path: a char** into which a pointer to the answer is copied
* @subsystem: subsystem of interest (i.e. freezer).
* @cgpath: a container's (relative) cgroup path, i.e. "/lxc/c1".
* *
* Returns 0 on success, -1 on error. * @subsystem : subsystem of interest (e.g. "freezer")
* @cgrelpath : a container's relative cgroup path (e.g. "lxc/c1")
*
* Returns absolute path on success, NULL on error. The caller must free()
* the returned path.
* *
* Note that @subsystem may be the name of an item (e.g. "freezer.state")
* in which case the subsystem will be determined by taking the string up
* to the first '.'
*/ */
extern int cgroup_path_get(char **path, const char *subsystem, const char *cgpath) char *cgroup_path_get(const char *subsystem, const char *cgrelpath)
{ {
int rc; int rc;
char *buf = NULL; char *buf = NULL;
char *retbuf = NULL; char *cgabspath = NULL;
buf = malloc(MAXPATHLEN * sizeof(char)); buf = malloc(MAXPATHLEN * sizeof(char));
if (!buf) { if (!buf) {
ERROR("malloc failed"); ERROR("malloc failed");
goto fail; goto out1;
} }
retbuf = malloc(MAXPATHLEN * sizeof(char)); cgabspath = malloc(MAXPATHLEN * sizeof(char));
if (!retbuf) { if (!cgabspath) {
ERROR("malloc failed"); ERROR("malloc failed");
goto fail; goto out2;
} }
/* lxc_cgroup_set passes a state object for the subsystem, /* lxc_cgroup_set passes a state object for the subsystem,
* so trim it to just the subsystem part */ * so trim it to just the subsystem part */
if (subsystem) { if (subsystem) {
rc = snprintf(retbuf, MAXPATHLEN, "%s", subsystem); rc = snprintf(cgabspath, MAXPATHLEN, "%s", subsystem);
if (rc < 0 || rc >= MAXPATHLEN) { if (rc < 0 || rc >= MAXPATHLEN) {
ERROR("subsystem name too long"); ERROR("subsystem name too long");
goto fail; goto err3;
} }
char *s = index(retbuf, '.'); char *s = index(cgabspath, '.');
if (s) if (s)
*s = '\0'; *s = '\0';
DEBUG("%s: called for subsys %s name %s\n", __func__, retbuf, cgpath); DEBUG("%s: called for subsys %s name %s\n", __func__,
subsystem, cgrelpath);
} }
if (get_cgroup_mount(subsystem ? retbuf : NULL, buf)) { if (get_cgroup_mount(subsystem ? cgabspath : NULL, buf)) {
ERROR("cgroup is not mounted"); ERROR("cgroup is not mounted");
goto fail; goto err3;
} }
rc = snprintf(retbuf, MAXPATHLEN, "%s/%s", buf, cgpath); rc = snprintf(cgabspath, MAXPATHLEN, "%s/%s", buf, cgrelpath);
if (rc < 0 || rc >= MAXPATHLEN) { if (rc < 0 || rc >= MAXPATHLEN) {
ERROR("name too long"); ERROR("name too long");
goto fail; goto err3;
} }
DEBUG("%s: returning %s for subsystem %s", __func__, retbuf, subsystem); DEBUG("%s: returning %s for subsystem %s relpath %s", __func__,
cgabspath, subsystem, cgrelpath);
goto out2;
if(buf) err3:
free(buf); free(cgabspath);
cgabspath = NULL;
*path = retbuf; out2:
return 0; free(buf);
fail: out1:
if (buf) return cgabspath;
free(buf);
if (retbuf)
free(retbuf);
return -1;
} }
/* /*
* lxc_cgroup_path_get: determine full pathname for a cgroup * lxc_cgroup_path_get: Get the absolute pathname for a cgroup
* file for a specific container. * file for a running container.
* @path: char ** used to return the answer. *
* @subsystem: cgroup subsystem (i.e. "freezer") for which to * @subsystem : subsystem of interest (e.g. "freezer"). If NULL, then
* return an answer. If NULL, then the first cgroup entry in * the first cgroup entry in mtab will be used.
* mtab will be used. * @name : name of container to connect to
* @lxcpath : the lxcpath in which the container is running
* *
* This is the exported function, which determines cgpath from the * This is the exported function, which determines cgpath from the
* monitor running in lxcpath. * lxc-start of the @name container running in @lxcpath.
* *
* Returns 0 on success, < 0 on error. * Returns path on success, NULL on error. The caller must free()
* the returned path.
*/ */
int lxc_cgroup_path_get(char **path, const char *subsystem, const char *name, const char *lxcpath) char *lxc_cgroup_path_get(const char *subsystem, const char *name,
const char *lxcpath)
{ {
int ret; char *cgabspath;
char *cgpath; char *cgrelpath;
cgpath = lxc_cmd_get_cgroup_path(subsystem, name, lxcpath); cgrelpath = lxc_cmd_get_cgroup_path(name, lxcpath);
if (!cgpath) if (!cgrelpath)
return -1; return NULL;
ret = cgroup_path_get(path, subsystem, cgpath); cgabspath = cgroup_path_get(subsystem, cgrelpath);
free(cgpath); free(cgrelpath);
return ret; return cgabspath;
} }
/* /*
* small helper which simply write a value into a (cgroup) file * do_cgroup_set: Write a value into a cgroup file
*
* @path : absolute path to cgroup file
* @value : value to write into file
*
* Returns 0 on success, < 0 on error.
*/ */
static int do_cgroup_set(const char *path, const char *value) static int do_cgroup_set(const char *path, const char *value)
{ {
...@@ -267,87 +278,86 @@ static int do_cgroup_set(const char *path, const char *value) ...@@ -267,87 +278,86 @@ static int do_cgroup_set(const char *path, const char *value)
} }
/* /*
* small helper to write a value into a file in a particular directory. * lxc_cgroup_set_bypath: Write a value into a cgroup file
* @cgpath: the directory in which to find the file *
* @filename: the file (under cgpath) to which to write * @cgrelpath : a container's relative cgroup path (e.g. "lxc/c1")
* @value: what to write * @filename : the cgroup file to write (e.g. "freezer.state")
* @value : value to write into file
* *
* Returns 0 on success, < 0 on error. * Returns 0 on success, < 0 on error.
*/ */
int lxc_cgroup_set_bypath(const char *cgpath, const char *filename, const char *value) int lxc_cgroup_set_bypath(const char *cgrelpath, const char *filename, const char *value)
{ {
int ret; int ret;
char *dirpath = NULL; char *cgabspath;
char path[MAXPATHLEN]; char path[MAXPATHLEN];
ret = cgroup_path_get(&dirpath, filename, cgpath); cgabspath = cgroup_path_get(filename, cgrelpath);
if (ret) if (!cgabspath)
goto fail; return -1;
ret = snprintf(path, MAXPATHLEN, "%s/%s", dirpath, filename); ret = snprintf(path, MAXPATHLEN, "%s/%s", cgabspath, filename);
if (ret < 0 || ret >= MAXPATHLEN) { if (ret < 0 || ret >= MAXPATHLEN) {
ERROR("pathname too long"); ERROR("pathname too long");
goto fail; ret = -1;
goto out;
} }
return do_cgroup_set(path, value); ret = do_cgroup_set(path, value);
fail: out:
if(dirpath) free(cgabspath);
free(dirpath); return ret;
return -1;
} }
/* /*
* set a cgroup value for a container * lxc_cgroup_set: Write a value into a cgroup file
* *
* @name: name of the container * @name : name of container to connect to
* @filename: the cgroup file (i.e. freezer.state) whose value to change * @filename : the cgroup file to write (e.g. "freezer.state")
* @value: the value to write to the file * @value : value to write into file
* @lxcpath: the lxcpath under which the container is running. * @lxcpath : the lxcpath in which the container is running
* *
* Returns 0 on success, < 0 on error. * Returns 0 on success, < 0 on error.
*/ */
int lxc_cgroup_set(const char *name, const char *filename, const char *value, int lxc_cgroup_set(const char *name, const char *filename, const char *value,
const char *lxcpath) const char *lxcpath)
{ {
int ret; int ret;
char *dirpath = NULL; char *cgabspath;
char path[MAXPATHLEN]; char path[MAXPATHLEN];
ret = lxc_cgroup_path_get(&dirpath, filename, name, lxcpath); cgabspath = lxc_cgroup_path_get(filename, name, lxcpath);
if (ret) if (!cgabspath)
goto fail; return -1;
ret = snprintf(path, MAXPATHLEN, "%s/%s", dirpath, filename); ret = snprintf(path, MAXPATHLEN, "%s/%s", cgabspath, filename);
if (ret < 0 || ret >= MAXPATHLEN) { if (ret < 0 || ret >= MAXPATHLEN) {
ERROR("pathname too long"); ERROR("pathname too long");
goto fail; ret = -1;
goto out;
} }
return do_cgroup_set(path, value); ret = do_cgroup_set(path, value);
fail: out:
if(dirpath) free(cgabspath);
free(dirpath); return ret;
return -1;
} }
/* /*
* Get value of a cgroup setting for a container. * lxc_cgroup_get: Read value from a cgroup file
* *
* @name: name of the container * @name : name of container to connect to
* @filename: the cgroup file to read (i.e. 'freezer.state') * @filename : the cgroup file to read (e.g. "freezer.state")
* @value: a preallocated char* into which to copy the answer * @value : a pre-allocated buffer to copy the answer into
* @len: the length of pre-allocated @value * @len : the length of pre-allocated @value
* @lxcpath: the lxcpath in which the container is running (i.e. * @lxcpath : the lxcpath in which the container is running
* /var/lib/lxc)
* *
* Returns < 0 on error, or the number of bytes read. * Returns the number of bytes read on success, < 0 on error
* *
* If you pass in NULL value or 0 len, then you are asking for the size of the * If you pass in NULL value or 0 len, the return value will be the size of
* file. * the file, and @value will not contain the contents.
* *
* Note that we can't get the file size quickly through stat or lseek. * Note that we can't get the file size quickly through stat or lseek.
* Therefore if you pass in len > 0 but less than the file size, your only * Therefore if you pass in len > 0 but less than the file size, your only
...@@ -357,25 +367,26 @@ fail: ...@@ -357,25 +367,26 @@ fail:
int lxc_cgroup_get(const char *name, const char *filename, char *value, int lxc_cgroup_get(const char *name, const char *filename, char *value,
size_t len, const char *lxcpath) size_t len, const char *lxcpath)
{ {
int fd, ret = -1; int fd, ret;
char *dirpath = NULL; char *cgabspath;
char path[MAXPATHLEN]; char path[MAXPATHLEN];
int rc;
ret = lxc_cgroup_path_get(&dirpath, filename, name, lxcpath); cgabspath = lxc_cgroup_path_get(filename, name, lxcpath);
if (ret) if (!cgabspath)
goto fail; return -1;
rc = snprintf(path, MAXPATHLEN, "%s/%s", dirpath, filename); ret = snprintf(path, MAXPATHLEN, "%s/%s", cgabspath, filename);
if (rc < 0 || rc >= MAXPATHLEN) { if (ret < 0 || ret >= MAXPATHLEN) {
ERROR("pathname too long"); ERROR("pathname too long");
goto fail; ret = -1;
goto out;
} }
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
if (fd < 0) { if (fd < 0) {
ERROR("open %s : %s", path, strerror(errno)); ERROR("open %s : %s", path, strerror(errno));
goto fail; ret = -1;
goto out;
} }
if (!len || !value) { if (!len || !value) {
...@@ -394,47 +405,45 @@ int lxc_cgroup_get(const char *name, const char *filename, char *value, ...@@ -394,47 +405,45 @@ int lxc_cgroup_get(const char *name, const char *filename, char *value,
ERROR("read %s : %s", path, strerror(errno)); ERROR("read %s : %s", path, strerror(errno));
close(fd); close(fd);
out:
free(cgabspath);
return ret; return ret;
fail:
if(dirpath)
free(dirpath);
return -1;
} }
int lxc_cgroup_nrtasks(const char *cgpath) int lxc_cgroup_nrtasks(const char *cgrelpath)
{ {
char *dirpath = NULL; char *cgabspath = NULL;
char path[MAXPATHLEN]; char path[MAXPATHLEN];
int pid, ret, count = 0; int pid, ret;
FILE *file; FILE *file;
int rc;
ret = cgroup_path_get(&dirpath, NULL, cgpath); cgabspath = cgroup_path_get(NULL, cgrelpath);
if (ret) if (!cgabspath)
goto fail; return -1;
rc = snprintf(path, MAXPATHLEN, "%s/tasks", dirpath); ret = snprintf(path, MAXPATHLEN, "%s/tasks", cgabspath);
if (rc < 0 || rc >= MAXPATHLEN) { if (ret < 0 || ret >= MAXPATHLEN) {
ERROR("pathname too long"); ERROR("pathname too long");
goto fail; ret = -1;
goto out;
} }
file = fopen(path, "r"); file = fopen(path, "r");
if (!file) { if (!file) {
SYSERROR("fopen '%s' failed", path); SYSERROR("fopen '%s' failed", path);
return -1; ret = -1;
goto out;
} }
ret = 0;
while (fscanf(file, "%d", &pid) != EOF) while (fscanf(file, "%d", &pid) != EOF)
count++; ret++;
fclose(file); fclose(file);
return count; out:
fail: free(cgabspath);
if(dirpath) return ret;
free(dirpath);
return -1;
} }
/* /*
...@@ -654,12 +663,12 @@ char *lxc_cgroup_path_create(const char *lxcgroup, const char *name) ...@@ -654,12 +663,12 @@ char *lxc_cgroup_path_create(const char *lxcgroup, const char *name)
char buf[LARGE_MAXPATHLEN] = {0}; char buf[LARGE_MAXPATHLEN] = {0};
if (create_lxcgroups(lxcgroup) < 0)
return NULL;
if (!allcgroups) if (!allcgroups)
return NULL; return NULL;
if (create_lxcgroups(lxcgroup) < 0)
goto err1;
again: again:
if (visited) { if (visited) {
/* we're checking for a new name, so start over with all cgroup /* we're checking for a new name, so start over with all cgroup
...@@ -670,9 +679,7 @@ again: ...@@ -670,9 +679,7 @@ again:
file = setmntent(MTAB, "r"); file = setmntent(MTAB, "r");
if (!file) { if (!file) {
SYSERROR("failed to open %s", MTAB); SYSERROR("failed to open %s", MTAB);
if (allcgroups) goto err1;
free(allcgroups);
return NULL;
} }
if (i) if (i)
...@@ -730,6 +737,7 @@ next: ...@@ -730,6 +737,7 @@ next:
fail: fail:
endmntent(file); endmntent(file);
err1:
free(allcgroups); free(allcgroups);
if (visited) if (visited)
free(visited); free(visited);
...@@ -880,7 +888,7 @@ int lxc_cgroup_attach(pid_t pid, const char *name, const char *lxcpath) ...@@ -880,7 +888,7 @@ int lxc_cgroup_attach(pid_t pid, const char *name, const char *lxcpath)
int ret; int ret;
char *dirpath; char *dirpath;
dirpath = lxc_cmd_get_cgroup_path(NULL, name, lxcpath); dirpath = lxc_cmd_get_cgroup_path(name, lxcpath);
if (!dirpath) { if (!dirpath) {
ERROR("Error getting cgroup for container %s: %s", lxcpath, name); ERROR("Error getting cgroup for container %s: %s", lxcpath, name);
return -1; return -1;
......
src/lxc/cgroup.h
...@@ -23,15 +23,13 @@ ...@@ -23,15 +23,13 @@
#ifndef _cgroup_h #ifndef _cgroup_h
#define _cgroup_h #define _cgroup_h
#define MAXPRIOLEN 24
struct lxc_handler; struct lxc_handler;
extern int lxc_cgroup_destroy(const char *cgpath); extern int lxc_cgroup_destroy(const char *cgpath);
extern int lxc_cgroup_path_get(char **path, const char *subsystem, const char *name, extern char *lxc_cgroup_path_get(const char *subsystem, const char *name,
const char *lxcpath); const char *lxcpath);
extern int lxc_cgroup_nrtasks(const char *cgpath); extern int lxc_cgroup_nrtasks(const char *cgpath);
extern char *lxc_cgroup_path_create(const char *lxcgroup, const char *name); extern char *lxc_cgroup_path_create(const char *lxcgroup, const char *name);
extern int lxc_cgroup_enter(const char *cgpath, pid_t pid); extern int lxc_cgroup_enter(const char *cgpath, pid_t pid);
extern int lxc_cgroup_attach(pid_t pid, const char *name, const char *lxcpath); extern int lxc_cgroup_attach(pid_t pid, const char *name, const char *lxcpath);
extern int cgroup_path_get(char **path, const char *subsystem, const char *cgpath); extern char *cgroup_path_get(const char *subsystem, const char *cgpath);
#endif #endif
src/lxc/commands.c
...@@ -335,15 +335,13 @@ static int lxc_cmd_get_clone_flags_callback(int fd, struct lxc_cmd_req *req, ...@@ -335,15 +335,13 @@ static int lxc_cmd_get_clone_flags_callback(int fd, struct lxc_cmd_req *req,
* particular subsystem. This is the cgroup path relative to the root * particular subsystem. This is the cgroup path relative to the root
* of the cgroup filesystem. * of the cgroup filesystem.
* *
* @subsystem : the cgroup subsystem of interest (i.e. freezer)
* @name : name of container to connect to * @name : name of container to connect to
* @lxcpath : the lxcpath in which the container is running * @lxcpath : the lxcpath in which the container is running
* *
* Returns the path on success, NULL on failure. The caller must free() the * Returns the path on success, NULL on failure. The caller must free() the
* returned path. * returned path.
*/ */
char *lxc_cmd_get_cgroup_path(const char *subsystem, const char *name, char *lxc_cmd_get_cgroup_path(const char *name, const char *lxcpath)
const char *lxcpath)
{ {
int ret, stopped = 0; int ret, stopped = 0;
struct lxc_cmd_rr cmd = { struct lxc_cmd_rr cmd = {
......
src/lxc/commands.h
...@@ -67,8 +67,7 @@ struct lxc_cmd_console_rsp_data { ...@@ -67,8 +67,7 @@ struct lxc_cmd_console_rsp_data {
extern int lxc_cmd_console(const char *name, int *ttynum, int *fd, extern int lxc_cmd_console(const char *name, int *ttynum, int *fd,
const char *lxcpath); const char *lxcpath);
extern char *lxc_cmd_get_cgroup_path(const char *subsystem, extern char *lxc_cmd_get_cgroup_path(const char *name, const char *lxcpath);
const char *name, const char *lxcpath);
extern int lxc_cmd_get_clone_flags(const char *name, const char *lxcpath); extern int lxc_cmd_get_clone_flags(const char *name, const char *lxcpath);
extern char *lxc_cmd_get_config_item(const char *name, const char *item, const char *lxcpath); extern char *lxc_cmd_get_config_item(const char *name, const char *item, const char *lxcpath);
extern pid_t lxc_cmd_get_init_pid(const char *name, const char *lxcpath); extern pid_t lxc_cmd_get_init_pid(const char *name, const char *lxcpath);
......
src/lxc/freezer.c
...@@ -120,19 +120,16 @@ out: ...@@ -120,19 +120,16 @@ out:
static int freeze_unfreeze(const char *name, int freeze, const char *lxcpath) static int freeze_unfreeze(const char *name, int freeze, const char *lxcpath)
{ {
char *nsgroup = NULL; char *cgabspath;
int ret; int ret;
ret = lxc_cgroup_path_get(&nsgroup, "freezer", name, lxcpath);
if (ret)
goto fail;
return do_unfreeze(nsgroup, freeze, name, lxcpath); cgabspath = lxc_cgroup_path_get("freezer", name, lxcpath);
if (!cgabspath)
return -1;
fail: ret = do_unfreeze(cgabspath, freeze, name, lxcpath);
if (nsgroup) free(cgabspath);
free(nsgroup); return ret;
return -1;
} }
int lxc_freeze(const char *name, const char *lxcpath) int lxc_freeze(const char *name, const char *lxcpath)
...@@ -146,19 +143,16 @@ int lxc_unfreeze(const char *name, const char *lxcpath) ...@@ -146,19 +143,16 @@ int lxc_unfreeze(const char *name, const char *lxcpath)
return freeze_unfreeze(name, 0, lxcpath); return freeze_unfreeze(name, 0, lxcpath);
} }
int lxc_unfreeze_bypath(const char *cgpath) int lxc_unfreeze_bypath(const char *cgrelpath)
{ {
char *nsgroup = NULL; char *cgabspath;
int ret; int ret;
ret = cgroup_path_get(&nsgroup, "freezer", cgpath);
if (ret)
goto fail;
return do_unfreeze(nsgroup, 0, NULL, NULL); cgabspath = cgroup_path_get("freezer", cgrelpath);
if (!cgabspath)
return -1;
fail: ret = do_unfreeze(cgabspath, 0, NULL, NULL);
if (nsgroup) free(cgabspath);
free(nsgroup); return ret;
return -1;
} }
src/lxc/lxccontainer.c
...@@ -555,7 +555,7 @@ static bool create_container_dir(struct lxc_container *c) ...@@ -555,7 +555,7 @@ static bool create_container_dir(struct lxc_container *c)
* for ->create, argv contains the arguments to pass to the template, * for ->create, argv contains the arguments to pass to the template,
* terminated by NULL. If no arguments, you can just pass NULL. * terminated by NULL. If no arguments, you can just pass NULL.
*/ */
static bool lxcapi_create(struct lxc_container *c, char *t, char *const argv[]) static bool lxcapi_create(struct lxc_container *c, const char *t, char *const argv[])
{ {
bool bret = false; bool bret = false;
pid_t pid; pid_t pid;
...@@ -621,7 +621,7 @@ static bool lxcapi_create(struct lxc_container *c, char *t, char *const argv[]) ...@@ -621,7 +621,7 @@ static bool lxcapi_create(struct lxc_container *c, char *t, char *const argv[])
newargv = malloc(nargs * sizeof(*newargv)); newargv = malloc(nargs * sizeof(*newargv));
if (!newargv) if (!newargv)
exit(1); exit(1);
newargv[0] = t; newargv[0] = (char *)t;
len = strlen(c->config_path) + strlen(c->name) + strlen("--path=") + 2; len = strlen(c->config_path) + strlen(c->name) + strlen("--path=") + 2;
patharg = malloc(len); patharg = malloc(len);
...@@ -702,7 +702,7 @@ static bool lxcapi_shutdown(struct lxc_container *c, int timeout) ...@@ -702,7 +702,7 @@ static bool lxcapi_shutdown(struct lxc_container *c, int timeout)
return retv; return retv;
} }
static bool lxcapi_createl(struct lxc_container *c, char *t, ...) static bool lxcapi_createl(struct lxc_container *c, const char *t, ...)
{ {
bool bret = false; bool bret = false;
char **args = NULL, **temp; char **args = NULL, **temp;
......
src/lxc/lxccontainer.h
...@@ -48,8 +48,8 @@ struct lxc_container { ...@@ -48,8 +48,8 @@ struct lxc_container {
bool (*set_config_item)(struct lxc_container *c, const char *key, const char *value); bool (*set_config_item)(struct lxc_container *c, const char *key, const char *value);
bool (*destroy)(struct lxc_container *c); bool (*destroy)(struct lxc_container *c);
bool (*save_config)(struct lxc_container *c, const char *alt_file); bool (*save_config)(struct lxc_container *c, const char *alt_file);
bool (*create)(struct lxc_container *c, char *t, char *const argv[]); bool (*create)(struct lxc_container *c, const char *t, char *const argv[]);
bool (*createl)(struct lxc_container *c, char *t, ...); bool (*createl)(struct lxc_container *c, const char *t, ...);
/* send SIGPWR. if timeout is not 0 or -1, do a hard stop after timeout seconds */ /* send SIGPWR. if timeout is not 0 or -1, do a hard stop after timeout seconds */
bool (*shutdown)(struct lxc_container *c, int timeout); bool (*shutdown)(struct lxc_container *c, int timeout);
/* clear all network or capability items in the in-memory configuration */ /* clear all network or capability items in the in-memory configuration */
......
src/lxc/state.c
...@@ -69,38 +69,40 @@ lxc_state_t lxc_str2state(const char *state) ...@@ -69,38 +69,40 @@ lxc_state_t lxc_str2state(const char *state)
static lxc_state_t freezer_state(const char *name, const char *lxcpath) static lxc_state_t freezer_state(const char *name, const char *lxcpath)
{ {
char *nsgroup = NULL; char *cgabspath = NULL;
char freezer[MAXPATHLEN]; char freezer[MAXPATHLEN];
char status[MAXPATHLEN]; char status[MAXPATHLEN];
FILE *file; FILE *file;
int err; int ret;
err = lxc_cgroup_path_get(&nsgroup, "freezer", name, lxcpath); cgabspath = lxc_cgroup_path_get("freezer", name, lxcpath);
if (err) if (!cgabspath)
goto fail; return -1;
err = snprintf(freezer, MAXPATHLEN, "%s/freezer.state", nsgroup); ret = snprintf(freezer, MAXPATHLEN, "%s/freezer.state", cgabspath);
if (err < 0 || err >= MAXPATHLEN) if (ret < 0 || ret >= MAXPATHLEN)
goto fail; goto out;
file = fopen(freezer, "r"); file = fopen(freezer, "r");
if (!file) if (!file) {
goto fail; ret = -1;
goto out;
}
err = fscanf(file, "%s", status); ret = fscanf(file, "%s", status);
fclose(file); fclose(file);
if (err == EOF) { if (ret == EOF) {
SYSERROR("failed to read %s", freezer); SYSERROR("failed to read %s", freezer);
goto fail; ret = -1;
goto out;
} }
return lxc_str2state(status); ret = lxc_str2state(status);
fail: out:
if (nsgroup) free(cgabspath);
free(nsgroup); return ret;
return -1;
} }
lxc_state_t lxc_getstate(const char *name, const char *lxcpath) lxc_state_t lxc_getstate(const char *name, const char *lxcpath)
......
src/tests/cgpath.c
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
*/ */
#include "../lxc/lxccontainer.h" #include "../lxc/lxccontainer.h"
#include <limits.h>
#include <unistd.h> #include <unistd.h>
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
...@@ -30,137 +31,324 @@ ...@@ -30,137 +31,324 @@
#include "../lxc/commands.h" #include "../lxc/commands.h"
#define MYNAME "lxctest1" #define MYNAME "lxctest1"
#define MYNAME2 "lxctest2"
#define TSTERR(x) do { \ #define TSTERR(fmt, ...) do { \
fprintf(stderr, "%d: %s\n", __LINE__, x); \ fprintf(stderr, "%s:%d " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__); \
} while (0) } while (0)
int main() /*
* test_same_name: Create the same named container within a group
*
* @group : name of the container group or NULL for default "lxc"
* @name : name of the container
*
* Note, lxc will append a -<nr> to duplicate container names. This is what
* is tested here.
*
* Returns 0 on success, < 0 on failure
*/
static int test_same_name(const char *group, const char *name)
{ {
struct lxc_container *c = NULL, *c2 = NULL; int ret = -1;
char *path; char *cgrelpath1;
char *dirpath = NULL; char *cgrelpath2;
int len; char relpath[PATH_MAX+1];
int ret, retv = -1;
/* won't require privilege necessarily once users are classified by sprintf(relpath, "%s/%s-1", group ? group : "lxc", name);
* pam_cgroup */
if (geteuid() != 0) { cgrelpath1 = lxc_cgroup_path_create(group, name);
TSTERR("requires privilege"); if (!cgrelpath1) {
exit(0); TSTERR("lxc_cgroup_path_create returned NULL");
goto err1;
}
cgrelpath2 = lxc_cgroup_path_create(group, name);
if (!cgrelpath2) {
TSTERR("lxc_cgroup_path_create returned NULL");
goto err2;
}
if (strcmp(cgrelpath2, relpath)) {
TSTERR("unexpected name for duplicate %s", cgrelpath2);
goto err3;
}
ret = 0;
err3:
lxc_cgroup_destroy(cgrelpath2);
free(cgrelpath2);
err2:
lxc_cgroup_destroy(cgrelpath1);
free(cgrelpath1);
err1:
return ret;
}
/*
* test_basic: Test cgroup functions that don't require a running container
*
* @group : name of the container group or NULL for default "lxc"
* @name : name of the container
*
* Returns 0 on success, < 0 on failure
*/
static int test_basic(const char *group, const char *name)
{
int ret = -1;
char *cgabspath;
char *cgrelpath;
char relpath[PATH_MAX+1];
sprintf(relpath, "%s/%s", group ? group : "lxc", name);
cgrelpath = lxc_cgroup_path_create(group, name);
if (!cgrelpath) {
TSTERR("lxc_cgroup_path_create returned NULL");
goto err1;
}
if (!strstr(cgrelpath, relpath)) {
TSTERR("lxc_cgroup_path_create %s not in %s", relpath, cgrelpath);
goto err2;
}
cgabspath = cgroup_path_get("freezer", cgrelpath);
if (!cgabspath) {
TSTERR("cgroup_path_get returned NULL");
goto err2;
}
if (!strstr(cgabspath, relpath)) {
TSTERR("cgroup_path_get %s not in %s", relpath, cgabspath);
goto err3;
}
ret = lxc_cgroup_destroy(cgrelpath);
if (ret < 0) {
TSTERR("lxc_cgroup_destroy failed");
goto err3;
}
err3:
free(cgabspath);
err2:
free(cgrelpath);
err1:
return ret;
}
/*
* test_running_container: test cgroup functions against a running container
*
* @group : name of the container group or NULL for default "lxc"
* @name : name of the container
*/
static int test_running_container(const char *lxcpath,
const char *group, const char *name)
{
int nrtasks, ret = -1;
struct lxc_container *c = NULL;
char *cgrelpath;
char *cgabspath;
char relpath[PATH_MAX+1];
char abspath[PATH_MAX+1];
char value[NAME_MAX], value_save[NAME_MAX];
sprintf(relpath, "%s/%s", group ? group : "lxc", name);
if ((c = lxc_container_new(name, lxcpath)) == NULL) {
TSTERR("container %s couldn't instantiate", name);
goto err1;
}
if (!c->is_defined(c)) {
TSTERR("container %s does not exist", name);
goto err2;
}
cgrelpath = lxc_cmd_get_cgroup_path(c->name, c->config_path);
if (!cgrelpath) {
TSTERR("lxc_cmd_get_cgroup_path returned NULL");
goto err2;
}
if (!strstr(cgrelpath, relpath)) {
TSTERR("lxc_cmd_get_cgroup_path %s not in %s", relpath, cgrelpath);
goto err3;
}
/* test get/set value using memory.swappiness file */
ret = lxc_cgroup_get(c->name, "memory.swappiness", value,
sizeof(value), c->config_path);
if (ret < 0) {
TSTERR("lxc_cgroup_get failed");
goto err3;
} }
strcpy(value_save, value);
printf("Basic cgroup path tests...\n"); ret = lxc_cgroup_set_bypath(cgrelpath, "memory.swappiness", "100");
path = lxc_cgroup_path_create(NULL, MYNAME); if (ret < 0) {
if (!path || !(len = strlen(path))) { TSTERR("lxc_cgroup_set_bypath failed");
TSTERR("zero result from lxc_cgroup_path_create"); goto err3;
exit(1);
} }
if (!strstr(path, "lxc/" MYNAME)) { ret = lxc_cgroup_get(c->name, "memory.swappiness", value,
TSTERR("lxc_cgroup_path_create NULL lxctest1"); sizeof(value), c->config_path);
exit(1); if (ret < 0) {
TSTERR("lxc_cgroup_get failed");
goto err3;
}
if (strcmp(value, "100\n")) {
TSTERR("lxc_cgroup_set_bypath failed to set value >%s<", value);
goto err3;
}
/* restore original value */
ret = lxc_cgroup_set(c->name, "memory.swappiness", value_save,
c->config_path);
if (ret < 0) {
TSTERR("lxc_cgroup_set failed");
goto err3;
}
ret = lxc_cgroup_get(c->name, "memory.swappiness", value,
sizeof(value), c->config_path);
if (ret < 0) {
TSTERR("lxc_cgroup_get failed");
goto err3;
}
if (strcmp(value, value_save)) {
TSTERR("lxc_cgroup_set failed to set value >%s<", value);
goto err3;
} }
free(path);
path = lxc_cgroup_path_create("ab", MYNAME); nrtasks = lxc_cgroup_nrtasks(cgrelpath);
if (!path || !(len = strlen(path))) { if (nrtasks < 1) {
TSTERR("zero result from lxc_cgroup_path_create"); TSTERR("failed getting nrtasks");
exit(1); goto err3;
} }
if (!strstr(path, "ab/" MYNAME)) {
TSTERR("lxc_cgroup_path_create ab lxctest1"); cgabspath = lxc_cgroup_path_get("freezer", c->name, c->config_path);
exit(1); if (!cgabspath) {
TSTERR("lxc_cgroup_path_get returned NULL");
goto err3;
} }
free(path); sprintf(abspath, "%s/%s/%s", "freezer", group ? group : "lxc", c->name);
printf("... passed\n"); if (!strstr(cgabspath, abspath)) {
TSTERR("lxc_cgroup_path_get %s not in %s", abspath, cgabspath);
goto err4;
}
free(cgabspath);
cgabspath = lxc_cgroup_path_get("freezer.state", c->name, c->config_path);
if (!cgabspath) {
TSTERR("lxc_cgroup_path_get returned NULL");
goto err3;
}
sprintf(abspath, "%s/%s/%s", "freezer", group ? group : "lxc", c->name);
if (!strstr(cgabspath, abspath)) {
TSTERR("lxc_cgroup_path_get %s not in %s", abspath, cgabspath);
goto err4;
}
ret = 0;
err4:
free(cgabspath);
err3:
free(cgrelpath);
err2:
lxc_container_put(c);
err1:
return ret;
}
static int test_container(const char *lxcpath,
const char *group, const char *name,
const char *template)
{
int ret;
struct lxc_container *c = NULL;
printf("Container creation tests...\n"); if (lxcpath) {
ret = mkdir(lxcpath, 0755);
if (ret < 0 && errno != EEXIST) {
TSTERR("failed to mkdir %s %s", lxcpath, strerror(errno));
goto out1;
}
}
ret = -1;
if ((c = lxc_container_new(MYNAME, NULL)) == NULL) { if ((c = lxc_container_new(name, lxcpath)) == NULL) {
TSTERR("instantiating first container"); TSTERR("instantiating container %s", name);
exit(1); goto out1;
} }
if (c->is_defined(c)) { if (c->is_defined(c)) {
c->stop(c); c->stop(c);
c->destroy(c); c->destroy(c);
c = lxc_container_new(MYNAME, NULL); c = lxc_container_new(name, lxcpath);
} }
c->set_config_item(c, "lxc.network.type", "empty"); c->set_config_item(c, "lxc.network.type", "empty");
if (!c->createl(c, "ubuntu", NULL)) { if (!c->createl(c, template, NULL)) {
TSTERR("creating first container"); TSTERR("creating container %s", name);
goto out; goto out2;
} }
c->load_config(c, NULL); c->load_config(c, NULL);
c->want_daemonize(c); c->want_daemonize(c);
if (!c->startl(c, 0, NULL)) { if (!c->startl(c, 0, NULL)) {
TSTERR("starting first container"); TSTERR("starting container %s", name);
goto out; goto out3;
} }
printf("first container passed. Now two containers...\n");
char *nsgroup; ret = test_running_container(lxcpath, group, name);
#define ALTBASE "/var/lib/lxctest2"
ret = mkdir(ALTBASE, 0755);
ret = lxc_cgroup_path_get(&nsgroup, "freezer", MYNAME, c->get_config_path(c)); c->stop(c);
if (ret < 0 || !strstr(nsgroup, "lxc/" MYNAME)) { out3:
TSTERR("getting first cgroup path from lxc_command"); c->destroy(c);
goto out; out2:
lxc_container_put(c);
out1:
return ret;
}
int main()
{
int ret = EXIT_FAILURE;
/* won't require privilege necessarily once users are classified by
* pam_cgroup */
if (geteuid() != 0) {
TSTERR("requires privilege");
exit(0);
} }
/* start second container */ if (test_basic(NULL, MYNAME) < 0)
if ((c2 = lxc_container_new(MYNAME2, ALTBASE)) == NULL) {
TSTERR("instantiating second container");
goto out; goto out;
} if (test_basic("ab", MYNAME) < 0)
if (c2->is_defined(c2)) {
c2->stop(c2);
c2->destroy(c2);
c2 = lxc_container_new(MYNAME2, ALTBASE);
}
c2->set_config_item(c2, "lxc.network.type", "empty");
if (!c2->createl(c2, "ubuntu", NULL)) {
TSTERR("creating second container");
goto out; goto out;
} printf("Basic cgroup path tests...Passed\n");
c2->load_config(c2, NULL); if (test_same_name(NULL, MYNAME) < 0)
c2->want_daemonize(c2);
if (!c2->startl(c2, 0, NULL)) {
TSTERR("starting second container");
goto out; goto out;
} if (test_same_name("ab", MYNAME) < 0)
goto out;
printf("Same name tests...Passed\n");
ret = lxc_cgroup_path_get(&nsgroup, "freezer", MYNAME2, c2->get_config_path(c2)); #if TEST_ALREADY_RUNNING_CT
if (ret < 0 || !strstr(nsgroup, "lxc/" MYNAME2)) {
TSTERR("getting second cgroup path from lxc_command"); /*
* This is useful for running with valgrind to test for memory
* leaks. The container should already be running, we can't start
* the container ourselves because valgrind gets confused by lxc's
* internal calls to clone.
*/
if (test_running_container(NULL, NULL, "bb01") < 0)
goto out; goto out;
} printf("Running container cgroup tests...Passed\n");
#else
dirpath = lxc_cmd_get_cgroup_path(NULL, c2->name, c2->config_path); if (test_container(NULL, NULL, MYNAME, "busybox") < 0)
if (!dirpath) {
TSTERR("getting second container's cgpath");
goto out; goto out;
} printf("Container creation tests...Passed\n");
if (lxc_cgroup_nrtasks(dirpath) < 1) { if (test_container("/var/lib/lxctest2", NULL, MYNAME, "busybox") < 0)
TSTERR("getting nrtasks");
goto out; goto out;
} printf("Container creation with LXCPATH tests...Passed\n");
printf("...passed\n");
retv = 0; #endif
ret = EXIT_SUCCESS;
out: out:
if (dirpath) return ret;
free(dirpath);
if (c2) {
c2->stop(c2);
c2->destroy(c2);
}
if (c) {
c->stop(c);
c->destroy(c);
}
return retv;
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment