ruby-lxc 1.0.1 → 1.0.2

data/ext/lxc/extconf.rb

@@ -3,5 +3,12 @@ require 'mkmf'
 abort 'missing liblxc' unless find_library('lxc', 'lxc_container_new')
 abort 'missing lxc/lxccontainer.h' unless have_header('lxc/lxccontainer.h')
 
+def add_define(name)
+  $defs.push("-D#{name}")
+end
+
+add_define "HAVE_RB_THREAD_CALL_WITHOUT_GVL" if have_func('rb_thread_call_without_gvl')
+add_define "HAVE_RB_THREAD_BLOCKING_REGION" if have_func('rb_thread_blocking_region')
+
 $CFLAGS += " -Wall #{ENV['CFLAGS']}"
 create_makefile('lxc/lxc')

data/ext/lxc/lxc.c

@@ -3,13 +3,46 @@
 #include <linux/sched.h>       /* for CLONE_* constants */
 #include <lxc/lxccontainer.h>
 #include <lxc/attach_options.h>
+#include <signal.h>
 #include <stdint.h>
 #include <string.h>
 
 #define SYMBOL(s) ID2SYM(rb_intern(s))
 
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+/* Defined in Ruby, but not in all Ruby versions' header files */
+extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
+                                        rb_unblock_function_t *ubf,
+                                        void *data2);
+
+#define RETURN_WITHOUT_GVL_TYPE void *
+#define RETURN_WITHOUT_GVL(x) return (void *)(intptr_t)(x)
+#define RELEASING_GVL(func, arg) \
+    (int)(intptr_t)rb_thread_call_without_gvl(func, arg, NULL, NULL)
+#define RELEASING_GVL2(func, arg, killfunc, killarg) \
+    (int)(intptr_t)rb_thread_call_without_gvl(func, arg, killfunc, killarg)
+#define RELEASING_GVL_VOID(func, arg) \
+    rb_thread_call_without_gvl(func, arg, NULL, NULL)
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#define RETURN_WITHOUT_GVL_TYPE VALUE
+#define RETURN_WITHOUT_GVL(x) return INT2NUM(x)
+#define RELEASING_GVL(func, arg) \
+    NUM2INT(rb_thread_blocking_region(func, arg, NULL, NULL))
+#define RELEASING_GVL2(func, arg, killfunc, killarg) \
+    NUM2INT(rb_thread_blocking_region(func, arg, killfunc, killarg))
+#define RELEASING_GVL_VOID(func, arg) \
+    rb_thread_blocking_region(func, arg, NULL, NULL)
+#else
+#define RETURN_WITHOUT_GVL_TYPE int
+#define RETURN_WITHOUT_GVL(x) return x
+#define RELEASING_GVL(func, arg) func(arg)
+#define RELEASING_GVL_VOID(func, arg) func(arg)
+#define RELEASING_GVL2(func, arg, killfunc, killarg) func(arg)
+#endif
+
 extern int lxc_wait_for_pid_status(pid_t pid);
 extern long lxc_config_parse_arch(const char *arch);
+extern const char *lxc_strerror(int error);
 
 static VALUE Container;
 static VALUE Error;
@@ -161,6 +194,32 @@ lxc_version(VALUE self)
     return rb_str_new2(lxc_get_version());
 }
 
+struct list_containers_without_gvl_args {
+    int active;
+    int defined;
+    char *config;
+    char **names;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+list_containers_without_gvl(void *args_void)
+{
+    struct list_containers_without_gvl_args *args =
+        (struct list_containers_without_gvl_args *)args_void;
+    int num_containers = 0;
+    args->names = NULL;
+    if (args->active && args->defined) {
+        num_containers = list_all_containers(args->config, &args->names, NULL);
+    } else if (args->active) {
+        num_containers =
+            list_active_containers(args->config, &args->names, NULL);
+    } else if (args->defined) {
+        num_containers =
+            list_defined_containers(args->config, &args->names, NULL);
+    }
+    RETURN_WITHOUT_GVL(num_containers);
+}
+
 /*
  * call-seq:
  *   LXC.list_containers([opts])
@@ -175,36 +234,33 @@ static VALUE
 lxc_list_containers(int argc, VALUE *argv, VALUE self)
 {
     int i, num_containers;
-    int active, defined;
-    char *config;
-    char **names;
     VALUE rb_active, rb_defined, rb_config;
     VALUE rb_opts;
     VALUE rb_containers;
+    struct list_containers_without_gvl_args args;
 
     rb_scan_args(argc, argv, "01", &rb_opts);
 
-    if (NIL_P(rb_opts)) {
-        active = 1;
-        defined = 1;
-        config = NULL;
-    } else {
+    args.active = 1;
+    args.defined = 1;
+    args.config = NULL;
+
+    if (!NIL_P(rb_opts)) {
         Check_Type(rb_opts, T_HASH);
+
         rb_active = rb_hash_aref(rb_opts, SYMBOL("active"));
-        active = (rb_active != Qnil) && (rb_active != Qfalse);
+        if (!NIL_P(rb_active))
+            args.active = rb_active != Qfalse;
+
         rb_defined = rb_hash_aref(rb_opts, SYMBOL("defined"));
-        defined = (rb_defined != Qnil) && (rb_defined != Qfalse);
+        if (!NIL_P(rb_defined))
+            args.defined = rb_defined != Qfalse;
+
         rb_config = rb_hash_aref(rb_opts, SYMBOL("config_path"));
-        config = NIL_P(rb_config) ? NULL : StringValuePtr(rb_config);
+        if (!NIL_P(rb_config))
+            args.config = StringValuePtr(rb_config);
     }
-
-    num_containers = 0;
-    if (active && defined)
-        num_containers = list_all_containers(config, &names, NULL);
-    else if (active)
-        num_containers = list_active_containers(config, &names, NULL);
-    else if (defined)
-        num_containers = list_defined_containers(config, &names, NULL);
+    num_containers = RELEASING_GVL(list_containers_without_gvl, &args);
     if (num_containers < 0)
         rb_raise(Error, "failure to list containers");
 
@@ -214,10 +270,10 @@ lxc_list_containers(int argc, VALUE *argv, VALUE self)
      * ie, don't use free_c_string_array().
      */
     for (i = 0; i < num_containers; i++) {
-        rb_ary_store(rb_containers, i, rb_str_new2(names[i]));
-        free(names[i]);
+        rb_ary_store(rb_containers, i, rb_str_new2(args.names[i]));
+        free(args.names[i]);
     }
-    free(names);
+    free(args.names);
 
     return rb_containers;
 }
