discover: Make device handler a little more testable
authorJeremy Kerr <jk@ozlabs.org>
Fri, 3 May 2013 06:31:55 +0000 (14:31 +0800)
committerJeremy Kerr <jk@ozlabs.org>
Wed, 15 May 2013 07:33:15 +0000 (15:33 +0800)
This change moves some of the device-handler code into an #ifdef-ed
section, so we can easily drop the stuff that's not required for
testing.

Although the change is quite large, most of it is moving entire
functions around.

Signed-off-by: Jeremy Kerr <jk@ozlabs.org>
discover/device-handler.c

index 23961249ff595b857b327a34f025e31c64a97d1d..8e71310ef5e614b38e9475478a117e7fed66f18d 100644 (file)
@@ -33,203 +33,169 @@ struct device_handler {
        struct list             unresolved_boot_options;
 };
 
        struct list             unresolved_boot_options;
 };
 
-static bool resource_is_resolved(struct resource *res)
+void discover_context_add_boot_option(struct discover_context *ctx,
+               struct discover_boot_option *boot_option)
 {
 {
-       return !res || res->resolved;
+       boot_option->source = ctx->parser;
+       list_add_tail(&ctx->boot_options, &boot_option->list);
+       talloc_steal(ctx, boot_option);
 }
 
 }
 
-/* We only use this in an assert, which will disappear if we're compiling
- * with NDEBUG, so we need the 'used' attribute for these builds */
-static bool __attribute__((used)) boot_option_is_resolved(
-               struct discover_boot_option *opt)
+/**
+ * device_handler_get_device_count - Get the count of current handler devices.
+ */
+
+int device_handler_get_device_count(const struct device_handler *handler)
 {
 {
-       return resource_is_resolved(opt->boot_image) &&
-               resource_is_resolved(opt->initrd) &&
-               resource_is_resolved(opt->icon);
+       return handler->n_devices;
 }
 
 }
 
-static bool resource_resolve(struct resource *res, struct parser *parser,
-               struct device_handler *handler)
-{
-       if (resource_is_resolved(res))
-               return true;
+/**
+ * device_handler_get_device - Get a handler device by index.
+ */
 
 
-       parser->resolve_resource(handler, res);
+const struct discover_device *device_handler_get_device(
+       const struct device_handler *handler, unsigned int index)
+{
+       if (index >= handler->n_devices) {
+               assert(0 && "bad index");
+               return NULL;
+       }
 
 
-       return res->resolved;
+       return handler->devices[index];
 }
 
 }
 
-static bool boot_option_resolve(struct discover_boot_option *opt,
-               struct device_handler *handler)
+struct discover_boot_option *discover_boot_option_create(
+               struct discover_context *ctx,
+               struct discover_device *device)
 {
 {
-       return resource_resolve(opt->boot_image, opt->source, handler) &&
-               resource_resolve(opt->initrd, opt->source, handler) &&
-               resource_resolve(opt->icon, opt->source, handler);
+       struct discover_boot_option *opt;
+
+       opt = talloc_zero(ctx, struct discover_boot_option);
+       opt->option = talloc_zero(opt, struct boot_option);
+       opt->device = device;
+
+       return opt;
 }
 
 }
 
-static void boot_option_finalise(struct discover_boot_option *opt)
+static int device_match_path(struct discover_device *dev, const char *path)
 {
 {
-       assert(boot_option_is_resolved(opt));
+       return dev->device_path && !strcmp(dev->device_path, path);
+}
 
 
-       /* check that the parsers haven't set any of the final data */
-       assert(!opt->option->boot_image_file);
-       assert(!opt->option->initrd_file);
-       assert(!opt->option->icon_file);
-       assert(!opt->option->device_id);
+static int device_match_uuid(struct discover_device *dev, const char *uuid)
+{
+       return dev->uuid && !strcmp(dev->uuid, uuid);
+}
 
 
-       if (opt->boot_image)
-               opt->option->boot_image_file = opt->boot_image->url->full;
-       if (opt->initrd)
-               opt->option->initrd_file = opt->initrd->url->full;
-       if (opt->icon)
-               opt->option->icon_file = opt->icon->url->full;
+static int device_match_label(struct discover_device *dev, const char *label)
+{
+       return dev->label && !strcmp(dev->label, label);
+}
 
 
-       opt->option->device_id = opt->device->device->id;
+static int device_match_id(struct discover_device *dev, const char *id)
+{
+       return !strcmp(dev->device->id, id);
 }
 
 }
 
