示例#1
0
/*
  Given fname, find the bootinfo module associated with it.

  Return NULL on failure 
*/
static L4_BootRec_t *
find_bootrec(const char *fname)
{
	L4_KernelInterfacePage_t *kip;
	L4_BootRec_t *rec;
	void *bootinfo;
	unsigned num_recs, objs;

	/* Iterate through bootinfo */
	kip = L4_GetKernelInterface();
	bootinfo = (void*) L4_BootInfo(kip);
	num_recs = L4_BootInfo_Entries(bootinfo);
	rec = L4_BootInfo_FirstEntry(bootinfo);

	while(num_recs > 0) {
		L4_Word_t type;
		/* find what type it is */
		type = L4_BootRec_Type(rec);
		objs = 0;
		if (type == L4_BootInfo_Module && 
		    (strcmp(L4_Module_Cmdline(rec), fname) == 0)) {
			/* Found it! */
			break;
		}
		rec = L4_BootRec_Next(rec);
		num_recs--;
	}

	if (num_recs > 0) {
		return rec;
	} else {
		return NULL;
	}
}
示例#2
0
void
freevms_main(void)
{
    char                        *command_line;

#   define                      ROOT_DEVICE_LENGTH 80
    char                        root_device[ROOT_DEVICE_LENGTH];
#   define                      CONSOLE_DEVICE_LENGTH 80
    char                        console_device[CONSOLE_DEVICE_LENGTH];

    L4_BootRec_t                *boot_record;

    L4_KernelInterfacePage_t    *kip;

    L4_ProcDesc_t               *main_proc_desc;

    L4_ThreadId_t               root_tid;
    L4_ThreadId_t               s0_tid;

    L4_Word_t                   api_flags;
    L4_Word_t                   boot_info;
    L4_Word_t                   i;
    L4_Word_t                   kernel_id;
    L4_Word_t                   kernel_interface;
    L4_Word_t                   num_boot_info_entries;
    L4_Word_t                   num_processors;
    L4_Word_t                   page_bits;
    L4_Word_t                   pagesize;

    struct vms$meminfo          mem_info;

    vms$pd_initialized = 0;

    notice("\n");
    notice(">>> FreeVMS %s (R)\n", FREEVMS_VERSION);
    notice("\n");

    kip = (L4_KernelInterfacePage_t *) L4_KernelInterface(&kernel_interface,
            &api_flags, &kernel_id);

    notice(SYSBOOT_I_SYSBOOT "leaving kernel privileges\n");
    notice(SYSBOOT_I_SYSBOOT "launching FreeVMS kernel with executive "
            "privileges\n");
    root_tid = L4_Myself();
    s0_tid = L4_GlobalId(kip->ThreadInfo.X.UserBase, 1);

    notice(SYSBOOT_I_SYSBOOT "booting main processor\n");

    for(page_bits = 0; !((1 << page_bits) & L4_PageSizeMask(kip)); page_bits++);
    pagesize = (((vms$pointer) 1) << page_bits);
    notice(SYSBOOT_I_SYSBOOT "computing page size: %d bytes\n",
            (int) pagesize);

    num_processors = L4_NumProcessors((void *) kip);

    switch(num_processors - 1)
    {
        case 0:
            break;

        case 1:
            notice(SYSBOOT_I_SYSBOOT "booting %d secondary processor\n",
                    (int) (num_processors - 1));
            break;

        default:
            notice(SYSBOOT_I_SYSBOOT "booting %d secondary processors\n",
                    (int) (num_processors - 1));
            break;
    }

    for(i = 0; i < num_processors; i++)
    {
        main_proc_desc = L4_ProcDesc((void *) kip, i);
        notice(SYSBOOT_I_SYSBOOT "CPU%d EXTFREQ=%d MHz, INTFREQ=%d MHz\n",
                (int) i, (int) (main_proc_desc->X.ExternalFreq / 1000),
                (int) (main_proc_desc->X.InternalFreq / 1000));
    }

    L4_Sigma0_GetPage(L4_nilthread, L4_Fpage(L4_BootInfo(kip), pagesize));

    boot_info = L4_BootInfo((void *) kip);
    num_boot_info_entries = L4_BootInfo_Entries((void *) boot_info);
    boot_record = L4_BootInfo_FirstEntry((void *) boot_info);

    for(i = 2; i < num_boot_info_entries; i++)
    {
        PANIC(L4_BootRec_Type(boot_record) != L4_BootInfo_SimpleExec);
        command_line = L4_SimpleExec_Cmdline(boot_record);

        if ((strstr(command_line, "vmskernel.sys") != NULL) && (i == 3))
        {
            break;
        }

        boot_record = L4_BootRec_Next(boot_record);
    }

    PANIC(L4_BootRec_Type(boot_record) != L4_BootInfo_SimpleExec);
    command_line = L4_SimpleExec_Cmdline(boot_record);
    notice(SYSBOOT_I_SYSBOOT "parsing command line: %s\n", command_line);
    sys$parsing(command_line, (char *) "root", root_device,
            ROOT_DEVICE_LENGTH);
    notice(SYSBOOT_I_SYSBOOT "selecting root device: %s\n", root_device);
    sys$parsing(command_line, (char *) "console", console_device,
            CONSOLE_DEVICE_LENGTH);
    notice(SYSBOOT_I_SYSBOOT "selecting console device: %s\n", console_device);

    dbg$virtual_memory = (strstr(command_line, " dbg$virtual_memory") != NULL)
            ? 1 : 0;
    dbg$sys_pagefault = (strstr(command_line, " dbg$sys_pagefault") != NULL)
            ? 1 : 0;
    dbg$vms_pagefault = (strstr(command_line, " dbg$vms_pagefault") != NULL)
            ? 1 : 0;

    // Starting virtual memory subsystem
    sys$mem_init(kip, &mem_info, pagesize);
    sys$bootstrap(&mem_info, pagesize);
    sys$objtable_init();
    sys$utcb_init(kip);
    sys$pd_init(&mem_info);
    sys$thread_init(kip);
    sys$populate_init_objects(&mem_info, pagesize);

    dev$init();
    names$init();

    sys$pager(kip, &mem_info, pagesize, root_device);
    sys$init(kip, &mem_info, pagesize, root_device);
    sys$loop();

    notice(">>> System halted\n");
    return;
}
示例#3
0
int main (void)
{
    L4_Word_t total;

    printf("\n\nHasenpfeffer operating system\n");
    printf("Copyright (C) 2005,2006. Senko Rasic <*****@*****.**>\n\n");


    printf("Initializing root task...\n");
    L4_KernelInterfacePage_t *kip = (L4_KernelInterfacePage_t *) L4_GetKernelInterface();
    void *bi = (void *) L4_BootInfo(kip);
    
    // we need to preload these I/O pages
    // ATA
    L4_Sigma0_GetPage(L4_nilthread, L4_Fpage(0x0000, 4096));

    // KIP
    L4_Sigma0_GetPage(L4_nilthread, L4_Fpage(L4_BootInfo(kip), 4096));
    L4_BootRec_t *br = NULL;

    if (L4_BootInfo_Valid((void *) bi)) {
        int n = L4_BootInfo_Entries(bi);
        br = L4_BootInfo_FirstEntry(bi);
        while (--n) {
            /* touch roottask data from here, because sigma0 only gives pages to initial *thread* */
            if (L4_BootRec_Type(br) == L4_BootInfo_SimpleExec) {
                L4_Word_t mi;
                for (mi = 0; mi < L4_Module_Size(br); mi += 4096) {
                    L4_Sigma0_GetPage(L4_nilthread, L4_Fpage(L4_Module_Start(br) + mi, 4096));
                }
            }
            br = L4_BootRec_Next(br);
        }
    } else {
        printf("panic: invalid bootinfo data\n");
        return 0;
    }

    memory_init();
    total = memory_get_free();

    printf("Creating root memory manager...\n");
    mman_tid = create_local_thread("root memory manager", kip, 1, memman, 4096);
    thread_init(mman_tid);

    printf("Initializing root task manager...\n");
    HpfCapability full, newthread, newtask;
    task_manager_init(&full, &newtask, &newthread);

    dir_paths[0] = "/process/TaskManager";
    dir_caps[0] = full;
    n_paths = 1;

    printf("Loading initial programs...\n");
    int n = L4_BootInfo_Entries(bi);
    br = L4_BootInfo_FirstEntry(bi);
    int first_program = 1;
    while (--n) {
        if (L4_BootRec_Type(br) == L4_BootInfo_Module) {
            L4_ThreadId_t tid = launch(br);
            if (first_program) {
                first_program = 0;

                // this is the root directory server
                if (hermes_capability(tid, &(dir_caps[1]))) {
                    // dir_paths[1] = "/process/DirectoryService";
                    dir_paths[1] = ""; // <- catch-all
                    n_paths = 2;
                }
            }
        }
        br = L4_BootRec_Next(br);
    }

    printf("Init done, running...\n\n");
    task_manager_main();

    return 0;
}
示例#4
0
static unsigned int
sys$bootinfo_find_initial_objects(L4_KernelInterfacePage_t *kip,
        unsigned int max, struct initial_obj *initial_objs)
{
    char                        data_name[INITIAL_NAME_MAX];

    L4_BootRec_t                *record;

    L4_Word_t                   dsize;
    L4_Word_t                   dstart;
    L4_Word_t                   tsize;
    L4_Word_t                   tstart;
    L4_Word_t                   type;

    unsigned int                count;
    unsigned int                flags;
    unsigned int                num_recs;
    unsigned int                objects;

    void                        *bootinfo;

#   define DIT_INITIAL          32L // Root task

    bootinfo = (void*) L4_BootInfo(kip);
    count = 0;

    // Check bootinfo validity

    if (L4_BootInfo_Valid(bootinfo) == 0)
    {
        return(0);
    }

    num_recs = L4_BootInfo_Entries(bootinfo);
    record = L4_BootInfo_FirstEntry(bootinfo);

    while(num_recs > 0)
    {
        PANIC(record == NULL);
        type = L4_BootRec_Type(record);
        objects = 0;

        switch(type)
        {
            case L4_BootInfo_Module:
                sys$add_initial_object(initial_objs++,
                        L4_Module_Cmdline(record),
                        L4_Module_Start(record),
                        (L4_Module_Start(record) + L4_Module_Size(record)) - 1,
                        0, VMS$IOF_APP | VMS$IOF_PHYS);
                objects = 1;
                break;

            case L4_BootInfo_SimpleExec:
                if (L4_SimpleExec_Flags(record) & DIT_INITIAL)
                {
                    flags = VMS$IOF_ROOT | VMS$IOF_VIRT;
                }
                else
                {
                    flags = VMS$IOF_APP;
                }

                tstart = L4_SimpleExec_TextVstart(record);
                tsize = L4_SimpleExec_TextSize(record);
                dstart = L4_SimpleExec_DataVstart(record);
                dsize = L4_SimpleExec_DataSize(record);

                sys$add_initial_object(initial_objs++,
                        L4_SimpleExec_Cmdline(record),
                        tstart, (tstart + tsize) - 1,
                        L4_SimpleExec_InitialIP(record),
                        flags | VMS$IOF_PHYS);
                objects = 1;

                if ((!((dstart < (tstart + tsize) && dstart >= tstart)))
                        && (dsize != 0))
                {
                    sys$strncpy(data_name, L4_SimpleExec_Cmdline(record),
                            INITIAL_NAME_MAX - 5);
                    sys$strncat(data_name, ".data", INITIAL_NAME_MAX);

                    sys$add_initial_object(initial_objs++, data_name,
                            dstart, dstart + dsize - 1, 0,
                            VMS$IOF_ROOT | VMS$IOF_VIRT | VMS$IOF_PHYS);
                    objects++;
                }

                break;

            case L4_BootInfo_Multiboot:
                sys$add_initial_object(initial_objs++, "MultiBoot information",
                        L4_MBI_Address(record), L4_MBI_Address(record) + 0xFFF,
                        0, VMS$IOF_PHYS | VMS$IOF_BOOT | VMS$IOF_VIRT);
                objects = 1;
                break;

            default:
                PANIC(1);
                break;
        }

        if (objects > 0)
        {
            count += objects;

            if (count == max) goto overflow;
        }

        record = L4_BootRec_Next(record);
        num_recs--;
    }

    sys$add_initial_object(initial_objs++, "Boot",
            (vms$pointer) bootinfo,
            (vms$pointer) bootinfo + (L4_BootInfo_Size(bootinfo) - 1),
            0, VMS$IOF_BOOT | VMS$IOF_PHYS | VMS$IOF_VIRT);
    count++;

overflow:
    return count;
}