git.osdn.net Git - tomoyo/tomoyo-test1.git/blob

1 // SPDX-License-Identifier: GPL-2.0

2 /*

3 * S390 version

4 * Copyright IBM Corp. 1999, 2012

5 * Author(s): Hartmut Penner (hp@de.ibm.com),

6 * Martin Schwidefsky (schwidefsky@de.ibm.com)

7 *

8 * Derived from "arch/i386/kernel/setup.c"

10 */

12 /*

13 * This file handles the architecture-dependent parts of initialization

14 */

16 #define KMSG_COMPONENT "setup"

17 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

19 #include <linux/errno.h>

20 #include <linux/export.h>

21 #include <linux/sched.h>

22 #include <linux/sched/task.h>

23 #include <linux/cpu.h>

24 #include <linux/kernel.h>

25 #include <linux/memblock.h>

26 #include <linux/mm.h>

27 #include <linux/stddef.h>

28 #include <linux/unistd.h>

29 #include <linux/ptrace.h>

30 #include <linux/random.h>

31 #include <linux/user.h>

32 #include <linux/tty.h>

33 #include <linux/ioport.h>

34 #include <linux/delay.h>

35 #include <linux/init.h>

36 #include <linux/initrd.h>

37 #include <linux/root_dev.h>

38 #include <linux/console.h>

39 #include <linux/kernel_stat.h>

40 #include <linux/dma-contiguous.h>

41 #include <linux/device.h>

42 #include <linux/notifier.h>

43 #include <linux/pfn.h>

44 #include <linux/ctype.h>

45 #include <linux/reboot.h>

46 #include <linux/topology.h>

47 #include <linux/kexec.h>

48 #include <linux/crash_dump.h>

49 #include <linux/memory.h>

50 #include <linux/compat.h>

51 #include <linux/start_kernel.h>

53 #include <asm/boot_data.h>

54 #include <asm/ipl.h>

55 #include <asm/facility.h>

56 #include <asm/smp.h>

57 #include <asm/mmu_context.h>

58 #include <asm/cpcmd.h>

59 #include <asm/lowcore.h>

60 #include <asm/nmi.h>

61 #include <asm/irq.h>

62 #include <asm/page.h>

63 #include <asm/ptrace.h>

64 #include <asm/sections.h>

65 #include <asm/ebcdic.h>

66 #include <asm/diag.h>

67 #include <asm/os_info.h>

68 #include <asm/sclp.h>

69 #include <asm/stacktrace.h>

70 #include <asm/sysinfo.h>

71 #include <asm/numa.h>

72 #include <asm/alternative.h>

73 #include <asm/nospec-branch.h>

74 #include <asm/mem_detect.h>

75 #include <asm/uv.h>

76 #include "entry.h"

78 /*

79 * Machine setup..

80 */

81 unsigned int console_mode = 0;

82 EXPORT_SYMBOL(console_mode);

84 unsigned int console_devno = -1;

85 EXPORT_SYMBOL(console_devno);

87 unsigned int console_irq = -1;

88 EXPORT_SYMBOL(console_irq);

90 unsigned long elf_hwcap __read_mostly = 0;

91 char elf_platform[ELF_PLATFORM_SIZE];

93 unsigned long int_hwcap = 0;

95 int __bootdata(noexec_disabled);

96 int __bootdata(memory_end_set);

97 unsigned long __bootdata(memory_end);

98 unsigned long __bootdata(vmalloc_size);

99 unsigned long __bootdata(max_physmem_end);

100 struct mem_detect_info __bootdata(mem_detect);

101

102 struct exception_table_entry *__bootdata_preserved(__start_dma_ex_table);

103 struct exception_table_entry *__bootdata_preserved(__stop_dma_ex_table);

104 unsigned long __bootdata_preserved(__swsusp_reset_dma);

105 unsigned long __bootdata_preserved(__stext_dma);

106 unsigned long __bootdata_preserved(__etext_dma);

107 unsigned long __bootdata_preserved(__sdma);

108 unsigned long __bootdata_preserved(__edma);

109 unsigned long __bootdata_preserved(__kaslr_offset);

110 unsigned int __bootdata_preserved(zlib_dfltcc_support);

111 EXPORT_SYMBOL(zlib_dfltcc_support);

112

113 unsigned long VMALLOC_START;

114 EXPORT_SYMBOL(VMALLOC_START);

115

116 unsigned long VMALLOC_END;

117 EXPORT_SYMBOL(VMALLOC_END);

118

119 struct page *vmemmap;

120 EXPORT_SYMBOL(vmemmap);

121

122 unsigned long MODULES_VADDR;

123 unsigned long MODULES_END;

124

125 /* An array with a pointer to the lowcore of every CPU. */

126 struct lowcore *lowcore_ptr[NR_CPUS];

127 EXPORT_SYMBOL(lowcore_ptr);

128

129 /*

130 * This is set up by the setup-routine at boot-time

131 * for S390 need to find out, what we have to setup

132 * using address 0x10400 ...

133 */

134

135 #include <asm/setup.h>

136

137 /*

138 * condev= and conmode= setup parameter.

139 */

140

141 static int __init condev_setup(char *str)

142 {

143 int vdev;

144

145 vdev = simple_strtoul(str, &str, 0);

146 if (vdev >= 0 && vdev < 65536) {

147 console_devno = vdev;

148 console_irq = -1;

149 }

150 return 1;

151 }

152

153 __setup("condev=", condev_setup);

154

155 static void __init set_preferred_console(void)

