[CRIU] [PATCH 1/3] libcriu: use criu_opts structure to keep all the options
Andrew Vagin
avagin at gmail.com
Tue Jul 21 02:10:23 PDT 2015
On Wed, Jul 15, 2015 at 04:45:02AM +0300, Ruslan Kuprieiev wrote:
> criu_opts contains rpc options and notify callback,
> so we can keep all options in just one structure.
> This will allow us to easily extend libcriu functionality
> and yet keep all options in one place.
>
> We're also not hiding rpc opts structure anymore, so
> it is pretty clear where power-user should put his own
> CriuOpts instance if he would like to do that.
>
> Signed-off-by: Ruslan Kuprieiev <rkuprieiev at cloudlinux.com>
> ---
> Makefile | 2 +-
> lib/criu.c | 469 ++++++++++++++++++++++++-------------------------------------
> lib/criu.h | 81 ++++++-----
> 3 files changed, 228 insertions(+), 324 deletions(-)
>
> diff --git a/Makefile b/Makefile
> index 6ed4c90..d67ed0b 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -161,7 +161,7 @@ SYSCALL-LIB := $(ARCH_DIR)/syscalls.built-in.o
> ARCH-LIB := $(ARCH_DIR)/crtools.built-in.o
> CRIU-SO := libcriu
> CRIU-LIB := lib/$(CRIU-SO).so
> -CRIU-INC := lib/criu.h include/criu-plugin.h include/criu-log.h protobuf/rpc.proto
> +CRIU-INC := lib/criu.h include/criu-plugin.h include/criu-log.h protobuf/rpc.proto protobuf/rpc.pb-c.h
> ifeq ($(piegen-y),y)
> piegen := pie/piegen/piegen
> endif
> diff --git a/lib/criu.c b/lib/criu.c
> index 329d051..3b36ddd 100644
> --- a/lib/criu.c
> +++ b/lib/criu.c
> @@ -19,8 +19,7 @@
> const char *criu_lib_version = CRIU_VERSION;
>
> static char *service_address = CR_DEFAULT_SERVICE_ADDRESS;
> -static CriuOpts *global_opts;
> -static int (*notify)(char *action, criu_notify_arg_t na);
> +static criu_opts *global_opts;
> static int saved_errno;
>
> void criu_set_service_address(char *path)
> @@ -31,42 +30,53 @@ void criu_set_service_address(char *path)
> service_address = CR_DEFAULT_SERVICE_ADDRESS;
> }
>
> -int criu_local_init_opts(void **o)
> +int criu_local_init_opts(criu_opts **o)
> {
> - if (*o) {
> - notify = NULL;
> - criu_opts__free_unpacked((CriuOpts *)*o, NULL);
> + criu_opts *opts = NULL;
> + CriuOpts *rpc = NULL;
> +
> + opts = *o;
> +
> + if (opts && opts->rpc)
> + criu_opts__free_unpacked(opts->rpc, NULL);
Do we need to release opts too?
> +
> + rpc = malloc(sizeof(CriuOpts));
> + if (rpc == NULL) {
> + perror("Can't allocate memory for criu RPC opts");
> + return -1;
> }
>
> - *o = malloc(sizeof(CriuOpts));
> - if (*o == NULL) {
> + criu_opts__init(rpc);
> +
> + opts = malloc(sizeof(criu_opts));
> + if (opts == NULL) {
You leak rpc here
> perror("Can't allocate memory for criu opts");
> return -1;
> }
>
> - criu_opts__init((CriuOpts *)*o);
> + opts->rpc = rpc;
> + opts->notify = NULL;
> +
> + *o = opts;
> +
> return 0;
> }
>
> int criu_init_opts(void)
> {
> - return criu_local_init_opts((void **)&global_opts);
> + return criu_local_init_opts(&global_opts);
> }
>
> -void criu_local_set_notify_cb(void *o, int (*cb)(char *action, criu_notify_arg_t na))
> +void criu_local_set_notify_cb(criu_opts *opts, int (*cb)(char *action, criu_notify_arg_t na))
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - notify = cb;
> - opts->has_notify_scripts = true;
> - opts->notify_scripts = true;
> + opts->notify = cb;
> + opts->rpc->has_notify_scripts = true;
> + opts->rpc->notify_scripts = true;
> }
>
> void criu_set_notify_cb(int (*cb)(char *action, criu_notify_arg_t na))
> {
> - criu_local_set_notify_cb((void *)global_opts, cb);
> + criu_local_set_notify_cb(global_opts, cb);
> }
>
> int criu_notify_pid(criu_notify_arg_t na)
> @@ -74,351 +84,260 @@ int criu_notify_pid(criu_notify_arg_t na)
> return na->has_pid ? na->pid : 0;
> }
>
> -void criu_local_set_pid(void *o, int pid)
> +void criu_local_set_pid(criu_opts *opts, int pid)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_pid = true;
> - opts->pid = pid;
> + opts->rpc->has_pid = true;
> + opts->rpc->pid = pid;
> }
>
> void criu_set_pid(int pid)
> {
> - criu_local_set_pid((void *)global_opts, pid);
> + criu_local_set_pid(global_opts, pid);
> }
>
> -void criu_local_set_images_dir_fd(void *o, int fd)
> +void criu_local_set_images_dir_fd(criu_opts *opts, int fd)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->images_dir_fd = fd;
> + opts->rpc->images_dir_fd = fd;
> }
>
> void criu_set_images_dir_fd(int fd)
> {
> - criu_local_set_images_dir_fd((void *)global_opts, fd);
> + criu_local_set_images_dir_fd(global_opts, fd);
> }
>
> -void criu_local_set_parent_images(void *o, char *path)
> +void criu_local_set_parent_images(criu_opts *opts, char *path)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->parent_img = strdup(path);
> + opts->rpc->parent_img = strdup(path);
> }
>
> void criu_set_parent_images(char *path)
> {
> - criu_local_set_parent_images((void *)global_opts, path);
> + criu_local_set_parent_images(global_opts, path);
> }
>
> -void criu_local_set_track_mem(void *o, bool track_mem)
> +void criu_local_set_track_mem(criu_opts *opts, bool track_mem)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_track_mem = true;
> - opts->track_mem = track_mem;
> + opts->rpc->has_track_mem = true;
> + opts->rpc->track_mem = track_mem;
> }
>
> void criu_set_track_mem(bool track_mem)
> {
> - criu_local_set_track_mem((void *)global_opts, track_mem);
> + criu_local_set_track_mem(global_opts, track_mem);
> }
>
> -void criu_local_set_auto_dedup(void *o, bool auto_dedup)
> +void criu_local_set_auto_dedup(criu_opts *opts, bool auto_dedup)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_auto_dedup = true;
> - opts->auto_dedup = auto_dedup;
> + opts->rpc->has_auto_dedup = true;
> + opts->rpc->auto_dedup = auto_dedup;
> }
>
> void criu_set_auto_dedup(bool auto_dedup)
> {
> - criu_local_set_auto_dedup((void *)global_opts, auto_dedup);
> + criu_local_set_auto_dedup(global_opts, auto_dedup);
> }
>
> -void criu_local_set_force_irmap(void *o, bool force_irmap)
> +void criu_local_set_force_irmap(criu_opts *opts, bool force_irmap)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_force_irmap = true;
> - opts->force_irmap = force_irmap;
> + opts->rpc->has_force_irmap = true;
> + opts->rpc->force_irmap = force_irmap;
> }
>
> void criu_set_force_irmap(bool force_irmap)
> {
> - criu_local_set_force_irmap((void *)global_opts, force_irmap);
> + criu_local_set_force_irmap(global_opts, force_irmap);
> }
>
> -void criu_local_set_link_remap(void *o, bool link_remap)
> +void criu_local_set_link_remap(criu_opts *opts, bool link_remap)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_link_remap = true;
> - opts->link_remap = link_remap;
> + opts->rpc->has_link_remap = true;
> + opts->rpc->link_remap = link_remap;
> }
>
> void criu_set_link_remap(bool link_remap)
> {
> - criu_local_set_link_remap((void *)global_opts, link_remap);
> + criu_local_set_link_remap(global_opts, link_remap);
> }
>
> -void criu_local_set_work_dir_fd(void *o, int fd)
> +void criu_local_set_work_dir_fd(criu_opts *opts, int fd)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_work_dir_fd = true;
> - opts->work_dir_fd = fd;
> + opts->rpc->has_work_dir_fd = true;
> + opts->rpc->work_dir_fd = fd;
> }
>
> void criu_set_work_dir_fd(int fd)
> {
> - criu_local_set_work_dir_fd((void *)global_opts, fd);
> + criu_local_set_work_dir_fd(global_opts, fd);
> }
>
> -void criu_local_set_leave_running(void *o, bool leave_running)
> +void criu_local_set_leave_running(criu_opts *opts, bool leave_running)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_leave_running = true;
> - opts->leave_running = leave_running;
> + opts->rpc->has_leave_running = true;
> + opts->rpc->leave_running = leave_running;
> }
>
> void criu_set_leave_running(bool leave_running)
> {
> - criu_local_set_leave_running((void *)global_opts, leave_running);
> + criu_local_set_leave_running(global_opts, leave_running);
> }
>
> -void criu_local_set_ext_unix_sk(void *o, bool ext_unix_sk)
> +void criu_local_set_ext_unix_sk(criu_opts *opts, bool ext_unix_sk)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_ext_unix_sk = true;
> - opts->ext_unix_sk = ext_unix_sk;
> + opts->rpc->has_ext_unix_sk = true;
> + opts->rpc->ext_unix_sk = ext_unix_sk;
> }
>
> void criu_set_ext_unix_sk(bool ext_unix_sk)
> {
> - criu_local_set_ext_unix_sk((void *)global_opts, ext_unix_sk);
> + criu_local_set_ext_unix_sk(global_opts, ext_unix_sk);
> }
>
> -void criu_local_set_tcp_established(void *o, bool tcp_established)
> +void criu_local_set_tcp_established(criu_opts *opts, bool tcp_established)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_tcp_established = true;
> - opts->tcp_established = tcp_established;
> + opts->rpc->has_tcp_established = true;
> + opts->rpc->tcp_established = tcp_established;
> }
>
> void criu_set_tcp_established(bool tcp_established)
> {
> - criu_local_set_tcp_established((void *)global_opts, tcp_established);
> + criu_local_set_tcp_established(global_opts, tcp_established);
> }
>
> -void criu_local_set_evasive_devices(void *o, bool evasive_devices)
> +void criu_local_set_evasive_devices(criu_opts *opts, bool evasive_devices)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_evasive_devices = true;
> - opts->evasive_devices = evasive_devices;
> + opts->rpc->has_evasive_devices = true;
> + opts->rpc->evasive_devices = evasive_devices;
> }
>
> void criu_set_evasive_devices(bool evasive_devices)
> {
> - criu_local_set_evasive_devices((void *)global_opts, evasive_devices);
> + criu_local_set_evasive_devices(global_opts, evasive_devices);
> }
>
> -void criu_local_set_shell_job(void *o, bool shell_job)
> +void criu_local_set_shell_job(criu_opts *opts, bool shell_job)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_shell_job = true;
> - opts->shell_job = shell_job;
> + opts->rpc->has_shell_job = true;
> + opts->rpc->shell_job = shell_job;
> }
>
> void criu_set_shell_job(bool shell_job)
> {
> - criu_local_set_shell_job((void *)global_opts, shell_job);
> + criu_local_set_shell_job(global_opts, shell_job);
> }
>
> -void criu_local_set_file_locks(void *o, bool file_locks)
> +void criu_local_set_file_locks(criu_opts *opts, bool file_locks)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_file_locks = true;
> - opts->file_locks = file_locks;
> + opts->rpc->has_file_locks = true;
> + opts->rpc->file_locks = file_locks;
> }
>
> void criu_set_file_locks(bool file_locks)
> {
> - criu_local_set_file_locks((void *)global_opts, file_locks);
> + criu_local_set_file_locks(global_opts, file_locks);
> }
>
> -void criu_local_set_log_level(void *o, int log_level)
> +void criu_local_set_log_level(criu_opts *opts, int log_level)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_log_level = true;
> - opts->log_level = log_level;
> + opts->rpc->has_log_level = true;
> + opts->rpc->log_level = log_level;
> }
>
> void criu_set_log_level(int log_level)
> {
> - criu_local_set_log_level((void *)global_opts, log_level);
> + criu_local_set_log_level(global_opts, log_level);
> }
>
> -void criu_local_set_root(void *o, char *root)
> +void criu_local_set_root(criu_opts *opts, char *root)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->root = strdup(root);
> + opts->rpc->root = strdup(root);
> }
>
> void criu_set_root(char *root)
> {
> - criu_local_set_root((void *)global_opts, root);
> + criu_local_set_root(global_opts, root);
> }
>
> -void criu_local_set_manage_cgroups(void *o, bool manage)
> +void criu_local_set_manage_cgroups(criu_opts *opts, bool manage)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_manage_cgroups = true;
> - opts->manage_cgroups = manage;
> + opts->rpc->has_manage_cgroups = true;
> + opts->rpc->manage_cgroups = manage;
> }
>
> void criu_set_manage_cgroups(bool manage)
> {
> - criu_local_set_manage_cgroups((void *)global_opts, manage);
> + criu_local_set_manage_cgroups(global_opts, manage);
> }
>
> -void criu_local_set_auto_ext_mnt(void *o, bool val)
> +void criu_local_set_auto_ext_mnt(criu_opts *opts, bool val)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_auto_ext_mnt = true;
> - opts->auto_ext_mnt = val;
> + opts->rpc->has_auto_ext_mnt = true;
> + opts->rpc->auto_ext_mnt = val;
> }
>
> void criu_set_auto_ext_mnt(bool val)
> {
> - criu_local_set_auto_ext_mnt((void *)global_opts, val);
> + criu_local_set_auto_ext_mnt(global_opts, val);
> }
>
> -void criu_local_set_ext_sharing(void *o, bool val)
> +void criu_local_set_ext_sharing(criu_opts *opts, bool val)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_ext_sharing = true;
> - opts->ext_sharing = val;
> + opts->rpc->has_ext_sharing = true;
> + opts->rpc->ext_sharing = val;
> }
>
> void criu_set_ext_sharing(bool val)
> {
> - criu_local_set_ext_sharing((void *)global_opts, val);
> + criu_local_set_ext_sharing(global_opts, val);
> }
>
> -void criu_local_set_ext_masters(void *o, bool val)
> +void criu_local_set_ext_masters(criu_opts *opts, bool val)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_ext_masters = true;
> - opts->ext_masters = val;
> + opts->rpc->has_ext_masters = true;
> + opts->rpc->ext_masters = val;
> }
>
> void criu_set_ext_masters(bool val)
> {
> - criu_local_set_ext_masters((void *)global_opts, val);
> + criu_local_set_ext_masters(global_opts, val);
> }
>
> -void criu_local_set_log_file(void *o, char *log_file)
> +void criu_local_set_log_file(criu_opts *opts, char *log_file)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->log_file = strdup(log_file);
> + opts->rpc->log_file = strdup(log_file);
> }
>
> void criu_set_log_file(char *log_file)
> {
> - criu_local_set_log_file((void *)global_opts, log_file);
> + criu_local_set_log_file(global_opts, log_file);
> }
>
> -void criu_local_set_cpu_cap(void *o, unsigned int cap)
> +void criu_local_set_cpu_cap(criu_opts *opts, unsigned int cap)
> {
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
> -
> - opts->has_cpu_cap = true;
> - opts->cpu_cap = cap;
> + opts->rpc->has_cpu_cap = true;
> + opts->rpc->cpu_cap = cap;
> }
>
> void criu_set_cpu_cap(unsigned int cap)
> {
> - criu_local_set_cpu_cap((void *)global_opts, cap);
> + criu_local_set_cpu_cap(global_opts, cap);
> }
>
> -int criu_local_set_exec_cmd(void *o, int argc, char *argv[])
> +int criu_local_set_exec_cmd(criu_opts *opts, int argc, char *argv[])
> {
> int i;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> - opts->n_exec_cmd = argc;
> - opts->exec_cmd = malloc((argc) * sizeof(char *));
> + opts->rpc->n_exec_cmd = argc;
> + opts->rpc->exec_cmd = malloc((argc) * sizeof(char *));
>
> - if (opts->exec_cmd) {
> + if (opts->rpc->exec_cmd) {
> for (i = 0; i < argc; i++) {
> - opts->exec_cmd[i] = strdup(argv[i]);
> - if (!opts->exec_cmd[i]) {
> + opts->rpc->exec_cmd[i] = strdup(argv[i]);
> + if (!opts->rpc->exec_cmd[i]) {
> while (i > 0)
> - free(opts->exec_cmd[i--]);
> - free(opts->exec_cmd);
> - opts->n_exec_cmd = 0;
> - opts->exec_cmd = NULL;
> + free(opts->rpc->exec_cmd[i--]);
> + free(opts->rpc->exec_cmd);
> + opts->rpc->n_exec_cmd = 0;
> + opts->rpc->exec_cmd = NULL;
> goto out;
> }
> }
> @@ -431,16 +350,13 @@ out:
>
> int criu_set_exec_cmd(int argc, char *argv[])
> {
> - return criu_local_set_exec_cmd((void *)global_opts, argc, argv);
> + return criu_local_set_exec_cmd(global_opts, argc, argv);
> }
>
> -int criu_local_add_ext_mount(void *o, char *key, char *val)
> +int criu_local_add_ext_mount(criu_opts *opts, char *key, char *val)
> {
> int nr;
> ExtMountMap **a, *m;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> m = malloc(sizeof(*m));
> if (!m)
> @@ -454,14 +370,14 @@ int criu_local_add_ext_mount(void *o, char *key, char *val)
> if (!m->val)
> goto er_k;
>
> - nr = opts->n_ext_mnt + 1;
> - a = realloc(opts->ext_mnt, nr * sizeof(m));
> + nr = opts->rpc->n_ext_mnt + 1;
> + a = realloc(opts->rpc->ext_mnt, nr * sizeof(m));
> if (!a)
> goto er_v;
>
> a[nr - 1] = m;
> - opts->ext_mnt = a;
> - opts->n_ext_mnt = nr;
> + opts->rpc->ext_mnt = a;
> + opts->rpc->n_ext_mnt = nr;
> return 0;
>
> er_v:
> @@ -476,16 +392,13 @@ er:
>
> int criu_add_ext_mount(char *key, char *val)
> {
> - return criu_local_add_ext_mount((void *)global_opts, key, val);
> + return criu_local_add_ext_mount(global_opts, key, val);
> }
>
> -int criu_local_add_cg_root(void *o, char *ctrl, char *path)
> +int criu_local_add_cg_root(criu_opts *opts, char *ctrl, char *path)
> {
> int nr;
> CgroupRoot **a, *root;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> root = malloc(sizeof(*root));
> if (!root)
> @@ -502,14 +415,14 @@ int criu_local_add_cg_root(void *o, char *ctrl, char *path)
> if (!root->path)
> goto er_c;
>
> - nr = opts->n_cg_root + 1;
> - a = realloc(opts->cg_root, nr * sizeof(root));
> + nr = opts->rpc->n_cg_root + 1;
> + a = realloc(opts->rpc->cg_root, nr * sizeof(root));
> if (!a)
> goto er_p;
>
> a[nr - 1] = root;
> - opts->cg_root = a;
> - opts->n_cg_root = nr;
> + opts->rpc->cg_root = a;
> + opts->rpc->n_cg_root = nr;
> return 0;
>
> er_p:
> @@ -525,16 +438,13 @@ er:
>
> int criu_add_cg_root(char *ctrl, char *path)
> {
> - return criu_local_add_cg_root((void *)global_opts, ctrl, path);
> + return criu_local_add_cg_root(global_opts, ctrl, path);
> }
>
> -int criu_local_add_veth_pair(void *o, char *in, char *out)
> +int criu_local_add_veth_pair(criu_opts *opts, char *in, char *out)
> {
> int nr;
> CriuVethPair **a, *p;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> p = malloc(sizeof(*p));
> if (!p)
> @@ -548,14 +458,14 @@ int criu_local_add_veth_pair(void *o, char *in, char *out)
> if (!p->if_out)
> goto er_i;
>
> - nr = opts->n_veths + 1;
> - a = realloc(opts->veths, nr * sizeof(p));
> + nr = opts->rpc->n_veths + 1;
> + a = realloc(opts->rpc->veths, nr * sizeof(p));
> if (!a)
> goto er_o;
>
> a[nr - 1] = p;
> - opts->veths = a;
> - opts->n_veths = nr;
> + opts->rpc->veths = a;
> + opts->rpc->n_veths = nr;
> return 0;
>
> er_o:
> @@ -570,31 +480,28 @@ er:
>
> int criu_add_veth_pair(char *in, char *out)
> {
> - return criu_local_add_veth_pair((void *)global_opts, in, out);
> + return criu_local_add_veth_pair(global_opts, in, out);
> }
>
> -int criu_local_add_enable_fs(void *o, char *fs)
> +int criu_local_add_enable_fs(criu_opts *opts, char *fs)
> {
> int nr;
> char *str = NULL;
> char **ptr = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> str = strdup(fs);
> if (!str)
> goto err;
>
> - nr = opts->n_enable_fs + 1;
> - ptr = realloc(opts->enable_fs, nr * sizeof(*ptr));
> + nr = opts->rpc->n_enable_fs + 1;
> + ptr = realloc(opts->rpc->enable_fs, nr * sizeof(*ptr));
> if (!ptr)
> goto err;
>
> ptr[nr - 1] = str;
>
> - opts->n_enable_fs = nr;
> - opts->enable_fs = ptr;
> + opts->rpc->n_enable_fs = nr;
> + opts->rpc->enable_fs = ptr;
>
> return 0;
>
> @@ -609,32 +516,29 @@ err:
>
> int criu_add_enable_fs(char *fs)
> {
> - return criu_local_add_enable_fs((void *)global_opts, fs);
> + return criu_local_add_enable_fs(global_opts, fs);
> }
>
>
> -int criu_local_add_skip_mnt(void *o, char *mnt)
> +int criu_local_add_skip_mnt(criu_opts *opts, char *mnt)
> {
> int nr;
> char *str = NULL;
> char **ptr = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> str = strdup(mnt);
> if (!str)
> goto err;
>
> - nr = opts->n_skip_mnt + 1;
> - ptr = realloc(opts->skip_mnt, nr * sizeof(*ptr));
> + nr = opts->rpc->n_skip_mnt + 1;
> + ptr = realloc(opts->rpc->skip_mnt, nr * sizeof(*ptr));
> if (!ptr)
> goto err;
>
> ptr[nr - 1] = str;
>
> - opts->n_skip_mnt = nr;
> - opts->skip_mnt = ptr;
> + opts->rpc->n_skip_mnt = nr;
> + opts->rpc->skip_mnt = ptr;
>
> return 0;
>
> @@ -649,7 +553,7 @@ err:
>
> int criu_add_skip_mnt(char *mnt)
> {
> - return criu_local_add_skip_mnt((void *)global_opts, mnt);
> + return criu_local_add_skip_mnt(global_opts, mnt);
> }
>
> static CriuResp *recv_resp(int socket_fd)
> @@ -763,7 +667,7 @@ static int criu_connect(void)
> return fd;
> }
>
> -static int send_req_and_recv_resp_sk(int fd, CriuReq *req, CriuResp **resp)
> +static int send_req_and_recv_resp_sk(int fd, criu_opts *opts, CriuReq *req, CriuResp **resp)
> {
> int ret = 0;
>
> @@ -781,8 +685,8 @@ again:
> }
>
> if ((*resp)->type == CRIU_REQ_TYPE__NOTIFY) {
> - if (notify)
> - ret = notify((*resp)->notify->script, (*resp)->notify);
> + if (opts->notify)
> + ret = opts->notify((*resp)->notify->script, (*resp)->notify);
>
> ret = send_notify_ack(fd, ret);
> if (!ret)
> @@ -808,7 +712,7 @@ exit:
> return ret;
> }
>
> -static int send_req_and_recv_resp(CriuReq *req, CriuResp **resp)
> +static int send_req_and_recv_resp(criu_opts *opts, CriuReq *req, CriuResp **resp)
> {
> int fd;
> int ret = 0;
> @@ -818,14 +722,14 @@ static int send_req_and_recv_resp(CriuReq *req, CriuResp **resp)
> perror("Can't connect to criu");
> ret = -ECONNREFUSED;
> } else {
> - ret = send_req_and_recv_resp_sk(fd, req, resp);
> + ret = send_req_and_recv_resp_sk(fd, opts, req, resp);
> close(fd);
> }
>
> return ret;
> }
>
> -int criu_check(void)
> +int criu_local_check(criu_opts *opts)
> {
> int ret = -1;
> CriuReq req = CRIU_REQ__INIT;
> @@ -835,7 +739,7 @@ int criu_check(void)
>
> req.type = CRIU_REQ_TYPE__CHECK;
>
> - ret = send_req_and_recv_resp(&req, &resp);
> + ret = send_req_and_recv_resp(opts, &req, &resp);
> if (ret)
> goto exit;
>
> @@ -850,21 +754,23 @@ exit:
> return ret;
> }
>
> -int criu_local_dump(void *o)
> +int criu_check(void)
> +{
> + return criu_local_check(global_opts);
> +}
> +
> +int criu_local_dump(criu_opts *opts)
> {
> int ret = -1;
> CriuReq req = CRIU_REQ__INIT;
> CriuResp *resp = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> saved_errno = 0;
>
> req.type = CRIU_REQ_TYPE__DUMP;
> - req.opts = opts;
> + req.opts = opts->rpc;
>
> - ret = send_req_and_recv_resp(&req, &resp);
> + ret = send_req_and_recv_resp(opts, &req, &resp);
> if (ret)
> goto exit;
>
> @@ -887,22 +793,19 @@ exit:
>
> int criu_dump(void)
> {
> - return criu_local_dump((void *)global_opts);
> + return criu_local_dump(global_opts);
> }
>
> -int criu_local_dump_iters(void *o, int (*more)(criu_predump_info pi))
> +int criu_local_dump_iters(criu_opts *opts, int (*more)(criu_predump_info pi))
> {
> int ret = -1, fd = -1, uret;
> CriuReq req = CRIU_REQ__INIT;
> CriuResp *resp = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> saved_errno = 0;
>
> req.type = CRIU_REQ_TYPE__PRE_DUMP;
> - req.opts = opts;
> + req.opts = opts->rpc;
>
> ret = -EINVAL;
> /*
> @@ -912,7 +815,7 @@ int criu_local_dump_iters(void *o, int (*more)(criu_predump_info pi))
> * Calls w/o iteration callback is, well, not
> * allowed either.
> */
> - if (!opts->has_pid || !more)
> + if (!opts->rpc->has_pid || !more)
> goto exit;
>
> ret = -ECONNREFUSED;
> @@ -921,7 +824,7 @@ int criu_local_dump_iters(void *o, int (*more)(criu_predump_info pi))
> goto exit;
>
> while (1) {
> - ret = send_req_and_recv_resp_sk(fd, &req, &resp);
> + ret = send_req_and_recv_resp_sk(fd, opts, &req, &resp);
> if (ret)
> goto exit;
>
> @@ -943,7 +846,7 @@ int criu_local_dump_iters(void *o, int (*more)(criu_predump_info pi))
> }
>
> req.type = CRIU_REQ_TYPE__DUMP;
> - ret = send_req_and_recv_resp_sk(fd, &req, &resp);
> + ret = send_req_and_recv_resp_sk(fd, opts, &req, &resp);
> if (!ret)
> ret = (resp->success ? 0 : -EBADE);
> exit:
> @@ -962,21 +865,18 @@ int criu_dump_iters(int (*more)(criu_predump_info pi))
> return criu_local_dump_iters((void *)global_opts, more);
> }
>
> -int criu_local_restore(void *o)
> +int criu_local_restore(criu_opts *opts)
> {
> int ret = -1;
> CriuReq req = CRIU_REQ__INIT;
> CriuResp *resp = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> saved_errno = 0;
>
> req.type = CRIU_REQ_TYPE__RESTORE;
> - req.opts = opts;
> + req.opts = opts->rpc;
>
> - ret = send_req_and_recv_resp(&req, &resp);
> + ret = send_req_and_recv_resp(opts, &req, &resp);
> if (ret)
> goto exit;
>
> @@ -996,17 +896,14 @@ exit:
>
> int criu_restore(void)
> {
> - return criu_local_restore((void *)global_opts);
> + return criu_local_restore(global_opts);
> }
>
> -int criu_local_restore_child(void *o)
> +int criu_local_restore_child(criu_opts *opts)
> {
> int sks[2], pid, ret = -1;
> CriuReq req = CRIU_REQ__INIT;
> CriuResp *resp = NULL;
> - CriuOpts *opts;
> -
> - opts = (CriuOpts *)o;
>
> if (socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sks))
> goto out;
> @@ -1048,12 +945,12 @@ int criu_local_restore_child(void *o)
> close(sks[1]);
>
> req.type = CRIU_REQ_TYPE__RESTORE;
> - req.opts = opts;
> + req.opts = opts->rpc;
>
> req.opts->has_rst_sibling = true;
> req.opts->rst_sibling = true;
>
> - ret = send_req_and_recv_resp_sk(sks[0], &req, &resp);
> + ret = send_req_and_recv_resp_sk(sks[0], opts, &req, &resp);
>
> close(sks[0]);
> waitpid(pid, NULL, 0);
> @@ -1074,5 +971,5 @@ err:
>
> int criu_restore_child(void)
> {
> - return criu_local_restore_child((void *)global_opts);
> + return criu_local_restore_child(global_opts);
> }
> diff --git a/lib/criu.h b/lib/criu.h
> index 547f931..ae34357 100644
> --- a/lib/criu.h
> +++ b/lib/criu.h
> @@ -20,6 +20,7 @@
> #define __CRIU_LIB_H__
>
> #include <stdbool.h>
> +#include "rpc.pb-c.h"
>
> void criu_set_service_address(char *path);
>
> @@ -120,42 +121,48 @@ int criu_dump_iters(int (*more)(criu_predump_info pi));
> * structure and lets you set individual options in it.
> */
>
> -int criu_local_init_opts(void **opts);
> -
> -void criu_local_set_pid(void *opts, int pid);
> -void criu_local_set_images_dir_fd(void *opts, int fd); /* must be set for dump/restore */
> -void criu_local_set_parent_images(void *opts, char *path);
> -void criu_local_set_work_dir_fd(void *opts, int fd);
> -void criu_local_set_leave_running(void *opts, bool leave_running);
> -void criu_local_set_ext_unix_sk(void *opts, bool ext_unix_sk);
> -void criu_local_set_tcp_established(void *opts, bool tcp_established);
> -void criu_local_set_evasive_devices(void *opts, bool evasive_devices);
> -void criu_local_set_shell_job(void *opts, bool shell_job);
> -void criu_local_set_file_locks(void *opts, bool file_locks);
> -void criu_local_set_track_mem(void *opts, bool track_mem);
> -void criu_local_set_auto_dedup(void *opts, bool auto_dedup);
> -void criu_local_set_force_irmap(void *opts, bool force_irmap);
> -void criu_local_set_link_remap(void *opts, bool link_remap);
> -void criu_local_set_log_level(void *opts, int log_level);
> -void criu_local_set_log_file(void *opts, char *log_file);
> -void criu_local_set_cpu_cap(void *opts, unsigned int cap);
> -void criu_local_set_root(void *opts, char *root);
> -void criu_local_set_manage_cgroups(void *opts, bool manage);
> -void criu_local_set_auto_ext_mnt(void *opts, bool val);
> -void criu_local_set_ext_sharing(void *opts, bool val);
> -void criu_local_set_ext_masters(void *opts, bool val);
> -int criu_local_set_exec_cmd(void *opts, int argc, char *argv[]);
> -int criu_local_add_ext_mount(void *opts, char *key, char *val);
> -int criu_local_add_veth_pair(void *opts, char *in, char *out);
> -int criu_local_add_cg_root(void *opts, char *ctrl, char *path);
> -int criu_local_add_enable_fs(void *opts, char *fs);
> -int criu_local_add_skip_mnt(void *opts, char *mnt);
> -
> -void criu_local_set_notify_cb(void *opts, int (*cb)(char *action, criu_notify_arg_t na));
> -
> -int criu_local_dump(void *opts);
> -int criu_local_restore(void *opts);
> -int criu_local_restore_child(void *opts);
> -int criu_local_dump_iters(void *opts, int (*more)(criu_predump_info pi));
> +typedef struct {
> + CriuOpts *rpc; /* Generic RPC options in protobuf format */
> + int (*notify)(char *action, criu_notify_arg_t na);
> +} criu_opts;
> +
> +int criu_local_init_opts(criu_opts **opts);
> +
> +void criu_local_set_pid(criu_opts *opts, int pid);
> +void criu_local_set_images_dir_fd(criu_opts *opts, int fd); /* must be set for dump/restore */
> +void criu_local_set_parent_images(criu_opts *opts, char *path);
> +void criu_local_set_work_dir_fd(criu_opts *opts, int fd);
> +void criu_local_set_leave_running(criu_opts *opts, bool leave_running);
> +void criu_local_set_ext_unix_sk(criu_opts *opts, bool ext_unix_sk);
> +void criu_local_set_tcp_established(criu_opts *opts, bool tcp_established);
> +void criu_local_set_evasive_devices(criu_opts *opts, bool evasive_devices);
> +void criu_local_set_shell_job(criu_opts *opts, bool shell_job);
> +void criu_local_set_file_locks(criu_opts *opts, bool file_locks);
> +void criu_local_set_track_mem(criu_opts *opts, bool track_mem);
> +void criu_local_set_auto_dedup(criu_opts *opts, bool auto_dedup);
> +void criu_local_set_force_irmap(criu_opts *opts, bool force_irmap);
> +void criu_local_set_link_remap(criu_opts *opts, bool link_remap);
> +void criu_local_set_log_level(criu_opts *opts, int log_level);
> +void criu_local_set_log_file(criu_opts *opts, char *log_file);
> +void criu_local_set_cpu_cap(criu_opts *opts, unsigned int cap);
> +void criu_local_set_root(criu_opts *opts, char *root);
> +void criu_local_set_manage_cgroups(criu_opts *opts, bool manage);
> +void criu_local_set_auto_ext_mnt(criu_opts *opts, bool val);
> +void criu_local_set_ext_sharing(criu_opts *opts, bool val);
> +void criu_local_set_ext_masters(criu_opts *opts, bool val);
> +int criu_local_set_exec_cmd(criu_opts *opts, int argc, char *argv[]);
> +int criu_local_add_ext_mount(criu_opts *opts, char *key, char *val);
> +int criu_local_add_veth_pair(criu_opts *opts, char *in, char *out);
> +int criu_local_add_cg_root(criu_opts *opts, char *ctrl, char *path);
> +int criu_local_add_enable_fs(criu_opts *opts, char *fs);
> +int criu_local_add_skip_mnt(criu_opts *opts, char *mnt);
> +
> +void criu_local_set_notify_cb(criu_opts *opts, int (*cb)(char *action, criu_notify_arg_t na));
> +
> +int criu_local_check(criu_opts *opts);
> +int criu_local_dump(criu_opts *opts);
> +int criu_local_restore(criu_opts *opts);
> +int criu_local_restore_child(criu_opts *opts);
> +int criu_local_dump_iters(criu_opts *opts, int (*more)(criu_predump_info pi));
>
> #endif /* __CRIU_LIB_H__ */
> --
> 2.1.0
>
> _______________________________________________
> CRIU mailing list
> CRIU at openvz.org
> https://lists.openvz.org/mailman/listinfo/criu
More information about the CRIU
mailing list