-static void process_boot_option_queue(struct device_handler *handler)
+static struct discover_device *device_lookup(
+               struct device_handler *device_handler,
+               int (match_fn)(struct discover_device *, const char *),
+               const char *str)
 {
 {
-       struct discover_boot_option *opt, *tmp;
+       struct discover_device *dev;
+       unsigned int i;
 
 
-       list_for_each_entry_safe(&handler->unresolved_boot_options,
-                       opt, tmp, list) {
+       if (!str)
+               return NULL;
 
 
-               if (!boot_option_resolve(opt, handler))
-                       continue;
+       for (i = 0; i < device_handler->n_devices; i++) {
+               dev = device_handler->devices[i];
 
 
-               list_remove(&opt->list);
-               list_add(&opt->device->boot_options, &opt->list);
-               talloc_steal(opt->device, opt);
-               boot_option_finalise(opt);
-               discover_server_notify_boot_option_add(handler->server,
-                                                       opt->option);
+               if (match_fn(dev, str))
+                       return dev;
        }
        }
+
+       return NULL;
 }
 
 }
 
-/**
- * context_commit - Commit a temporary discovery context to the handler,
- * and notify the clients about any new options / devices
- */
-static void context_commit(struct device_handler *handler,
-               struct discover_context *ctx)
+struct discover_device *device_lookup_by_name(struct device_handler *handler,
+               const char *name)
 {
 {
-       struct discover_device *dev = ctx->device;
-       struct discover_boot_option *opt, *tmp;
-       unsigned int i, existing_device = 0;
-
-       /* do we already have this device? */
-       for (i = 0; i < handler->n_devices; i++) {
-               if (ctx->device == handler->devices[i]) {
-                       existing_device = 1;
-                       break;
-               }
-       }
-
-       /* if not already present, add the device to the handler's array */
-       if (!existing_device) {
-               handler->n_devices++;
-               handler->devices = talloc_realloc(handler, handler->devices,
-                       struct discover_device *, handler->n_devices);
-               handler->devices[handler->n_devices - 1] = dev;
-               talloc_steal(handler, dev);
+       struct discover_device *dev;
+       char *path;
 
 
-               discover_server_notify_device_add(handler->server, dev->device);
+       if (strncmp(name, "/dev/", strlen("/dev/")))
+               path = talloc_asprintf(NULL, "/dev/%s", name);
+       else
+               path = talloc_strdup(NULL, name);
 
 
-               /* this new device might be able to resolve existing boot
-                * options */
-               process_boot_option_queue(handler);
-       }
+       dev = device_lookup_by_path(handler, path);
 
 
+       talloc_free(path);
 
 
-       /* move boot options from the context to the device */
-       list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
-               list_remove(&opt->list);
+       return dev;
+}
 
 
-               if (boot_option_resolve(opt, handler)) {
-                       list_add(&dev->boot_options, &opt->list);
-                       talloc_steal(dev, opt);
-                       boot_option_finalise(opt);
-                       discover_server_notify_boot_option_add(handler->server,
-                                                               opt->option);
-               } else {
-                       if (!opt->source->resolve_resource) {
-                               pb_log("parser %s gave us an unresolved "
-                                       "resource (%s), but no way to "
-                                       "resolve it\n",
-                                       opt->source->name, opt->option->id);
-                               talloc_free(opt);
-                       } else {
-                               pb_log("boot option %s is unresolved, "
-                                               "adding to queue\n",
-                                               opt->option->id);
-                               list_add(&handler->unresolved_boot_options,
-                                               &opt->list);
-                               talloc_steal(handler, opt);
-                       }
-               }
-       }
+struct discover_device *device_lookup_by_path(
+               struct device_handler *device_handler,
+               const char *path)
+{
+       return device_lookup(device_handler, device_match_path, path);
 }
 
 }
 
