Merge branch 'master' of ssh://code.systems.ethz.ch:8006/diffusion/BFI/barrelfish
[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 }
71
72 errval_t watch_for_cores(void)
73 {
74     octopus_trigger_id_t tid;
75     return oct_trigger_existing_and_watch(processor_regex, cpu_change_event,
76                                           NULL, &tid);
77 }
78
79 errval_t start_boot_driver(coreid_t where, struct module_info* mi,
80         char* record)
81 {
82     assert(mi != NULL);
83     errval_t err;
84
85     if (!is_auto_driver(mi)) {
86         return KALUGA_ERR_DRIVER_NOT_AUTO;
87     }
88
89     // Construct additional command line arguments containing pci-id.
90     // We need one extra entry for the new argument.
91     char **argv = mi->argv;
92     bool cleanup = false;
93     char barrelfish_id_s[10];
94     size_t argc = mi->argc;
95
96     KALUGA_DEBUG("Starting corectrl for %s\n", record);
97     uint64_t barrelfish_id, cpu_type, hw_id, enabled = 0;
98     err = oct_read(record, "_ { " HW_PROCESSOR_GENERIC_FIELDS " }",
99                             &enabled, &barrelfish_id, &hw_id, &cpu_type);
100     if (err_is_ok(err)) {
101         /*
102          * XXX: change this to a generic cpuhwid instead of apic!
103          */
104         skb_add_fact("corename(%"PRIu64", %s, apic(%"PRIu64")).",
105                      barrelfish_id, cpu_type_to_archstr(cpu_type), hw_id);
106
107         /* we are already running */
108         if (barrelfish_id == my_core_id) {
109             return SYS_ERR_OK;
110         }
111
112         if (!enabled) {
113             printf("CPU %" PRIu64 " is not enabled. Skipping driver initialization\n",
114                     barrelfish_id);
115             return SYS_ERR_OK;
116         }
117
118         argv = malloc((argc+5) * sizeof(char *));
119         memcpy(argv, mi->argv, argc * sizeof(char *));
120         snprintf(barrelfish_id_s, 10, "%"PRIu64"", barrelfish_id);
121
122         argv[argc] = "boot";
123         argc += 1;
124         argv[argc] = barrelfish_id_s;
125         argc += 1;
126         // Copy kernel args over to new core
127         struct module_info* cpu_module = find_module("cpu");
128         if (cpu_module != NULL && strlen(cpu_module->args) > 1) {
129             KALUGA_DEBUG("%s:%s:%d: Boot with cpu arg %s and barrelfish_id_s=%s\n",
130                          __FILE__, __FUNCTION__, __LINE__, cpu_module->args, barrelfish_id_s);
131             argv[argc] = "-a";
132             argc += 1;
133             argv[argc] = cpu_module->args;
134             argc += 1;
135         }
136         argv[argc] = NULL;
137
138         cleanup = true;
139     }
140     else {
141         DEBUG_ERR(err, "Malformed CPU record?");
142         return err;
143     }
144
145     struct capref task_cap_kernel;
146     task_cap_kernel.cnode = cnode_task;
147     task_cap_kernel.slot = TASKCN_SLOT_KERNELCAP;
148
149 #ifdef KALUGA_SERVICE_DEBUG
150     struct capability info;
151     err = debug_cap_identify(task_cap_kernel, &info);
152     if (err_is_fail(err)) {
153         USER_PANIC_ERR(err, "Can not identify the capability.");
154     }
155     char buffer[1024];
156     debug_print_cap(buffer, 1024, &info);
157     KALUGA_DEBUG("%s:%d: capability=%s\n", __FILE__, __LINE__, buffer);
158 #endif
159
160     struct capref inheritcn_cap;
161     err = alloc_inheritcn_with_caps(&inheritcn_cap,
162                                     NULL_CAP, NULL_CAP, task_cap_kernel);
163     if (err_is_fail(err)) {
164         DEBUG_ERR(err, "alloc_inheritcn_with_caps failed.");
165     }
166
167     err = spawn_program_with_caps(where, mi->path, argv,
168                                   environ, inheritcn_cap,
169                                   NULL_CAP, SPAWN_FLAGS_NEW_DOMAIN,
170                                   &mi->did[0]);
171     if (err_is_fail(err)) {
172         DEBUG_ERR(err, "Spawning %s failed.", mi->path);
173     }
174
175     if (cleanup) {
176         free(argv);
177     }
178
179     return err;
180 }
181
182
183 static void spawnd_change_event(octopus_mode_t mode, char* record, void* state)
184 {
185     size_t count = (size_t) state;
186     static coreid_t spawnd_counter = 0;
187
188     if (mode & OCT_ON_SET) {
189         KALUGA_DEBUG("spawnd found: %s\n", record);
190         spawnd_counter++;
191
192         if (spawnd_counter == count) {
193             KALUGA_DEBUG("Found enough spawnds, setting all_spawnds_up\n");
194             errval_t err = oct_set("all_spawnds_up { iref: 0 }");
195             assert(err_is_ok(err));
196         }
197     }
198 }
199
200 errval_t wait_for_all_spawnds(void)
201 {
202     // Note: The whole wait for all_spawnds_up thing is a hack.
203     // Our overall design goal is a system where cores
204     // come and go dynamically and we do not want / need
205     // to wait for a stable state.
206     // However, some of our code (for example domain spanning)
207     // still assumes a fixed set of cores and will deadlock
208     // otherwise. Therefore we need to fix those parts first.
209     KALUGA_DEBUG("Waiting for acpi");
210     char* record = NULL;
211     errval_t err = oct_wait_for(&record, "acpi { iref: _ }");
212     if (err_is_fail(err)) {
213         return err_push(err, KALUGA_ERR_WAITING_FOR_ACPI);
214     }
215
216     // No we should be able to get core count
217     // of all cores to estimate the amount of
218     // spawnd's we have to expect (one per core)
219     char** names;
220     size_t count;
221     err = oct_get_names(&names, &count, processor_regex);
222     if (err_is_fail(err)) {
223         return err_push(err, KALUGA_ERR_QUERY_LOCAL_APIC);
224     }
225     oct_free_names(names, count);
226
227     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
228     octopus_trigger_id_t tid;
229     return oct_trigger_existing_and_watch(spawnds, spawnd_change_event, (void*)count, &tid);
230 }