@@ -383,9 +439,27 @@ container_state(VALUE self)
     return rb_str_intern(rb_funcall(rb_state, rb_intern("downcase"), 0));
 }
 
+struct add_device_node_without_gvl_args {
+    struct container_data *data;
+    char *src_path;
+    char *dest_path;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+add_device_node_without_gvl(void *args_void)
+{
+    struct add_device_node_without_gvl_args *args =
+        (struct add_device_node_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->add_device_node(args->data->container,
+                                               args->src_path,
+                                               args->dest_path)
+    );
+}
+
 /*
  * call-seq:
- *   container.add_device_node(src_path, dst_path = src_path)
+ *   container.add_device_node(src_path, dest_path = src_path)
  *
  * Adds a device node to the container.
  */
@@ -393,17 +467,16 @@ static VALUE
 container_add_device_node(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *src_path, *dst_path;
-    struct container_data *data;
-    VALUE rb_src_path, rb_dst_path;
+    VALUE rb_src_path, rb_dest_path;
+    struct add_device_node_without_gvl_args args;
 
-    rb_scan_args(argc, argv, "11", &rb_src_path, &rb_dst_path);
-    src_path = NIL_P(rb_src_path) ? NULL : StringValuePtr(rb_src_path);
-    dst_path = NIL_P(rb_dst_path) ? NULL : StringValuePtr(rb_dst_path);
+    rb_scan_args(argc, argv, "11", &rb_src_path, &rb_dest_path);
+    args.src_path = StringValuePtr(rb_src_path);
+    args.dest_path = NIL_P(rb_dest_path) ? NULL : StringValuePtr(rb_dest_path);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->add_device_node(data->container, src_path, dst_path);
+    ret = RELEASING_GVL(add_device_node_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to add device node");
 
@@ -593,6 +666,20 @@ err:
     return NULL;
 }
 
+static RETURN_WITHOUT_GVL_TYPE
+lxc_wait_for_pid_status_without_gvl(void *pid)
+{
+    RETURN_WITHOUT_GVL(lxc_wait_for_pid_status(*(pid_t*)pid));
+}
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) || defined(HAVE_RB_THREAD_BLOCKING_REGION)
+static void
+kill_pid_without_gvl(void *pid)
+{
+    kill(*(pid_t *)pid, SIGKILL);
+}
+#endif
+
 /*
  * call-seq:
  *   container.attach(opts = {}, &block)
@@ -650,7 +737,8 @@ container_attach(int argc, VALUE *argv, VALUE self)
         goto out;
 
     if (wait) {
-        ret = lxc_wait_for_pid_status(pid);
+        ret = RELEASING_GVL2(lxc_wait_for_pid_status_without_gvl, &pid,
+                             kill_pid_without_gvl, &pid);
         /* handle case where attach fails */
         if (WIFEXITED(ret) && WEXITSTATUS(ret) == 255)
             ret = -1;
@@ -702,6 +790,31 @@ container_clear_config_item(VALUE self, VALUE rb_key)
     return self;
 }
 