-void discover_context_add_boot_option(struct discover_context *ctx,
-               struct discover_boot_option *boot_option)
+struct discover_device *device_lookup_by_uuid(
+               struct device_handler *device_handler,
+               const char *uuid)
 {
 {
-       boot_option->source = ctx->parser;
-       list_add_tail(&ctx->boot_options, &boot_option->list);
-       talloc_steal(ctx, boot_option);
+       return device_lookup(device_handler, device_match_uuid, uuid);
 }
 
 }
 
-/**
- * device_handler_remove - Remove a device from the handler device array.
- */
+struct discover_device *device_lookup_by_label(
+               struct device_handler *device_handler,
+               const char *label)
+{
+       return device_lookup(device_handler, device_match_label, label);
+}
 
 
-static void device_handler_remove(struct device_handler *handler,
-       struct discover_device *device)
+struct discover_device *device_lookup_by_id(
+               struct device_handler *device_handler,
+               const char *id)
 {
 {
-       unsigned int i;
+       return device_lookup(device_handler, device_match_id, id);
+}
 
 
-       for (i = 0; i < handler->n_devices; i++)
-               if (handler->devices[i] == device)
-                       break;
+void device_handler_destroy(struct device_handler *handler)
+{
+       talloc_free(handler);
+}
 
 
-       if (i == handler->n_devices) {
-               assert(0 && "unknown device");
-               return;
-       }
+#ifdef PETITBOOT_TEST
 
 
-       handler->n_devices--;
-       memmove(&handler->devices[i], &handler->devices[i + 1],
-               (handler->n_devices - i) * sizeof(handler->devices[0]));
-       handler->devices = talloc_realloc(handler, handler->devices,
-               struct discover_device *, handler->n_devices);
+/* we have a simplified interface for petitboot testing, but still want
+ * to keep struct device_handler opaque. */
+struct device_handler *device_handler_init(
+               struct discover_server *server __attribute__((unused)),
+               int dry_run __attribute__((unused)))
+{
+       struct device_handler *handler;
 
 
-       discover_server_notify_device_remove(handler->server, device->device);
+       handler = talloc_zero(NULL, struct device_handler);
+       list_init(&handler->unresolved_boot_options);
 
 
-       talloc_free(device);
+       return handler;
 }
 
 }
 
-/**
- * device_handler_get_device_count - Get the count of current handler devices.
- */
-
-int device_handler_get_device_count(const struct device_handler *handler)
+void device_handler_add_device(struct device_handler *handler,
+               struct discover_device *dev)
 {
 {
-       return handler->n_devices;
+       handler->n_devices++;
+       handler->devices = talloc_realloc(handler, handler->devices,
+               struct discover_device *, handler->n_devices);
+       handler->devices[handler->n_devices - 1] = dev;
 }
 
 }
 