156 {

157 if (CONSOLE_IS_3215 || CONSOLE_IS_SCLP)

158 add_preferred_console("ttyS", 0, NULL);

159 else if (CONSOLE_IS_3270)

160 add_preferred_console("tty3270", 0, NULL);

161 else if (CONSOLE_IS_VT220)

162 add_preferred_console("ttyS", 1, NULL);

163 else if (CONSOLE_IS_HVC)

164 add_preferred_console("hvc", 0, NULL);

165 }

166

167 static int __init conmode_setup(char *str)

168 {

169 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)

170 if (!strcmp(str, "hwc") || !strcmp(str, "sclp"))

171 SET_CONSOLE_SCLP;

172 #endif

173 #if defined(CONFIG_TN3215_CONSOLE)

174 if (!strcmp(str, "3215"))

175 SET_CONSOLE_3215;

176 #endif

177 #if defined(CONFIG_TN3270_CONSOLE)

178 if (!strcmp(str, "3270"))

179 SET_CONSOLE_3270;

180 #endif

181 set_preferred_console();

182 return 1;

183 }

184

185 __setup("conmode=", conmode_setup);

186

187 static void __init conmode_default(void)

188 {

189 char query_buffer[1024];

190 char *ptr;

191

192 if (MACHINE_IS_VM) {

193 cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);

194 console_devno = simple_strtoul(query_buffer + 5, NULL, 16);

195 ptr = strstr(query_buffer, "SUBCHANNEL =");

196 console_irq = simple_strtoul(ptr + 13, NULL, 16);

197 cpcmd("QUERY TERM", query_buffer, 1024, NULL);

198 ptr = strstr(query_buffer, "CONMODE");

199 /*

200 * Set the conmode to 3215 so that the device recognition

201 * will set the cu_type of the console to 3215. If the

202 * conmode is 3270 and we don't set it back then both

203 * 3215 and the 3270 driver will try to access the console

204 * device (3215 as console and 3270 as normal tty).

205 */

206 cpcmd("TERM CONMODE 3215", NULL, 0, NULL);

207 if (ptr == NULL) {

208 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)

209 SET_CONSOLE_SCLP;

210 #endif

211 return;

212 }

213 if (str_has_prefix(ptr + 8, "3270")) {

214 #if defined(CONFIG_TN3270_CONSOLE)

215 SET_CONSOLE_3270;

216 #elif defined(CONFIG_TN3215_CONSOLE)

217 SET_CONSOLE_3215;

218 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)

219 SET_CONSOLE_SCLP;

220 #endif

221 } else if (str_has_prefix(ptr + 8, "3215")) {

222 #if defined(CONFIG_TN3215_CONSOLE)

223 SET_CONSOLE_3215;

224 #elif defined(CONFIG_TN3270_CONSOLE)

225 SET_CONSOLE_3270;

226 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)

227 SET_CONSOLE_SCLP;

228 #endif

229 }

230 } else if (MACHINE_IS_KVM) {

231 if (sclp.has_vt220 && IS_ENABLED(CONFIG_SCLP_VT220_CONSOLE))

232 SET_CONSOLE_VT220;

233 else if (sclp.has_linemode && IS_ENABLED(CONFIG_SCLP_CONSOLE))

234 SET_CONSOLE_SCLP;

235 else

236 SET_CONSOLE_HVC;

237 } else {

238 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)

239 SET_CONSOLE_SCLP;

240 #endif

241 }

242 }

243

244 #ifdef CONFIG_CRASH_DUMP

245 static void __init setup_zfcpdump(void)

246 {

247 if (ipl_info.type != IPL_TYPE_FCP_DUMP)

248 return;

249 if (OLDMEM_BASE)

250 return;

251 strcat(boot_command_line, " cio_ignore=all,!ipldev,!condev");

252 console_loglevel = 2;

253 }

254 #else

255 static inline void setup_zfcpdump(void) {}

256 #endif /* CONFIG_CRASH_DUMP */

257

258 /*

259 * Reboot, halt and power_off stubs. They just call _machine_restart,

260 * _machine_halt or _machine_power_off.

261 */

262

263 void machine_restart(char *command)

264 {

265 if ((!in_interrupt() && !in_atomic()) || oops_in_progress)

266 /*

267 * Only unblank the console if we are called in enabled

268 * context or a bust_spinlocks cleared the way for us.

269 */

270 console_unblank();

271 _machine_restart(command);

272 }

273

274 void machine_halt(void)

275 {

276 if (!in_interrupt() || oops_in_progress)

277 /*

278 * Only unblank the console if we are called in enabled

279 * context or a bust_spinlocks cleared the way for us.

280 */

281 console_unblank();

282 _machine_halt();

283 }

284

285 void machine_power_off(void)

286 {

287 if (!in_interrupt() || oops_in_progress)

288 /*

289 * Only unblank the console if we are called in enabled

290 * context or a bust_spinlocks cleared the way for us.

291 */

292 console_unblank();

293 _machine_power_off();

294 }

295

296 /*

297 * Dummy power off function.

298 */

299 void (*pm_power_off)(void) = machine_power_off;

300 EXPORT_SYMBOL_GPL(pm_power_off);

301

302 void *restart_stack __section(.data);

303

304 unsigned long stack_alloc(void)

305 {

306 #ifdef CONFIG_VMAP_STACK

307 return (unsigned long)

308 __vmalloc_node_range(THREAD_SIZE, THREAD_SIZE,

309 VMALLOC_START, VMALLOC_END,

310 THREADINFO_GFP,

311 PAGE_KERNEL, 0, NUMA_NO_NODE,

312 __builtin_return_address(0));

313 #else

314 return __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER);