+struct clone_without_gvl_args {
+    struct container_data *data;
+    struct lxc_container *new_container;
+    char *name;
+    char *config_path;
+    int flags;
+    char *bdev_type;
+    char *bdev_data;
+    uint64_t new_size;
+    char **hook_args;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+clone_without_gvl(void *args_void)
+{
+    struct clone_without_gvl_args *args =
+        (struct clone_without_gvl_args *)args_void;
+    struct lxc_container *container = args->data->container;
+    args->new_container =
+        container->clone(container, args->name,
+                         args->config_path, args->flags, args->bdev_type,
+                         args->bdev_data, args->new_size, args->hook_args);
+    RETURN_WITHOUT_GVL(0);
+}
+
 /*
  * call-seq:
  *   container.clone(clone_name, opts = {})
@@ -719,27 +832,22 @@ container_clear_config_item(VALUE self, VALUE rb_key)
 static VALUE
 container_clone(int argc, VALUE *argv, VALUE self)
 {
-    int flags;
-    uint64_t new_size;
-    char *name, *config_path, *bdev_type, *bdev_data;
-    char **hook_args;
-    struct lxc_container *container, *new_container;
-    struct container_data *data;
     VALUE rb_name, rb_opts;
     VALUE rb_flags, rb_config_path, rb_bdev_type, rb_bdev_data;
     VALUE rb_new_size, rb_hook_args;
     VALUE rb_args[2];
+    struct clone_without_gvl_args args;
 
     rb_scan_args(argc, argv, "11", &rb_name, &rb_opts);
 
-    name = StringValuePtr(rb_name);
+    args.name = StringValuePtr(rb_name);
 
-    config_path = NULL;
-    flags       = 0;
-    bdev_type   = NULL;
-    bdev_data   = NULL;
-    new_size    = 0;
-    hook_args   = NULL;
+    args.config_path = NULL;
+    args.flags       = 0;
+    args.bdev_type   = NULL;
+    args.bdev_data   = NULL;
+    args.new_size    = 0;
+    args.hook_args   = NULL;
 
     rb_config_path = Qnil;
 
@@ -747,49 +855,68 @@ container_clone(int argc, VALUE *argv, VALUE self)
         Check_Type(rb_opts, T_HASH);
         rb_config_path = rb_hash_aref(rb_opts, SYMBOL("config_path"));
         if (!NIL_P(rb_config_path))
-            config_path = StringValuePtr(rb_config_path);
+            args.config_path = StringValuePtr(rb_config_path);
 
         rb_flags = rb_hash_aref(rb_opts, SYMBOL("flags"));
         if (!NIL_P(rb_flags))
-            flags = NUM2INT(rb_flags);
+            args.flags = NUM2INT(rb_flags);
 
         rb_bdev_type = rb_hash_aref(rb_opts, SYMBOL("bdev_type"));
         if (!NIL_P(rb_bdev_type))
-            bdev_type = StringValuePtr(rb_bdev_type);
+            args.bdev_type = StringValuePtr(rb_bdev_type);
 
         rb_bdev_data = rb_hash_aref(rb_opts, SYMBOL("bdev_data"));
         if (!NIL_P(rb_bdev_data))
-            bdev_data = StringValuePtr(rb_bdev_data);
+            args.bdev_data = StringValuePtr(rb_bdev_data);
 
         rb_new_size = rb_hash_aref(rb_opts, SYMBOL("new_size"));
         if (!NIL_P(rb_bdev_data))
-            new_size = NUM2ULL(rb_new_size);
+            args.new_size = NUM2ULL(rb_new_size);
 
         rb_hook_args = rb_hash_aref(rb_opts, SYMBOL("hook_args"));
         if (!NIL_P(rb_hook_args))
-            hook_args = ruby_to_c_string_array(rb_hook_args);
+            args.hook_args = ruby_to_c_string_array(rb_hook_args);
     }
 
-    Data_Get_Struct(self, struct container_data, data);
-    container = data->container;
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    new_container = container->clone(container, name, config_path,
-                                     flags, bdev_type, bdev_data, new_size,
-                                     hook_args);
+    RELEASING_GVL_VOID(clone_without_gvl, &args);
 
-    if (hook_args)
-        free_c_string_array(hook_args);
+    if (args.hook_args)
+        free_c_string_array(args.hook_args);
 
-    if (new_container == NULL)
+    if (args.new_container == NULL)
         rb_raise(Error, "unable to clone container");
 
-    lxc_container_put(new_container);
+    lxc_container_put(args.new_container);
 
     rb_args[0] = rb_name;
     rb_args[1] = rb_config_path;
     return rb_class_new_instance(2, rb_args, Container);
 }
 
+struct console_without_gvl_args {
+    struct container_data *data;
+    int tty_num;
+    int stdin_fd;
+    int stdout_fd;
+    int stderr_fd;
+    int escape;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+console_without_gvl(void *args_void)
+{
+    struct console_without_gvl_args *args =
+        (struct console_without_gvl_args *)args_void;
+    struct lxc_container *container = args->data->container;
+    RETURN_WITHOUT_GVL(
+        container->console(container, args->tty_num,
+                           args->stdin_fd, args->stdout_fd,
+                           args->stderr_fd, args->escape)
+    );
+}
+
 /*
  * call-seq:
  *   container.console(opts = {})
@@ -807,29 +934,44 @@ static VALUE
 container_console(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    int tty_num = -1, stdin_fd = 0, stdout_fd = 1, stderr_fd = 2, escape = 1;
-    struct container_data *data;
-    struct lxc_container *container;
+    struct console_without_gvl_args args;
     VALUE rb_opts;
+    VALUE rb_opt;
+
+    args.tty_num = -1;
+    args.stdin_fd = 0;
+    args.stdout_fd = 1;
+    args.stderr_fd = 2;
+    args.escape = 1;
 
     rb_scan_args(argc, argv, "01", &rb_opts);
     switch (TYPE(rb_opts)) {
     case T_HASH:
-        tty_num   = NUM2INT(rb_hash_aref(rb_opts, SYMBOL("tty_num")));
-        stdin_fd  = NUM2INT(rb_hash_aref(rb_opts, SYMBOL("stdin_fd")));
-        stdout_fd = NUM2INT(rb_hash_aref(rb_opts, SYMBOL("stdout_fd")));
-        stderr_fd = NUM2INT(rb_hash_aref(rb_opts, SYMBOL("stderr_fd")));
-        escape    = NUM2INT(rb_hash_aref(rb_opts, SYMBOL("escape")));
+        rb_opt = rb_hash_aref(rb_opts, SYMBOL("tty_num"));
+        if (!NIL_P(rb_opt))
+          args.tty_num = NUM2INT(rb_opt);
+        rb_opt = rb_hash_aref(rb_opts, SYMBOL("stdin_fd"));
+        if (!NIL_P(rb_opt))
+          args.stdin_fd = NUM2INT(rb_opt);
+        rb_opt = rb_hash_aref(rb_opts, SYMBOL("stdout_fd"));
+        if (!NIL_P(rb_opt))
+          args.stdout_fd = NUM2INT(rb_opt);
+        rb_opt = rb_hash_aref(rb_opts, SYMBOL("stderr_fd"));
+        if (!NIL_P(rb_opt))
+          args.stderr_fd = NUM2INT(rb_opt);
+        rb_opt = rb_hash_aref(rb_opts, SYMBOL("escape"));
+        if (!NIL_P(rb_opt))
+          args.escape = NUM2INT(rb_opt);
+        break;
+    case T_NIL:
         break;
     default:
         rb_raise(rb_eArgError, "options must be a hash");
     }
 
-    Data_Get_Struct(self, struct container_data, data);
-    container = data->container;
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = container->console(container, tty_num, stdin_fd, stdout_fd, stderr_fd,
-                             escape);
+    ret = RELEASING_GVL(console_without_gvl, &args);
     if (ret != 0)
         rb_raise(Error, "unable to access container console");
 
@@ -863,6 +1005,27 @@ container_console_fd(int argc, VALUE *argv, VALUE self)
     return rb_class_new_instance(1, rb_io_args, rb_cIO);
 }
 
+/* Used to run container->create outside of GIL */
+struct container_create_without_gvl_args {
+    struct container_data *data;
+    char *template;
+    char *bdevtype;
+    int flags;
+    char **args;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+container_create_without_gvl(void *args_void)
+{
+    struct container_create_without_gvl_args *args =
+        (struct container_create_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->create(args->data->container, args->template,
+                                      args->bdevtype, NULL, args->flags,
+                                      args->args)
+    );
+}
+
 /*
  * call-seq:
  *   container.create(template, bdevtype = nil, flags = 0, args = [])
@@ -876,28 +1039,27 @@ container_console_fd(int argc, VALUE *argv, VALUE self)
 static VALUE
 container_create(int argc, VALUE *argv, VALUE self)
 {
-    int ret, flags;
-    char *template;
-    char *bdevtype;
-    char **args = { NULL };
-    struct container_data *data;
-    struct lxc_container *container;
+    int ret;
     VALUE rb_template, rb_bdevtype, rb_flags, rb_args;
+    struct container_create_without_gvl_args args;
+    char **default_args = { NULL };
 
-    rb_scan_args(argc, argv, "13", &rb_template, &rb_bdevtype, &rb_flags, &rb_args);
+    args.args = default_args;
+    rb_scan_args(argc, argv, "13",
+                 &rb_template, &rb_bdevtype, &rb_flags, &rb_args);
 
-    template = StringValuePtr(rb_template);
-    bdevtype = NIL_P(rb_bdevtype) ? NULL : StringValuePtr(rb_bdevtype);
-    flags = NIL_P(rb_flags) ? 0 : NUM2INT(rb_flags);
+    args.template = StringValuePtr(rb_template);
+    args.bdevtype = NIL_P(rb_bdevtype) ? NULL : StringValuePtr(rb_bdevtype);
+    args.flags = NIL_P(rb_flags) ? 0 : NUM2INT(rb_flags);
     if (!NIL_P(rb_args))
-        args = ruby_to_c_string_array(rb_args);
+        args.args = ruby_to_c_string_array(rb_args);
 
-    Data_Get_Struct(self, struct container_data, data);
-    container = data->container;
-    ret = container->create(container, template, bdevtype, NULL, flags, args);
+    Data_Get_Struct(self, struct container_data, args.data);
+
+    ret = RELEASING_GVL(container_create_without_gvl, &args);
 
     if (!NIL_P(rb_args))
-        free_c_string_array(args);
+        free_c_string_array(args.args);
 
     if (!ret)
         rb_raise(Error, "unable to create container");
@@ -905,6 +1067,14 @@ container_create(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+
+static RETURN_WITHOUT_GVL_TYPE
+destroy_without_gvl(void *data_void)
+{
+    struct container_data *data = (struct container_data *)data_void;
+    RETURN_WITHOUT_GVL(data->container->destroy(data->container));
+}
+
 /*
  * call-seq:
  *   container.destroy
@@ -919,12 +1089,19 @@ container_destroy(VALUE self)
 
     Data_Get_Struct(self, struct container_data, data);
 
-    ret = data->container->destroy(data->container);
+    ret = RELEASING_GVL(destroy_without_gvl, data);
     if (!ret)
         rb_raise(Error, "unable to destroy container");
     return self;
 }
 
+static RETURN_WITHOUT_GVL_TYPE
+freeze_without_gvl(void *data_void)
+{
+    struct container_data *data = (struct container_data *)data_void;
+    RETURN_WITHOUT_GVL(data->container->freeze(data->container));
+}
+
 /*
  * call-seq:
  *   container.freeze
@@ -939,7 +1116,7 @@ container_freeze(VALUE self)
 
     Data_Get_Struct(self, struct container_data, data);
 
-    ret = data->container->freeze(data->container);
+    ret = RELEASING_GVL(freeze_without_gvl, data);
     if (!ret)
         rb_raise(Error, "unable to freeze container");
 
@@ -1146,6 +1323,21 @@ container_ips(int argc, VALUE *argv, VALUE self)
     return rb_ips;
 }
 
+struct load_config_without_gvl_args {
+    struct container_data *data;
+    char *path;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+load_config_without_gvl(void *args_void)
+{
+    struct load_config_without_gvl_args *args =
+        (struct load_config_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->load_config(args->data->container, args->path)
+    );
+}
+
 /*
  * call-seq:
  *   container.load_config(config_path = nil)
@@ -1156,22 +1348,28 @@ static VALUE
 container_load_config(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *path;
-    struct container_data *data;
     VALUE rb_path;
+    struct load_config_without_gvl_args args;
 
     rb_scan_args(argc, argv, "01", &rb_path);
-    path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
+    args.path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->load_config(data->container, path);
+    ret = RELEASING_GVL(load_config_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to load configuration file");
 
     return self;
 }
 
+static RETURN_WITHOUT_GVL_TYPE
+reboot_without_gvl(void* data_void)
+{
+    struct container_data *data = (struct container_data *)data_void;
+    RETURN_WITHOUT_GVL(data->container->reboot(data->container));
+}
+
 /*
  * call-seq:
  *   container.reboot
@@ -1186,16 +1384,34 @@ container_reboot(VALUE self)
 
     Data_Get_Struct(self, struct container_data, data);
 
-    ret = data->container->reboot(data->container);
+    ret = RELEASING_GVL(reboot_without_gvl, data);
     if (!ret)
         rb_raise(Error, "unable to reboot container");
 
     return self;
 }
 
+struct remove_device_node_without_gvl_args {
+    struct container_data *data;
+    char *src_path;
+    char *dest_path;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+remove_device_node_without_gvl(void *args_void)
+{
+    struct remove_device_node_without_gvl_args *args =
+        (struct remove_device_node_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->remove_device_node(args->data->container,
+                                                  args->src_path,
+                                                  args->dest_path)
+    );
+}
+
 /*
  * call-seq:
- *   container.remove_device_node(src_path, dst_path = src_path)
+ *   container.remove_device_node(src_path, dest_path = src_path)
  *
  * Removes a device node from the container.
  */
@@ -1203,25 +1419,37 @@ static VALUE
 container_remove_device_node(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *src_path, *dst_path;
-    struct lxc_container *container;
-    struct container_data *data;
-    VALUE rb_src_path, rb_dst_path;
+    VALUE rb_src_path, rb_dest_path;
+    struct remove_device_node_without_gvl_args args;
 
-    rb_scan_args(argc, argv, "11", &rb_src_path, &rb_dst_path);
-    src_path = StringValuePtr(rb_src_path);
-    dst_path = NIL_P(rb_dst_path) ? NULL : StringValuePtr(rb_dst_path);
+    rb_scan_args(argc, argv, "11", &rb_src_path, &rb_dest_path);
+    args.src_path = StringValuePtr(rb_src_path);
+    args.dest_path = NIL_P(rb_dest_path) ? NULL : StringValuePtr(rb_dest_path);
 
-    Data_Get_Struct(self, struct container_data, data);
-    container = data->container;
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = container->remove_device_node(container, src_path, dst_path);
+    ret = RELEASING_GVL(remove_device_node_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to remove device node");
 
     return self;
 }
 
+struct rename_without_gvl_args {
+    struct container_data *data;
+    char *name;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+rename_without_gvl(void *args_void)
+{
+    struct rename_without_gvl_args *args =
+        (struct rename_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->rename(args->data->container, args->name)
+    );
+}
+
 /*
  * call-seq:
  *   container.rename(new_name)
@@ -1233,14 +1461,14 @@ static VALUE
 container_rename(VALUE self, VALUE rb_name)
 {
     int ret;
-    char *name;
-    struct container_data *data;
     VALUE rb_args[2];
+    struct rename_without_gvl_args args;
 
-    name = StringValuePtr(rb_name);
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
+
+    args.name = StringValuePtr(rb_name);
 
-    ret = data->container->rename(data->container, name);
+    ret = RELEASING_GVL(rename_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to rename container");
 
@@ -1278,20 +1506,34 @@ container_running_config_item(VALUE self, VALUE rb_key)
     return rb_value;
 }
 
+struct save_config_without_gvl_args {
+    struct container_data *data;
+    char *path;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+save_config_without_gvl(void *args_void)
+{
+    struct save_config_without_gvl_args *args =
+        (struct save_config_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->save_config(args->data->container, args->path)
+    );
+}
+
 static VALUE
 container_save_config(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *path;
-    struct container_data *data;
     VALUE rb_path;
+    struct save_config_without_gvl_args args;
 
     rb_scan_args(argc, argv, "01", &rb_path);
-    path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
+    args.path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->save_config(data->container, path);
+    ret = RELEASING_GVL(save_config_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to save configuration file");
 
@@ -1391,6 +1633,21 @@ container_set_config_path(VALUE self, VALUE rb_path)
     return self;
 }
 
+struct shutdown_without_gvl_args {
+    struct container_data *data;
+    int timeout;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+shutdown_without_gvl(void* args_void)
+{
+    struct shutdown_without_gvl_args *args =
+        (struct shutdown_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->shutdown(args->data->container, args->timeout)
+    );
+}
+
 /*
  * call-seq:
  *   container.shutdown(timeout = -1)
@@ -1402,22 +1659,38 @@ container_set_config_path(VALUE self, VALUE rb_path)
 static VALUE
 container_shutdown(int argc, VALUE *argv, VALUE self)
 {
-    int ret, timeout;
-    struct container_data *data;
+    int ret;
     VALUE rb_timeout;
+    struct shutdown_without_gvl_args args;
 
     rb_scan_args(argc, argv, "01", &rb_timeout);
-    timeout = NIL_P(rb_timeout) ? -1 : NUM2INT(rb_timeout);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
+
+    args.timeout = NIL_P(rb_timeout) ? -1 : NUM2INT(rb_timeout);
 
-    ret = data->container->shutdown(data->container, timeout);
+    ret = RELEASING_GVL(shutdown_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to shutdown container");
 
     return self;
 }
 
+struct snapshot_without_gvl_args {
+    struct container_data *data;
+    char *path;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+snapshot_without_gvl(void* args_void)
+{
+    struct snapshot_without_gvl_args *args =
+        (struct snapshot_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->snapshot(args->data->container, args->path)
+    );
+}
+
 /*
  * call-seq:
  *   container.snapshot(path = nil)
@@ -1428,17 +1701,16 @@ static VALUE
 container_snapshot(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *path;
     char new_name[20];
-    struct container_data *data;
     VALUE rb_path;
+    struct snapshot_without_gvl_args args;
 
     rb_scan_args(argc, argv, "01", &rb_path);
-    path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
+    args.path = NIL_P(rb_path) ? NULL : StringValuePtr(rb_path);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->snapshot(data->container, path);
+    ret = RELEASING_GVL(snapshot_without_gvl, &args);
     if (ret < 0)
         rb_raise(Error, "unable to snapshot container");
 
@@ -1449,6 +1721,22 @@ container_snapshot(int argc, VALUE *argv, VALUE self)
     return rb_str_new2(new_name);
 }
 
+struct snapshot_destroy_without_gvl_args {
+    struct container_data *data;
+    char *name;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+snapshot_destroy_without_gvl(void *args_void)
+{
+    struct snapshot_destroy_without_gvl_args *args =
+        (struct snapshot_destroy_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->snapshot_destroy(args->data->container,
+                                                args->name)
+    );
+}
+
 /*
  * call-seq:
  *   container.snapshot_destroy(name)
@@ -1459,20 +1747,35 @@ static VALUE
 container_snapshot_destroy(VALUE self, VALUE rb_name)
 {
     int ret;
-    char *name;
-    struct container_data *data;
+    struct snapshot_destroy_without_gvl_args args;
 
-    name = StringValuePtr(rb_name);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    Data_Get_Struct(self, struct container_data, data);
+    args.name = StringValuePtr(rb_name);
 
-    ret = data->container->snapshot_destroy(data->container, name);
+    ret = RELEASING_GVL(snapshot_destroy_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to destroy snapshot");
 
     return self;
 }
 
+struct snapshot_list_without_gvl_args {
+    struct container_data *data;
+    struct lxc_snapshot *snapshots;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+snapshot_list_without_gvl(void *args_void)
+{
+    struct snapshot_list_without_gvl_args *args =
+        (struct snapshot_list_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->snapshot_list(args->data->container,
+                                             &args->snapshots)
+    );
+}
+
 /*
  * call-seq:
  *   container.snapshot_list
@@ -1483,30 +1786,47 @@ static VALUE
 container_snapshot_list(VALUE self)
 {
     int i, num_snapshots;
-    struct lxc_snapshot *snapshots;
-    struct container_data *data;
     VALUE rb_snapshots;
+    struct snapshot_list_without_gvl_args args;
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    num_snapshots = data->container->snapshot_list(data->container, &snapshots);
+    num_snapshots = RELEASING_GVL(snapshot_list_without_gvl, &args);
     if (num_snapshots < 0)
         rb_raise(Error, "unable to list snapshots");
 
     rb_snapshots = rb_ary_new2(num_snapshots);
     for (i = 0; i < num_snapshots; i++) {
         VALUE attrs = rb_ary_new2(4);
-        rb_ary_store(attrs, 0, rb_str_new2(snapshots[i].name));
-        rb_ary_store(attrs, 1, rb_str_new2(snapshots[i].comment_pathname));
-        rb_ary_store(attrs, 2, rb_str_new2(snapshots[i].timestamp));
-        rb_ary_store(attrs, 3, rb_str_new2(snapshots[i].lxcpath));
-        snapshots[i].free(&snapshots[i]);
+        rb_ary_store(attrs, 0, rb_str_new2(args.snapshots[i].name));
+        rb_ary_store(attrs, 1, rb_str_new2(args.snapshots[i].comment_pathname));
+        rb_ary_store(attrs, 2, rb_str_new2(args.snapshots[i].timestamp));
+        rb_ary_store(attrs, 3, rb_str_new2(args.snapshots[i].lxcpath));
+        args.snapshots[i].free(&args.snapshots[i]);
         rb_ary_store(rb_snapshots, i, attrs);
     }
 
     return rb_snapshots;
 }
 
+struct snapshot_restore_without_gvl_args {
+    struct container_data *data;
+    char *name;
+    char *new_name;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+snapshot_restore_without_gvl(void *args_void)
+{
+    struct snapshot_restore_without_gvl_args *args =
+        (struct snapshot_restore_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->snapshot_restore(args->data->container,
+                                                args->name,
+                                                args->new_name)
+    );
+}
+
 /*
  * call-seq:
  *   container.snapshot_restore(name, new_name = nil)
@@ -1517,23 +1837,44 @@ static VALUE
 container_snapshot_restore(int argc, VALUE *argv, VALUE self)
 {
     int ret;
-    char *name, *new_name;
-    struct container_data *data;
+    struct snapshot_restore_without_gvl_args args;
     VALUE rb_name, rb_new_name;
 
     rb_scan_args(argc, argv, "11", &rb_name, &rb_new_name);
-    name = StringValuePtr(rb_name);
-    new_name = NIL_P(rb_new_name) ? NULL : StringValuePtr(rb_new_name);
+    args.name = StringValuePtr(rb_name);
+    args.new_name = NIL_P(rb_new_name) ? NULL : StringValuePtr(rb_new_name);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->snapshot_restore(data->container, name, new_name);
+    ret = RELEASING_GVL(snapshot_restore_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "unable to restore snapshot");
 
     return self;
 }
 
+
+struct start_without_gvl_args {
+    struct container_data *data;
+    int use_init;
+    int daemonize;
+    int close_fds;
+    char **args;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+start_without_gvl(void *args_void)
+{
+    struct start_without_gvl_args *args =
+        (struct start_without_gvl_args *)args_void;
+    struct lxc_container *container = args->data->container;
+    container->want_close_all_fds(container, args->close_fds);
+    container->want_daemonize(container, args->daemonize);
+    RETURN_WITHOUT_GVL(
+        container->start(container, args->use_init, args->args)
+    );
+}
+
 /*
  * call-seq:
  *   container.start(opts = {})
@@ -1548,41 +1889,42 @@ container_snapshot_restore(int argc, VALUE *argv, VALUE self)
 static VALUE
 container_start(int argc, VALUE *argv, VALUE self)
 {
-    int ret, use_init, daemonize, close_fds;
-    char **args;
-    struct container_data *data;
+    int ret;
     VALUE rb_use_init, rb_daemonize, rb_close_fds, rb_args, rb_opts;
+    struct start_without_gvl_args args;
 
-    use_init = 0;
-    daemonize = 1;
-    close_fds = 0;
-    args = NULL;
+    args.use_init = 0;
+    args.daemonize = 1;
+    args.close_fds = 0;
+    args.args = NULL;
     rb_args = Qnil;
 
     rb_scan_args(argc, argv, "01", &rb_opts);
     if (!NIL_P(rb_opts)) {
         Check_Type(rb_opts, T_HASH);
         rb_use_init = rb_hash_aref(rb_opts, SYMBOL("use_init"));
-        use_init = (rb_use_init != Qnil) && (rb_use_init != Qfalse);
+        if (!NIL_P(rb_use_init))
+            args.use_init = (rb_use_init != Qfalse);
 
         rb_daemonize = rb_hash_aref(rb_opts, SYMBOL("daemonize"));
-        daemonize = (rb_daemonize != Qnil) && (rb_daemonize != Qfalse);
+        if (!NIL_P(rb_daemonize))
+            args.daemonize = (rb_daemonize != Qfalse);
 
         rb_close_fds = rb_hash_aref(rb_opts, SYMBOL("close_fds"));
-        close_fds = (rb_close_fds != Qnil) && (rb_close_fds != Qfalse);
+        if (!NIL_P(rb_close_fds))
+            args.close_fds = (rb_close_fds != Qfalse);
 
         rb_args = rb_hash_aref(rb_opts, SYMBOL("args"));
-        args = NIL_P(rb_args) ? NULL : ruby_to_c_string_array(rb_args);
+        if (!NIL_P(rb_args))
+            args.args = ruby_to_c_string_array(rb_args);
     }
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    data->container->want_close_all_fds(data->container, close_fds);
-    data->container->want_daemonize(data->container, daemonize);
-    ret = data->container->start(data->container, use_init, args);
+    ret = RELEASING_GVL(start_without_gvl, &args);
 
     if (!NIL_P(rb_args))
-        free_c_string_array(args);
+        free_c_string_array(args.args);
 
     if (!ret)
         rb_raise(Error, "unable to start container");
@@ -1590,6 +1932,13 @@ container_start(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+static RETURN_WITHOUT_GVL_TYPE
+stop_without_gvl(void *data_void)
+{
+    struct container_data *data = (struct container_data *)data_void;
+    RETURN_WITHOUT_GVL(data->container->stop(data->container));
+}
+
 /*
  * call-seq:
  *   container.stop
@@ -1604,13 +1953,20 @@ container_stop(VALUE self)
 
     Data_Get_Struct(self, struct container_data, data);
 
-    ret = data->container->stop(data->container);
+    ret = RELEASING_GVL(stop_without_gvl, data);
     if (!ret)
         rb_raise(Error, "unable to stop container");
 
     return self;
 }
 
+static RETURN_WITHOUT_GVL_TYPE
+unfreeze_without_gvl(void *data_void)
+{
+    struct container_data *data = (struct container_data *)data_void;
+    RETURN_WITHOUT_GVL(data->container->unfreeze(data->container));
+}
+
 /*
  * call-seq:
  *   container.unfreeze
@@ -1625,13 +1981,30 @@ container_unfreeze(VALUE self)
 
     Data_Get_Struct(self, struct container_data, data);
 
-    ret = data->container->unfreeze(data->container);
+    ret = RELEASING_GVL(unfreeze_without_gvl, data);
     if (!ret)
-        rb_raise(Error, "unable to unfreeze container");
+        rb_raise(Error, "unable to unfreeze container: %s", lxc_strerror(ret));
 
     return self;
 }
 
+struct wait_without_gvl_args {
+    struct container_data *data;
+    int timeout;
+    char *state;
+};
+
+static RETURN_WITHOUT_GVL_TYPE
+wait_without_gvl(void *args_void)
+{
+    struct wait_without_gvl_args *args =
+        (struct wait_without_gvl_args *)args_void;
+    RETURN_WITHOUT_GVL(
+        args->data->container->wait(args->data->container, args->state,
+                                    args->timeout)
+    );
+}
+
 /*
  * call-seq:
  *   container.wait(state, timeout = -1)
@@ -1642,22 +2015,21 @@ container_unfreeze(VALUE self)
 static VALUE
 container_wait(int argc, VALUE *argv, VALUE self)
 {
-    int ret, timeout;
-    char *state;
-    struct container_data *data;
+    int ret;
     VALUE rb_state_str, rb_state, rb_timeout;
+    struct wait_without_gvl_args args;
 
     rb_scan_args(argc, argv, "11", &rb_state, &rb_timeout);
 
     rb_state_str = rb_funcall(rb_state, rb_intern("to_s"), 0);
     rb_state_str = rb_funcall(rb_state_str, rb_intern("upcase"), 0);
-    state = StringValuePtr(rb_state_str);
+    args.state = StringValuePtr(rb_state_str);
 
-    timeout = NIL_P(rb_timeout) ? -1 : NUM2INT(rb_timeout);
+    args.timeout = NIL_P(rb_timeout) ? -1 : NUM2INT(rb_timeout);
 
-    Data_Get_Struct(self, struct container_data, data);
+    Data_Get_Struct(self, struct container_data, args.data);
 
-    ret = data->container->wait(data->container, state, timeout);
+    ret = RELEASING_GVL(wait_without_gvl, &args);
     if (!ret)
         rb_raise(Error, "error waiting for container");
 
@@ -1713,7 +2085,7 @@ Init_lxc(void)
     rb_define_method(Container, "load_config", container_load_config, -1);
     rb_define_method(Container, "reboot", container_reboot, 0);
     rb_define_method(Container, "remove_device_node",
-                     container_remove_device_node, 0);
+                     container_remove_device_node, -1);
     rb_define_method(Container, "rename", container_rename, 1);
     rb_define_method(Container, "running_config_item",
                      container_running_config_item, 1);

data/lib/lxc/version.rb

@@ -1,3 +1,3 @@
 module LXC
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lxc
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-06 00:00:00.000000000 Z
+date: 2014-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler