discover: Add logging for default boot option behaviour
[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         pb_log("Timeout expired, booting default option %s\n", opt->option->id);
429
430         boot(handler, handler->default_boot_option, NULL,
431                         handler->dry_run, boot_status, handler);
432         return 0;
433 }
434
435 static void set_default(struct device_handler *handler,
436                 struct discover_boot_option *opt)
437 {
438         if (handler->default_boot_option)
439                 return;
440
441         if (!handler->default_enabled)
442                 return;
443
444         pb_log("Boot option %s set as default\n", opt->option->id);
445
446         handler->default_boot_option = opt;
447         handler->sec_to_boot = DEFAULT_BOOT_TIMEOUT_SEC;
448         default_timeout(handler);
449 }
450
451 static bool resource_is_resolved(struct resource *res)
452 {
453         return !res || res->resolved;
454 }
455
456 /* We only use this in an assert, which will disappear if we're compiling
457  * with NDEBUG, so we need the 'used' attribute for these builds */
458 static bool __attribute__((used)) boot_option_is_resolved(
459                 struct discover_boot_option *opt)
460 {
461         return resource_is_resolved(opt->boot_image) &&
462                 resource_is_resolved(opt->initrd) &&
463                 resource_is_resolved(opt->icon);
464 }
465
466 static bool resource_resolve(struct resource *res, const char *name,
467                 struct discover_boot_option *opt,
468                 struct device_handler *handler)
469 {
470         struct parser *parser = opt->source;
471
472         if (resource_is_resolved(res))
473                 return true;
474
475         pb_log("Attempting to resolve resource %s->%s with parser %s\n",
476                         opt->option->id, name, parser->name);
477         parser->resolve_resource(handler, res);
478
479         return res->resolved;
480 }
481
482 static bool boot_option_resolve(struct discover_boot_option *opt,
483                 struct device_handler *handler)
484 {
485         return resource_resolve(opt->boot_image, "boot_image", opt, handler) &&
486                 resource_resolve(opt->initrd, "initrd", opt, handler) &&
487                 resource_resolve(opt->icon, "icon", opt, handler);
488 }
489
490 static void boot_option_finalise(struct device_handler *handler,
491                 struct discover_boot_option *opt)
492 {
493         assert(boot_option_is_resolved(opt));
494
495         /* check that the parsers haven't set any of the final data */
496         assert(!opt->option->boot_image_file);
497         assert(!opt->option->initrd_file);
498         assert(!opt->option->icon_file);
499         assert(!opt->option->device_id);
500
501         if (opt->boot_image)
502                 opt->option->boot_image_file = opt->boot_image->url->full;
503         if (opt->initrd)
504                 opt->option->initrd_file = opt->initrd->url->full;
505         if (opt->icon)
506                 opt->option->icon_file = opt->icon->url->full;
507
508         opt->option->device_id = opt->device->device->id;
509
510         if (opt->option->is_default)
511                 set_default(handler, opt);
512 }
513
514 static void process_boot_option_queue(struct device_handler *handler)
515 {
516         struct discover_boot_option *opt, *tmp;
517
518         list_for_each_entry_safe(&handler->unresolved_boot_options,
519                         opt, tmp, list) {
520
521                 pb_log("queue: attempting resolution for %s\n",
522                                 opt->option->id);
523
524                 if (!boot_option_resolve(opt, handler))
525                         continue;
526
527                 pb_log("\tresolved!\n");
528
529                 list_remove(&opt->list);
530                 list_add_tail(&opt->device->boot_options, &opt->list);
531                 talloc_steal(opt->device, opt);
532                 boot_option_finalise(handler, opt);
533                 discover_server_notify_boot_option_add(handler->server,
534                                                         opt->option);
535         }
536 }
537
538 /**
539  * context_commit - Commit a temporary discovery context to the handler,
540  * and notify the clients about any new options / devices
541  */
542 static void context_commit(struct device_handler *handler,
543                 struct discover_context *ctx)
544 {
545         struct discover_device *dev = ctx->device;
546         struct discover_boot_option *opt, *tmp;
547         unsigned int i, existing_device = 0;
548
549         /* do we already have this device? */
550         for (i = 0; i < handler->n_devices; i++) {
551                 if (ctx->device == handler->devices[i]) {
552                         existing_device = 1;
553                         break;
554                 }
555         }
556
557         /* if not already present, add the device to the handler's array */
558         if (!existing_device) {
559                 handler->n_devices++;
560                 handler->devices = talloc_realloc(handler, handler->devices,
561                         struct discover_device *, handler->n_devices);
562                 handler->devices[handler->n_devices - 1] = dev;
563                 talloc_steal(handler, dev);
564
565                 discover_server_notify_device_add(handler->server, dev->device);
566
567                 /* this new device might be able to resolve existing boot
568                  * options */
569                 pb_log("New device %s, processing queue\n", dev->device->id);
570                 process_boot_option_queue(handler);
571         }
572
573
574         /* move boot options from the context to the device */
575         list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
576                 list_remove(&opt->list);
577
578                 if (boot_option_resolve(opt, handler)) {
579                         pb_log("boot option %s is resolved, "
580                                         "sending to clients\n",
581                                         opt->option->id);
582                         list_add_tail(&dev->boot_options, &opt->list);
583                         talloc_steal(dev, opt);
584                         boot_option_finalise(handler, opt);
585                         discover_server_notify_boot_option_add(handler->server,
586                                                                 opt->option);
587                 } else {
588                         if (!opt->source->resolve_resource) {
589                                 pb_log("parser %s gave us an unresolved "
590                                         "resource (%s), but no way to "
591                                         "resolve it\n",
592                                         opt->source->name, opt->option->id);
593                                 talloc_free(opt);
594                         } else {
595                                 pb_log("boot option %s is unresolved, "
596                                                 "adding to queue\n",
597                                                 opt->option->id);
598                                 list_add(&handler->unresolved_boot_options,
599                                                 &opt->list);
600                                 talloc_steal(handler, opt);
601                         }
602                 }
603         }
604 }
605
606 static int handle_add_udev_event(struct device_handler *handler,
607                 struct event *event)
608 {
609         struct discover_context *ctx;
610         struct discover_device *dev;
611         const char *param;
612         int rc;
613
614         /* create our context */
615         ctx = talloc(handler, struct discover_context);
616         ctx->event = event;
617         list_init(&ctx->boot_options);
618
619         /* create our top-level device */
620         dev = discover_device_create(handler, ctx, event);
621
622         ctx->device = dev;
623
624         /* try to parse UUID and labels */
625         param = event_get_param(ctx->event, "ID_FS_UUID");
626         if (param)
627                 dev->uuid = talloc_strdup(dev, param);
628
629         param = event_get_param(ctx->event, "ID_FS_LABEL");
630         if (param)
631                 dev->label = talloc_strdup(dev, param);
632
633         rc = mount_device(dev);
634         if (rc) {
635                 talloc_free(ctx);
636                 return 0;
637         }
638
639         /* run the parsers. This will populate the ctx's boot_option list. */
640         iterate_parsers(ctx, CONF_METHOD_LOCAL_FILE);
641
642         /* add discovered stuff to the handler */
643         context_commit(handler, ctx);
644
645         talloc_free(ctx);
646
647         return 0;
648 }
649
650 static int handle_remove_udev_event(struct device_handler *handler,
651                 struct event *event)
652 {
653         struct discover_device *dev;
654
655         dev = find_device(handler, event->device);
656         if (!dev)
657                 return 0;
658
659         /* remove device from handler device array */
660         device_handler_remove(handler, dev);
661
662         return 0;
663 }
664
665 static int handle_add_user_event(struct device_handler *handler,
666                 struct event *event)
667 {
668         struct discover_context *ctx;
669         struct discover_device *dev;
670         int rc;
671
672         assert(event->device);
673
674         ctx = talloc(handler, struct discover_context);
675         ctx->event = event;
676         list_init(&ctx->boot_options);
677
678         dev = discover_device_create(handler, ctx, event);
679         ctx->device = dev;
680
681         rc = parse_user_event(ctx, event);
682
683         if (!rc)
684                 context_commit(handler, ctx);
685
686         return rc;
687 }
688
689 static int handle_remove_user_event(struct device_handler *handler,
690                 struct event *event)
691 {
692         struct discover_device *dev = find_device(handler, event->device);
693
694         if (!dev)
695                 return 0;
696
697         /* remove device from handler device array */
698         device_handler_remove(handler, dev);
699
700         return 0;
701 }
702
703 static enum conf_method parse_conf_method(const char *str)
704 {
705
706         if (!strcasecmp(str, "dhcp")) {
707                 return CONF_METHOD_DHCP;
708         }
709         return CONF_METHOD_UNKNOWN;
710 }
711
712 static int handle_conf_user_event(struct device_handler *handler,
713                 struct event *event)
714 {
715         struct discover_context *ctx;
716         struct discover_device *dev;
717         enum conf_method method;
718         const char *val;
719
720         ctx = talloc(handler, struct discover_context);
721         ctx->event = event;
722         list_init(&ctx->boot_options);
723
724         val = event_get_param(event, "url");
725         if (!val) {
726                 talloc_free(ctx);
727                 return 0;
728         }
729
730         ctx->conf_url = pb_url_parse(ctx, val);
731         if (!ctx->conf_url) {
732                 talloc_free(ctx);
733                 return 0;
734         }
735
736         val = event_get_param(event, "method");
737         if (!val) {
738                 talloc_free(ctx);
739                 return 0;
740         }
741
742         method = parse_conf_method(val);
743         if (method == CONF_METHOD_UNKNOWN) {
744                 talloc_free(ctx);
745                 return 0;
746         }
747
748         dev = discover_device_create(handler, ctx, event);
749         ctx->device = dev;
750
751         iterate_parsers(ctx, method);
752
753         context_commit(handler, ctx);
754
755         return 0;
756 }
757
758 typedef int (*event_handler)(struct device_handler *, struct event *);
759
760 static event_handler handlers[EVENT_TYPE_MAX][EVENT_ACTION_MAX] = {
761         [EVENT_TYPE_UDEV] = {
762                 [EVENT_ACTION_ADD]      = handle_add_udev_event,
763                 [EVENT_ACTION_REMOVE]   = handle_remove_udev_event,
764         },
765         [EVENT_TYPE_USER] = {
766                 [EVENT_ACTION_ADD]      = handle_add_user_event,
767                 [EVENT_ACTION_REMOVE]   = handle_remove_user_event,
768                 [EVENT_ACTION_CONF]     = handle_conf_user_event,
769         }
770 };
771
772 int device_handler_event(struct device_handler *handler,
773                 struct event *event)
774 {
775         if (event->type >= EVENT_TYPE_MAX ||
776                         event->action >= EVENT_ACTION_MAX ||
777                         !handlers[event->type][event->action]) {
778                 pb_log("%s unknown type/action: %d/%d\n", __func__,
779                                 event->type, event->action);
780                 return 0;
781         }
782
783         return handlers[event->type][event->action](handler, event);
784 }
785
786 static struct discover_boot_option *find_boot_option_by_id(
787                 struct device_handler *handler, const char *id)
788 {
789         unsigned int i;
790
791         for (i = 0; i < handler->n_devices; i++) {
792                 struct discover_device *dev = handler->devices[i];
793                 struct discover_boot_option *opt;
794
795                 list_for_each_entry(&dev->boot_options, opt, list)
796                         if (!strcmp(opt->option->id, id))
797                                 return opt;
798         }
799
800         return NULL;
801 }
802
803 void device_handler_boot(struct device_handler *handler,
804                 struct boot_command *cmd)
805 {
806         struct discover_boot_option *opt;
807
808         opt = find_boot_option_by_id(handler, cmd->option_id);
809
810         boot(handler, opt, cmd, handler->dry_run, boot_status, handler);
811 }
812
813 void device_handler_cancel_default(struct device_handler *handler)
814 {
815         struct boot_status status;
816
817         if (handler->timeout_waiter)
818                 waiter_remove(handler->timeout_waiter);
819
820         handler->timeout_waiter = NULL;
821         handler->default_enabled = false;
822
823         /* we only send status if we had a default boot option queued */
824         if (!handler->default_boot_option)
825                 return;
826
827         pb_log("Cancelling default boot option\n");
828
829         handler->default_boot_option = NULL;
830
831         status.type = BOOT_STATUS_INFO;
832         status.progress = -1;
833         status.detail = NULL;
834         status.message = "Default boot cancelled";
835
836         discover_server_notify_boot_status(handler->server, &status);
837 }
838 #endif