315 #endif

316 }

317

318 void stack_free(unsigned long stack)

319 {

320 #ifdef CONFIG_VMAP_STACK

321 vfree((void *) stack);

322 #else

323 free_pages(stack, THREAD_SIZE_ORDER);

324 #endif

325 }

326

327 int __init arch_early_irq_init(void)

328 {

329 unsigned long stack;

330

331 stack = __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER);

332 if (!stack)

333 panic("Couldn't allocate async stack");

334 S390_lowcore.async_stack = stack + STACK_INIT_OFFSET;

335 return 0;

336 }

337

338 static int __init async_stack_realloc(void)

339 {

340 unsigned long old, new;

341

342 old = S390_lowcore.async_stack - STACK_INIT_OFFSET;

343 new = stack_alloc();

344 if (!new)

345 panic("Couldn't allocate async stack");

346 S390_lowcore.async_stack = new + STACK_INIT_OFFSET;

347 free_pages(old, THREAD_SIZE_ORDER);

348 return 0;

349 }

350 early_initcall(async_stack_realloc);

351

352 void __init arch_call_rest_init(void)

353 {

354 unsigned long stack;

355

356 stack = stack_alloc();

357 if (!stack)

358 panic("Couldn't allocate kernel stack");

359 current->stack = (void *) stack;

360 #ifdef CONFIG_VMAP_STACK

361 current->stack_vm_area = (void *) stack;

362 #endif

363 set_task_stack_end_magic(current);

364 stack += STACK_INIT_OFFSET;

365 S390_lowcore.kernel_stack = stack;

366 CALL_ON_STACK_NORETURN(rest_init, stack);

367 }

368

369 static void __init setup_lowcore_dat_off(void)

370 {

371 struct lowcore *lc;

372

373 /*

374 * Setup lowcore for boot cpu

375 */

376 BUILD_BUG_ON(sizeof(struct lowcore) != LC_PAGES * PAGE_SIZE);

377 lc = memblock_alloc_low(sizeof(*lc), sizeof(*lc));

378 if (!lc)

379 panic("%s: Failed to allocate %zu bytes align=%zx\n",

380 __func__, sizeof(*lc), sizeof(*lc));

381

382 lc->restart_psw.mask = PSW_KERNEL_BITS;

383 lc->restart_psw.addr = (unsigned long) restart_int_handler;

384 lc->external_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_MCHECK;

385 lc->external_new_psw.addr = (unsigned long) ext_int_handler;

386 lc->svc_new_psw.mask = PSW_KERNEL_BITS |

387 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;

388 lc->svc_new_psw.addr = (unsigned long) system_call;

389 lc->program_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_MCHECK;

390 lc->program_new_psw.addr = (unsigned long) pgm_check_handler;

391 lc->mcck_new_psw.mask = PSW_KERNEL_BITS;

392 lc->mcck_new_psw.addr = (unsigned long) mcck_int_handler;

393 lc->io_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_MCHECK;

394 lc->io_new_psw.addr = (unsigned long) io_int_handler;

395 lc->clock_comparator = clock_comparator_max;

396 lc->nodat_stack = ((unsigned long) &init_thread_union)

397 + THREAD_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);

398 lc->current_task = (unsigned long)&init_task;

399 lc->lpp = LPP_MAGIC;

400 lc->machine_flags = S390_lowcore.machine_flags;

401 lc->preempt_count = S390_lowcore.preempt_count;

402 lc->stfl_fac_list = S390_lowcore.stfl_fac_list;

403 memcpy(lc->stfle_fac_list, S390_lowcore.stfle_fac_list,

404 sizeof(lc->stfle_fac_list));

405 memcpy(lc->alt_stfle_fac_list, S390_lowcore.alt_stfle_fac_list,

406 sizeof(lc->alt_stfle_fac_list));

407 nmi_alloc_boot_cpu(lc);

408 vdso_alloc_boot_cpu(lc);

409 lc->sync_enter_timer = S390_lowcore.sync_enter_timer;

410 lc->async_enter_timer = S390_lowcore.async_enter_timer;

411 lc->exit_timer = S390_lowcore.exit_timer;

412 lc->user_timer = S390_lowcore.user_timer;

413 lc->system_timer = S390_lowcore.system_timer;

414 lc->steal_timer = S390_lowcore.steal_timer;

415 lc->last_update_timer = S390_lowcore.last_update_timer;

416 lc->last_update_clock = S390_lowcore.last_update_clock;

417

418 /*

419 * Allocate the global restart stack which is the same for

420 * all CPUs in cast *one* of them does a PSW restart.

421 */

422 restart_stack = memblock_alloc(THREAD_SIZE, THREAD_SIZE);

423 if (!restart_stack)

424 panic("%s: Failed to allocate %lu bytes align=0x%lx\n",

425 __func__, THREAD_SIZE, THREAD_SIZE);

426 restart_stack += STACK_INIT_OFFSET;

427

428 /*

429 * Set up PSW restart to call ipl.c:do_restart(). Copy the relevant

430 * restart data to the absolute zero lowcore. This is necessary if

431 * PSW restart is done on an offline CPU that has lowcore zero.

432 */

433 lc->restart_stack = (unsigned long) restart_stack;

434 lc->restart_fn = (unsigned long) do_restart;

435 lc->restart_data = 0;

436 lc->restart_source = -1UL;

437