-/**
- * device_handler_get_device - Get a handler device by index.
- */
-
-const struct discover_device *device_handler_get_device(
-       const struct device_handler *handler, unsigned int index)
-{
-       if (index >= handler->n_devices) {
-               assert(0 && "bad index");
-               return NULL;
-       }
-
-       return handler->devices[index];
-}
+#else
 
 static int mount_device(struct discover_device *dev)
 {
 
 static int mount_device(struct discover_device *dev)
 {
@@ -302,76 +268,248 @@ static int umount_device(struct discover_device *dev)
        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
                return -1;
 
        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
                return -1;
 
-       pb_rmdir_recursive(mount_base(), dev->mount_path);
+       pb_rmdir_recursive(mount_base(), dev->mount_path);
+
+       return 0;
+}
+
+struct device_handler *device_handler_init(struct discover_server *server,
+               int dry_run)
+{
+       struct device_handler *handler;
+
+       handler = talloc(NULL, struct device_handler);
+       handler->devices = NULL;
+       handler->n_devices = 0;
+       handler->server = server;
+       handler->dry_run = dry_run;
+       list_init(&handler->unresolved_boot_options);
+
+       /* set up our mount point base */
+       pb_mkdir_recursive(mount_base());
+
+       parser_init();
+
+       return handler;
+}
+
+static int destroy_device(void *arg)
+{
+       struct discover_device *dev = arg;
+
+       umount_device(dev);
+
+       return 0;
+}
+
+static struct discover_device *find_device(struct device_handler *handler,
+               const char *id)
+{
+       struct discover_device *dev;
+       unsigned int i;
+
+       for (i = 0; i < handler->n_devices; i++) {
+               dev = handler->devices[i];
+               if (!strcmp(dev->device->id, id))
+                       return dev;
+       }
+
+       return NULL;
+}
+
+static struct discover_device *discover_device_create(
+               struct device_handler *handler,
+               struct discover_context *ctx,
+               struct event *event)
+{
+       struct discover_device *dev;
+       const char *devname;
+
+       dev = find_device(handler, event->device);
+       if (dev)
+               return dev;
+
+       dev = talloc_zero(ctx, struct discover_device);
+       dev->device = talloc_zero(dev, struct device);
+       list_init(&dev->boot_options);
+
+       devname = event_get_param(ctx->event, "DEVNAME");
+       if (devname)
+               dev->device_path = talloc_strdup(dev, devname);
+
+       dev->device->id = talloc_strdup(dev, event->device);
+
+       talloc_set_destructor(dev, destroy_device);
+
+       return dev;
+}
+
+/**
+ * device_handler_remove - Remove a device from the handler device array.
+ */
+
+static void device_handler_remove(struct device_handler *handler,
+       struct discover_device *device)
+{
+       unsigned int i;
+
+       for (i = 0; i < handler->n_devices; i++)
+               if (handler->devices[i] == device)
+                       break;
+
+       if (i == handler->n_devices) {
+               assert(0 && "unknown device");
+               return;
+       }
+
+       handler->n_devices--;
+       memmove(&handler->devices[i], &handler->devices[i + 1],
+               (handler->n_devices - i) * sizeof(handler->devices[0]));
+       handler->devices = talloc_realloc(handler, handler->devices,
+               struct discover_device *, handler->n_devices);
+
+       discover_server_notify_device_remove(handler->server, device->device);
+
+       talloc_free(device);
+}
+
+static bool resource_is_resolved(struct resource *res)
+{
+       return !res || res->resolved;
+}
+
+/* We only use this in an assert, which will disappear if we're compiling
+ * with NDEBUG, so we need the 'used' attribute for these builds */
+static bool __attribute__((used)) boot_option_is_resolved(
+               struct discover_boot_option *opt)
+{
+       return resource_is_resolved(opt->boot_image) &&
+               resource_is_resolved(opt->initrd) &&
+               resource_is_resolved(opt->icon);
+}
+
+static bool resource_resolve(struct resource *res, struct parser *parser,
+               struct device_handler *handler)
+{
+       if (resource_is_resolved(res))
+               return true;
+
+       parser->resolve_resource(handler, res);
+
+       return res->resolved;
+}
 
 
-       return 0;
+static bool boot_option_resolve(struct discover_boot_option *opt,
+               struct device_handler *handler)
+{
+       return resource_resolve(opt->boot_image, opt->source, handler) &&
+               resource_resolve(opt->initrd, opt->source, handler) &&
+               resource_resolve(opt->icon, opt->source, handler);
 }
 
 }
 
-static struct discover_device *find_device(struct device_handler *handler,
-               const char *id)
+static void boot_option_finalise(struct discover_boot_option *opt)
 {
 {
-       struct discover_device *dev;
-       unsigned int i;
+       assert(boot_option_is_resolved(opt));
 
 
-       for (i = 0; i < handler->n_devices; i++) {
-               dev = handler->devices[i];
-               if (!strcmp(dev->device->id, id))
-                       return dev;
-       }
+       /* check that the parsers haven't set any of the final data */
+       assert(!opt->option->boot_image_file);
+       assert(!opt->option->initrd_file);
+       assert(!opt->option->icon_file);
+       assert(!opt->option->device_id);
 
 
-       return NULL;
+       if (opt->boot_image)
+               opt->option->boot_image_file = opt->boot_image->url->full;
+       if (opt->initrd)
+               opt->option->initrd_file = opt->initrd->url->full;
+       if (opt->icon)
+               opt->option->icon_file = opt->icon->url->full;
+
+       opt->option->device_id = opt->device->device->id;
 }
 
 }
 
