process: Cancel all asynchronous jobs on reinit

[petitboot] / discover / device-handler.c

diff --git a/discover/device-handler.c b/discover/device-handler.c
index f8b7bf5be94f9f87be9d4b588ff43a708ec42bfb..3cf7edff082d9f6f880ccdd19c18fa698490cbce 100644 (file)
--- a/discover/device-handler.c
+++ b/discover/device-handler.c
@@ -46,6 +46,14 @@ enum default_priority {
        DEFAULT_PRIORITY_DISABLED       = 0xff,
 };
 
+struct progress_info {
+       unsigned int                    percentage;
+       unsigned long                   size;           /* size in bytes */
+
+       const struct process_info       *procinfo;
+       struct list_item        list;
+};
+
 struct device_handler {
        struct discover_server  *server;
        int                     dry_run;
@@ -72,6 +80,9 @@ struct device_handler {
 
        struct boot_task        *pending_boot;
        bool                    pending_boot_is_default;
+
+       struct list             progress;
+       unsigned int            n_progress;
 };
 
 static int mount_device(struct discover_device *dev);
@@ -314,6 +325,8 @@ struct device_handler *device_handler_init(struct discover_server *server,
 
        list_init(&handler->unresolved_boot_options);
 
+       list_init(&handler->progress);
+
        /* set up our mount point base */
        pb_mkdir_recursive(mount_base());
 
@@ -338,6 +351,15 @@ void device_handler_reinit(struct device_handler *handler)
        unsigned int i;
 
        device_handler_cancel_default(handler);
+       /* Cancel any pending non-default boot */
+       if (handler->pending_boot) {
+               boot_cancel(handler->pending_boot);
+               handler->pending_boot = NULL;
+               handler->pending_boot_is_default = false;
+       }
+
+       /* Cancel any remaining async jobs */
+       process_stop_async_all();
 
        /* free unresolved boot options */
        list_for_each_entry_safe(&handler->unresolved_boot_options,
@@ -429,6 +451,7 @@ static void _device_handler_vstatus(struct device_handler *handler,
 
        status.type = type;
        status.message = talloc_vasprintf(handler, fmt, ap);
+       status.backlog = false;
 
        device_handler_status(handler, &status);
 
@@ -487,6 +510,110 @@ void device_handler_status_err(struct device_handler *handler,
        va_end(ap);
 }
 
+void device_handler_status_download(struct device_handler *handler,
+               const struct process_info *procinfo,
+               unsigned int percentage, unsigned int size, char suffix)
+{
+       struct progress_info *p, *progress = NULL;
+       uint64_t current_converted, current = 0;
+       const char *units = " kMGTP";
+       unsigned long size_bytes;
+       char *update = NULL;
+       double total = 0;
+       unsigned int i;
+       int unit = 0;
+
+       list_for_each_entry(&handler->progress, p, list)
+               if (p->procinfo == procinfo)
+                       progress = p;
+
+       if (!progress) {
+               pb_log("Registering new progress struct\n");
+               progress = talloc_zero(handler, struct progress_info);
+               if (!progress) {
+                       pb_log("Failed to allocate room for progress struct\n");
+                       return;
+               }
+               progress->procinfo = procinfo;
+               list_add(&handler->progress, &progress->list);
+               handler->n_progress++;
+       }
+
+       size_bytes = size;
+       for (i = 0; i < strlen(units); i++) {
+               if (units[i] == suffix)
+                       break;
+       }
+
+       if (i >= strlen(units)) {
+           pb_log("Couldn't recognise suffix '%c'\n", suffix);
+           size_bytes = 0;
+       } else {
+               while (i--)
+                       size_bytes <<= 10;
+       }
+
+       progress->percentage = percentage;
+       progress->size = size_bytes;
+
+       /*
+        * Aggregate the info we have and update status. If a progress struct
+        * has zero for both percentage and size we assume progress information
+        * is unavailable and fall back to a generic progress message.
+        */
+       list_for_each_entry(&handler->progress, p, list) {
+               uint64_t c;
+               double t;
+               if (!p->percentage || !p->size) {
+                       update = talloc_asprintf(handler,
+                                       _("%u downloads in progress..."),
+                                       handler->n_progress);
+                       current = total = 0;
+                       break;
+               }
+
+               c = p->size;
+               t = (100 * c) / p->percentage;
+
+               current += c;
+               total += t;
+       }
+
+       if (total) {
+               current_converted = current;
+               while (current_converted >= 1000) {
+                       current_converted >>= 10;
+                       unit++;
+               }
+               update = talloc_asprintf(handler,
+                               _("%u %s downloading: %.0f%% - %lu%cB"),
+                               handler->n_progress,
+                               ngettext("item", "items", handler->n_progress),
+                               (current / total) * 100, current_converted,
+                               units[unit]);
+       }
+
+       if (!update) {
+               pb_log("%s: failed to allocate new status\n", __func__);
+       } else {
+               device_handler_status_info(handler, "%s\n", update);
+               talloc_free(update);
+       }
+}
+
+void device_handler_status_download_remove(struct device_handler *handler,
+               struct process_info *procinfo)
+{
+       struct progress_info *p, *tmp;
+
+       list_for_each_entry_safe(&handler->progress, p, tmp, list)
+               if (p->procinfo == procinfo) {
+                       list_remove(&p->list);
+                       talloc_free(p);
+                       handler->n_progress--;
+               }
+}
+
 static void device_handler_boot_status_cb(void *arg, struct status *status)
 {
        device_handler_status(arg, status);
@@ -500,6 +627,7 @@ static void countdown_status(struct device_handler *handler,
        status.type = STATUS_INFO;
        status.message = talloc_asprintf(handler,
                        _("Booting in %d sec: %s"), sec, opt->option->name);
+       status.backlog = false;
 
        device_handler_status(handler, &status);
 
@@ -920,8 +1048,6 @@ int device_handler_discover(struct device_handler *handler,
                _("Processing new %s device"),
                device_type_display_name(dev->device->type));
 
-       process_boot_option_queue(handler);
-
        /* create our context */
        ctx = device_handler_discover_context_create(handler, dev);
 
@@ -939,9 +1065,8 @@ int device_handler_discover(struct device_handler *handler,
        /* add discovered stuff to the handler */
        device_handler_discover_context_commit(handler, ctx);
 
+       process_boot_option_queue(handler);
 out:
-       device_handler_status_dev_info(handler, dev, _("Processing complete"));
-
        talloc_unlink(handler, ctx);
 
        return 0;
@@ -954,7 +1079,8 @@ int device_handler_dhcp(struct device_handler *handler,
        struct discover_context *ctx;
 
        device_handler_status_dev_info(handler, dev,
-                       _("Processing dhcp event"));
+                       _("Processing DHCP lease response (ip: %s)"),
+                       event_get_param(event, "ip"));
 
        /* create our context */
        ctx = device_handler_discover_context_create(handler, dev);
@@ -965,8 +1091,6 @@ int device_handler_dhcp(struct device_handler *handler,
 
        device_handler_discover_context_commit(handler, ctx);
 
-       device_handler_status_dev_info(handler, dev, _("Processing complete"));
-
        talloc_unlink(handler, ctx);
 
        return 0;