438 /* Setup absolute zero lowcore */

439 mem_assign_absolute(S390_lowcore.restart_stack, lc->restart_stack);

440 mem_assign_absolute(S390_lowcore.restart_fn, lc->restart_fn);

441 mem_assign_absolute(S390_lowcore.restart_data, lc->restart_data);

442 mem_assign_absolute(S390_lowcore.restart_source, lc->restart_source);

443 mem_assign_absolute(S390_lowcore.restart_psw, lc->restart_psw);

444

445 lc->spinlock_lockval = arch_spin_lockval(0);

446 lc->spinlock_index = 0;

447 arch_spin_lock_setup(0);

448 lc->br_r1_trampoline = 0x07f1; /* br %r1 */

449

450 set_prefix((u32)(unsigned long) lc);

451 lowcore_ptr[0] = lc;

452 }

453

454 static void __init setup_lowcore_dat_on(void)

455 {

456 __ctl_clear_bit(0, 28);

457 S390_lowcore.external_new_psw.mask |= PSW_MASK_DAT;

458 S390_lowcore.svc_new_psw.mask |= PSW_MASK_DAT;

459 S390_lowcore.program_new_psw.mask |= PSW_MASK_DAT;

460 S390_lowcore.io_new_psw.mask |= PSW_MASK_DAT;

461 __ctl_set_bit(0, 28);

462 }

463

464 static struct resource code_resource = {

465 .name = "Kernel code",

466 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,

467 };

468

469 static struct resource data_resource = {

470 .name = "Kernel data",

471 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,

472 };

473

474 static struct resource bss_resource = {

475 .name = "Kernel bss",

476 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,

477 };

478

479 static struct resource __initdata *standard_resources[] = {

480 &code_resource,

481 &data_resource,

482 &bss_resource,

483 };

484

485 static void __init setup_resources(void)

486 {

487 struct resource *res, *std_res, *sub_res;

488 struct memblock_region *reg;

489 int j;

490

491 code_resource.start = (unsigned long) _text;

492 code_resource.end = (unsigned long) _etext - 1;

493 data_resource.start = (unsigned long) _etext;

494 data_resource.end = (unsigned long) _edata - 1;

495 bss_resource.start = (unsigned long) __bss_start;

496 bss_resource.end = (unsigned long) __bss_stop - 1;

497

498 for_each_memblock(memory, reg) {

499 res = memblock_alloc(sizeof(*res), 8);

500 if (!res)

501 panic("%s: Failed to allocate %zu bytes align=0x%x\n",

502 __func__, sizeof(*res), 8);

503 res->flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM;

504

505 res->name = "System RAM";

506 res->start = reg->base;

507 res->end = reg->base + reg->size - 1;

508 request_resource(&iomem_resource, res);

509

510 for (j = 0; j < ARRAY_SIZE(standard_resources); j++) {

511 std_res = standard_resources[j];

512 if (std_res->start < res->start ||

513 std_res->start > res->end)

514 continue;

515 if (std_res->end > res->end) {

516 sub_res = memblock_alloc(sizeof(*sub_res), 8);

517 if (!sub_res)

518 panic("%s: Failed to allocate %zu bytes align=0x%x\n",

519 __func__, sizeof(*sub_res), 8);

520 *sub_res = *std_res;

521 sub_res->end = res->end;

522 std_res->start = res->end + 1;

523 request_resource(res, sub_res);

524 } else {

525 request_resource(res, std_res);

526 }

527 }

528 }

529 #ifdef CONFIG_CRASH_DUMP

530 /*

531 * Re-add removed crash kernel memory as reserved memory. This makes

532 * sure it will be mapped with the identity mapping and struct pages

533 * will be created, so it can be resized later on.

534 * However add it later since the crash kernel resource should not be

535 * part of the System RAM resource.

536 */

537 if (crashk_res.end) {

538 memblock_add_node(crashk_res.start, resource_size(&crashk_res), 0);

539 memblock_reserve(crashk_res.start, resource_size(&crashk_res));

540 insert_resource(&iomem_resource, &crashk_res);

541 }

542 #endif

543 }

544

545 static void __init setup_memory_end(void)

546 {

547 unsigned long vmax, tmp;

548

549 /* Choose kernel address space layout: 3 or 4 levels. */

550 if (IS_ENABLED(CONFIG_KASAN)) {

551 vmax = IS_ENABLED(CONFIG_KASAN_S390_4_LEVEL_PAGING)

552 ? _REGION1_SIZE

553 : _REGION2_SIZE;

554 } else {

555 tmp = (memory_end ?: max_physmem_end) / PAGE_SIZE;

556 tmp = tmp * (sizeof(struct page) + PAGE_SIZE);

557 if (tmp + vmalloc_size + MODULES_LEN <= _REGION2_SIZE)

558 vmax = _REGION2_SIZE; /* 3-level kernel page table */

559 else

560 vmax = _REGION1_SIZE; /* 4-level kernel page table */

561 }

562

563 if (is_prot_virt_host())

564 adjust_to_uv_max(&vmax);

565

566 /* module area is at the end of the kernel address space. */

567 MODULES_END = vmax;

568 MODULES_VADDR = MODULES_END - MODULES_LEN;

569 VMALLOC_END = MODULES_VADDR;

570 VMALLOC_START = VMALLOC_END - vmalloc_size;

571

572 /* Split remaining virtual space between 1:1 mapping & vmemmap array */

573 tmp = VMALLOC_START / (PAGE_SIZE + sizeof(struct page));

574 /* vmemmap contains a multiple of PAGES_PER_SECTION struct pages */

575 tmp = SECTION_ALIGN_UP(tmp);

576 tmp = VMALLOC_START - tmp * sizeof(struct page);

577 tmp &= ~((vmax >> 11) - 1); /* align to page table level */

578 tmp = min(tmp, 1UL << MAX_PHYSMEM_BITS);

579 vmemmap = (struct page *) tmp;

580

581 /* Take care that memory_end is set and <= vmemmap */

582 memory_end = min(memory_end ?: max_physmem_end, (unsigned long)vmemmap);

583 #ifdef CONFIG_KASAN

584 /* fit in kasan shadow memory region between 1:1 and vmemmap */

585 memory_end = min(memory_end, KASAN_SHADOW_START);

586 vmemmap = max(vmemmap, (struct page *)KASAN_SHADOW_END);

587 #endif

588 max_pfn = max_low_pfn = PFN_DOWN(memory_end);

589 memblock_remove(memory_end, ULONG_MAX);

590

591 pr_notice("The maximum memory size is %luMB\n", memory_end >> 20);

592 }

