arch/um/kernel/um_arch.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   4  */
   5
   6 #include <linux/delay.h>
   7 #include <linux/init.h>
   8 #include <linux/mm.h>
   9 #include <linux/ctype.h>
  10 #include <linux/module.h>
  11 #include <linux/panic_notifier.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/string.h>
  14 #include <linux/utsname.h>
  15 #include <linux/sched.h>
  16 #include <linux/sched/task.h>
  17 #include <linux/kmsg_dump.h>
  18 #include <linux/suspend.h>
  19
  20 #include <asm/processor.h>
  21 #include <asm/cpufeature.h>
  22 #include <asm/sections.h>
  23 #include <asm/setup.h>
  24 #include <as-layout.h>
  25 #include <arch.h>
  26 #include <init.h>
  27 #include <kern.h>
  28 #include <kern_util.h>
  29 #include <mem_user.h>
  30 #include <os.h>
  31
  32 #define DEFAULT_COMMAND_LINE_ROOT "root=98:0"
  33 #define DEFAULT_COMMAND_LINE_CONSOLE "console=tty"
  34
  35 /* Changed in add_arg and setup_arch, which run before SMP is started */
  36 static char __initdata command_line[COMMAND_LINE_SIZE] = { 0 };
  37
  38 static void __init add_arg(char *arg)
  39 {
  40         if (strlen(command_line) + strlen(arg) + 1 > COMMAND_LINE_SIZE) {
  41                 os_warn("add_arg: Too many command line arguments!\n");
  42                 exit(1);
  43         }
  44         if (strlen(command_line) > 0)
  45                 strcat(command_line, " ");
  46         strcat(command_line, arg);
  47 }
  48
  49 /*
  50  * These fields are initialized at boot time and not changed.
  51  * XXX This structure is used only in the non-SMP case.  Maybe this
  52  * should be moved to smp.c.
  53  */
  54 struct cpuinfo_um boot_cpu_data = {
  55         .loops_per_jiffy        = 0,
  56         .ipi_pipe               = { -1, -1 },
  57         .cache_alignment        = L1_CACHE_BYTES,
  58         .x86_capability         = { 0 }
  59 };
  60
  61 EXPORT_SYMBOL(boot_cpu_data);
  62
  63 union thread_union cpu0_irqstack
  64         __section(".data..init_irqstack") =
  65                 { .thread_info = INIT_THREAD_INFO(init_task) };
  66
  67 /* Changed in setup_arch, which is called in early boot */
  68 static char host_info[(__NEW_UTS_LEN + 1) * 5];
  69
  70 static int show_cpuinfo(struct seq_file *m, void *v)
  71 {
  72         int i = 0;
  73
  74         seq_printf(m, "processor\t: %d\n", i);
  75         seq_printf(m, "vendor_id\t: User Mode Linux\n");
  76         seq_printf(m, "model name\t: UML\n");
  77         seq_printf(m, "mode\t\t: skas\n");
  78         seq_printf(m, "host\t\t: %s\n", host_info);
  79         seq_printf(m, "fpu\t\t: %s\n", cpu_has(&boot_cpu_data, X86_FEATURE_FPU) ? "yes" : "no");
  80         seq_printf(m, "flags\t\t:");
  81         for (i = 0; i < 32*NCAPINTS; i++)
  82                 if (cpu_has(&boot_cpu_data, i) && (x86_cap_flags[i] != NULL))
  83                         seq_printf(m, " %s", x86_cap_flags[i]);
  84         seq_printf(m, "\n");
  85         seq_printf(m, "cache_alignment\t: %d\n", boot_cpu_data.cache_alignment);
  86         seq_printf(m, "bogomips\t: %lu.%02lu\n",
  87                    loops_per_jiffy/(500000/HZ),
  88                    (loops_per_jiffy/(5000/HZ)) % 100);
  89
  90
  91         return 0;
  92 }
  93
  94 static void *c_start(struct seq_file *m, loff_t *pos)
  95 {
  96         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
  97 }
  98
  99 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 100 {
 101         ++*pos;
 102         return c_start(m, pos);
 103 }
 104
 105 static void c_stop(struct seq_file *m, void *v)
 106 {
 107 }
 108
 109 const struct seq_operations cpuinfo_op = {
 110         .start  = c_start,
 111         .next   = c_next,
 112         .stop   = c_stop,
 113         .show   = show_cpuinfo,
 114 };
 115
 116 /* Set in linux_main */
 117 unsigned long uml_physmem;
 118 EXPORT_SYMBOL(uml_physmem);
 119
 120 unsigned long uml_reserved; /* Also modified in mem_init */
 121 unsigned long start_vm;
 122 unsigned long end_vm;
 123
 124 /* Set in uml_ncpus_setup */
 125 int ncpus = 1;
 126
 127 /* Set in early boot */
 128 static int have_root __initdata;
 129 static int have_console __initdata;
 130
 131 /* Set in uml_mem_setup and modified in linux_main */
 132 long long physmem_size = 32 * 1024 * 1024;
 133 EXPORT_SYMBOL(physmem_size);
 134
 135 static const char *usage_string =
 136 "User Mode Linux v%s\n"
 137 "       available at http://user-mode-linux.sourceforge.net/\n\n";
 138
 139 static int __init uml_version_setup(char *line, int *add)
 140 {
 141         /* Explicitly use printf() to show version in stdout */
 142         printf("%s\n", init_utsname()->release);
 143         exit(0);
 144
 145         return 0;
 146 }
 147
 148 __uml_setup("--version", uml_version_setup,
 149 "--version\n"
 150 "    Prints the version number of the kernel.\n\n"
 151 );
 152
 153 static int __init uml_root_setup(char *line, int *add)
 154 {
 155         have_root = 1;
 156         return 0;
 157 }
 158
 159 __uml_setup("root=", uml_root_setup,
 160 "root=<file containing the root fs>\n"
 161 "    This is actually used by the generic kernel in exactly the same\n"
 162 "    way as in any other kernel. If you configure a number of block\n"
 163 "    devices and want to boot off something other than ubd0, you \n"
 164 "    would use something like:\n"
 165 "        root=/dev/ubd5\n\n"
 166 );
 167
 168 static int __init no_skas_debug_setup(char *line, int *add)
 169 {
 170         os_warn("'debug' is not necessary to gdb UML in skas mode - run\n");
 171         os_warn("'gdb linux'\n");
 172
 173         return 0;
 174 }
 175
 176 __uml_setup("debug", no_skas_debug_setup,
 177 "debug\n"
 178 "    this flag is not needed to run gdb on UML in skas mode\n\n"
 179 );
 180
 181 static int __init uml_console_setup(char *line, int *add)
 182 {
 183         have_console = 1;
 184         return 0;
 185 }
 186
 187 __uml_setup("console=", uml_console_setup,
 188 "console=<preferred console>\n"
 189 "    Specify the preferred console output driver\n\n"
 190 );
 191
 192 static int __init Usage(char *line, int *add)
 193 {
 194         const char **p;
 195
 196         printf(usage_string, init_utsname()->release);
 197         p = &__uml_help_start;
 198         /* Explicitly use printf() to show help in stdout */
 199         while (p < &__uml_help_end) {
 200                 printf("%s", *p);
 201                 p++;
 202         }
 203         exit(0);
 204         return 0;
 205 }
 206
 207 __uml_setup("--help", Usage,
 208 "--help\n"
 209 "    Prints this message.\n\n"
 210 );
 211
 212 static void __init uml_checksetup(char *line, int *add)
 213 {
 214         struct uml_param *p;
 215
 216         p = &__uml_setup_start;
 217         while (p < &__uml_setup_end) {
 218                 size_t n;
 219
 220                 n = strlen(p->str);
 221                 if (!strncmp(line, p->str, n) && p->setup_func(line + n, add))
 222                         return;
 223                 p++;
 224         }
 225 }
 226
 227 static void __init uml_postsetup(void)
 228 {
 229         initcall_t *p;
 230
 231         p = &__uml_postsetup_start;
 232         while (p < &__uml_postsetup_end) {
 233                 (*p)();
 234                 p++;
 235         }
 236         return;
 237 }
 238
 239 static int panic_exit(struct notifier_block *self, unsigned long unused1,
 240                       void *unused2)
 241 {
 242         kmsg_dump(KMSG_DUMP_PANIC);
 243         bust_spinlocks(1);
 244         bust_spinlocks(0);
 245         uml_exitcode = 1;
 246         os_dump_core();
 247         return 0;
 248 }
 249
 250 static struct notifier_block panic_exit_notifier = {
 251         .notifier_call          = panic_exit,
 252         .next                   = NULL,
 253         .priority               = 0
 254 };
 255
 256 void uml_finishsetup(void)
 257 {
 258         atomic_notifier_chain_register(&panic_notifier_list,
 259                                        &panic_exit_notifier);
 260
 261         uml_postsetup();
 262
 263         new_thread_handler();
 264 }
 265
 266 /* Set during early boot */
 267 unsigned long stub_start;
 268 unsigned long task_size;
 269 EXPORT_SYMBOL(task_size);
 270
 271 unsigned long host_task_size;
 272
 273 unsigned long brk_start;
 274 unsigned long end_iomem;
 275 EXPORT_SYMBOL(end_iomem);
 276
 277 #define MIN_VMALLOC (32 * 1024 * 1024)
 278
 279 static void parse_host_cpu_flags(char *line)
 280 {
 281         int i;
 282         for (i = 0; i < 32*NCAPINTS; i++) {
 283                 if ((x86_cap_flags[i] != NULL) && strstr(line, x86_cap_flags[i]))
 284                         set_cpu_cap(&boot_cpu_data, i);
 285         }
 286 }
 287 static void parse_cache_line(char *line)
 288 {
 289         long res;
 290         char *to_parse = strstr(line, ":");
 291         if (to_parse) {
 292                 to_parse++;
 293                 while (*to_parse != 0 && isspace(*to_parse)) {
 294                         to_parse++;
 295                 }
 296                 if (kstrtoul(to_parse, 10, &res) == 0 && is_power_of_2(res))
 297                         boot_cpu_data.cache_alignment = res;
 298                 else
 299                         boot_cpu_data.cache_alignment = L1_CACHE_BYTES;
 300         }
 301 }
 302
 303 int __init linux_main(int argc, char **argv)
 304 {
 305         unsigned long avail, diff;
 306         unsigned long virtmem_size, max_physmem;
 307         unsigned long stack;
 308         unsigned int i;
 309         int add;
 310
 311         for (i = 1; i < argc; i++) {
 312                 if ((i == 1) && (argv[i][0] == ' '))
 313                         continue;
 314                 add = 1;
 315                 uml_checksetup(argv[i], &add);
 316                 if (add)
 317                         add_arg(argv[i]);
 318         }
 319         if (have_root == 0)
 320                 add_arg(DEFAULT_COMMAND_LINE_ROOT);
 321
 322         if (have_console == 0)
 323                 add_arg(DEFAULT_COMMAND_LINE_CONSOLE);
 324
 325         host_task_size = os_get_top_address();
 326         /* reserve two pages for the stubs */
 327         host_task_size -= 2 * PAGE_SIZE;
 328         stub_start = host_task_size;
 329
 330         /*
 331          * TASK_SIZE needs to be PGDIR_SIZE aligned or else exit_mmap craps
 332          * out
 333          */
 334         task_size = host_task_size & PGDIR_MASK;
 335
 336         /* OS sanity checks that need to happen before the kernel runs */
 337         os_early_checks();
 338
 339         get_host_cpu_features(parse_host_cpu_flags, parse_cache_line);
 340
 341         brk_start = (unsigned long) sbrk(0);
 342
 343         /*
 344          * Increase physical memory size for exec-shield users
 345          * so they actually get what they asked for. This should
 346          * add zero for non-exec shield users
 347          */
 348
 349         diff = UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
 350         if (diff > 1024 * 1024) {
 351                 os_info("Adding %ld bytes to physical memory to account for "
 352                         "exec-shield gap\n", diff);
 353                 physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
 354         }
 355
 356         uml_physmem = (unsigned long) __binary_start & PAGE_MASK;
 357
 358         /* Reserve up to 4M after the current brk */
 359         uml_reserved = ROUND_4M(brk_start) + (1 << 22);
 360
 361         setup_machinename(init_utsname()->machine);
 362
 363         highmem = 0;
 364         iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
 365         max_physmem = TASK_SIZE - uml_physmem - iomem_size - MIN_VMALLOC;
 366
 367         /*
 368          * Zones have to begin on a 1 << MAX_ORDER page boundary,
 369          * so this makes sure that's true for highmem
 370          */
 371         max_physmem &= ~((1 << (PAGE_SHIFT + MAX_ORDER)) - 1);
 372         if (physmem_size + iomem_size > max_physmem) {
 373                 highmem = physmem_size + iomem_size - max_physmem;
 374                 physmem_size -= highmem;
 375         }
 376
 377         high_physmem = uml_physmem + physmem_size;
 378         end_iomem = high_physmem + iomem_size;
 379         high_memory = (void *) end_iomem;
 380
 381         start_vm = VMALLOC_START;
 382
 383         virtmem_size = physmem_size;
 384         stack = (unsigned long) argv;
 385         stack &= ~(1024 * 1024 - 1);
 386         avail = stack - start_vm;
 387         if (physmem_size > avail)
 388                 virtmem_size = avail;
 389         end_vm = start_vm + virtmem_size;
 390
 391         if (virtmem_size < physmem_size)
 392                 os_info("Kernel virtual memory size shrunk to %lu bytes\n",
 393                         virtmem_size);
 394
 395         os_flush_stdout();
 396
 397         return start_uml();
 398 }
 399
 400 int __init __weak read_initrd(void)
 401 {
 402         return 0;
 403 }
 404
 405 void __init setup_arch(char **cmdline_p)
 406 {
 407         stack_protections((unsigned long) &init_thread_info);
 408         setup_physmem(uml_physmem, uml_reserved, physmem_size, highmem);
 409         mem_total_pages(physmem_size, iomem_size, highmem);
 410         read_initrd();
 411
 412         paging_init();
 413         strlcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
 414         *cmdline_p = command_line;
 415         setup_hostinfo(host_info, sizeof host_info);
 416 }
 417
 418 void __init check_bugs(void)
 419 {
 420         arch_check_bugs();
 421         os_check_bugs();
 422 }
 423
 424 void apply_retpolines(s32 *start, s32 *end)
 425 {
 426 }
 427
 428 void apply_alternatives(struct alt_instr *start, struct alt_instr *end)
 429 {
 430 }
 431
 432 void *text_poke(void *addr, const void *opcode, size_t len)
 433 {
 434         /*
 435          * In UML, the only reference to this function is in
 436          * apply_relocate_add(), which shouldn't ever actually call this
 437          * because UML doesn't have live patching.
 438          */
 439         WARN_ON(1);
 440
 441         return memcpy(addr, opcode, len);
 442 }
 443
 444 void text_poke_sync(void)
 445 {
 446 }
 447
 448 void uml_pm_wake(void)
 449 {
 450         pm_system_wakeup();
 451 }
 452
 453 #ifdef CONFIG_PM_SLEEP
 454 static int um_suspend_valid(suspend_state_t state)
 455 {
 456         return state == PM_SUSPEND_MEM;
 457 }
 458
 459 static int um_suspend_prepare(void)
 460 {
 461         um_irqs_suspend();
 462         return 0;
 463 }
 464
 465 static int um_suspend_enter(suspend_state_t state)
 466 {
 467         if (WARN_ON(state != PM_SUSPEND_MEM))
 468                 return -EINVAL;
 469
 470         /*
 471          * This is identical to the idle sleep, but we've just
 472          * (during suspend) turned off all interrupt sources
 473          * except for the ones we want, so now we can only wake
 474          * up on something we actually want to wake up on. All
 475          * timing has also been suspended.
 476          */
 477         um_idle_sleep();
 478         return 0;
 479 }
 480
 481 static void um_suspend_finish(void)
 482 {
 483         um_irqs_resume();
 484 }
 485
 486 const struct platform_suspend_ops um_suspend_ops = {
 487         .valid = um_suspend_valid,
 488         .prepare = um_suspend_prepare,
 489         .enter = um_suspend_enter,
 490         .finish = um_suspend_finish,
 491 };
 492
 493 static int init_pm_wake_signal(void)
 494 {
 495         /*
 496          * In external time-travel mode we can't use signals to wake up
 497          * since that would mess with the scheduling. We'll have to do
 498          * some additional work to support wakeup on virtio devices or
 499          * similar, perhaps implementing a fake RTC controller that can
 500          * trigger wakeup (and request the appropriate scheduling from
 501          * the external scheduler when going to suspend.)
 502          */
 503         if (time_travel_mode != TT_MODE_EXTERNAL)
 504                 register_pm_wake_signal();
 505
 506         suspend_set_ops(&um_suspend_ops);
 507
 508         return 0;
 509 }
 510
 511 late_initcall(init_pm_wake_signal);
 512 #endif