Skip to content

L
lxc
Unverified Commit 826a94a5 by Christian Brauner Committed by GitHub
Options

Merge pull request #2544 from 2xsec/bugfix

tools: add default log priority & cleanups
parents 5493a1bf 34a10bfa
Showing with 742 additions and 731 deletions
src/lxc/tools/lxc_attach.c
......@@ -45,6 +45,21 @@
lxc_log_define(lxc_attach, lxc);
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static int add_to_simple_array(char ***array, ssize_t *capacity, char *value);
static bool stdfd_is_pty(void);
static int lxc_attach_create_log_file(const char *log_file);
static int elevated_privileges;
static signed long new_personality = -1;
static int namespace_flags = -1;
static int remount_sys_proc;
static lxc_attach_env_policy_t env_policy = LXC_ATTACH_KEEP_ENV;
static char **extra_env;
static ssize_t extra_env_size;
static char **extra_keep;
static ssize_t extra_keep_size;
static const struct option my_longopts[] = {
{"elevated-privileges", optional_argument, 0, 'e'},
{"arch", required_argument, 0, 'a'},
......@@ -60,43 +75,60 @@ static const struct option my_longopts[] = {
LXC_COMMON_OPTIONS
};
static int elevated_privileges = 0;
static signed long new_personality = -1;
static int namespace_flags = -1;
static int remount_sys_proc = 0;
static lxc_attach_env_policy_t env_policy = LXC_ATTACH_KEEP_ENV;
static char **extra_env = NULL;
static ssize_t extra_env_size = 0;
static char **extra_keep = NULL;
static ssize_t extra_keep_size = 0;
static int add_to_simple_array(char ***array, ssize_t *capacity, char *value)
{
ssize_t count = 0;
if (!array)
return -1;
if (*array)
for (; (*array)[count]; count++);
/* we have to reallocate */
if (count >= *capacity - 1) {
ssize_t new_capacity = ((count + 1) / 32 + 1) * 32;
char **new_array = realloc((void*)*array, sizeof(char *) * new_capacity);
if (!new_array)
return -1;
memset(&new_array[count], 0, sizeof(char*)*(new_capacity - count));
*array = new_array;
*capacity = new_capacity;
}
if (!(*array))
return -1;
(*array)[count] = value;
return 0;
}
static struct lxc_arguments my_args = {
.progname = "lxc-attach",
.help = "\
--name=NAME [-- COMMAND]\n\
\n\
Execute the specified COMMAND - enter the container NAME\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-e, --elevated-privileges=PRIVILEGES\n\
Use elevated privileges instead of those of the\n\
container. If you don't specify privileges to be\n\
elevated as OR'd list: CAP, CGROUP and LSM (capabilities,\n\
cgroup and restrictions, respectively) then all of them\n\
will be elevated.\n\
WARNING: This may leak privileges into the container.\n\
Use with care.\n\
-a, --arch=ARCH Use ARCH for program instead of container's own\n\
architecture.\n\
-s, --namespaces=FLAGS\n\
Don't attach to all the namespaces of the container\n\
but just to the following OR'd list of flags:\n\
MOUNT, PID, UTSNAME, IPC, USER or NETWORK.\n\
WARNING: Using -s implies -e with all privileges\n\
elevated, it may therefore leak privileges into the\n\
container. Use with care.\n\
-R, --remount-sys-proc\n\
Remount /sys and /proc if not attaching to the\n\
mount namespace when using -s in order to properly\n\
reflect the correct namespace context. See the\n\
lxc-attach(1) manual page for details.\n\
--clear-env Clear all environment variables before attaching.\n\
The attached shell/program will start with only\n\
container=lxc set.\n\
--keep-env Keep all current environment variables. This\n\
is the current default behaviour, but is likely to\n\
change in the future.\n\
-L, --pty-log=FILE\n\
Log pty output to FILE\n\
-v, --set-var Set an additional variable that is seen by the\n\
attached program in the container. May be specified\n\
multiple times.\n\
--keep-var Keep an additional environment variable. Only\n\
applicable if --clear-env is specified. May be used\n\
multiple times.\n\
-f, --rcfile=FILE\n\
Load configuration file FILE\n\
",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
......@@ -160,65 +192,45 @@ static int my_parser(struct lxc_arguments *args, int c, char *arg)
return 0;
}
static struct lxc_arguments my_args = {
.progname = "lxc-attach",
.help = "\
--name=NAME [-- COMMAND]\n\
\n\
Execute the specified COMMAND - enter the container NAME\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-e, --elevated-privileges=PRIVILEGES\n\
Use elevated privileges instead of those of the\n\
container. If you don't specify privileges to be\n\
elevated as OR'd list: CAP, CGROUP and LSM (capabilities,\n\
cgroup and restrictions, respectively) then all of them\n\
will be elevated.\n\
WARNING: This may leak privileges into the container.\n\
Use with care.\n\
-a, --arch=ARCH Use ARCH for program instead of container's own\n\
architecture.\n\
-s, --namespaces=FLAGS\n\
Don't attach to all the namespaces of the container\n\
but just to the following OR'd list of flags:\n\
MOUNT, PID, UTSNAME, IPC, USER or NETWORK.\n\
WARNING: Using -s implies -e with all privileges\n\
elevated, it may therefore leak privileges into the\n\
container. Use with care.\n\
-R, --remount-sys-proc\n\
Remount /sys and /proc if not attaching to the\n\
mount namespace when using -s in order to properly\n\
reflect the correct namespace context. See the\n\
lxc-attach(1) manual page for details.\n\
--clear-env Clear all environment variables before attaching.\n\
The attached shell/program will start with only\n\
container=lxc set.\n\
--keep-env Keep all current environment variables. This\n\
is the current default behaviour, but is likely to\n\
change in the future.\n\
-L, --pty-log=FILE\n\
Log pty output to FILE\n\
-v, --set-var Set an additional variable that is seen by the\n\
attached program in the container. May be specified\n\
multiple times.\n\
--keep-var Keep an additional environment variable. Only\n\
applicable if --clear-env is specified. May be used\n\
multiple times.\n\
-f, --rcfile=FILE\n\
Load configuration file FILE\n\
",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
};
static int add_to_simple_array(char ***array, ssize_t *capacity, char *value)
{
ssize_t count = 0;
if (!array)
return -1;
if (*array)
for (; (*array)[count]; count++);
/* we have to reallocate */
if (count >= *capacity - 1) {
ssize_t new_capacity = ((count + 1) / 32 + 1) * 32;
char **new_array = realloc((void*)*array, sizeof(char *) * new_capacity);
if (!new_array)
return -1;
memset(&new_array[count], 0, sizeof(char*)*(new_capacity - count));
*array = new_array;
*capacity = new_capacity;
}
if (!(*array))
return -1;
(*array)[count] = value;
return 0;
}
static bool stdfd_is_pty(void)
{
if (isatty(STDIN_FILENO))
return true;
if (isatty(STDOUT_FILENO))
return true;
if (isatty(STDERR_FILENO))
return true;
......@@ -240,40 +252,34 @@ static int lxc_attach_create_log_file(const char *log_file)
int main(int argc, char *argv[])
{
int ret = -1, r;
int ret = -1;
int wexit = 0;
struct lxc_log log;
pid_t pid;
lxc_attach_options_t attach_options = LXC_ATTACH_OPTIONS_DEFAULT;
lxc_attach_command_t command = (lxc_attach_command_t){.program = NULL};
r = lxc_caps_init();
if (r)
if (lxc_caps_init())
exit(EXIT_FAILURE);
r = lxc_arguments_parse(&my_args, argc, argv);
if (r)
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
if (geteuid()) {
if (geteuid())
if (access(my_args.lxcpath[0], O_RDONLY) < 0) {
ERROR("You lack access to %s", my_args.lxcpath[0]);
exit(EXIT_FAILURE);
}
}
struct lxc_container *c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c)
......
src/lxc/tools/lxc_cgroup.c
......@@ -36,23 +36,15 @@
lxc_log_define(lxc_cgroup, lxc);
static int my_checker(const struct lxc_arguments* args)
{
if (!args->argc) {
ERROR("Missing state object");
return -1;
}
return 0;
}
static int my_checker(const struct lxc_arguments *args);
static const struct option my_longopts[] = {
LXC_COMMON_OPTIONS
};
static struct lxc_arguments my_args = {
.progname = "lxc-cgroup",
.help = "\
.progname = "lxc-cgroup",
.help = "\
--name=NAME state-object [value]\n\
\n\
Get or set the value of a state object (for example, 'cpuset.cpus')\n\
......@@ -61,11 +53,23 @@ in the container's cgroup for the corresponding subsystem.\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = NULL,
.checker = my_checker,
.options = my_longopts,
.parser = NULL,
.checker = my_checker,
.log_priority = "ERROR",
.log_file = "none",
};
static int my_checker(const struct lxc_arguments *args)
{
if (!args->argc) {
ERROR("Missing state object");
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
char *state_object = NULL, *value = NULL;
......@@ -75,18 +79,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
state_object = my_args.argv[0];
......@@ -143,6 +144,7 @@ int main(int argc, char *argv[])
lxc_container_put(c);
exit(EXIT_FAILURE);
}
INFO("%*s", ret, buffer);
}
......
src/lxc/tools/lxc_checkpoint.c
......@@ -30,16 +30,24 @@
#include "log.h"
#include "utils.h"
static char *checkpoint_dir = NULL;
static bool stop = false;
static bool verbose = false;
static bool do_restore = false;
static bool daemonize_set = false;
static bool pre_dump = false;
static char *predump_dir = NULL;
static char *actionscript_path = NULL;
#define OPT_PREDUMP_DIR (OPT_USAGE + 1)
#define OPT_PREDUMP_DIR OPT_USAGE + 1
lxc_log_define(lxc_checkpoint, lxc);
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static int my_checker(const struct lxc_arguments *args);
static bool checkpoint(struct lxc_container *c);
static bool restore_finalize(struct lxc_container *c);
static bool restore(struct lxc_container *c);
static char *checkpoint_dir;
static bool stop;
static bool verbose;
static bool do_restore;
static bool daemonize_set;
static bool pre_dump;
static char *predump_dir;
static char *actionscript_path;
static const struct option my_longopts[] = {
{"checkpoint-dir", required_argument, 0, 'D'},
......@@ -54,31 +62,39 @@ static const struct option my_longopts[] = {
LXC_COMMON_OPTIONS
};
lxc_log_define(lxc_checkpoint, lxc);
static int my_checker(const struct lxc_arguments *args)
{
if (do_restore && stop) {
ERROR("-s not compatible with -r");
return -1;
} else if (!do_restore && daemonize_set) {
ERROR("-d/-F not compatible with -r");
return -1;
}
if (!checkpoint_dir) {
ERROR("-D is required");
return -1;
}
if (pre_dump && do_restore) {
ERROR("-p not compatible with -r");
return -1;
}
return 0;
}
static struct lxc_arguments my_args = {
.progname = "lxc-checkpoint",
.help = "\
--name=NAME\n\
\n\
lxc-checkpoint checkpoints and restores a container\n\
Serializes a container's running state to disk to allow restoring it in\n\
its running state at a later time.\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-r, --restore Restore container\n\
-D, --checkpoint-dir=DIR directory to save the checkpoint in\n\
-v, --verbose Enable verbose criu logs\n\
-A, --action-script=PATH Path to criu action script\n\
Checkpoint options:\n\
-s, --stop Stop the container after checkpointing.\n\
-p, --pre-dump Only pre-dump the memory of the container.\n\
Container keeps on running and following\n\
checkpoints will only dump the changes.\n\
--predump-dir=DIR path to images from previous dump (relative to -D)\n\
Restore options:\n\
-d, --daemon Daemonize the container (default)\n\
-F, --foreground Start with the current tty attached to /dev/console\n\
--rcfile=FILE Load configuration file FILE\n\
",
.options = my_longopts,
.parser = my_parser,
.daemonize = 1,
.checker = my_checker,
.log_priority = "ERROR",
.log_file = "none",
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
......@@ -88,7 +104,7 @@ static int my_parser(struct lxc_arguments *args, int c, char *arg)
if (!checkpoint_dir)
return -1;
break;
case 'A':
case 'A':
actionscript_path = strdup(arg);
if (!actionscript_path)
return -1;
......@@ -123,37 +139,29 @@ static int my_parser(struct lxc_arguments *args, int c, char *arg)
return 0;
}
static struct lxc_arguments my_args = {
.progname = "lxc-checkpoint",
.help = "\
--name=NAME\n\
\n\
lxc-checkpoint checkpoints and restores a container\n\
Serializes a container's running state to disk to allow restoring it in\n\
its running state at a later time.\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-r, --restore Restore container\n\
-D, --checkpoint-dir=DIR directory to save the checkpoint in\n\
-v, --verbose Enable verbose criu logs\n\
-A, --action-script=PATH Path to criu action script\n\
Checkpoint options:\n\
-s, --stop Stop the container after checkpointing.\n\
-p, --pre-dump Only pre-dump the memory of the container.\n\
Container keeps on running and following\n\
checkpoints will only dump the changes.\n\
--predump-dir=DIR path to images from previous dump (relative to -D)\n\
Restore options:\n\
-d, --daemon Daemonize the container (default)\n\
-F, --foreground Start with the current tty attached to /dev/console\n\
--rcfile=FILE Load configuration file FILE\n\
",
.options = my_longopts,
.parser = my_parser,
.daemonize = 1,
.checker = my_checker,
};
static int my_checker(const struct lxc_arguments *args)
{
if (do_restore && stop) {
ERROR("-s not compatible with -r");
return -1;
} else if (!do_restore && daemonize_set) {
ERROR("-d/-F not compatible with -r");
return -1;
}
if (!checkpoint_dir) {
ERROR("-D is required");
return -1;
}
if (pre_dump && do_restore) {
ERROR("-p not compatible with -r");
return -1;
}
return 0;
}
static bool checkpoint(struct lxc_container *c)
{
......@@ -262,18 +270,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
......
src/lxc/tools/lxc_console.c
......@@ -44,28 +44,8 @@
lxc_log_define(lxc_console, lxc);
static char etoc(const char *expr)
{
/* returns "control code" of given expression */
char c = expr[0] == '^' ? expr[1] : expr[0];
return 1 + ((c > 'Z') ? (c - 'a') : (c - 'Z'));
}
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 't':
if (lxc_safe_uint(arg, &args->ttynum) < 0)
return -1;
break;
case 'e':
args->escape = etoc(arg);
break;
}
return 0;
}
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static char etoc(const char *expr);
static const struct option my_longopts[] = {
{"tty", required_argument, 0, 't'},
......@@ -74,8 +54,8 @@ static const struct option my_longopts[] = {
};
static struct lxc_arguments my_args = {
.progname = "lxc-console",
.help = "\
.progname = "lxc-console",
.help = "\
--name=NAME [--tty NUMBER]\n\
\n\
lxc-console logs on the container with the identifier NAME\n\
......@@ -85,35 +65,56 @@ Options :\n\
-t, --tty=NUMBER console tty number\n\
-e, --escape=PREFIX prefix for escape command\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.ttynum = -1,
.escape = 1,
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
.ttynum = -1,
.escape = 1,
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 't':
if (lxc_safe_uint(arg, &args->ttynum) < 0)
return -1;
break;
case 'e':
args->escape = etoc(arg);
break;
}
return 0;
}
static char etoc(const char *expr)
{
/* returns "control code" of given expression */
char c = expr[0] == '^' ? expr[1] : expr[0];
return 1 + ((c > 'Z') ? (c - 'a') : (c - 'Z'));
}
int main(int argc, char *argv[])
{
int ret;
struct lxc_container *c;
struct lxc_log log;
ret = lxc_arguments_parse(&my_args, argc, argv);
if (ret)
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
......
src/lxc/tools/lxc_create.c
......@@ -31,64 +31,15 @@
#include "arguments.h"
#include "log.h"
#include "storage_utils.h"
#include "utils.h"
lxc_log_define(lxc_create, lxc);
static uint64_t get_fssize(char *s)
{
uint64_t ret;
char *end;
ret = strtoull(s, &end, 0);
if (end == s)
{
ERROR("Invalid blockdev size '%s', using default size", s);
return 0;
}
while (isblank(*end))
end++;
if (*end == '\0')
ret *= 1024ULL * 1024ULL; /* MB by default */
else if (*end == 'b' || *end == 'B')
ret *= 1ULL;
else if (*end == 'k' || *end == 'K')
ret *= 1024ULL;
else if (*end == 'm' || *end == 'M')
ret *= 1024ULL * 1024ULL;
else if (*end == 'g' || *end == 'G')
ret *= 1024ULL * 1024ULL * 1024ULL;
else if (*end == 't' || *end == 'T')
ret *= 1024ULL * 1024ULL * 1024ULL * 1024ULL;
else
{
ERROR("Invalid blockdev unit size '%c' in '%s', using default size", *end, s);
return 0;
}
return ret;
}
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 'B': args->bdevtype = arg; break;
case 'f': args->configfile = arg; break;
case 't': args->template = arg; break;
case '0': args->lvname = arg; break;
case '1': args->vgname = arg; break;
case '2': args->thinpool = arg; break;
case '3': args->fstype = arg; break;
case '4': args->fssize = get_fssize(arg); break;
case '5': args->zfsroot = arg; break;
case '6': args->dir = arg; break;
case '7': args->rbdname = arg; break;
case '8': args->rbdpool = arg; break;
}
return 0;
}
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static uint64_t get_fssize(char *s);
static void create_helpfn(const struct lxc_arguments *args);
static bool validate_bdev_args(struct lxc_arguments *args);
static const struct option my_longopts[] = {
{"bdev", required_argument, 0, 'B'},
......@@ -106,35 +57,10 @@ static const struct option my_longopts[] = {
LXC_COMMON_OPTIONS
};
static void create_helpfn(const struct lxc_arguments *args)
{
char *argv[3], *path;
pid_t pid;
if (!args->template)
return;
pid = fork();
if (pid) {
(void)wait_for_pid(pid);
return;
}
path = get_template_path(args->template);
argv[0] = path;
argv[1] = "-h";
argv[2] = NULL;
execv(path, argv);
ERROR("Error executing %s -h", path);
_exit(EXIT_FAILURE);
}
static struct lxc_arguments my_args = {
.progname = "lxc-create",
.helpfn = create_helpfn,
.help = "\
.progname = "lxc-create",
.helpfn = create_helpfn,
.help = "\
--name=NAME --template=TEMPLATE [OPTION...]\n\
\n\
lxc-create creates a container\n\
......@@ -170,64 +96,148 @@ Options :\n\
--fssize=SIZE[U] Create filesystem of\n\
size SIZE * unit U (bBkKmMgGtT)\n\
(Default: 1G, default unit: M)\n",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
};
static bool validate_bdev_args(struct lxc_arguments *a)
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 'B':
args->bdevtype = arg;
break;
case 'f':
args->configfile = arg;
break;
case 't':
args->template = arg;
break;
case '0':
args->lvname = arg;
break;
case '1':
args->vgname = arg;
break;
case '2':
args->thinpool = arg;
break;
case '3':
args->fstype = arg;
break;
case '4':
args->fssize = get_fssize(arg);
break;
case '5':
args->zfsroot = arg;
break;
case '6':
args->dir = arg;
break;
case '7':
args->rbdname = arg;
break;
case '8':
args->rbdpool = arg;
break;
}
return 0;
}
static uint64_t get_fssize(char *s)
{
uint64_t ret;
char *end;
ret = strtoull(s, &end, 0);
if (end == s) {
ERROR("Invalid blockdev size '%s', using default size", s);
return 0;
}
while (isblank(*end))
end++;
if (*end == '\0') {
ret *= 1024ULL * 1024ULL; /* MB by default */
} else if (*end == 'b' || *end == 'B') {
ret *= 1ULL;
} else if (*end == 'k' || *end == 'K') {
ret *= 1024ULL;
} else if (*end == 'm' || *end == 'M') {
ret *= 1024ULL * 1024ULL;
} else if (*end == 'g' || *end == 'G') {
ret *= 1024ULL * 1024ULL * 1024ULL;
} else if (*end == 't' || *end == 'T') {
ret *= 1024ULL * 1024ULL * 1024ULL * 1024ULL;
} else {
ERROR("Invalid blockdev unit size '%c' in '%s', using default size", *end, s);
return 0;
}
return ret;
}
static void create_helpfn(const struct lxc_arguments *args)
{
char *argv[3], *path;
pid_t pid;
if (!args->template)
return;
pid = fork();
if (pid) {
(void)wait_for_pid(pid);
return;
}
path = get_template_path(args->template);
argv[0] = path;
argv[1] = "-h";
argv[2] = NULL;
execv(path, argv);
ERROR("Error executing %s -h", path);
_exit(EXIT_FAILURE);
}
static bool validate_bdev_args(struct lxc_arguments *args)
{
if (strncmp(a->bdevtype, "best", strlen(a->bdevtype)) != 0) {
if (a->fstype || a->fssize) {
if (strncmp(a->bdevtype, "lvm", strlen(a->bdevtype)) != 0 &&
strncmp(a->bdevtype, "loop", strlen(a->bdevtype)) != 0 &&
strncmp(a->bdevtype, "rbd", strlen(a->bdevtype)) != 0) {
if (strncmp(args->bdevtype, "best", strlen(args->bdevtype)) != 0) {
if (args->fstype || args->fssize)
if (strncmp(args->bdevtype, "lvm", strlen(args->bdevtype)) != 0 &&
strncmp(args->bdevtype, "loop", strlen(args->bdevtype)) != 0 &&
strncmp(args->bdevtype, "rbd", strlen(args->bdevtype)) != 0) {
ERROR("Filesystem type and size are only valid with block devices");
return false;
}
}
if (strncmp(a->bdevtype, "lvm", strlen(a->bdevtype)) != 0) {
if (a->lvname || a->vgname || a->thinpool) {
if (strncmp(args->bdevtype, "lvm", strlen(args->bdevtype)) != 0)
if (args->lvname || args->vgname || args->thinpool) {
ERROR("--lvname, --vgname and --thinpool are only valid with -B lvm");
return false;
}
}
if (strncmp(a->bdevtype, "rbd", strlen(a->bdevtype)) != 0) {
if (a->rbdname || a->rbdpool) {
if (strncmp(args->bdevtype, "rbd", strlen(args->bdevtype)) != 0)
if (args->rbdname || args->rbdpool) {
ERROR("--rbdname and --rbdpool are only valid with -B rbd");
return false;
}
}
if (strncmp(a->bdevtype, "zfs", strlen(a->bdevtype)) != 0) {
if (a->zfsroot) {
if (strncmp(args->bdevtype, "zfs", strlen(args->bdevtype)) != 0)
if (args->zfsroot) {
ERROR("zfsroot is only valid with -B zfs");
return false;
}
}
}
return true;
}
static bool is_valid_storage_type(const char *type)
{
if (strcmp(type, "dir") == 0 ||
strcmp(type, "btrfs") == 0 ||
strcmp(type, "loop") == 0 ||
strcmp(type, "lvm") == 0 ||
strcmp(type, "nbd") == 0 ||
strcmp(type, "overlay") == 0 ||
strcmp(type, "overlayfs") == 0 ||
strcmp(type, "rbd") == 0 ||
strcmp(type, "zfs") == 0)
return true;
return false;
}
int main(int argc, char *argv[])
{
struct lxc_container *c;
......@@ -238,21 +248,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
if (!my_args.log_file)
log.file = "none";
else
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
if (!my_args.template) {
ERROR("A template must be specified");
......@@ -318,13 +322,12 @@ int main(int argc, char *argv[])
spec.fssize = my_args.fssize;
if ((strncmp(my_args.bdevtype, "zfs", strlen(my_args.bdevtype)) == 0) ||
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0)) {
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0))
if (my_args.zfsroot)
spec.zfs.zfsroot = my_args.zfsroot;
}
if ((strncmp(my_args.bdevtype, "lvm", strlen(my_args.bdevtype)) == 0) ||
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0)) {
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0)) {
if (my_args.lvname)
spec.lvm.lv = my_args.lvname;
......@@ -336,7 +339,7 @@ int main(int argc, char *argv[])
}
if ((strncmp(my_args.bdevtype, "rbd", strlen(my_args.bdevtype)) == 0) ||
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0)) {
(strncmp(my_args.bdevtype, "best", strlen(my_args.bdevtype)) == 0)) {
if (my_args.rbdname)
spec.rbd.rbdname = my_args.rbdname;
......@@ -354,7 +357,7 @@ int main(int argc, char *argv[])
flags = LXC_CREATE_QUIET;
if (!c->create(c, my_args.template, my_args.bdevtype, &spec, flags, &argv[optind])) {
fprintf(stderr, "Error creating container %s\n", c->name);
ERROR("Failed to create container %s", c->name);
lxc_container_put(c);
exit(EXIT_FAILURE);
}
......
src/lxc/tools/lxc_destroy.c
......@@ -35,6 +35,8 @@
lxc_log_define(lxc_destroy, lxc);
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static bool do_destroy(struct lxc_container *c);
static bool do_destroy_with_snapshots(struct lxc_container *c);
static const struct option my_longopts[] = {
{"force", no_argument, 0, 'f'},
......@@ -43,8 +45,8 @@ static const struct option my_longopts[] = {
};
static struct lxc_arguments my_args = {
.progname = "lxc-destroy",
.help = "\
.progname = "lxc-destroy",
.help = "\
--name=NAME [-f] [-P lxcpath]\n\
\n\
lxc-destroy destroys a container with the identifier NAME\n\
......@@ -54,106 +56,35 @@ Options :\n\
-s, --snapshots destroy including all snapshots\n\
-f, --force wait for the container to shut down\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.task = DESTROY,
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
.task = DESTROY,
};
static bool do_destroy(struct lxc_container *c);
static bool do_destroy_with_snapshots(struct lxc_container *c);
int main(int argc, char *argv[])
{
struct lxc_container *c;
struct lxc_log log;
bool bret;
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
ERROR("System error loading container");
exit(EXIT_FAILURE);
}
if (my_args.rcfile) {
c->clear_config(c);
if (!c->load_config(c, my_args.rcfile)) {
ERROR("Failed to load rcfile");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
c->configfile = strdup(my_args.rcfile);
if (!c->configfile) {
ERROR("Out of memory setting new config filename");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
}
if (!c->may_control(c)) {
ERROR("Insufficent privileges to control %s", my_args.name);
lxc_container_put(c);
exit(EXIT_FAILURE);
}
if (!c->is_defined(c)) {
ERROR("Container is not defined");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
if (my_args.task == SNAP) {
bret = do_destroy_with_snapshots(c);
if (bret)
ERROR("Destroyed container %s including snapshots", my_args.name);
} else {
bret = do_destroy(c);
if (bret)
ERROR("Destroyed container %s", my_args.name);
}
lxc_container_put(c);
if (bret)
exit(EXIT_SUCCESS);
exit(EXIT_FAILURE);
}
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 'f': args->force = 1; break;
case 's': args->task = SNAP; break;
case 'f':
args->force = 1;
break;
case 's':
args->task = SNAP;
break;
}
return 0;
}
static bool do_destroy(struct lxc_container *c)
{
int ret;
bool bret = true;
char path[MAXPATHLEN];
/* First check whether the container has dependent clones or snapshots. */
int ret = snprintf(path, MAXPATHLEN, "%s/%s/lxc_snapshots", c->config_path, c->name);
ret = snprintf(path, MAXPATHLEN, "%s/%s/lxc_snapshots", c->config_path, c->name);
if (ret < 0 || ret >= MAXPATHLEN)
return false;
......@@ -187,9 +118,8 @@ static bool do_destroy(struct lxc_container *c)
char buf[256];
ret = c->get_config_item(c, "lxc.ephemeral", buf, 256);
if (ret > 0 && strcmp(buf, "0") == 0) {
if (ret > 0 && strcmp(buf, "0") == 0)
bret = c->destroy(c);
}
}
if (!bret) {
......@@ -273,3 +203,75 @@ static bool do_destroy_with_snapshots(struct lxc_container *c)
return bret;
}
int main(int argc, char *argv[])
{
struct lxc_container *c;
struct lxc_log log;
bool bret;
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
ERROR("System error loading container");
exit(EXIT_FAILURE);
}
if (my_args.rcfile) {
c->clear_config(c);
if (!c->load_config(c, my_args.rcfile)) {
ERROR("Failed to load rcfile");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
c->configfile = strdup(my_args.rcfile);
if (!c->configfile) {
ERROR("Out of memory setting new config filename");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
}
if (!c->may_control(c)) {
ERROR("Insufficent privileges to control %s", my_args.name);
lxc_container_put(c);
exit(EXIT_FAILURE);
}
if (!c->is_defined(c)) {
ERROR("Container is not defined");
lxc_container_put(c);
exit(EXIT_FAILURE);
}
if (my_args.task == SNAP) {
bret = do_destroy_with_snapshots(c);
if (bret)
ERROR("Destroyed container %s including snapshots", my_args.name);
} else {
bret = do_destroy(c);
if (bret)
ERROR("Destroyed container %s", my_args.name);
}
lxc_container_put(c);
if (bret)
exit(EXIT_SUCCESS);
exit(EXIT_FAILURE);
}
src/lxc/tools/lxc_device.c
......@@ -33,21 +33,23 @@
#include "log.h"
#include "utils.h"
lxc_log_define(lxc_device, lxc);
#if HAVE_IFADDRS_H
#include <ifaddrs.h>
#else
#include "include/ifaddrs.h"
#endif
lxc_log_define(lxc_device, lxc);
static bool is_interface(const char *dev_name, pid_t pid);
static const struct option my_longopts[] = {
LXC_COMMON_OPTIONS
};
static struct lxc_arguments my_args = {
.progname = "lxc-device",
.help = "\
.progname = "lxc-device",
.help = "\
--name=NAME -- add|del DEV\n\
\n\
lxc-device attach or detach DEV to or from container.\n\
......@@ -55,9 +57,11 @@ lxc-device attach or detach DEV to or from container.\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
};
static bool is_interface(const char *dev_name, pid_t pid)
......@@ -110,25 +114,22 @@ int main(int argc, char *argv[])
}
if (lxc_arguments_parse(&my_args, argc, argv))
goto err;
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
ERROR("%s doesn't exist", my_args.name);
goto err;
exit(EXIT_FAILURE);
}
if (my_args.rcfile) {
......@@ -136,65 +137,60 @@ int main(int argc, char *argv[])
if (!c->load_config(c, my_args.rcfile)) {
ERROR("Failed to load rcfile");
goto err1;
goto err;
}
c->configfile = strdup(my_args.rcfile);
if (!c->configfile) {
ERROR("Out of memory setting new config filename");
goto err1;
goto err;
}
}
if (!c->is_running(c)) {
ERROR("Container %s is not running", c->name);
goto err1;
goto err;
}
if (my_args.argc < 2) {
ERROR("Error: no command given (Please see --help output)");
goto err1;
goto err;
}
cmd = my_args.argv[0];
dev_name = my_args.argv[1];
if (my_args.argc < 3)
dst_name = dev_name;
else
dst_name = my_args.argv[2];
if (strncmp(cmd, "add", strlen(cmd)) == 0) {
if (is_interface(dev_name, 1)) {
if (is_interface(dev_name, 1))
ret = c->attach_interface(c, dev_name, dst_name);
} else {
else
ret = c->add_device_node(c, dev_name, dst_name);
}
if (ret != true) {
ERROR("Failed to add %s to %s", dev_name, c->name);
goto err1;
goto err;
}
} else if (strncmp(cmd, "del", strlen(cmd)) == 0) {
if (is_interface(dev_name, c->init_pid(c))) {
if (is_interface(dev_name, c->init_pid(c)))
ret = c->detach_interface(c, dev_name, dst_name);
} else {
else
ret = c->remove_device_node(c, dev_name, dst_name);
}
if (ret != true) {
ERROR("Failed to del %s from %s", dev_name, c->name);
goto err1;
goto err;
}
} else {
ERROR("Error: Please use add or del (Please see --help output)");
goto err1;
goto err;
}
exit(EXIT_SUCCESS);
err1:
lxc_container_put(c);
err:
lxc_container_put(c);
exit(EXIT_FAILURE);
}
src/lxc/tools/lxc_execute.c
......@@ -43,8 +43,46 @@
lxc_log_define(lxc_execute, lxc);
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static bool set_argv(struct lxc_container *c, struct lxc_arguments *args);
static struct lxc_list defines;
static const struct option my_longopts[] = {
{"daemon", no_argument, 0, 'd'},
{"rcfile", required_argument, 0, 'f'},
{"define", required_argument, 0, 's'},
{"uid", required_argument, 0, 'u'},
{"gid", required_argument, 0, 'g'},
{"share-net", required_argument, 0, OPT_SHARE_NET},
{"share-ipc", required_argument, 0, OPT_SHARE_IPC},
{"share-uts", required_argument, 0, OPT_SHARE_UTS},
{"share-pid", required_argument, 0, OPT_SHARE_PID},
LXC_COMMON_OPTIONS
};
static struct lxc_arguments my_args = {
.progname = "lxc-execute",
.help = "\
--name=NAME -- COMMAND\n\
\n\
lxc-execute creates a container with the identifier NAME\n\
and execs COMMAND into this container.\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-d, --daemon Daemonize the container\n\
-f, --rcfile=FILE Load configuration file FILE\n\
-s, --define KEY=VAL Assign VAL to configuration variable KEY\n\
-u, --uid=UID Execute COMMAND with UID inside the container\n\
-g, --gid=GID Execute COMMAND with GID inside the container\n",
.options = my_longopts,
.parser = my_parser,
.log_priority = "ERROR",
.log_file = "none",
.daemonize = 0,
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
int ret;
......@@ -82,43 +120,9 @@ static int my_parser(struct lxc_arguments *args, int c, char *arg)
args->share_ns[LXC_NS_PID] = arg;
break;
}
return 0;
}
static const struct option my_longopts[] = {
{"daemon", no_argument, 0, 'd'},
{"rcfile", required_argument, 0, 'f'},
{"define", required_argument, 0, 's'},
{"uid", required_argument, 0, 'u'},
{"gid", required_argument, 0, 'g'},
{"share-net", required_argument, 0, OPT_SHARE_NET},
{"share-ipc", required_argument, 0, OPT_SHARE_IPC},
{"share-uts", required_argument, 0, OPT_SHARE_UTS},
{"share-pid", required_argument, 0, OPT_SHARE_PID},
LXC_COMMON_OPTIONS
};
static struct lxc_arguments my_args = {
.progname = "lxc-execute",
.help = "\
--name=NAME -- COMMAND\n\
\n\
lxc-execute creates a container with the identifier NAME\n\
and execs COMMAND into this container.\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-d, --daemon Daemonize the container\n\
-f, --rcfile=FILE Load configuration file FILE\n\
-s, --define KEY=VAL Assign VAL to configuration variable KEY\n\
-u, --uid=UID Execute COMMAND with UID inside the container\n\
-g, --gid=GID Execute COMMAND with GID inside the container\n",
.options = my_longopts,
.parser = my_parser,
.daemonize = 0,
};
static bool set_argv(struct lxc_container *c, struct lxc_arguments *args)
{
int ret;
......@@ -134,6 +138,7 @@ static bool set_argv(struct lxc_container *c, struct lxc_arguments *args)
return false;
args->argv = components;
for (p = components; *p; p++)
args->argc++;
......@@ -156,18 +161,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(err);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(err);
}
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(err);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
......@@ -195,12 +197,11 @@ int main(int argc, char *argv[])
goto out;
}
if (my_args.argc == 0) {
if (my_args.argc == 0)
if (!set_argv(c, &my_args)) {
ERROR("Missing command to execute!");
goto out;
}
}
bret = lxc_config_define_load(&defines, c);
if (!bret)
......@@ -244,12 +245,11 @@ int main(int argc, char *argv[])
if (c->daemonize) {
err = EXIT_SUCCESS;
} else {
if (WIFEXITED(c->error_num)) {
if (WIFEXITED(c->error_num))
err = WEXITSTATUS(c->error_num);
} else {
else
/* Try to die with the same signal the task did. */
kill(0, WTERMSIG(c->error_num));
}
}
out:
......
src/lxc/tools/lxc_freeze.c
......@@ -41,8 +41,8 @@ static const struct option my_longopts[] = {
};
static struct lxc_arguments my_args = {
.progname = "lxc-freeze",
.help = "\
.progname = "lxc-freeze",
.help = "\
--name=NAME\n\
\n\
lxc-freeze freezes a container with the identifier NAME\n\
......@@ -50,9 +50,11 @@ lxc-freeze freezes a container with the identifier NAME\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
};
int main(int argc, char *argv[])
......@@ -63,18 +65,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
......
src/lxc/tools/lxc_start.c
......@@ -46,41 +46,58 @@
#include "confile.h"
#include "log.h"
static struct lxc_list defines;
lxc_log_define(lxc_start, lxc);
static int ensure_path(struct lxc_arguments *args, char **confpath, const char *path)
{
int err = -1, fd;
char *fullpath = NULL;
if (path) {
if (access(path, W_OK)) {
fd = creat(path, 0600);
if (fd < 0 && errno != EEXIST) {
ERROR("Failed to create '%s'", path);
goto err;
}
if (fd >= 0)
close(fd);
}
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static int ensure_path(struct lxc_arguments *args, char **confpath, const char *path);
fullpath = realpath(path, NULL);
if (!fullpath) {
ERROR("Failed to get the real path of '%s'", path);
goto err;
}
*confpath = fullpath;
}
static struct lxc_list defines;
err = EXIT_SUCCESS;
static const struct option my_longopts[] = {
{"daemon", no_argument, 0, 'd'},
{"foreground", no_argument, 0, 'F'},
{"rcfile", required_argument, 0, 'f'},
{"define", required_argument, 0, 's'},
{"console", required_argument, 0, 'c'},
{"console-log", required_argument, 0, 'L'},
{"close-all-fds", no_argument, 0, 'C'},
{"pidfile", required_argument, 0, 'p'},
{"share-net", required_argument, 0, OPT_SHARE_NET},
{"share-ipc", required_argument, 0, OPT_SHARE_IPC},
{"share-uts", required_argument, 0, OPT_SHARE_UTS},
{"share-pid", required_argument, 0, OPT_SHARE_PID},
LXC_COMMON_OPTIONS
};
err:
return err;
}
static struct lxc_arguments my_args = {
.progname = "lxc-start",
.help = "\
--name=NAME -- COMMAND\n\
\n\
lxc-start start COMMAND in specified container NAME\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-d, --daemon Daemonize the container (default)\n\
-F, --foreground Start with the current tty attached to /dev/console\n\
-p, --pidfile=FILE Create a file with the process id\n\
-f, --rcfile=FILE Load configuration file FILE\n\
-c, --console=FILE Use specified FILE for the container console\n\
-L, --console-log=FILE Log container console output to FILE\n\
-C, --close-all-fds If any fds are inherited, close them\n\
If not specified, exit with failure instead\n\
Note: --daemon implies --close-all-fds\n\
-s, --define KEY=VAL Assign VAL to configuration variable KEY\n\
--share-[net|ipc|uts|pid]=NAME Share a namespace with another container or pid\n\
",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
.daemonize = 1,
.pidfile = NULL,
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
......@@ -124,49 +141,34 @@ static int my_parser(struct lxc_arguments *args, int c, char *arg)
return 0;
}
static const struct option my_longopts[] = {
{"daemon", no_argument, 0, 'd'},
{"foreground", no_argument, 0, 'F'},
{"rcfile", required_argument, 0, 'f'},
{"define", required_argument, 0, 's'},
{"console", required_argument, 0, 'c'},
{"console-log", required_argument, 0, 'L'},
{"close-all-fds", no_argument, 0, 'C'},
{"pidfile", required_argument, 0, 'p'},
{"share-net", required_argument, 0, OPT_SHARE_NET},
{"share-ipc", required_argument, 0, OPT_SHARE_IPC},
{"share-uts", required_argument, 0, OPT_SHARE_UTS},
{"share-pid", required_argument, 0, OPT_SHARE_PID},
LXC_COMMON_OPTIONS
};
static int ensure_path(struct lxc_arguments *args, char **confpath, const char *path)
{
int fd;
char *fullpath = NULL;
static struct lxc_arguments my_args = {
.progname = "lxc-start",
.help = "\
--name=NAME -- COMMAND\n\
\n\
lxc-start start COMMAND in specified container NAME\n\
\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
-d, --daemon Daemonize the container (default)\n\
-F, --foreground Start with the current tty attached to /dev/console\n\
-p, --pidfile=FILE Create a file with the process id\n\
-f, --rcfile=FILE Load configuration file FILE\n\
-c, --console=FILE Use specified FILE for the container console\n\
-L, --console-log=FILE Log container console output to FILE\n\
-C, --close-all-fds If any fds are inherited, close them\n\
If not specified, exit with failure instead\n\
Note: --daemon implies --close-all-fds\n\
-s, --define KEY=VAL Assign VAL to configuration variable KEY\n\
--share-[net|ipc|uts|pid]=NAME Share a namespace with another container or pid\n\
",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.daemonize = 1,
.pidfile = NULL,
};
if (path) {
if (access(path, W_OK)) {
fd = creat(path, 0600);
if (fd < 0 && errno != EEXIST) {
ERROR("Failed to create '%s'", path);
return -1;
}
if (fd >= 0)
close(fd);
}
fullpath = realpath(path, NULL);
if (!fullpath) {
ERROR("Failed to get the real path of '%s'", path);
return -1;
}
*confpath = fullpath;
}
return 0;
}
int main(int argc, char *argv[])
{
......@@ -194,18 +196,15 @@ int main(int argc, char *argv[])
else
args = my_args.argv;
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(err);
}
if (lxc_log_init(&log))
exit(err);
lxcpath = my_args.lxcpath[0];
if (access(lxcpath, O_RDONLY) < 0) {
......@@ -297,12 +296,11 @@ int main(int argc, char *argv[])
goto out;
}
if (my_args.pidfile != NULL) {
if (my_args.pidfile)
if (ensure_path(&my_args, &c->pidfile, my_args.pidfile) < 0) {
ERROR("Failed to ensure pidfile '%s'", my_args.pidfile);
goto out;
}
}
if (my_args.console)
if (!c->set_config_item(c, "lxc.console.path", my_args.console))
......@@ -315,9 +313,8 @@ int main(int argc, char *argv[])
if (!lxc_setup_shared_ns(&my_args, c))
goto out;
if (!my_args.daemonize) {
if (!my_args.daemonize)
c->want_daemonize(c, false);
}
if (my_args.close_all_fds)
c->want_close_all_fds(c, true);
......
src/lxc/tools/lxc_stop.c
......@@ -34,36 +34,12 @@
#include "log.h"
#include "utils.h"
#define OPT_NO_LOCK OPT_USAGE + 1
#define OPT_NO_KILL OPT_USAGE + 2
#define OPT_NO_LOCK (OPT_USAGE + 1)
#define OPT_NO_KILL (OPT_USAGE + 2)
lxc_log_define(lxc_stop, lxc);
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 'r':
args->reboot = 1;
break;
case 'W':
args->nowait = 1;
break;
case 't':
if (lxc_safe_long(arg, &args->timeout) < 0)
return -1;
break;
case 'k':
args->hardstop = 1;
break;
case OPT_NO_LOCK:
args->nolock = 1;
break;
case OPT_NO_KILL:
args->nokill = 1;
break;
}
return 0;
}
static int my_parser(struct lxc_arguments *args, int c, char *arg);
static const struct option my_longopts[] = {
{"reboot", no_argument, 0, 'r'},
......@@ -76,8 +52,8 @@ static const struct option my_longopts[] = {
};
static struct lxc_arguments my_args = {
.progname = "lxc-stop",
.help = "\
.progname = "lxc-stop",
.help = "\
--name=NAME\n\
\n\
lxc-stop stops a container with the identifier NAME\n\
......@@ -91,12 +67,40 @@ Options :\n\
--nolock Avoid using API locks\n\
--nokill Only request clean shutdown, don't force kill after timeout\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.timeout = -2,
.options = my_longopts,
.parser = my_parser,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
.timeout = -2,
};
static int my_parser(struct lxc_arguments *args, int c, char *arg)
{
switch (c) {
case 'r':
args->reboot = 1;
break;
case 'W':
args->nowait = 1;
break;
case 't':
if (lxc_safe_long(arg, &args->timeout) < 0)
return -1;
break;
case 'k':
args->hardstop = 1;
break;
case OPT_NO_LOCK:
args->nolock = 1;
break;
case OPT_NO_KILL:
args->nokill = 1;
break;
}
return 0;
}
int main(int argc, char *argv[])
{
struct lxc_container *c;
......@@ -107,18 +111,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(ret);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(ret);
}
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(ret);
/* Set default timeout */
if (my_args.timeout == -2) {
......
src/lxc/tools/lxc_unfreeze.c
......@@ -40,8 +40,8 @@ static const struct option my_longopts[] = {
};
static struct lxc_arguments my_args = {
.progname = "lxc-unfreeze",
.help = "\
.progname = "lxc-unfreeze",
.help = "\
--name=NAME\n\
\n\
lxc-unfreeze unfreezes a container with the identifier NAME\n\
......@@ -49,9 +49,11 @@ lxc-unfreeze unfreezes a container with the identifier NAME\n\
Options :\n\
-n, --name=NAME NAME of the container\n\
--rcfile=FILE Load configuration file FILE\n",
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.options = my_longopts,
.parser = NULL,
.checker = NULL,
.log_priority = "ERROR",
.log_file = "none",
};
int main(int argc, char *argv[])
......@@ -62,18 +64,15 @@ int main(int argc, char *argv[])
if (lxc_arguments_parse(&my_args, argc, argv))
exit(EXIT_FAILURE);
/* Only create log if explicitly instructed */
if (my_args.log_file || my_args.log_priority) {
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
log.name = my_args.name;
log.file = my_args.log_file;
log.level = my_args.log_priority;
log.prefix = my_args.progname;
log.quiet = my_args.quiet;
log.lxcpath = my_args.lxcpath[0];
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
}
if (lxc_log_init(&log))
exit(EXIT_FAILURE);
c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
if (!c) {
......
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