fish: add missing include to unbreak build
[barrelfish] / usr / kaluga / start_cpu.c
1 /**
2  * \file
3  * \brief Code responsible for booting application cores
4  */
5
6 /*
7  * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
8  * All rights reserved.
9  *
10  * This file is distributed under the terms in the attached LICENSE file.
11  * If you do not find this file, copies can be found by writing to:
12  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
13  */
14
15 #include <stdlib.h>
16 #include <stdbool.h>
17 #include <stdio.h>
18 #include <assert.h>
19
20 #include <barrelfish/barrelfish.h>
21 #include <barrelfish/cpu_arch.h>
22
23 #include <if/monitor_defs.h>
24
25 #include <octopus/octopus.h>
26 #include <skb/skb.h>
27 #include <trace/trace.h>
28 #include <barrelfish/spawn_client.h>
29
30 #include <hw_records.h>
31
32 #include "kaluga.h"
33
34 static const char *processor_regex = HW_PROCESSOR_GENERIC_REGEX;
35
36 static void cpu_change_event(octopus_mode_t mode, char* record, void* state)
37 {
38     if (mode & OCT_ON_SET) {
39         KALUGA_DEBUG("CPU found: %s\n", record);
40
41         /* try to extract basic information from the record */
42         uint64_t barrelfish_id, type, hw_id, enabled = 0;
43         errval_t err = oct_read(record, "_ { " HW_PROCESSOR_GENERIC_FIELDS " }",
44                                 &enabled, &barrelfish_id, &hw_id, &type);
45         if (err_is_fail(err)) {
46             DEBUG_ERR(err, "Cannot read record.");
47             printf("Malformed CPU record. Do not boot discovered CPU %"PRIu64".\n",
48                     barrelfish_id);
49             goto out;
50         }
51
52         /* find the corectrl module for the given cpu type */
53         struct module_info* mi = find_corectrl_for_cpu_type((enum cpu_type)type);
54         if (mi != NULL) {
55             err = mi->start_function(0, mi, record);
56             if (err_is_fail(err)) {
57                 printf("Boot driver not found. Do not boot discovered CPU %"PRIu64".\n",
58                        barrelfish_id);
59                 goto out;
60             }
61         }
62     }
63     if (mode & OCT_ON_DEL) {
64         KALUGA_DEBUG("CPU removed: %s\n", record);
65         assert(!"NYI");
66     }
67
68 out:
69     assert(!(mode & OCT_REMOVED));
70     free(record);
71 }
72
73 errval_t watch_for_cores(void)
74 {
75     octopus_trigger_id_t tid;
76     return oct_trigger_existing_and_watch(processor_regex, cpu_change_event,
77                                           NULL, &tid);
78 }
79
80 errval_t start_boot_driver(coreid_t where, struct module_info* mi,
81         char* record)
82 {
83     assert(mi != NULL);
84     errval_t err;
85
86     if (!is_auto_driver(mi)) {
87         return KALUGA_ERR_DRIVER_NOT_AUTO;
88     }
89
90     // Construct additional command line arguments containing pci-id.
91     // We need one extra entry for the new argument.
92     char **argv = mi->argv;
93     bool cleanup = false;
94     char barrelfish_id_s[10];
95     size_t argc = mi->argc;
96
97     KALUGA_DEBUG("Starting corectrl for %s\n", record);
98     uint64_t barrelfish_id, cpu_type, hw_id, enabled = 0;
99     err = oct_read(record, "_ { " HW_PROCESSOR_GENERIC_FIELDS " }",
100                             &enabled, &barrelfish_id, &hw_id, &cpu_type);
101     if (err_is_ok(err)) {
102         /*
103          * XXX: change this to a generic cpuhwid instead of apic!
104          */
105         skb_add_fact("corename(%"PRIu64", %s, apic(%"PRIu64")).",
106                      barrelfish_id, cpu_type_to_archstr(cpu_type), hw_id);
107
108         /* we are already running */
109         if (barrelfish_id == my_core_id) {
110             return SYS_ERR_OK;
111         }
112
113         if (!enabled) {
114             printf("CPU %" PRIu64 " is not enabled. Skipping driver initialization\n",
115                     barrelfish_id);
116             return SYS_ERR_OK;
117         }
118
119         argv = malloc((argc+5) * sizeof(char *));
120         memcpy(argv, mi->argv, argc * sizeof(char *));
121         snprintf(barrelfish_id_s, 10, "%"PRIu64"", barrelfish_id);
122
123         argv[argc] = "boot";
124         argc += 1;
125         argv[argc] = barrelfish_id_s;
126         argc += 1;
127         // Copy kernel args over to new core
128         struct module_info* cpu_module = find_module("cpu");
129         if (cpu_module != NULL && strlen(cpu_module->args) > 1) {
130             KALUGA_DEBUG("%s:%s:%d: Boot with cpu arg %s and barrelfish_id_s=%s\n",
131                          __FILE__, __FUNCTION__, __LINE__, cpu_module->args, barrelfish_id_s);
132             argv[argc] = "-a";
133             argc += 1;
134             argv[argc] = cpu_module->args;
135             argc += 1;
136         }
137         argv[argc] = NULL;
138
139         cleanup = true;
140     }
141     else {
142         DEBUG_ERR(err, "Malformed CPU record?");
143         return err;
144     }
145
146     struct capref task_cap_kernel;
147     task_cap_kernel.cnode = cnode_task;
148     task_cap_kernel.slot = TASKCN_SLOT_KERNELCAP;
149
150 #ifdef KALUGA_SERVICE_DEBUG
151     struct capability info;
152     err = debug_cap_identify(task_cap_kernel, &info);
153     if (err_is_fail(err)) {
154         USER_PANIC_ERR(err, "Can not identify the capability.");
155     }
156     char buffer[1024];
157     debug_print_cap(buffer, 1024, &info);
158     KALUGA_DEBUG("%s:%d: capability=%s\n", __FILE__, __LINE__, buffer);
159 #endif
160
161     struct capref inheritcn_cap;
162     err = alloc_inheritcn_with_caps(&inheritcn_cap,
163                                     NULL_CAP, NULL_CAP, task_cap_kernel);
164     if (err_is_fail(err)) {
165         DEBUG_ERR(err, "alloc_inheritcn_with_caps failed.");
166     }
167
168     err = spawn_program_with_caps(where, mi->path, argv,
169                                   environ, inheritcn_cap,
170                                   NULL_CAP, SPAWN_FLAGS_NEW_DOMAIN,
171                                   &mi->did[0]);
172     if (err_is_fail(err)) {
173         DEBUG_ERR(err, "Spawning %s failed.", mi->path);
174     }
175
176     if (cleanup) {
177         free(argv);
178     }
179
180     return err;
181 }
182
183
184 static void spawnd_change_event(octopus_mode_t mode, char* record, void* state)
185 {
186     size_t count = (size_t) state;
187     static coreid_t spawnd_counter = 0;
188
189     if (mode & OCT_ON_SET) {
190         KALUGA_DEBUG("spawnd found: %s\n", record);
191         spawnd_counter++;
192
193         if (spawnd_counter == count) {
194             KALUGA_DEBUG("Found enough spawnds, setting all_spawnds_up\n");
195             errval_t err = oct_set("all_spawnds_up { iref: 0 }");
196             assert(err_is_ok(err));
197         }
198     }
199 }
200
201 errval_t wait_for_all_spawnds(void)
202 {
203     // Note: The whole wait for all_spawnds_up thing is a hack.
204     // Our overall design goal is a system where cores
205     // come and go dynamically and we do not want / need
206     // to wait for a stable state.
207     // However, some of our code (for example domain spanning)
208     // still assumes a fixed set of cores and will deadlock
209     // otherwise. Therefore we need to fix those parts first.
210     KALUGA_DEBUG("Waiting for acpi");
211     char* record = NULL;
212     errval_t err = oct_wait_for(&record, "acpi { iref: _ }");
213     free(record);
214     if (err_is_fail(err)) {
215         return err_push(err, KALUGA_ERR_WAITING_FOR_ACPI);
216     }
217
218     // No we should be able to get core count
219     // of all cores to estimate the amount of
220     // spawnd's we have to expect (one per core)
221     char** names;
222     size_t count;
223     err = oct_get_names(&names, &count, processor_regex);
224     if (err_is_fail(err)) {
225         return err_push(err, KALUGA_ERR_QUERY_LOCAL_APIC);
226     }
227     oct_free_names(names, count);
228
229     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
230     octopus_trigger_id_t tid;
231     return oct_trigger_existing_and_watch(spawnds, spawnd_change_event, (void*)count, &tid);
232 }