discover: Add "cancel default boot" messages
[petitboot] / discover / device-handler.c
1
2 #include <assert.h>
3 #include <stdlib.h>
4 #include <unistd.h>
5 #include <string.h>
6 #include <errno.h>
7 #include <sys/stat.h>
8 #include <sys/wait.h>
9
10 #include <talloc/talloc.h>
11 #include <list/list.h>
12 #include <log/log.h>
13 #include <types/types.h>
14 #include <system/system.h>
15 #include <url/url.h>
16
17 #include "device-handler.h"
18 #include "discover-server.h"
19 #include "event.h"
20 #include "parser.h"
21 #include "resource.h"
22 #include "udev.h"
23 #include "paths.h"
24 #include "boot.h"
25
26 struct device_handler {
27         struct discover_server  *server;
28         int                     dry_run;
29
30         struct discover_device  **devices;
31         unsigned int            n_devices;
32
33         struct waitset          *waitset;
34         struct waiter           *timeout_waiter;
35         bool                    default_enabled;
36         unsigned int            sec_to_boot;
37
38         struct discover_boot_option *default_boot_option;
39         struct list             unresolved_boot_options;
40 };
41
42 void discover_context_add_boot_option(struct discover_context *ctx,
43                 struct discover_boot_option *boot_option)
44 {
45         boot_option->source = ctx->parser;
46         list_add_tail(&ctx->boot_options, &boot_option->list);
47         talloc_steal(ctx, boot_option);
48 }
49
50 /**
51  * device_handler_get_device_count - Get the count of current handler devices.
52  */
53
54 int device_handler_get_device_count(const struct device_handler *handler)
55 {
56         return handler->n_devices;
57 }
58
59 /**
60  * device_handler_get_device - Get a handler device by index.
61  */
62
63 const struct discover_device *device_handler_get_device(
64         const struct device_handler *handler, unsigned int index)
65 {
66         if (index >= handler->n_devices) {
67                 assert(0 && "bad index");
68                 return NULL;
69         }
70
71         return handler->devices[index];
72 }
73
74 struct discover_boot_option *discover_boot_option_create(
75                 struct discover_context *ctx,
76                 struct discover_device *device)
77 {
78         struct discover_boot_option *opt;
79
80         opt = talloc_zero(ctx, struct discover_boot_option);
81         opt->option = talloc_zero(opt, struct boot_option);
82         opt->device = device;
83
84         return opt;
85 }
86
87 static int device_match_path(struct discover_device *dev, const char *path)
88 {
89         return dev->device_path && !strcmp(dev->device_path, path);
90 }
91
92 static int device_match_uuid(struct discover_device *dev, const char *uuid)
93 {
94         return dev->uuid && !strcmp(dev->uuid, uuid);
95 }
96
97 static int device_match_label(struct discover_device *dev, const char *label)
98 {
99         return dev->label && !strcmp(dev->label, label);
100 }
101
102 static int device_match_id(struct discover_device *dev, const char *id)
103 {
104         return !strcmp(dev->device->id, id);
105 }
106
107 static struct discover_device *device_lookup(
108                 struct device_handler *device_handler,
109                 int (match_fn)(struct discover_device *, const char *),
110                 const char *str)
111 {
112         struct discover_device *dev;
113         unsigned int i;
114
115         if (!str)
116                 return NULL;
117
118         for (i = 0; i < device_handler->n_devices; i++) {
119                 dev = device_handler->devices[i];
120
121                 if (match_fn(dev, str))
122                         return dev;
123         }
124
125         return NULL;
126 }
127
128 struct discover_device *device_lookup_by_name(struct device_handler *handler,
129                 const char *name)
130 {
131         struct discover_device *dev;
132         char *path;
133
134         if (strncmp(name, "/dev/", strlen("/dev/")))
135                 path = talloc_asprintf(NULL, "/dev/%s", name);
136         else
137                 path = talloc_strdup(NULL, name);
138
139         dev = device_lookup_by_path(handler, path);
140
141         talloc_free(path);
142
143         return dev;
144 }
145
146 struct discover_device *device_lookup_by_path(
147                 struct device_handler *device_handler,
148                 const char *path)
149 {
150         return device_lookup(device_handler, device_match_path, path);
151 }
152
153 struct discover_device *device_lookup_by_uuid(
154                 struct device_handler *device_handler,
155                 const char *uuid)
156 {
157         return device_lookup(device_handler, device_match_uuid, uuid);
158 }
159
160 struct discover_device *device_lookup_by_label(
161                 struct device_handler *device_handler,
162                 const char *label)
163 {
164         return device_lookup(device_handler, device_match_label, label);
165 }
166
167 struct discover_device *device_lookup_by_id(
168                 struct device_handler *device_handler,
169                 const char *id)
170 {
171         return device_lookup(device_handler, device_match_id, id);
172 }
173
174 void device_handler_destroy(struct device_handler *handler)
175 {
176         talloc_free(handler);
177 }
178
179 #ifdef PETITBOOT_TEST
180
181 /* we have a simplified interface for petitboot testing, but still want
182  * to keep struct device_handler opaque. */
183 struct device_handler *device_handler_init(
184                 struct discover_server *server __attribute__((unused)),
185                 struct waitset *waitset __attribute__((unused)),
186                 int dry_run __attribute__((unused)))
187 {
188         struct device_handler *handler;
189
190         handler = talloc_zero(NULL, struct device_handler);
191         list_init(&handler->unresolved_boot_options);
192
193         return handler;
194 }
195
196 void device_handler_add_device(struct device_handler *handler,
197                 struct discover_device *dev)
198 {
199         handler->n_devices++;
200         handler->devices = talloc_realloc(handler, handler->devices,
201                 struct discover_device *, handler->n_devices);
202         handler->devices[handler->n_devices - 1] = dev;
203 }
204
205 #else
206
207 static int mount_device(struct discover_device *dev)
208 {
209         const char *argv[6];
210
211         if (!dev->device_path)
212                 return -1;
213
214         if (!dev->mount_path)
215                 dev->mount_path = join_paths(dev, mount_base(),
216                                                 dev->device_path);
217
218         if (pb_mkdir_recursive(dev->mount_path))
219                 pb_log("couldn't create mount directory %s: %s\n",
220                                 dev->mount_path, strerror(errno));
221
222         argv[0] = pb_system_apps.mount;
223         argv[1] = dev->device_path;
224         argv[2] = dev->mount_path;
225         argv[3] = "-o";
226         argv[4] = "ro";
227         argv[5] = NULL;
228
229         if (pb_run_cmd(argv, 1, 0)) {
230
231                 /* Retry mount without ro option. */
232
233                 argv[0] = pb_system_apps.mount;
234                 argv[1] = dev->device_path;
235                 argv[2] = dev->mount_path;
236                 argv[3] = NULL;
237
238                 if (pb_run_cmd(argv, 1, 0))
239                         goto out_rmdir;
240         }
241
242         return 0;
243
244 out_rmdir:
245         pb_rmdir_recursive(mount_base(), dev->mount_path);
246         return -1;
247 }
248
249 static int umount_device(struct discover_device *dev)
250 {
251         int status;
252         pid_t pid;
253
254         if (!dev->mount_path)
255                 return 0;
256
257         pid = fork();
258         if (pid == -1) {
259                 pb_log("%s: fork failed: %s\n", __func__, strerror(errno));
260                 return -1;
261         }
262
263         if (pid == 0) {
264                 execl(pb_system_apps.umount, pb_system_apps.umount,
265                                                 dev->mount_path, NULL);
266                 exit(EXIT_FAILURE);
267         }
268
269         if (waitpid(pid, &status, 0) == -1) {
270                 pb_log("%s: waitpid failed: %s\n", __func__,
271                                 strerror(errno));
272                 return -1;
273         }
274
275         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
276                 return -1;
277
278         pb_rmdir_recursive(mount_base(), dev->mount_path);
279
280         return 0;
281 }
282
283 struct device_handler *device_handler_init(struct discover_server *server,
284                 struct waitset *waitset, int dry_run)
285 {
286         struct device_handler *handler;
287
288         handler = talloc(NULL, struct device_handler);
289         handler->devices = NULL;
290         handler->n_devices = 0;
291         handler->server = server;
292         handler->waitset = waitset;
293         handler->dry_run = dry_run;
294         handler->default_boot_option = NULL;
295         handler->default_enabled = true;
296         list_init(&handler->unresolved_boot_options);
297
298         /* set up our mount point base */
299         pb_mkdir_recursive(mount_base());
300
301         parser_init();
302
303         return handler;
304 }
305
306 static int destroy_device(void *arg)
307 {
308         struct discover_device *dev = arg;
309
310         umount_device(dev);
311
312         return 0;
313 }
314
315 static struct discover_device *find_device(struct device_handler *handler,
316                 const char *id)
317 {
318         struct discover_device *dev;
319         unsigned int i;
320
321         for (i = 0; i < handler->n_devices; i++) {
322                 dev = handler->devices[i];
323                 if (!strcmp(dev->device->id, id))
324                         return dev;
325         }
326
327         return NULL;
328 }
329
330 static struct discover_device *discover_device_create(
331                 struct device_handler *handler,
332                 struct discover_context *ctx,
333                 struct event *event)
334 {
335         struct discover_device *dev;
336         const char *devname;
337
338         dev = find_device(handler, event->device);
339         if (dev)
340                 return dev;
341
342         dev = talloc_zero(ctx, struct discover_device);
343         dev->device = talloc_zero(dev, struct device);
344         list_init(&dev->boot_options);
345
346         devname = event_get_param(ctx->event, "DEVNAME");
347         if (devname)
348                 dev->device_path = talloc_strdup(dev, devname);
349
350         dev->device->id = talloc_strdup(dev, event->device);
351
352         talloc_set_destructor(dev, destroy_device);
353
354         return dev;
355 }
356
357 /**
358  * device_handler_remove - Remove a device from the handler device array.
359  */
360
361 static void device_handler_remove(struct device_handler *handler,
362         struct discover_device *device)
363 {
364         unsigned int i;
365
366         for (i = 0; i < handler->n_devices; i++)
367                 if (handler->devices[i] == device)
368                         break;
369
370         if (i == handler->n_devices) {
371                 assert(0 && "unknown device");
372                 return;
373         }
374
375         handler->n_devices--;
376         memmove(&handler->devices[i], &handler->devices[i + 1],
377                 (handler->n_devices - i) * sizeof(handler->devices[0]));
378         handler->devices = talloc_realloc(handler, handler->devices,
379                 struct discover_device *, handler->n_devices);
380
381         discover_server_notify_device_remove(handler->server, device->device);
382
383         talloc_free(device);
384 }
385
386 static void boot_status(void *arg, struct boot_status *status)
387 {
388         struct device_handler *handler = arg;
389
390         discover_server_notify_boot_status(handler->server, status);
391 }
392
393 static void countdown_status(struct device_handler *handler,
394                 struct discover_boot_option *opt, unsigned int sec)
395 {
396         struct boot_status status;
397
398         status.type = BOOT_STATUS_INFO;
399         status.progress = -1;
400         status.detail = NULL;
401         status.message = talloc_asprintf(handler,
402                         "Booting %s in %d sec", opt->option->name, sec);
403
404         discover_server_notify_boot_status(handler->server, &status);
405
406         talloc_free(status.message);
407 }
408
409 static int default_timeout(void *arg)
410 {
411         struct device_handler *handler = arg;
412         struct discover_boot_option *opt;
413
414         if (!handler->default_boot_option)
415                 return 0;
416
417         opt = handler->default_boot_option;
418
419         if (handler->sec_to_boot) {
420                 countdown_status(handler, opt, handler->sec_to_boot);
421                 handler->sec_to_boot--;
422                 handler->timeout_waiter = waiter_register_timeout(
423                                                 handler->waitset, 1000,
424                                                 default_timeout, handler);
425                 return 0;
426         }
427
428         boot(handler, handler->default_boot_option, NULL,
429                         handler->dry_run, boot_status, handler);
430         return 0;
431 }
432
433 static void set_default(struct device_handler *handler,
434                 struct discover_boot_option *opt)
435 {
436         if (handler->default_boot_option)
437                 return;
438
439         if (!handler->default_enabled)
440                 return;
441
442         handler->default_boot_option = opt;
443         handler->sec_to_boot = DEFAULT_BOOT_TIMEOUT_SEC;
444         default_timeout(handler);
445 }
446
447 static bool resource_is_resolved(struct resource *res)
448 {
449         return !res || res->resolved;
450 }
451
452 /* We only use this in an assert, which will disappear if we're compiling
453  * with NDEBUG, so we need the 'used' attribute for these builds */
454 static bool __attribute__((used)) boot_option_is_resolved(
455                 struct discover_boot_option *opt)
456 {
457         return resource_is_resolved(opt->boot_image) &&
458                 resource_is_resolved(opt->initrd) &&
459                 resource_is_resolved(opt->icon);
460 }
461
462 static bool resource_resolve(struct resource *res, const char *name,
463                 struct discover_boot_option *opt,
464                 struct device_handler *handler)
465 {
466         struct parser *parser = opt->source;
467
468         if (resource_is_resolved(res))
469                 return true;
470
471         pb_log("Attempting to resolve resource %s->%s with parser %s\n",
472                         opt->option->id, name, parser->name);
473         parser->resolve_resource(handler, res);
474
475         return res->resolved;
476 }
477
478 static bool boot_option_resolve(struct discover_boot_option *opt,
479                 struct device_handler *handler)
480 {
481         return resource_resolve(opt->boot_image, "boot_image", opt, handler) &&
482                 resource_resolve(opt->initrd, "initrd", opt, handler) &&
483                 resource_resolve(opt->icon, "icon", opt, handler);
484 }
485
486 static void boot_option_finalise(struct device_handler *handler,
487                 struct discover_boot_option *opt)
488 {
489         assert(boot_option_is_resolved(opt));
490
491         /* check that the parsers haven't set any of the final data */
492         assert(!opt->option->boot_image_file);
493         assert(!opt->option->initrd_file);
494         assert(!opt->option->icon_file);
495         assert(!opt->option->device_id);
496
497         if (opt->boot_image)
498                 opt->option->boot_image_file = opt->boot_image->url->full;
499         if (opt->initrd)
500                 opt->option->initrd_file = opt->initrd->url->full;
501         if (opt->icon)
502                 opt->option->icon_file = opt->icon->url->full;
503
504         opt->option->device_id = opt->device->device->id;
505
506         if (opt->option->is_default)
507                 set_default(handler, opt);
508 }
509
510 static void process_boot_option_queue(struct device_handler *handler)
511 {
512         struct discover_boot_option *opt, *tmp;
513
514         list_for_each_entry_safe(&handler->unresolved_boot_options,
515                         opt, tmp, list) {
516
517                 pb_log("queue: attempting resolution for %s\n",
518                                 opt->option->id);
519
520                 if (!boot_option_resolve(opt, handler))
521                         continue;
522
523                 pb_log("\tresolved!\n");
524
525                 list_remove(&opt->list);
526                 list_add_tail(&opt->device->boot_options, &opt->list);
527                 talloc_steal(opt->device, opt);
528                 boot_option_finalise(handler, opt);
529                 discover_server_notify_boot_option_add(handler->server,
530                                                         opt->option);
531         }
532 }
533
534 /**
535  * context_commit - Commit a temporary discovery context to the handler,
536  * and notify the clients about any new options / devices
537  */
538 static void context_commit(struct device_handler *handler,
539                 struct discover_context *ctx)
540 {
541         struct discover_device *dev = ctx->device;
542         struct discover_boot_option *opt, *tmp;
543         unsigned int i, existing_device = 0;
544
545         /* do we already have this device? */
546         for (i = 0; i < handler->n_devices; i++) {
547                 if (ctx->device == handler->devices[i]) {
548                         existing_device = 1;
549                         break;
550                 }
551         }
552
553         /* if not already present, add the device to the handler's array */
554         if (!existing_device) {
555                 handler->n_devices++;
556                 handler->devices = talloc_realloc(handler, handler->devices,
557                         struct discover_device *, handler->n_devices);
558                 handler->devices[handler->n_devices - 1] = dev;
559                 talloc_steal(handler, dev);
560
561                 discover_server_notify_device_add(handler->server, dev->device);
562
563                 /* this new device might be able to resolve existing boot
564                  * options */
565                 pb_log("New device %s, processing queue\n", dev->device->id);
566                 process_boot_option_queue(handler);
567         }
568
569
570         /* move boot options from the context to the device */
571         list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
572                 list_remove(&opt->list);
573
574                 if (boot_option_resolve(opt, handler)) {
575                         pb_log("boot option %s is resolved, "
576                                         "sending to clients\n",
577                                         opt->option->id);
578                         list_add_tail(&dev->boot_options, &opt->list);
579                         talloc_steal(dev, opt);
580                         boot_option_finalise(handler, opt);
581                         discover_server_notify_boot_option_add(handler->server,
582                                                                 opt->option);
583                 } else {
584                         if (!opt->source->resolve_resource) {
585                                 pb_log("parser %s gave us an unresolved "
586                                         "resource (%s), but no way to "
587                                         "resolve it\n",
588                                         opt->source->name, opt->option->id);
589                                 talloc_free(opt);
590                         } else {
591                                 pb_log("boot option %s is unresolved, "
592                                                 "adding to queue\n",
593                                                 opt->option->id);
594                                 list_add(&handler->unresolved_boot_options,
595                                                 &opt->list);
596                                 talloc_steal(handler, opt);
597                         }
598                 }
599         }
600 }
601
602 static int handle_add_udev_event(struct device_handler *handler,
603                 struct event *event)
604 {
605         struct discover_context *ctx;
606         struct discover_device *dev;
607         const char *param;
608         int rc;
609
610         /* create our context */
611         ctx = talloc(handler, struct discover_context);
612         ctx->event = event;
613         list_init(&ctx->boot_options);
614
615         /* create our top-level device */
616         dev = discover_device_create(handler, ctx, event);
617
618         ctx->device = dev;
619
620         /* try to parse UUID and labels */
621         param = event_get_param(ctx->event, "ID_FS_UUID");
622         if (param)
623                 dev->uuid = talloc_strdup(dev, param);
624
625         param = event_get_param(ctx->event, "ID_FS_LABEL");
626         if (param)
627                 dev->label = talloc_strdup(dev, param);
628
629         rc = mount_device(dev);
630         if (rc) {
631                 talloc_free(ctx);
632                 return 0;
633         }
634
635         /* run the parsers. This will populate the ctx's boot_option list. */
636         iterate_parsers(ctx, CONF_METHOD_LOCAL_FILE);
637
638         /* add discovered stuff to the handler */
639         context_commit(handler, ctx);
640
641         talloc_free(ctx);
642
643         return 0;
644 }
645
646 static int handle_remove_udev_event(struct device_handler *handler,
647                 struct event *event)
648 {
649         struct discover_device *dev;
650
651         dev = find_device(handler, event->device);
652         if (!dev)
653                 return 0;
654
655         /* remove device from handler device array */
656         device_handler_remove(handler, dev);
657
658         return 0;
659 }
660
661 static int handle_add_user_event(struct device_handler *handler,
662                 struct event *event)
663 {
664         struct discover_context *ctx;
665         struct discover_device *dev;
666         int rc;
667
668         assert(event->device);
669
670         ctx = talloc(handler, struct discover_context);
671         ctx->event = event;
672         list_init(&ctx->boot_options);
673
674         dev = discover_device_create(handler, ctx, event);
675         ctx->device = dev;
676
677         rc = parse_user_event(ctx, event);
678
679         if (!rc)
680                 context_commit(handler, ctx);
681
682         return rc;
683 }
684
685 static int handle_remove_user_event(struct device_handler *handler,
686                 struct event *event)
687 {
688         struct discover_device *dev = find_device(handler, event->device);
689
690         if (!dev)
691                 return 0;
692
693         /* remove device from handler device array */
694         device_handler_remove(handler, dev);
695
696         return 0;
697 }
698
699 static enum conf_method parse_conf_method(const char *str)
700 {
701
702         if (!strcasecmp(str, "dhcp")) {
703                 return CONF_METHOD_DHCP;
704         }
705         return CONF_METHOD_UNKNOWN;
706 }
707
708 static int handle_conf_user_event(struct device_handler *handler,
709                 struct event *event)
710 {
711         struct discover_context *ctx;
712         struct discover_device *dev;
713         enum conf_method method;
714         const char *val;
715
716         ctx = talloc(handler, struct discover_context);
717         ctx->event = event;
718         list_init(&ctx->boot_options);
719
720         val = event_get_param(event, "url");
721         if (!val) {
722                 talloc_free(ctx);
723                 return 0;
724         }
725
726         ctx->conf_url = pb_url_parse(ctx, val);
727         if (!ctx->conf_url) {
728                 talloc_free(ctx);
729                 return 0;
730         }
731
732         val = event_get_param(event, "method");
733         if (!val) {
734                 talloc_free(ctx);
735                 return 0;
736         }
737
738         method = parse_conf_method(val);
739         if (method == CONF_METHOD_UNKNOWN) {
740                 talloc_free(ctx);
741                 return 0;
742         }
743
744         dev = discover_device_create(handler, ctx, event);
745         ctx->device = dev;
746
747         iterate_parsers(ctx, method);
748
749         context_commit(handler, ctx);
750
751         return 0;
752 }
753
754 typedef int (*event_handler)(struct device_handler *, struct event *);
755
756 static event_handler handlers[EVENT_TYPE_MAX][EVENT_ACTION_MAX] = {
757         [EVENT_TYPE_UDEV] = {
758                 [EVENT_ACTION_ADD]      = handle_add_udev_event,
759                 [EVENT_ACTION_REMOVE]   = handle_remove_udev_event,
760         },
761         [EVENT_TYPE_USER] = {
762                 [EVENT_ACTION_ADD]      = handle_add_user_event,
763                 [EVENT_ACTION_REMOVE]   = handle_remove_user_event,
764                 [EVENT_ACTION_CONF]     = handle_conf_user_event,
765         }
766 };
767
768 int device_handler_event(struct device_handler *handler,
769                 struct event *event)
770 {
771         if (event->type >= EVENT_TYPE_MAX ||
772                         event->action >= EVENT_ACTION_MAX ||
773                         !handlers[event->type][event->action]) {
774                 pb_log("%s unknown type/action: %d/%d\n", __func__,
775                                 event->type, event->action);
776                 return 0;
777         }
778
779         return handlers[event->type][event->action](handler, event);
780 }
781
782 static struct discover_boot_option *find_boot_option_by_id(
783                 struct device_handler *handler, const char *id)
784 {
785         unsigned int i;
786
787         for (i = 0; i < handler->n_devices; i++) {
788                 struct discover_device *dev = handler->devices[i];
789                 struct discover_boot_option *opt;
790
791                 list_for_each_entry(&dev->boot_options, opt, list)
792                         if (!strcmp(opt->option->id, id))
793                                 return opt;
794         }
795
796         return NULL;
797 }
798
799 void device_handler_boot(struct device_handler *handler,
800                 struct boot_command *cmd)
801 {
802         struct discover_boot_option *opt;
803
804         opt = find_boot_option_by_id(handler, cmd->option_id);
805
806         boot(handler, opt, cmd, handler->dry_run, boot_status, handler);
807 }
808
809 void device_handler_cancel_default(struct device_handler *handler)
810 {
811         struct boot_status status;
812
813         if (handler->timeout_waiter)
814                 waiter_remove(handler->timeout_waiter);
815
816         handler->timeout_waiter = NULL;
817         handler->default_enabled = false;
818
819         /* we only send status if we had a default boot option queued */
820         if (!handler->default_boot_option)
821                 return;
822
823         handler->default_boot_option = NULL;
824
825         status.type = BOOT_STATUS_INFO;
826         status.progress = -1;
827         status.detail = NULL;
828         status.message = "Default boot cancelled";
829
830         discover_server_notify_boot_status(handler->server, &status);
831 }
832 #endif