cp/nucleus/init.c

   1 /*
   2  * (C) Copyright 2007-2011  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * This file is released under the GPLv2.  See the COPYING file for more
   5  * details.
   6  */
   7
   8 #include <binfmt_elf.h>
   9 #include <symtab.h>
  10 #include <mm.h>
  11 #include <cpu.h>
  12 #include <dat.h>
  13 #include <slab.h>
  14 #include <page.h>
  15 #include <buddy.h>
  16 #include <io.h>
  17 #include <sched.h>
  18 #include <device.h>
  19 #include <console.h>
  20 #include <interrupt.h>
  21 #include <magic.h>
  22 #include <guest.h>
  23 #include <sclp.h>
  24
  25 static struct psw new_io_psw = {
  26         .ea     = 1,
  27         .ba     = 1,
  28
  29         .ptr  = (u64) &IO_INT,
  30 };
  31
  32 static struct psw new_ext_psw = {
  33         .ea     = 1,
  34         .ba     = 1,
  35
  36         .ptr    = (u64) &EXT_INT,
  37 };
  38
  39 static struct psw new_svc_psw = {
  40         .ea     = 1,
  41         .ba     = 1,
  42
  43         .ptr    = (u64) &SVC_INT,
  44 };
  45
  46 static struct psw new_pgm_psw = {
  47         .ea     = 1,
  48         .ba     = 1,
  49
  50         .ptr    = (u64) &PGM_INT,
  51 };
  52
  53 static struct psw new_mch_psw = {
  54         .ea     = 1,
  55         .ba     = 1,
  56
  57         .ptr    = (u64) &MCH_INT,
  58 };
  59
  60 u8 *int_stack_ptr;
  61
  62 struct fs *sysfs;
  63
  64 const u8 zeropage[PAGE_SIZE];
  65
  66 /* the time HVF got IPLd */
  67 struct datetime ipltime;
  68
  69 static void init_int_stack(void)
  70 {
  71         struct page *page;
  72
  73         page = alloc_pages(0, ZONE_NORMAL);
  74         assert(page);
  75
  76         int_stack_ptr = PAGE_SIZE + (u8*)page_to_addr(page);
  77 }
  78
  79 static void idle_task_body(void)
  80 {
  81         /*
  82          * Warning: hack alert! The following overrides what __init_task
  83          * set, this allows us to skip the usual start_task wrapper.
  84          */
  85         current->regs.psw.w   = 1;
  86         current->regs.psw.ptr = MAGIC_PSW_IDLE_CODE;
  87
  88         /*
  89          * Load the new PSW that'll wait with special magic code set
  90          */
  91         lpswe(&current->regs.psw);
  92
  93         BUG();
  94 }
  95
  96 static void __add_internal_users()
  97 {
  98         struct list_head vdevs;
  99         struct directory_prop prop = {
 100                 .got_storage = 1,
 101                 .storage = 1024 * 1024, /* 1MB */
 102         };
 103
 104         INIT_LIST_HEAD(&vdevs);
 105
 106         directory_alloc_user("*LOGIN", AUTH_G, &prop, &vdevs);
 107 }
 108
 109 static int __finish_loading(void *data)
 110 {
 111         struct virt_sys *login;
 112         u32 iplsch;
 113         char *err;
 114         int ret;
 115
 116         iplsch = (u32) (u64) data;
 117
 118         /*
 119          * Load the config file
 120          */
 121         sysfs = load_config(iplsch);
 122         if (IS_ERR(sysfs))
 123                 BUG();
 124
 125         /* add internal users */
 126         __add_internal_users();
 127
 128         /*
 129          * Alright, we have the config, we now need to set up the *LOGIN
 130          * guest and attach the operator console rdev to it
 131          */
 132         login = guest_create("*LOGIN", NULL);
 133         if (!login) {
 134                 err = "failed to create guest";
 135                 goto die;
 136         }
 137
 138         ret = guest_ipl_nss(login, "login");
 139         if (ret) {
 140                 err = "failed to IPL NSS";
 141                 goto die;
 142         }
 143
 144         /* start *LOGIN */
 145         ret = guest_begin(login);
 146         if (ret) {
 147                 err = "failed to begin guest";
 148                 goto die;
 149         }
 150
 151         /*
 152          * attach the operator rdev to *LOGIN, any available vdev
 153          *
 154          * Since we already IPL'd & began the guest, this will generate a
 155          * Channel Report Word and a Machine Check Interrupt in the guest.
 156          */
 157         ret = guest_attach(login, sysconf.oper_con, -1);
 158         if (ret) {
 159                 err = "failed to attach operator console";
 160                 goto die;
 161         }
 162
 163         /*
 164          * At this point we know that *LOGIN is running.  From this point
 165          * on, we can handle Machine Check Interrupts (of the
 166          * Channel-Report-Pending subclass) safely and sanely.  Let's enable
 167          * the the subclass.
 168          */
 169         set_cr(14, get_cr(14) | BIT64(35));
 170
 171         /*
 172          * IPL is more or less done
 173          */
 174         get_parsed_tod(&ipltime);
 175
 176         sclp_msg("IPL AT %02d:%02d:%02d UTC %04d-%02d-%02d\n\n",
 177                    ipltime.th, ipltime.tm, ipltime.ts, ipltime.dy,
 178                    ipltime.dm, ipltime.dd);
 179
 180         return 0;
 181
 182 die:
 183         sclp_msg("Failed to initialize '*LOGIN' guest: %s\n", err);
 184         BUG();
 185         return 0;
 186 }
 187
 188 /*
 189  * This is where everything starts
 190  */
 191 void start(u64 __memsize, u32 __iplsch, Elf64_Ehdr *__elfhdr)
 192 {
 193         u64 first_free_page;
 194         u64 struct_page_bytes;
 195         struct psw psw;
 196
 197         /*
 198          * ticks starts at 0
 199          */
 200         ticks = 0;
 201
 202         /*
 203          * save total system memory size & the symbol table pointer
 204          */
 205         memsize = __memsize;
 206         symtab = __elfhdr;
 207
 208         /*
 209          * Initialize struct page entries
 210          */
 211         init_pages();
 212
 213         /*
 214          * Calculate address of the first free page (we may have to round
 215          * up)
 216          */
 217         struct_page_bytes = (memsize >> PAGE_SHIFT) * sizeof(struct page);
 218
 219         first_free_page = (u64) PAGE_INFO_BASE + struct_page_bytes;
 220         if (struct_page_bytes & (PAGE_SIZE-1))
 221                 first_free_page += PAGE_SIZE - (struct_page_bytes & (PAGE_SIZE-1));
 222
 223         /*
 224          * Initialize the buddy allocator
 225          */
 226         init_buddy_alloc(first_free_page);
 227
 228         /*
 229          * Initialize slab allocator default caches
 230          */
 231         init_slab();
 232
 233         /*
 234          * Set up interrupt PSWs
 235          */
 236         memcpy(IO_INT_NEW_PSW, &new_io_psw, sizeof(struct psw));
 237         memcpy(EXT_INT_NEW_PSW, &new_ext_psw, sizeof(struct psw));
 238         memcpy(SVC_INT_NEW_PSW, &new_svc_psw, sizeof(struct psw));
 239         memcpy(PGM_INT_NEW_PSW, &new_pgm_psw, sizeof(struct psw));
 240         memcpy(MCH_INT_NEW_PSW, &new_mch_psw, sizeof(struct psw));
 241
 242         /* Turn on Low-address Protection */
 243         lap_on();
 244
 245         /*
 246          * Set up page table entries for the nucleus
 247          */
 248         setup_dat();
 249
 250         /*
 251          * Allocate & initialize the interrupt stack
 252          */
 253         init_int_stack();
 254
 255         /*
 256          * Initialize the io subsystem
 257          */
 258         init_io();
 259
 260         /*
 261          * Register all the device drivers
 262          */
 263         register_drivers();
 264
 265         /*
 266          * Time to enable interrupts => load new psw
 267          */
 268         memset(&psw, 0, sizeof(struct psw));
 269         psw.io  = 1;
 270         psw.ea  = 1;
 271         psw.ba  = 1;
 272
 273         asm volatile(
 274                 "       larl    %%r1,0f\n"
 275                 "       stg     %%r1,%0\n"
 276                 "       lpswe   %1\n"
 277                 "0:\n"
 278         : /* output */
 279           "=m" (psw.ptr)
 280         : /* input */
 281           "m" (psw)
 282         : /* clobbered */
 283           "r1"
 284         );
 285
 286         /*
 287          * Let's discover all the devices attached
 288          */
 289         scan_devices();
 290
 291         /*
 292          * Initialize the process scheduler
 293          */
 294         init_sched();
 295
 296         /*
 297          * Start tracking locking dependencies
 298          */
 299         ldep_on();
 300
 301         /*
 302          * Create a thread that'll finish setting everything up for us
 303          */
 304         create_task("*finish-loading", __finish_loading, (void*) (u64) __iplsch);
 305
 306         /*
 307          * THIS IS WHERE THE IDLE TASK BEGINS
 308          */
 309
 310         idle_task_body();
 311 }
 312