Subversion Repositories HelenOS

Rev

Rev 3022 | Rev 4201 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3022 Rev 4055
Line 59... Line 59...
59
#include <proc/task.h>
59
#include <proc/task.h>
60
#include <proc/tasklet.h>
60
#include <proc/tasklet.h>
61
#include <main/kinit.h>
61
#include <main/kinit.h>
62
#include <main/version.h>
62
#include <main/version.h>
63
#include <console/kconsole.h>
63
#include <console/kconsole.h>
-
 
64
#include <console/console.h>
64
#include <cpu.h>
65
#include <cpu.h>
65
#include <align.h>
66
#include <align.h>
66
#include <interrupt.h>
67
#include <interrupt.h>
67
#include <mm/frame.h>
68
#include <mm/frame.h>
68
#include <mm/page.h>
69
#include <mm/page.h>
Line 76... Line 77...
76
#include <arch.h>
77
#include <arch.h>
77
#include <arch/faddr.h>
78
#include <arch/faddr.h>
78
#include <ipc/ipc.h>
79
#include <ipc/ipc.h>
79
#include <macros.h>
80
#include <macros.h>
80
#include <adt/btree.h>
81
#include <adt/btree.h>
81
#include <console/klog.h>
-
 
82
#include <smp/smp.h>
82
#include <smp/smp.h>
83
#include <ddi/ddi.h>
83
#include <ddi/ddi.h>
-
 
84
#include <main/main.h>
84
 
85
 
85
/** Global configuration structure. */
86
/** Global configuration structure. */
86
config_t config;
87
config_t config;
87
 
88
 
88
/** Initial user-space tasks */
89
/** Initial user-space tasks */
Line 102... Line 103...
102
 * These 'hardcoded' variables will be intialized by
103
 * These 'hardcoded' variables will be intialized by
103
 * the linker or the low level assembler code with
104
 * the linker or the low level assembler code with
104
 * appropriate sizes and addresses.
105
 * appropriate sizes and addresses.
105
 */
106
 */
106
 
107
 
107
/**< Virtual address of where the kernel is loaded. */
108
/** Virtual address of where the kernel is loaded. */
108
uintptr_t hardcoded_load_address = 0;
109
uintptr_t hardcoded_load_address = 0;
109
/**< Size of the kernel code in bytes. */
110
/** Size of the kernel code in bytes. */
110
size_t hardcoded_ktext_size = 0;
111
size_t hardcoded_ktext_size = 0;
111
/**< Size of the kernel data in bytes. */
112
/** Size of the kernel data in bytes. */
112
size_t hardcoded_kdata_size = 0;
113
size_t hardcoded_kdata_size = 0;
113
/**< Lowest safe stack virtual address. */
114
/** Lowest safe stack virtual address. */
114
uintptr_t stack_safe = 0;      
115
uintptr_t stack_safe = 0;      
115
 
116
 
116
void main_bsp(void);
-
 
117
void main_ap(void);
-
 
118
 
-
 
119
/*
117
/*
120
 * These two functions prevent stack from underflowing during the
118
 * These two functions prevent stack from underflowing during the
121
 * kernel boot phase when SP is set to the very top of the reserved
119
 * kernel boot phase when SP is set to the very top of the reserved
122
 * space. The stack could get corrupted by a fooled compiler-generated
120
 * space. The stack could get corrupted by a fooled compiler-generated
123
 * pop sequence otherwise.
121
 * pop sequence otherwise.
Line 129... Line 127...
129
 
127
 
130
#define CONFIG_STACK_SIZE   ((1 << STACK_FRAMES) * STACK_SIZE)
128
#define CONFIG_STACK_SIZE   ((1 << STACK_FRAMES) * STACK_SIZE)
131
 
129
 
132
/** Main kernel routine for bootstrap CPU.
130
/** Main kernel routine for bootstrap CPU.
133
 *
131
 *
134
 * Initializes the kernel by bootstrap CPU.
132
 * The code here still runs on the boot stack, which knows nothing about
135
 * This function passes control directly to
133
 * preemption counts.  Because of that, this function cannot directly call
-
 
134
 * functions that disable or enable preemption (e.g. spinlock_lock()). The
-
 
135
 * primary task of this function is to calculate address of a new stack and
136
 * main_bsp_separated_stack().
136
 * switch to it.
137
 *
137
 *
138
 * Assuming interrupts_disable().
138
 * Assuming interrupts_disable().
139
 *
139
 *
140
 */