593

594 #ifdef CONFIG_CRASH_DUMP

595

596 /*

597 * When kdump is enabled, we have to ensure that no memory from

598 * the area [0 - crashkernel memory size] and

599 * [crashk_res.start - crashk_res.end] is set offline.

600 */

601 static int kdump_mem_notifier(struct notifier_block *nb,

602 unsigned long action, void *data)

603 {

604 struct memory_notify *arg = data;

605

606 if (action != MEM_GOING_OFFLINE)

607 return NOTIFY_OK;

608 if (arg->start_pfn < PFN_DOWN(resource_size(&crashk_res)))

609 return NOTIFY_BAD;

610 if (arg->start_pfn > PFN_DOWN(crashk_res.end))

611 return NOTIFY_OK;

612 if (arg->start_pfn + arg->nr_pages - 1 < PFN_DOWN(crashk_res.start))

613 return NOTIFY_OK;

614 return NOTIFY_BAD;

615 }

616

617 static struct notifier_block kdump_mem_nb = {

618 .notifier_call = kdump_mem_notifier,

619 };

620

621 #endif

622

623 /*

624 * Make sure that the area behind memory_end is protected

625 */

626 static void reserve_memory_end(void)

627 {

628 if (memory_end_set)

629 memblock_reserve(memory_end, ULONG_MAX);

630 }

631

632 /*

633 * Make sure that oldmem, where the dump is stored, is protected

634 */

635 static void reserve_oldmem(void)

636 {

637 #ifdef CONFIG_CRASH_DUMP

638 if (OLDMEM_BASE)

639 /* Forget all memory above the running kdump system */

640 memblock_reserve(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);

641 #endif

642 }

643

644 /*

645 * Make sure that oldmem, where the dump is stored, is protected

646 */

647 static void remove_oldmem(void)

648 {

649 #ifdef CONFIG_CRASH_DUMP

650 if (OLDMEM_BASE)

651 /* Forget all memory above the running kdump system */

652 memblock_remove(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);

653 #endif

654 }

655

656 /*

657 * Reserve memory for kdump kernel to be loaded with kexec

658 */

659 static void __init reserve_crashkernel(void)

660 {

661 #ifdef CONFIG_CRASH_DUMP

662 unsigned long long crash_base, crash_size;

663 phys_addr_t low, high;

664 int rc;

665

666 rc = parse_crashkernel(boot_command_line, memory_end, &crash_size,

667 &crash_base);

668

669 crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);

670 crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);

671 if (rc || crash_size == 0)

672 return;

673

674 if (memblock.memory.regions[0].size < crash_size) {

675 pr_info("crashkernel reservation failed: %s\n",

676 "first memory chunk must be at least crashkernel size");

677 return;

678 }

679

680 low = crash_base ?: OLDMEM_BASE;

681 high = low + crash_size;

682 if (low >= OLDMEM_BASE && high <= OLDMEM_BASE + OLDMEM_SIZE) {

683 /* The crashkernel fits into OLDMEM, reuse OLDMEM */

684 crash_base = low;

685 } else {

686 /* Find suitable area in free memory */

687 low = max_t(unsigned long, crash_size, sclp.hsa_size);

688 high = crash_base ? crash_base + crash_size : ULONG_MAX;

689

690 if (crash_base && crash_base < low) {

691 pr_info("crashkernel reservation failed: %s\n",

692 "crash_base too low");

693 return;

694 }

695 low = crash_base ?: low;

696 crash_base = memblock_find_in_range(low, high, crash_size,

697 KEXEC_CRASH_MEM_ALIGN);

698 }

699

700 if (!crash_base) {

701 pr_info("crashkernel reservation failed: %s\n",

702 "no suitable area found");

703 return;

704 }

705

706 if (register_memory_notifier(&kdump_mem_nb))

707 return;

708

709 if (!OLDMEM_BASE && MACHINE_IS_VM)

710 diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));

711 crashk_res.start = crash_base;

712 crashk_res.end = crash_base + crash_size - 1;

713 memblock_remove(crash_base, crash_size);

714 pr_info("Reserving %lluMB of memory at %lluMB "

715 "for crashkernel (System RAM: %luMB)\n",

716 crash_size >> 20, crash_base >> 20,

717 (unsigned long)memblock.memory.total_size >> 20);

718 os_info_crashkernel_add(crash_base, crash_size);

719 #endif

720 }

721

722 /*

723 * Reserve the initrd from being used by memblock

724 */

