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