-static int destroy_device(void *arg)
+static void process_boot_option_queue(struct device_handler *handler)
 {
 {
-       struct discover_device *dev = arg;
+       struct discover_boot_option *opt, *tmp;
 
 
-       umount_device(dev);
+       list_for_each_entry_safe(&handler->unresolved_boot_options,
+                       opt, tmp, list) {
 
 
-       return 0;
+               if (!boot_option_resolve(opt, handler))
+                       continue;
+
+               list_remove(&opt->list);
+               list_add(&opt->device->boot_options, &opt->list);
+               talloc_steal(opt->device, opt);
+               boot_option_finalise(opt);
+               discover_server_notify_boot_option_add(handler->server,
+                                                       opt->option);
+       }
 }
 
 }
 
-static struct discover_device *discover_device_create(
-               struct device_handler *handler,
-               struct discover_context *ctx,
-               struct event *event)
+/**
+ * context_commit - Commit a temporary discovery context to the handler,
+ * and notify the clients about any new options / devices
+ */
+static void context_commit(struct device_handler *handler,
+               struct discover_context *ctx)
 {
 {
-       struct discover_device *dev;
-       const char *devname;
-
-       dev = find_device(handler, event->device);
-       if (dev)
-               return dev;
-
-       dev = talloc_zero(ctx, struct discover_device);
-       dev->device = talloc_zero(dev, struct device);
-       list_init(&dev->boot_options);
+       struct discover_device *dev = ctx->device;
+       struct discover_boot_option *opt, *tmp;
+       unsigned int i, existing_device = 0;
 
 
-       devname = event_get_param(ctx->event, "DEVNAME");
-       if (devname)
-               dev->device_path = talloc_strdup(dev, devname);
+       /* do we already have this device? */
+       for (i = 0; i < handler->n_devices; i++) {
+               if (ctx->device == handler->devices[i]) {
+                       existing_device = 1;
+                       break;
+               }
+       }
 
 
-       dev->device->id = talloc_strdup(dev, event->device);
+       /* if not already present, add the device to the handler's array */
+       if (!existing_device) {
+               handler->n_devices++;
+               handler->devices = talloc_realloc(handler, handler->devices,
+                       struct discover_device *, handler->n_devices);
+               handler->devices[handler->n_devices - 1] = dev;
+               talloc_steal(handler, dev);
 
 
-       talloc_set_destructor(dev, destroy_device);
+               discover_server_notify_device_add(handler->server, dev->device);
 
 
-       return dev;
-}
+               /* this new device might be able to resolve existing boot
+                * options */
+               process_boot_option_queue(handler);
+       }
 
 
-struct discover_boot_option *discover_boot_option_create(
-               struct discover_context *ctx,
-               struct discover_device *device)
-{
-       struct discover_boot_option *opt;
 
 
-       opt = talloc_zero(ctx, struct discover_boot_option);
-       opt->option = talloc_zero(opt, struct boot_option);
-       opt->device = device;
+       /* move boot options from the context to the device */
+       list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
+               list_remove(&opt->list);
 
 
-       return opt;
+               if (boot_option_resolve(opt, handler)) {
+                       list_add(&dev->boot_options, &opt->list);
+                       talloc_steal(dev, opt);
+                       boot_option_finalise(opt);
+                       discover_server_notify_boot_option_add(handler->server,
+                                                               opt->option);
+               } else {
+                       if (!opt->source->resolve_resource) {
+                               pb_log("parser %s gave us an unresolved "
+                                       "resource (%s), but no way to "
+                                       "resolve it\n",
+                                       opt->source->name, opt->option->id);
+                               talloc_free(opt);
+                       } else {
+                               pb_log("boot option %s is unresolved, "
+                                               "adding to queue\n",
+                                               opt->option->id);
+                               list_add(&handler->unresolved_boot_options,
+                                               &opt->list);
+                               talloc_steal(handler, opt);
+                       }
+               }
+       }
 }
 
 }
 
