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