140
 */
141
void main_bsp(void)
141
void main_bsp(void)
Line 184... Line 184...
184
 * Second part of main_bsp().
184
 * Second part of main_bsp().
185
 *
185
 *
186
 */
186
 */
187
void main_bsp_separated_stack(void)
187
void main_bsp_separated_stack(void)
188
{
188
{
189
    task_t *k;
-
 
190
    thread_t *t;
189
    /* Keep this the first thing. */
191
    count_t i;
-
 
192
   
-
 
193
    the_initialize(THE);
190
    the_initialize(THE);
-
 
191
   
-
 
192
    version_print();
194
 
193
   
-
 
194
    LOG("\nconfig.base=%#" PRIp " config.kernel_size=%" PRIs
-
 
195
        "\nconfig.stack_base=%#" PRIp " config.stack_size=%" PRIs,
-
 
196
        config.base, config.kernel_size, config.stack_base,
-
 
197
        config.stack_size);
-
 
198
   
-
 
199
#ifdef CONFIG_KCONSOLE
195
    /*
200
    /*
196
     * kconsole data structures must be initialized very early
201
     * kconsole data structures must be initialized very early
197
     * because other subsystems will register their respective
202
     * because other subsystems will register their respective
198
     * commands.
203
     * commands.
199
     */
204
     */
200
    kconsole_init();
205
    LOG_EXEC(kconsole_init());
-
 
206
#endif
201
   
207
   
202
    /*
208
    /*
203
     * Exception handler initialization, before architecture
209
     * Exception handler initialization, before architecture
204
     * starts adding its own handlers
210
     * starts adding its own handlers
205
     */
211
     */
206
    exc_init();
212
    LOG_EXEC(exc_init());
207
 
213
   
208
    /*
214
    /*
209
     * Memory management subsystems initialization.
215
     * Memory management subsystems initialization.
210
     */
216
     */
211
    arch_pre_mm_init();
217
    LOG_EXEC(arch_pre_mm_init());
212
    frame_init();      
218
    LOG_EXEC(frame_init());
213
    /* Initialize at least 1 memory segment big enough for slab to work. */
-
 
214
    slab_cache_init();
-
 
215
    btree_init();
-
 
216
    as_init();
-
 
217
    page_init();
-
 
218
    tlb_init();
-
 
219
    ddi_init();
-
 
220
    tasklet_init();
-
 
221
    arch_post_mm_init();
-
 
222
   
219
   
-
 
220
    /* Initialize at least 1 memory segment big enough for slab to work. */
-
 
221
    LOG_EXEC(slab_cache_init());
-
 
222
    LOG_EXEC(btree_init());
223
    version_print();
223
    LOG_EXEC(as_init());
224
    printf("kernel: %.*p hardcoded_ktext_size=%zd KB, "
224
    LOG_EXEC(page_init());
-
 
225
    LOG_EXEC(tlb_init());
225
        "hardcoded_kdata_size=%zd KB\n", sizeof(uintptr_t) * 2,
226
    LOG_EXEC(ddi_init());
226
        config.base, SIZE2KB(hardcoded_ktext_size),
227
    LOG_EXEC(tasklet_init());
227
        SIZE2KB(hardcoded_kdata_size));
228
    LOG_EXEC(arch_post_mm_init());
228
    printf("stack:  %.*p size=%zd KB\n", sizeof(uintptr_t) * 2,
229
    LOG_EXEC(arch_pre_smp_init());
229
        config.stack_base, SIZE2KB(config.stack_size));
230
    LOG_EXEC(smp_init());
230
   
231
   
231
    arch_pre_smp_init();
-
 
232
    smp_init();
-
 
233
    /* Slab must be initialized after we know the number of processors. */
232
    /* Slab must be initialized after we know the number of processors. */
234
    slab_enable_cpucache();
233
    LOG_EXEC(slab_enable_cpucache());
235
   
234
   
236
    printf("Detected %zu CPU(s), %llu MB free memory\n",
235
    printf("Detected %" PRIc " CPU(s), %" PRIu64" MiB free memory\n",
237
        config.cpu_count, SIZE2MB(zone_total_size()));
236
        config.cpu_count, SIZE2MB(zone_total_size()));
238
    cpu_init();
-
 
239
   
237
   
-
 
238
    LOG_EXEC(cpu_init());
-
 
239
   
240
    calibrate_delay_loop();
240
    LOG_EXEC(calibrate_delay_loop());
241
    clock_counter_init();
241
    LOG_EXEC(clock_counter_init());
242
    timeout_init();
242
    LOG_EXEC(timeout_init());
243
    scheduler_init();
243
    LOG_EXEC(scheduler_init());
244
    task_init();
244
    LOG_EXEC(task_init());
245
    thread_init();
245
    LOG_EXEC(thread_init());
246
    futex_init();
246
    LOG_EXEC(futex_init());
247
    klog_init();
-
 
248
   
247
   
249
    if (init.cnt > 0) {
248
    if (init.cnt > 0) {
-
 
249
        count_t i;
250
        for (i = 0; i < init.cnt; i++)
250
        for (i = 0; i < init.cnt; i++)
251
            printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i,
251
            LOG("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
252
                sizeof(uintptr_t) * 2, init.tasks[i].addr, i,
252
                "].size=%#" PRIs "\n", i, init.tasks[i].addr, i,
253
                init.tasks[i].size);
253
                init.tasks[i].size);
254
    } else
254
    } else
255
        printf("No init binaries found\n");
255
        printf("No init binaries found\n");
256
   
256
   
257
    ipc_init();
257
    LOG_EXEC(ipc_init());
-
 
258
    LOG_EXEC(klog_init());
-
 
259
    LOG_EXEC(console_init());
-
 
260
   
-
 
261
#ifdef CONFIG_KCONSOLE
-
 
262
    LOG_EXEC(kconsole_notify_init());
-
 
263
#endif
258
 
264
   
259
    /*
265
    /*
260
     * Create kernel task.
266
     * Create kernel task.
261
     */
267
     */
262
    k = task_create(AS_KERNEL, "kernel");
268
    task_t *kernel = task_create(AS_KERNEL, "kernel");
263
    if (!k)
269
    if (!kernel)
264
        panic("can't create kernel task\n");
270
        panic("Cannot create kernel task.");
265
   
271
   
266
    /*
272
    /*
267
     * Create the first thread.
273
     * Create the first thread.
268
     */
274
     */
-
 
275
    thread_t *kinit_thread
269
    t = thread_create(kinit, NULL, k, 0, "kinit", true);
276
        = thread_create(kinit, NULL, kernel, 0, "kinit", true);
270
    if (!t)
277
    if (!kinit_thread)
271
        panic("can't create kinit thread\n");
278
        panic("Cannot create kinit thread.");
272
    thread_ready(t);
279
    LOG_EXEC(thread_ready(kinit_thread));
273
   
280
   
274
    /*
281
    /*
275
     * This call to scheduler() will return to kinit,
282
     * This call to scheduler() will return to kinit,
276
     * starting the thread of kernel threads.
283
     * starting the thread of kernel threads.
277
     */
284
     */
Line 320... Line 327...
320
    /*
327
    /*
321
     * If we woke kmp up before we left the kernel stack, we could
328
     * If we woke kmp up before we left the kernel stack, we could
322
     * collide with another CPU coming up. To prevent this, we
329
     * collide with another CPU coming up. To prevent this, we
323
     * switch to this cpu's private stack prior to waking kmp up.
330
     * switch to this cpu's private stack prior to waking kmp up.
324
     */
331
     */
-
 
332
    context_save(&CPU->saved_context);
325
    context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
333
    context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
326
        (uintptr_t) CPU->stack, CPU_STACK_SIZE);
334
        (uintptr_t) CPU->stack, CPU_STACK_SIZE);
327
    context_restore(&CPU->saved_context);
335
    context_restore(&CPU->saved_context);
328
    /* not reached */
336
    /* not reached */
329
}
337
}