725 static void __init reserve_initrd(void)

726 {

727 #ifdef CONFIG_BLK_DEV_INITRD

728 if (!INITRD_START || !INITRD_SIZE)

729 return;

730 initrd_start = INITRD_START;

731 initrd_end = initrd_start + INITRD_SIZE;

732 memblock_reserve(INITRD_START, INITRD_SIZE);

733 #endif

734 }

735

736 /*

737 * Reserve the memory area used to pass the certificate lists

738 */

739 static void __init reserve_certificate_list(void)

740 {

741 if (ipl_cert_list_addr)

742 memblock_reserve(ipl_cert_list_addr, ipl_cert_list_size);

743 }

744

745 static void __init reserve_mem_detect_info(void)

746 {

747 unsigned long start, size;

748

749 get_mem_detect_reserved(&start, &size);

750 if (size)

751 memblock_reserve(start, size);

752 }

753

754 static void __init free_mem_detect_info(void)

755 {

756 unsigned long start, size;

757

758 get_mem_detect_reserved(&start, &size);

759 if (size)

760 memblock_free(start, size);

761 }

762

763 static const char * __init get_mem_info_source(void)

764 {

765 switch (mem_detect.info_source) {

766 case MEM_DETECT_SCLP_STOR_INFO:

767 return "sclp storage info";

768 case MEM_DETECT_DIAG260:

769 return "diag260";

770 case MEM_DETECT_SCLP_READ_INFO:

771 return "sclp read info";

772 case MEM_DETECT_BIN_SEARCH:

773 return "binary search";

774 }

775 return "none";

776 }

777

778 static void __init memblock_add_mem_detect_info(void)

779 {

780 unsigned long start, end;

781 int i;

782

783 memblock_dbg("physmem info source: %s (%hhd)\n",

784 get_mem_info_source(), mem_detect.info_source);

785 /* keep memblock lists close to the kernel */

786 memblock_set_bottom_up(true);

787 for_each_mem_detect_block(i, &start, &end) {

788 memblock_add(start, end - start);

789 memblock_physmem_add(start, end - start);

790 }

791 memblock_set_bottom_up(false);

792 memblock_dump_all();

793 }

794

795 /*

796 * Check for initrd being in usable memory

797 */

798 static void __init check_initrd(void)

799 {

800 #ifdef CONFIG_BLK_DEV_INITRD

801 if (INITRD_START && INITRD_SIZE &&

802 !memblock_is_region_memory(INITRD_START, INITRD_SIZE)) {

803 pr_err("The initial RAM disk does not fit into the memory\n");

804 memblock_free(INITRD_START, INITRD_SIZE);

805 initrd_start = initrd_end = 0;

806 }

807 #endif

808 }

809

810 /*

811 * Reserve memory used for lowcore/command line/kernel image.

812 */

813 static void __init reserve_kernel(void)

814 {

815 unsigned long start_pfn = PFN_UP(__pa(_end));

816

817 memblock_reserve(0, HEAD_END);

818 memblock_reserve((unsigned long)_stext, PFN_PHYS(start_pfn)

819 - (unsigned long)_stext);

820 memblock_reserve(__sdma, __edma - __sdma);

821 }

822

823 static void __init setup_memory(void)

824 {

825 struct memblock_region *reg;

826

827 /*

828 * Init storage key for present memory

829 */

830 for_each_memblock(memory, reg) {

831 storage_key_init_range(reg->base, reg->base + reg->size);

832 }

833 psw_set_key(PAGE_DEFAULT_KEY);

834

835 /* Only cosmetics */

836 memblock_enforce_memory_limit(memblock_end_of_DRAM());

837 }

838

839 /*

840 * Setup hardware capabilities.

841 */

842 static int __init setup_hwcaps(void)