-
 static int handle_add_udev_event(struct device_handler *handler,
                struct event *event)
 {
 static int handle_add_udev_event(struct device_handler *handler,
                struct event *event)
 {
@@ -552,116 +690,11 @@ int device_handler_event(struct device_handler *handler,
        return handlers[event->type][event->action](handler, event);
 }
 
        return handlers[event->type][event->action](handler, event);
 }
 
-struct device_handler *device_handler_init(struct discover_server *server,
-               int dry_run)
-{
-       struct device_handler *handler;
-
-       handler = talloc(NULL, struct device_handler);
-       handler->devices = NULL;
-       handler->n_devices = 0;
-       handler->server = server;
-       handler->dry_run = dry_run;
-       list_init(&handler->unresolved_boot_options);
-
-       /* set up our mount point base */
-       pb_mkdir_recursive(mount_base());
-
-       parser_init();
-
-       return handler;
-}
-
-void device_handler_destroy(struct device_handler *handler)
-{
-       talloc_free(handler);
-}
-
-static int device_match_path(struct discover_device *dev, const char *path)
-{
-       return dev->device_path && !strcmp(dev->device_path, path);
-}
-
-static int device_match_uuid(struct discover_device *dev, const char *uuid)
-{
-       return dev->uuid && !strcmp(dev->uuid, uuid);
-}
-
-static int device_match_label(struct discover_device *dev, const char *label)
-{
-       return dev->label && !strcmp(dev->label, label);
-}
-
-static int device_match_id(struct discover_device *dev, const char *id)
-{
-       return !strcmp(dev->device->id, id);
-}
-
-static struct discover_device *device_lookup(
-               struct device_handler *device_handler,
-               int (match_fn)(struct discover_device *, const char *),
-               const char *str)
-{
-       struct discover_device *dev;
-       unsigned int i;
-
-       if (!str)
-               return NULL;
-
-       for (i = 0; i < device_handler->n_devices; i++) {
-               dev = device_handler->devices[i];
-
-               if (match_fn(dev, str))
-                       return dev;
-       }
-
-       return NULL;
-}
-
-struct discover_device *device_lookup_by_name(struct device_handler *handler,
-               const char *name)
-{
-       struct discover_device *dev;
-       char *path;
-
-       if (strncmp(name, "/dev/", strlen("/dev/")))
-               path = talloc_asprintf(NULL, "/dev/%s", name);
-       else
-               path = talloc_strdup(NULL, name);
-
-       dev = device_lookup_by_path(handler, path);
-
-       talloc_free(path);
-
-       return dev;
-}
-
-struct discover_device *device_lookup_by_path(
-               struct device_handler *device_handler,
-               const char *path)
-{
-       return device_lookup(device_handler, device_match_path, path);
-}
-
-struct discover_device *device_lookup_by_uuid(
-               struct device_handler *device_handler,
-               const char *uuid)
-{
-       return device_lookup(device_handler, device_match_uuid, uuid);
-}
-
-struct discover_device *device_lookup_by_label(
-               struct device_handler *device_handler,
-               const char *label)
+static void boot_status(void *arg, struct boot_status *status)
 {
 {
-       return device_lookup(device_handler, device_match_label, label);
-}
+       struct device_handler *handler = arg;
 
 
-struct discover_device *device_lookup_by_id(
-               struct device_handler *device_handler,
-               const char *id)
-{
-       return device_lookup(device_handler, device_match_id, id);
+       discover_server_notify_boot_status(handler->server, status);
 }
 
 static struct discover_boot_option *find_boot_option_by_id(
 }
 
 static struct discover_boot_option *find_boot_option_by_id(
@@ -681,13 +714,6 @@ static struct discover_boot_option *find_boot_option_by_id(
        return NULL;
 }
 
        return NULL;
 }
 
-static void boot_status(void *arg, struct boot_status *status)
-{
-       struct device_handler *handler = arg;
-
-       discover_server_notify_boot_status(handler->server, status);
-}
-
 void device_handler_boot(struct device_handler *handler,
                struct boot_command *cmd)
 {
 void device_handler_boot(struct device_handler *handler,
                struct boot_command *cmd)
 {
@@ -697,3 +723,4 @@ void device_handler_boot(struct device_handler *handler,
 
        boot(handler, opt, cmd, handler->dry_run, boot_status, handler);
 }
 
        boot(handler, opt, cmd, handler->dry_run, boot_status, handler);
 }
+#endif