Subversion Repositories HelenOS

Rev

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

Rev 2927 Rev 3149
Line 76... Line 76...
76 
#include <arch.h>
 76 
#include <arch.h>
77 
#include <arch/faddr.h>
 77 
#include <arch/faddr.h>
78 
#include <ipc/ipc.h>
 78 
#include <ipc/ipc.h>
79 
#include <macros.h>
 79 
#include <macros.h>
80 
#include <adt/btree.h>
 80 
#include <adt/btree.h>
81 
#include <console/klog.h>
 - 
 
82 
#include <smp/smp.h>
 81 
#include <smp/smp.h>
83 
#include <ddi/ddi.h>
 82 
#include <ddi/ddi.h>
84 
 
 83 
 
85 
/** Global configuration structure. */
 84 
/** Global configuration structure. */
86 
config_t config;
 85 
config_t config;
Line 138... Line 137...
138 
 * Assuming interrupts_disable().
 137 
 * Assuming interrupts_disable().
139 
 *
 138 
 *
140 
 */
 139 
 */
141 
void main_bsp(void)
 140 
void main_bsp(void)
142 
{
 141 
{
- 
 
 142 
    LOG();
- 
 
 143 
   
143 
    config.cpu_count = 1;
 144 
    config.cpu_count = 1;
144 
    config.cpu_active = 1;
 145 
    config.cpu_active = 1;
145 
   
 146 
   
146 
    config.base = hardcoded_load_address;
 147 
    config.base = hardcoded_load_address;
147 
    config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
 148 
    config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
Line 169... Line 170...
169 
    }
 170 
    }
170 
   
 171 
   
171 
    if (config.stack_base < stack_safe)
 172 
    if (config.stack_base < stack_safe)
172 
        config.stack_base = ALIGN_UP(stack_safe, PAGE_SIZE);
 173 
        config.stack_base = ALIGN_UP(stack_safe, PAGE_SIZE);
173 
   
 174 
   
- 
 
 175 
    version_print();
- 
 
 176 
   
- 
 
 177 
    LOG("\nconfig.base=%#" PRIp " config.kernel_size=%" PRIs
- 
 
 178 
        "\nconfig.stack_base=%#" PRIp " config.stack_size=%" PRIs,
- 
 
 179 
        config.base, config.kernel_size,
- 
 
 180 
        config.stack_base, config.stack_size);
- 
 
 181 
   
174 
    context_save(&ctx);
 182 
    context_save(&ctx);
175 
    context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base,
 183 
    context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base,
176 
        THREAD_STACK_SIZE);
 184 
        THREAD_STACK_SIZE);
177 
    context_restore(&ctx);
 185 
    context_restore(&ctx);
178 
    /* not reached */
 186 
    /* not reached */
Line 184... Line 192...
184 
 * Second part of main_bsp().
 192 
 * Second part of main_bsp().
185 
 *
 193 
 *
186 
 */
 194 
 */
187 
void main_bsp_separated_stack(void)
 195 
void main_bsp_separated_stack(void)
188 
{
 196 
{
189 
    task_t *k;
 - 
 
190 
    thread_t *t;
 - 
 
191 
    count_t i;
 197 
    LOG();
192 
   
 198 
   
193 
    the_initialize(THE);
 199 
    the_initialize(THE);
194 
 
 200 
 
195 
    /*
 201 
    /*
196 
     * kconsole data structures must be initialized very early
 202 
     * kconsole data structures must be initialized very early
197 
     * because other subsystems will register their respective
 203 
     * because other subsystems will register their respective
198 
     * commands.
 204 
     * commands.
199 
     */
 205 
     */
200 
    kconsole_init();
 206 
    LOG_EXEC(kconsole_init());
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" MB 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 
            printf("init[%" PRIc "].addr=%#" PRIp
- 
 
 252 
                ", init[%" PRIc "].size=%#" PRIs "\n",
252 
                sizeof(uintptr_t) * 2, init.tasks[i].addr, i,
 253 
                i, init.tasks[i].addr,
253 
                init.tasks[i].size);
 254 
                i, init.tasks[i].size);
254 
    } else
 255 
    } else
255 
        printf("No init binaries found\n");
 256 
        printf("No init binaries found\n");
256 
   
 257 
   
257 
    ipc_init();
 258 
    LOG_EXEC(ipc_init());
258 
 
 259 
 
259 
    /*
 260 
    /*
260 
     * Create kernel task.
 261 
     * Create kernel task.
261 
     */
 262 
     */
262 
    k = task_create(AS_KERNEL, "kernel");
 263 
    task_t *kernel = task_create(AS_KERNEL, "kernel");
263 
    if (!k)
 264 
    if (!kernel)
264 
        panic("can't create kernel task\n");
 265 
        panic("Can't create kernel task\n");
265 
   
 266 
   
266 
    /*
 267 
    /*
267 
     * Create the first thread.
 268 
     * Create the first thread.
268 
     */
 269 
     */
269 
    t = thread_create(kinit, NULL, k, 0, "kinit", true);
 270 
    thread_t *kinit_thread = thread_create(kinit, NULL, kernel, 0, "kinit", true);
270 
    if (!t)
 271 
    if (!kinit_thread)
271 
        panic("can't create kinit thread\n");
 272 
        panic("Can't create kinit thread\n");
272 
    thread_ready(t);
 273 
    LOG_EXEC(thread_ready(kinit_thread));
273 
   
 274 
   
274 
    /*
 275 
    /*
275 
     * This call to scheduler() will return to kinit,
 276 
     * This call to scheduler() will return to kinit,
276 
     * starting the thread of kernel threads.
 277 
     * starting the thread of kernel threads.
277 
     */
 278 
     */