source: mainline/kernel/generic/src/main/kinit.c@ 25939997

Last change on this file since 25939997 was 0f4f1b2, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 2 years ago

Add (and use) functions thread_start() and thread_detach()

Mostly cosmetic, with thread_start() replacing calls to thread_ready(),
but not consuming the passed reference, and thread_detach() being
synonym for thread_put(). Makes the code's function more obvious.

Also modify some threaded tests to use thread_join() for waiting,
instead of counting threads with atomics or semaphores.
  • Property mode set to 100644
File size: 8.5 KB
Line 
1/*
2 * Copyright (c) 2001-2004 Jakub Jermar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup kernel_generic
30 * @{
31 */
32
33/**
34 * @file
35 * @brief Kernel initialization thread.
36 *
37 * This file contains kinit kernel thread which carries out
38 * high level system initialization.
39 *
40 * This file is responsible for finishing SMP configuration
41 * and creation of userspace init tasks.
42 */
43
44#include <assert.h>
45#include <main/kinit.h>
46#include <config.h>
47#include <arch.h>
48#include <proc/scheduler.h>
49#include <proc/task.h>
50#include <proc/thread.h>
51#include <proc/program.h>
52#include <panic.h>
53#include <halt.h>
54#include <cpu.h>
55#include <arch/asm.h>
56#include <mm/page.h>
57#include <arch/mm/page.h>
58#include <mm/as.h>
59#include <mm/frame.h>
60#include <mm/km.h>
61#include <stdio.h>
62#include <log.h>
63#include <memw.h>
64#include <console/console.h>
65#include <interrupt.h>
66#include <console/kconsole.h>
67#include <security/perm.h>
68#include <lib/rd.h>
69#include <ipc/ipc.h>
70#include <str.h>
71#include <str_error.h>
72#include <sysinfo/stats.h>
73#include <sysinfo/sysinfo.h>
74#include <align.h>
75#include <stdlib.h>
76#include <debug/register.h>
77
78#ifdef CONFIG_SMP
79#include <smp/smp.h>
80#endif /* CONFIG_SMP */
81
82#include <synch/waitq.h>
83#include <synch/spinlock.h>
84
85#define ALIVE_CHARS 4
86
87#ifdef CONFIG_KCONSOLE
88static char alive[ALIVE_CHARS] = "-\\|/";
89#endif
90
91#define INIT_PREFIX "init:"
92#define INIT_PREFIX_LEN 5
93
94/** Kernel initialization thread.
95 *
96 * kinit takes care of higher level kernel
97 * initialization (i.e. thread creation,
98 * userspace initialization etc.).
99 *
100 * @param arg Not used.
101 */
102void kinit(void *arg)
103{
104 thread_t *thread;
105
106 interrupts_disable();
107
108#ifdef CONFIG_SMP
109 if (config.cpu_count > 1) {
110 semaphore_initialize(&ap_completion_semaphore, 0);
111
112 /*
113 * Create the kmp thread and wait for its completion.
114 * cpu1 through cpuN-1 will come up consecutively and
115 * not mess together with kcpulb threads.
116 * Just a beautification.
117 */
118 thread = thread_create(kmp, NULL, TASK,
119 THREAD_FLAG_UNCOUNTED, "kmp");
120 if (!thread)
121 panic("Unable to create kmp thread.");
122
123 thread_wire(thread, &cpus[0]);
124 thread_start(thread);
125 thread_join(thread);
126
127 /*
128 * For each CPU, create its load balancing thread.
129 */
130 unsigned int i;
131
132 for (i = 0; i < config.cpu_count; i++) {
133 thread = thread_create(kcpulb, NULL, TASK,
134 THREAD_FLAG_UNCOUNTED, "kcpulb");
135 if (thread != NULL) {
136 thread_wire(thread, &cpus[i]);
137 thread_start(thread);
138 thread_detach(thread);
139 } else
140 log(LF_OTHER, LVL_ERROR,
141 "Unable to create kcpulb thread for cpu%u", i);
142 }
143 }
144#endif /* CONFIG_SMP */
145
146 /*
147 * At this point SMP, if present, is configured.
148 */
149 ARCH_OP(post_smp_init);
150
151 /* Start thread computing system load */
152 thread = thread_create(kload, NULL, TASK, THREAD_FLAG_NONE,
153 "kload");
154 if (thread != NULL) {
155 thread_start(thread);
156 thread_detach(thread);
157 } else {
158 log(LF_OTHER, LVL_ERROR, "Unable to create kload thread");
159 }
160
161#ifdef CONFIG_KCONSOLE
162 if (stdin) {
163 /*
164 * Create kernel console.
165 */
166 thread = thread_create(kconsole_thread, NULL, TASK,
167 THREAD_FLAG_NONE, "kconsole");
168 if (thread != NULL) {
169 thread_start(thread);
170 thread_detach(thread);
171 } else {
172 log(LF_OTHER, LVL_ERROR,
173 "Unable to create kconsole thread");
174 }
175 }
176#endif /* CONFIG_KCONSOLE */
177
178 /*
179 * Store the default stack size in sysinfo so that uspace can create
180 * stack with this default size.
181 */
182 sysinfo_set_item_val("default.stack_size", NULL, STACK_SIZE_USER);
183
184 interrupts_enable();
185
186 /*
187 * Create user tasks, load RAM disk images.
188 */
189 size_t i;
190 program_t programs[CONFIG_INIT_TASKS] = { };
191
192 // FIXME: do not propagate arguments through sysinfo
193 // but pass them directly to the tasks
194 for (i = 0; i < init.cnt; i++) {
195 const char *arguments = init.tasks[i].arguments;
196 if (str_length(arguments) == 0)
197 continue;
198 if (str_length(init.tasks[i].name) == 0)
199 continue;
200 size_t arguments_size = str_size(arguments);
201
202 void *arguments_copy = malloc(arguments_size);
203 if (arguments_copy == NULL)
204 continue;
205 memcpy(arguments_copy, arguments, arguments_size);
206
207 char item_name[CONFIG_TASK_NAME_BUFLEN + 15];
208 snprintf(item_name, CONFIG_TASK_NAME_BUFLEN + 15,
209 "init_args.%s", init.tasks[i].name);
210
211 sysinfo_set_item_data(item_name, NULL, arguments_copy, arguments_size);
212 }
213
214 for (i = 0; i < init.cnt; i++) {
215 if (init.tasks[i].paddr % FRAME_SIZE) {
216 log(LF_OTHER, LVL_ERROR,
217 "init[%zu]: Address is not frame aligned", i);
218 programs[i].task = NULL;
219 continue;
220 }
221
222 /*
223 * Construct task name from the 'init:' prefix and the
224 * name stored in the init structure (if any).
225 */
226
227 char namebuf[TASK_NAME_BUFLEN];
228
229 const char *name = init.tasks[i].name;
230 if (name[0] == 0)
231 name = "<unknown>";
232
233 static_assert(TASK_NAME_BUFLEN >= INIT_PREFIX_LEN, "");
234 str_cpy(namebuf, TASK_NAME_BUFLEN, INIT_PREFIX);
235 str_cpy(namebuf + INIT_PREFIX_LEN,
236 TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
237
238 /*
239 * Create virtual memory mappings for init task images.
240 */
241 uintptr_t page = km_map(init.tasks[i].paddr,
242 init.tasks[i].size, PAGE_SIZE,
243 PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
244 assert(page);
245
246 if (str_cmp(name, "kernel.dbg") == 0) {
247 /*
248 * Not an actual init task, but rather debug sections extracted
249 * from the kernel ELF file and handed to us here so we can use
250 * it for debugging.
251 */
252
253 register_debug_data((void *) page, init.tasks[i].size);
254 programs[i].task = NULL;
255 continue;
256 }
257
258 if (str_cmp(name, "loader") == 0) {
259 /* Register image as the program loader */
260 if (program_loader == NULL) {
261 program_loader = (void *) page;
262 log(LF_OTHER, LVL_NOTE, "Program loader at %p",
263 program_loader);
264 } else {
265 log(LF_OTHER, LVL_ERROR,
266 "init[%zu]: Second binary named \"loader\""
267 " present.", i);
268 }
269
270 programs[i].task = NULL;
271 continue;
272 }
273
274 errno_t rc = program_create_from_image((void *) page, init.tasks[i].size, namebuf,
275 &programs[i]);
276
277 if (rc == 0) {
278 assert(programs[i].task != NULL);
279
280 /*
281 * Set permissions to init userspace tasks.
282 */
283 perm_set(programs[i].task,
284 PERM_PERM | PERM_MEM_MANAGER |
285 PERM_IO_MANAGER | PERM_IRQ_REG);
286
287 if (!ipc_box_0) {
288 ipc_box_0 = &programs[i].task->answerbox;
289 /*
290 * Hold the first task so that
291 * ipc_box_0 remains a valid pointer
292 * even if the first task exits for
293 * whatever reason.
294 */
295 task_hold(programs[i].task);
296 }
297
298 } else if (i == init.cnt - 1) {
299 /*
300 * Assume the last task is the RAM disk.
301 */
302 init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
303 } else {
304 log(LF_OTHER, LVL_ERROR,
305 "init[%zu]: Init binary load failed "
306 "(error %s, loader status %s)", i,
307 str_error_name(rc), str_error_name(programs[i].loader_status));
308 }
309 }
310
311 /*
312 * Run user tasks.
313 */
314 for (i = 0; i < init.cnt; i++) {
315 if (programs[i].task != NULL)
316 program_ready(&programs[i]);
317 }
318
319#ifdef CONFIG_KCONSOLE
320 if (!stdin) {
321 thread_sleep(10);
322 printf("kinit: No stdin\nKernel alive: .");
323
324 unsigned int i = 0;
325 while (true) {
326 printf("\b%c", alive[i % ALIVE_CHARS]);
327 thread_sleep(1);
328 i++;
329 }
330 }
331#endif /* CONFIG_KCONSOLE */
332}
333
334/** @}
335 */
Note: See TracBrowser for help on using the repository browser.