843 {

844 static const int stfl_bits[6] = { 0, 2, 7, 17, 19, 21 };

845 struct cpuid cpu_id;

846 int i;

847

848 /*

849 * The store facility list bits numbers as found in the principles

850 * of operation are numbered with bit 1UL<<31 as number 0 to

851 * bit 1UL<<0 as number 31.

852 * Bit 0: instructions named N3, "backported" to esa-mode

853 * Bit 2: z/Architecture mode is active

854 * Bit 7: the store-facility-list-extended facility is installed

855 * Bit 17: the message-security assist is installed

856 * Bit 19: the long-displacement facility is installed

857 * Bit 21: the extended-immediate facility is installed

858 * Bit 22: extended-translation facility 3 is installed

859 * Bit 30: extended-translation facility 3 enhancement facility

860 * These get translated to:

861 * HWCAP_S390_ESAN3 bit 0, HWCAP_S390_ZARCH bit 1,

862 * HWCAP_S390_STFLE bit 2, HWCAP_S390_MSA bit 3,

863 * HWCAP_S390_LDISP bit 4, HWCAP_S390_EIMM bit 5 and

864 * HWCAP_S390_ETF3EH bit 8 (22 && 30).

865 */

866 for (i = 0; i < 6; i++)

867 if (test_facility(stfl_bits[i]))

868 elf_hwcap |= 1UL << i;

869

870 if (test_facility(22) && test_facility(30))

871 elf_hwcap |= HWCAP_S390_ETF3EH;

872

873 /*

874 * Check for additional facilities with store-facility-list-extended.

875 * stfle stores doublewords (8 byte) with bit 1ULL<<63 as bit 0

876 * and 1ULL<<0 as bit 63. Bits 0-31 contain the same information

877 * as stored by stfl, bits 32-xxx contain additional facilities.

878 * How many facility words are stored depends on the number of

879 * doublewords passed to the instruction. The additional facilities

880 * are:

881 * Bit 42: decimal floating point facility is installed

882 * Bit 44: perform floating point operation facility is installed

883 * translated to:

884 * HWCAP_S390_DFP bit 6 (42 && 44).

885 */

886 if ((elf_hwcap & (1UL << 2)) && test_facility(42) && test_facility(44))

887 elf_hwcap |= HWCAP_S390_DFP;

888

889 /*

890 * Huge page support HWCAP_S390_HPAGE is bit 7.

891 */

892 if (MACHINE_HAS_EDAT1)

893 elf_hwcap |= HWCAP_S390_HPAGE;

894

895 /*

896 * 64-bit register support for 31-bit processes

897 * HWCAP_S390_HIGH_GPRS is bit 9.

898 */

899 elf_hwcap |= HWCAP_S390_HIGH_GPRS;

900

901 /*

902 * Transactional execution support HWCAP_S390_TE is bit 10.

903 */

904 if (MACHINE_HAS_TE)

905 elf_hwcap |= HWCAP_S390_TE;

906

907 /*

908 * Vector extension HWCAP_S390_VXRS is bit 11. The Vector extension

909 * can be disabled with the "novx" parameter. Use MACHINE_HAS_VX

910 * instead of facility bit 129.

911 */

912 if (MACHINE_HAS_VX) {

913 elf_hwcap |= HWCAP_S390_VXRS;

914 if (test_facility(134))

915 elf_hwcap |= HWCAP_S390_VXRS_EXT;

916 if (test_facility(135))

917 elf_hwcap |= HWCAP_S390_VXRS_BCD;

918 if (test_facility(148))

919 elf_hwcap |= HWCAP_S390_VXRS_EXT2;

920 if (test_facility(152))

921 elf_hwcap |= HWCAP_S390_VXRS_PDE;

922 }

923 if (test_facility(150))

924 elf_hwcap |= HWCAP_S390_SORT;

925 if (test_facility(151))

926 elf_hwcap |= HWCAP_S390_DFLT;

927

928 /*

929 * Guarded storage support HWCAP_S390_GS is bit 12.

930 */

931 if (MACHINE_HAS_GS)

932 elf_hwcap |= HWCAP_S390_GS;

933

934 get_cpu_id(&cpu_id);

935 add_device_randomness(&cpu_id, sizeof(cpu_id));

936 switch (cpu_id.machine) {

937 case 0x2064:

938 case 0x2066:

939 default: /* Use "z900" as default for 64 bit kernels. */

940 strcpy(elf_platform, "z900");

941 break;

942 case 0x2084:

943 case 0x2086:

944 strcpy(elf_platform, "z990");

945 break;

946 case 0x2094:

947 case 0x2096:

948 strcpy(elf_platform, "z9-109");

949 break;

950 case 0x2097:

951 case 0x2098:

952 strcpy(elf_platform, "z10");

953 break;

954 case 0x2817:

955 case 0x2818:

956 strcpy(elf_platform, "z196");

957 break;

958 case 0x2827:

959 case 0x2828:

960 strcpy(elf_platform, "zEC12");

961 break;

962 case 0x2964:

963 case 0x2965:

964 strcpy(elf_platform, "z13");

965 break;

966 case 0x3906:

967 case 0x3907:

968 strcpy(elf_platform, "z14");

969 break;

970 case 0x8561:

971 case 0x8562:

972 strcpy(elf_platform, "z15");

973 break;

974 }

975

976 /*

977 * Virtualization support HWCAP_INT_SIE is bit 0.

978 */

979 if (sclp.has_sief2)

980 int_hwcap |= HWCAP_INT_SIE;

981

982 return 0;

983 }

984 arch_initcall(setup_hwcaps);

985

986 /*

987 * Add system information as device randomness

988 */

989 static void __init setup_randomness(void)

990 {

991 struct sysinfo_3_2_2 *vmms;

992

993 vmms = (struct sysinfo_3_2_2 *) memblock_phys_alloc(PAGE_SIZE,

994 PAGE_SIZE);

995 if (!vmms)

996 panic("Failed to allocate memory for sysinfo structure\n");

997

998 if (stsi(vmms, 3, 2, 2) == 0 && vmms->count)

999 add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count);

1000 memblock_free((unsigned long) vmms, PAGE_SIZE);

1001 }

1002

1003 /*

1004 * Find the correct size for the task_struct. This depends on

1005 * the size of the struct fpu at the end of the thread_struct

1006 * which is embedded in the task_struct.

1007 */

1008 static void __init setup_task_size(void)

1009 {

1010 int task_size = sizeof(struct task_struct);

1011

1012 if (!MACHINE_HAS_VX) {

1013 task_size -= sizeof(__vector128) * __NUM_VXRS;

1014 task_size += sizeof(freg_t) * __NUM_FPRS;

1015 }

1016 arch_task_struct_size = task_size;

1017 }

1018

1019 /*

1020 * Issue diagnose 318 to set the control program name and

1021 * version codes.

1022 */

1023 static void __init setup_control_program_code(void)

1024 {

1025 union diag318_info diag318_info = {

1026 .cpnc = CPNC_LINUX,

1027 .cpvc_linux = 0,

1028 .cpvc_distro = {0},

1029 };

1030

1031 if (!sclp.has_diag318)

1032 return;

1033

1034 diag_stat_inc(DIAG_STAT_X318);

1035 asm volatile("diag %0,0,0x318\n" : : "d" (diag318_info.val));

1036 }

