cp/nucleus/init.c

   1 /*
   2  * (C) Copyright 2007-2019  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, true);
 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 complete 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         sclp_msg("HVF %s", VERSION);
 198
 199         /*
 200          * ticks starts at 0
 201          */
 202         ticks = 0;
 203
 204         /*
 205          * save total system memory size & the symbol table pointer
 206          */
 207         memsize = __memsize;
 208         symtab = __elfhdr;
 209
 210         /*
 211          * Initialize struct page entries
 212          */
 213         init_pages();
 214
 215         /*
 216          * Calculate address of the first free page (we may have to round
 217          * up)
 218          */
 219         struct_page_bytes = (memsize >> PAGE_SHIFT) * sizeof(struct page);
 220
 221         first_free_page = (u64) PAGE_INFO_BASE + struct_page_bytes;
 222         if (struct_page_bytes & (PAGE_SIZE-1))
 223                 first_free_page += PAGE_SIZE - (struct_page_bytes & (PAGE_SIZE-1));
 224
 225         /*
 226          * Initialize the buddy allocator
 227          */
 228         init_buddy_alloc(first_free_page);
 229
 230         /*
 231          * Initialize slab allocator default caches
 232          */
 233         init_slab();
 234
 235         /*
 236          * Set up interrupt PSWs
 237          */
 238         memcpy(IO_INT_NEW_PSW, &new_io_psw, sizeof(struct psw));
 239         memcpy(EXT_INT_NEW_PSW, &new_ext_psw, sizeof(struct psw));
 240         memcpy(SVC_INT_NEW_PSW, &new_svc_psw, sizeof(struct psw));
 241         memcpy(PGM_INT_NEW_PSW, &new_pgm_psw, sizeof(struct psw));
 242         memcpy(MCH_INT_NEW_PSW, &new_mch_psw, sizeof(struct psw));
 243
 244         /* Turn on Low-address Protection */
 245         lap_on();
 246
 247         /*
 248          * Set up page table entries for the nucleus
 249          */
 250         setup_dat();
 251
 252         /*
 253          * Allocate & initialize the interrupt stack
 254          */
 255         init_int_stack();
 256
 257         /*
 258          * Initialize the io subsystem
 259          */
 260         init_io();
 261
 262         /*
 263          * Register all the device drivers
 264          */
 265         register_drivers();
 266
 267         /*
 268          * Time to enable interrupts => load new psw
 269          */
 270         memset(&psw, 0, sizeof(struct psw));
 271         psw.io  = 1;
 272         psw.ea  = 1;
 273         psw.ba  = 1;
 274
 275         asm volatile(
 276                 "       larl    %%r1,0f\n"
 277                 "       stg     %%r1,%0\n"
 278                 "       lpswe   %1\n"
 279                 "0:\n"
 280         : /* output */
 281           "=m" (psw.ptr)
 282         : /* input */
 283           "m" (psw)
 284         : /* clobbered */
 285           "r1"
 286         );
 287
 288         /*
 289          * Let's discover all the devices attached
 290          */
 291         scan_devices();
 292
 293         /*
 294          * Initialize the process scheduler
 295          */
 296         init_sched();
 297
 298         /*
 299          * Start tracking locking dependencies
 300          */
 301         ldep_on();
 302
 303         /*
 304          * Create a thread that'll finish setting everything up for us
 305          */
 306         create_task("*finish-loading", __finish_loading, (void*) (u64) __iplsch);
 307
 308         /*
 309          * THIS IS WHERE THE IDLE TASK BEGINS
 310          */
 311
 312         idle_task_body();
 313 }
 314