1037

1038 /*

1039 * Print the component list from the IPL report

1040 */

1041 static void __init log_component_list(void)

1042 {

1043 struct ipl_rb_component_entry *ptr, *end;

1044 char *str;

1045

1046 if (!early_ipl_comp_list_addr)

1047 return;

1048 if (ipl_block.hdr.flags & IPL_PL_FLAG_SIPL)

1049 pr_info("Linux is running with Secure-IPL enabled\n");

1050 else

1051 pr_info("Linux is running with Secure-IPL disabled\n");

1052 ptr = (void *) early_ipl_comp_list_addr;

1053 end = (void *) ptr + early_ipl_comp_list_size;

1054 pr_info("The IPL report contains the following components:\n");

1055 while (ptr < end) {

1056 if (ptr->flags & IPL_RB_COMPONENT_FLAG_SIGNED) {

1057 if (ptr->flags & IPL_RB_COMPONENT_FLAG_VERIFIED)

1058 str = "signed, verified";

1059 else

1060 str = "signed, verification failed";

1061 } else {

1062 str = "not signed";

1063 }

1064 pr_info("%016llx - %016llx (%s)\n",

1065 ptr->addr, ptr->addr + ptr->len, str);

1066 ptr++;

1067 }

1068 }

1069

1070 /*

1071 * Setup function called from init/main.c just after the banner

1072 * was printed.

1073 */

1074

1075 void __init setup_arch(char **cmdline_p)

1076 {

1077 /*

1078 * print what head.S has found out about the machine

1079 */

1080 if (MACHINE_IS_VM)

1081 pr_info("Linux is running as a z/VM "

1082 "guest operating system in 64-bit mode\n");

1083 else if (MACHINE_IS_KVM)

1084 pr_info("Linux is running under KVM in 64-bit mode\n");

1085 else if (MACHINE_IS_LPAR)

1086 pr_info("Linux is running natively in 64-bit mode\n");

1087 else

1088 pr_info("Linux is running as a guest in 64-bit mode\n");

1089

1090 log_component_list();

1091

1092 /* Have one command line that is parsed and saved in /proc/cmdline */

1093 /* boot_command_line has been already set up in early.c */

1094 *cmdline_p = boot_command_line;

1095

1096 ROOT_DEV = Root_RAM0;

1097

1098 init_mm.start_code = (unsigned long) _text;

1099 init_mm.end_code = (unsigned long) _etext;

1100 init_mm.end_data = (unsigned long) _edata;

1101 init_mm.brk = (unsigned long) _end;

1102

1103 if (IS_ENABLED(CONFIG_EXPOLINE_AUTO))

1104 nospec_auto_detect();

1105

1106 parse_early_param();

1107 #ifdef CONFIG_CRASH_DUMP

1108 /* Deactivate elfcorehdr= kernel parameter */

1109 elfcorehdr_addr = ELFCORE_ADDR_MAX;

1110 #endif

1111

1112 os_info_init();

1113 setup_ipl();

1114 setup_task_size();

1115 setup_control_program_code();

1116

1117 /* Do some memory reservations *before* memory is added to memblock */

1118 reserve_memory_end();

1119 reserve_oldmem();

1120 reserve_kernel();

1121 reserve_initrd();

1122 reserve_certificate_list();

1123 reserve_mem_detect_info();

1124 memblock_allow_resize();

1125

1126 /* Get information about *all* installed memory */

1127 memblock_add_mem_detect_info();

1128

1129 free_mem_detect_info();

1130 remove_oldmem();

1131

1132 /*

1133 * Make sure all chunks are MAX_ORDER aligned so we don't need the

1134 * extra checks that HOLES_IN_ZONE would require.

1135 *

1136 * Is this still required?

1137 */

1138 memblock_trim_memory(1UL << (MAX_ORDER - 1 + PAGE_SHIFT));

1139

1140 if (is_prot_virt_host())

1141 setup_uv();

1142 setup_memory_end();

1143 setup_memory();

1144 dma_contiguous_reserve(memory_end);

1145 vmcp_cma_reserve();

1146

1147 check_initrd();

1148 reserve_crashkernel();

1149 #ifdef CONFIG_CRASH_DUMP

1150 /*

1151 * Be aware that smp_save_dump_cpus() triggers a system reset.

1152 * Therefore CPU and device initialization should be done afterwards.

1153 */

1154 smp_save_dump_cpus();

1155 #endif

1156

1157 setup_resources();

1158 setup_lowcore_dat_off();

1159 smp_fill_possible_mask();

1160 cpu_detect_mhz_feature();

1161 cpu_init();

1162 numa_setup();

1163 smp_detect_cpus();

1164 topology_init_early();

1165

1166 /*

1167 * Create kernel page tables and switch to virtual addressing.

1168 */

1169 paging_init();

1170

1171 /*

1172 * After paging_init created the kernel page table, the new PSWs

1173 * in lowcore can now run with DAT enabled.

1174 */

1175 setup_lowcore_dat_on();

1176

1177 /* Setup default console */

1178 conmode_default();

1179 set_preferred_console();

1180

1181 apply_alternative_instructions();

1182 if (IS_ENABLED(CONFIG_EXPOLINE))

1183 nospec_init_branches();

1184

1185 /* Setup zfcpdump support */

1186 setup_zfcpdump();

1187

1188 /* Add system specific data to the random pool */

1189 setup_randomness();

1190 }