~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/setup.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  S390 version
  3  *    Copyright IBM Corp. 1999, 2012
  4  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  5  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  6  *
  7  *  Derived from "arch/i386/kernel/setup.c"
  8  *    Copyright (C) 1995, Linus Torvalds
  9  */
 10 
 11 /*
 12  * This file handles the architecture-dependent parts of initialization
 13  */
 14 
 15 #define KMSG_COMPONENT "setup"
 16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 17 
 18 #include <linux/errno.h>
 19 #include <linux/export.h>
 20 #include <linux/sched.h>
 21 #include <linux/kernel.h>
 22 #include <linux/memblock.h>
 23 #include <linux/mm.h>
 24 #include <linux/stddef.h>
 25 #include <linux/unistd.h>
 26 #include <linux/ptrace.h>
 27 #include <linux/random.h>
 28 #include <linux/user.h>
 29 #include <linux/tty.h>
 30 #include <linux/ioport.h>
 31 #include <linux/delay.h>
 32 #include <linux/init.h>
 33 #include <linux/initrd.h>
 34 #include <linux/bootmem.h>
 35 #include <linux/root_dev.h>
 36 #include <linux/console.h>
 37 #include <linux/kernel_stat.h>
 38 #include <linux/dma-contiguous.h>
 39 #include <linux/device.h>
 40 #include <linux/notifier.h>
 41 #include <linux/pfn.h>
 42 #include <linux/ctype.h>
 43 #include <linux/reboot.h>
 44 #include <linux/topology.h>
 45 #include <linux/kexec.h>
 46 #include <linux/crash_dump.h>
 47 #include <linux/memory.h>
 48 #include <linux/compat.h>
 49 
 50 #include <asm/ipl.h>
 51 #include <asm/facility.h>
 52 #include <asm/smp.h>
 53 #include <asm/mmu_context.h>
 54 #include <asm/cpcmd.h>
 55 #include <asm/lowcore.h>
 56 #include <asm/irq.h>
 57 #include <asm/page.h>
 58 #include <asm/ptrace.h>
 59 #include <asm/sections.h>
 60 #include <asm/ebcdic.h>
 61 #include <asm/kvm_virtio.h>
 62 #include <asm/diag.h>
 63 #include <asm/os_info.h>
 64 #include <asm/sclp.h>
 65 #include <asm/sysinfo.h>
 66 #include <asm/numa.h>
 67 #include "entry.h"
 68 
 69 /*
 70  * Machine setup..
 71  */
 72 unsigned int console_mode = 0;
 73 EXPORT_SYMBOL(console_mode);
 74 
 75 unsigned int console_devno = -1;
 76 EXPORT_SYMBOL(console_devno);
 77 
 78 unsigned int console_irq = -1;
 79 EXPORT_SYMBOL(console_irq);
 80 
 81 unsigned long elf_hwcap __read_mostly = 0;
 82 char elf_platform[ELF_PLATFORM_SIZE];
 83 
 84 unsigned long int_hwcap = 0;
 85 
 86 int __initdata memory_end_set;
 87 unsigned long __initdata memory_end;
 88 unsigned long __initdata max_physmem_end;
 89 
 90 unsigned long VMALLOC_START;
 91 EXPORT_SYMBOL(VMALLOC_START);
 92 
 93 unsigned long VMALLOC_END;
 94 EXPORT_SYMBOL(VMALLOC_END);
 95 
 96 struct page *vmemmap;
 97 EXPORT_SYMBOL(vmemmap);
 98 
 99 unsigned long MODULES_VADDR;
100 unsigned long MODULES_END;
101 
102 /* An array with a pointer to the lowcore of every CPU. */
103 struct lowcore *lowcore_ptr[NR_CPUS];
104 EXPORT_SYMBOL(lowcore_ptr);
105 
106 /*
107  * This is set up by the setup-routine at boot-time
108  * for S390 need to find out, what we have to setup
109  * using address 0x10400 ...
110  */
111 
112 #include <asm/setup.h>
113 
114 /*
115  * condev= and conmode= setup parameter.
116  */
117 
118 static int __init condev_setup(char *str)
119 {
120         int vdev;
121 
122         vdev = simple_strtoul(str, &str, 0);
123         if (vdev >= 0 && vdev < 65536) {
124                 console_devno = vdev;
125                 console_irq = -1;
126         }
127         return 1;
128 }
129 
130 __setup("condev=", condev_setup);
131 
132 static void __init set_preferred_console(void)
133 {
134         if (CONSOLE_IS_3215 || CONSOLE_IS_SCLP)
135                 add_preferred_console("ttyS", 0, NULL);
136         else if (CONSOLE_IS_3270)
137                 add_preferred_console("tty3270", 0, NULL);
138         else if (CONSOLE_IS_VT220)
139                 add_preferred_console("ttyS", 1, NULL);
140         else if (CONSOLE_IS_HVC)
141                 add_preferred_console("hvc", 0, NULL);
142 }
143 
144 static int __init conmode_setup(char *str)
145 {
146 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
147         if (strncmp(str, "hwc", 4) == 0 || strncmp(str, "sclp", 5) == 0)
148                 SET_CONSOLE_SCLP;
149 #endif
150 #if defined(CONFIG_TN3215_CONSOLE)
151         if (strncmp(str, "3215", 5) == 0)
152                 SET_CONSOLE_3215;
153 #endif
154 #if defined(CONFIG_TN3270_CONSOLE)
155         if (strncmp(str, "3270", 5) == 0)
156                 SET_CONSOLE_3270;
157 #endif
158         set_preferred_console();
159         return 1;
160 }
161 
162 __setup("conmode=", conmode_setup);
163 
164 static void __init conmode_default(void)
165 {
166         char query_buffer[1024];
167         char *ptr;
168 
169         if (MACHINE_IS_VM) {
170                 cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);
171                 console_devno = simple_strtoul(query_buffer + 5, NULL, 16);
172                 ptr = strstr(query_buffer, "SUBCHANNEL =");
173                 console_irq = simple_strtoul(ptr + 13, NULL, 16);
174                 cpcmd("QUERY TERM", query_buffer, 1024, NULL);
175                 ptr = strstr(query_buffer, "CONMODE");
176                 /*
177                  * Set the conmode to 3215 so that the device recognition 
178                  * will set the cu_type of the console to 3215. If the
179                  * conmode is 3270 and we don't set it back then both
180                  * 3215 and the 3270 driver will try to access the console
181                  * device (3215 as console and 3270 as normal tty).
182                  */
183                 cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
184                 if (ptr == NULL) {
185 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
186                         SET_CONSOLE_SCLP;
187 #endif
188                         return;
189                 }
190                 if (strncmp(ptr + 8, "3270", 4) == 0) {
191 #if defined(CONFIG_TN3270_CONSOLE)
192                         SET_CONSOLE_3270;
193 #elif defined(CONFIG_TN3215_CONSOLE)
194                         SET_CONSOLE_3215;
195 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
196                         SET_CONSOLE_SCLP;
197 #endif
198                 } else if (strncmp(ptr + 8, "3215", 4) == 0) {
199 #if defined(CONFIG_TN3215_CONSOLE)
200                         SET_CONSOLE_3215;
201 #elif defined(CONFIG_TN3270_CONSOLE)
202                         SET_CONSOLE_3270;
203 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
204                         SET_CONSOLE_SCLP;
205 #endif
206                 }
207         } else if (MACHINE_IS_KVM) {
208                 if (sclp.has_vt220 && IS_ENABLED(CONFIG_SCLP_VT220_CONSOLE))
209                         SET_CONSOLE_VT220;
210                 else if (sclp.has_linemode && IS_ENABLED(CONFIG_SCLP_CONSOLE))
211                         SET_CONSOLE_SCLP;
212                 else
213                         SET_CONSOLE_HVC;
214         } else {
215 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
216                 SET_CONSOLE_SCLP;
217 #endif
218         }
219 }
220 
221 #ifdef CONFIG_CRASH_DUMP
222 static void __init setup_zfcpdump(void)
223 {
224         if (ipl_info.type != IPL_TYPE_FCP_DUMP)
225                 return;
226         if (OLDMEM_BASE)
227                 return;
228         strcat(boot_command_line, " cio_ignore=all,!ipldev,!condev");
229         console_loglevel = 2;
230 }
231 #else
232 static inline void setup_zfcpdump(void) {}
233 #endif /* CONFIG_CRASH_DUMP */
234 
235  /*
236  * Reboot, halt and power_off stubs. They just call _machine_restart,
237  * _machine_halt or _machine_power_off. 
238  */
239 
240 void machine_restart(char *command)
241 {
242         if ((!in_interrupt() && !in_atomic()) || oops_in_progress)
243                 /*
244                  * Only unblank the console if we are called in enabled
245                  * context or a bust_spinlocks cleared the way for us.
246                  */
247                 console_unblank();
248         _machine_restart(command);
249 }
250 
251 void machine_halt(void)
252 {
253         if (!in_interrupt() || oops_in_progress)
254                 /*
255                  * Only unblank the console if we are called in enabled
256                  * context or a bust_spinlocks cleared the way for us.
257                  */
258                 console_unblank();
259         _machine_halt();
260 }
261 
262 void machine_power_off(void)
263 {
264         if (!in_interrupt() || oops_in_progress)
265                 /*
266                  * Only unblank the console if we are called in enabled
267                  * context or a bust_spinlocks cleared the way for us.
268                  */
269                 console_unblank();
270         _machine_power_off();
271 }
272 
273 /*
274  * Dummy power off function.
275  */
276 void (*pm_power_off)(void) = machine_power_off;
277 EXPORT_SYMBOL_GPL(pm_power_off);
278 
279 static int __init early_parse_mem(char *p)
280 {
281         memory_end = memparse(p, &p);
282         memory_end &= PAGE_MASK;
283         memory_end_set = 1;
284         return 0;
285 }
286 early_param("mem", early_parse_mem);
287 
288 static int __init parse_vmalloc(char *arg)
289 {
290         if (!arg)
291                 return -EINVAL;
292         VMALLOC_END = (memparse(arg, &arg) + PAGE_SIZE - 1) & PAGE_MASK;
293         return 0;
294 }
295 early_param("vmalloc", parse_vmalloc);
296 
297 void *restart_stack __section(.data);
298 
299 static void __init setup_lowcore(void)
300 {
301         struct lowcore *lc;
302 
303         /*
304          * Setup lowcore for boot cpu
305          */
306         BUILD_BUG_ON(sizeof(struct lowcore) != LC_PAGES * 4096);
307         lc = memblock_virt_alloc_low(sizeof(*lc), sizeof(*lc));
308         lc->restart_psw.mask = PSW_KERNEL_BITS;
309         lc->restart_psw.addr = (unsigned long) restart_int_handler;
310         lc->external_new_psw.mask = PSW_KERNEL_BITS |
311                 PSW_MASK_DAT | PSW_MASK_MCHECK;
312         lc->external_new_psw.addr = (unsigned long) ext_int_handler;
313         lc->svc_new_psw.mask = PSW_KERNEL_BITS |
314                 PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
315         lc->svc_new_psw.addr = (unsigned long) system_call;
316         lc->program_new_psw.mask = PSW_KERNEL_BITS |
317                 PSW_MASK_DAT | PSW_MASK_MCHECK;
318         lc->program_new_psw.addr = (unsigned long) pgm_check_handler;
319         lc->mcck_new_psw.mask = PSW_KERNEL_BITS;
320         lc->mcck_new_psw.addr = (unsigned long) mcck_int_handler;
321         lc->io_new_psw.mask = PSW_KERNEL_BITS |
322                 PSW_MASK_DAT | PSW_MASK_MCHECK;
323         lc->io_new_psw.addr = (unsigned long) io_int_handler;
324         lc->clock_comparator = -1ULL;
325         lc->kernel_stack = ((unsigned long) &init_thread_union)
326                 + THREAD_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
327         lc->async_stack = (unsigned long)
328                 memblock_virt_alloc(ASYNC_SIZE, ASYNC_SIZE)
329                 + ASYNC_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
330         lc->panic_stack = (unsigned long)
331                 memblock_virt_alloc(PAGE_SIZE, PAGE_SIZE)
332                 + PAGE_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
333         lc->current_task = (unsigned long)&init_task;
334         lc->lpp = LPP_MAGIC;
335         lc->machine_flags = S390_lowcore.machine_flags;
336         lc->preempt_count = S390_lowcore.preempt_count;
337         lc->stfl_fac_list = S390_lowcore.stfl_fac_list;
338         memcpy(lc->stfle_fac_list, S390_lowcore.stfle_fac_list,
339                MAX_FACILITY_BIT/8);
340         if (MACHINE_HAS_VX)
341                 lc->vector_save_area_addr =
342                         (unsigned long) &lc->vector_save_area;
343         lc->vdso_per_cpu_data = (unsigned long) &lc->paste[0];
344         lc->sync_enter_timer = S390_lowcore.sync_enter_timer;
345         lc->async_enter_timer = S390_lowcore.async_enter_timer;
346         lc->exit_timer = S390_lowcore.exit_timer;
347         lc->user_timer = S390_lowcore.user_timer;
348         lc->system_timer = S390_lowcore.system_timer;
349         lc->steal_timer = S390_lowcore.steal_timer;
350         lc->last_update_timer = S390_lowcore.last_update_timer;
351         lc->last_update_clock = S390_lowcore.last_update_clock;
352 
353         restart_stack = memblock_virt_alloc(ASYNC_SIZE, ASYNC_SIZE);
354         restart_stack += ASYNC_SIZE;
355 
356         /*
357          * Set up PSW restart to call ipl.c:do_restart(). Copy the relevant
358          * restart data to the absolute zero lowcore. This is necessary if
359          * PSW restart is done on an offline CPU that has lowcore zero.
360          */
361         lc->restart_stack = (unsigned long) restart_stack;
362         lc->restart_fn = (unsigned long) do_restart;
363         lc->restart_data = 0;
364         lc->restart_source = -1UL;
365 
366         /* Setup absolute zero lowcore */
367         mem_assign_absolute(S390_lowcore.restart_stack, lc->restart_stack);
368         mem_assign_absolute(S390_lowcore.restart_fn, lc->restart_fn);
369         mem_assign_absolute(S390_lowcore.restart_data, lc->restart_data);
370         mem_assign_absolute(S390_lowcore.restart_source, lc->restart_source);
371         mem_assign_absolute(S390_lowcore.restart_psw, lc->restart_psw);
372 
373 #ifdef CONFIG_SMP
374         lc->spinlock_lockval = arch_spin_lockval(0);
375 #endif
376 
377         set_prefix((u32)(unsigned long) lc);
378         lowcore_ptr[0] = lc;
379 }
380 
381 static struct resource code_resource = {
382         .name  = "Kernel code",
383         .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
384 };
385 
386 static struct resource data_resource = {
387         .name = "Kernel data",
388         .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
389 };
390 
391 static struct resource bss_resource = {
392         .name = "Kernel bss",
393         .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
394 };
395 
396 static struct resource __initdata *standard_resources[] = {
397         &code_resource,
398         &data_resource,
399         &bss_resource,
400 };
401 
402 static void __init setup_resources(void)
403 {
404         struct resource *res, *std_res, *sub_res;
405         struct memblock_region *reg;
406         int j;
407 
408         code_resource.start = (unsigned long) &_text;
409         code_resource.end = (unsigned long) &_etext - 1;
410         data_resource.start = (unsigned long) &_etext;
411         data_resource.end = (unsigned long) &_edata - 1;
412         bss_resource.start = (unsigned long) &__bss_start;
413         bss_resource.end = (unsigned long) &__bss_stop - 1;
414 
415         for_each_memblock(memory, reg) {
416                 res = memblock_virt_alloc(sizeof(*res), 8);
417                 res->flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM;
418 
419                 res->name = "System RAM";
420                 res->start = reg->base;
421                 res->end = reg->base + reg->size - 1;
422                 request_resource(&iomem_resource, res);
423 
424                 for (j = 0; j < ARRAY_SIZE(standard_resources); j++) {
425                         std_res = standard_resources[j];
426                         if (std_res->start < res->start ||
427                             std_res->start > res->end)
428                                 continue;
429                         if (std_res->end > res->end) {
430                                 sub_res = memblock_virt_alloc(sizeof(*sub_res), 8);
431                                 *sub_res = *std_res;
432                                 sub_res->end = res->end;
433                                 std_res->start = res->end + 1;
434                                 request_resource(res, sub_res);
435                         } else {
436                                 request_resource(res, std_res);
437                         }
438                 }
439         }
440 #ifdef CONFIG_CRASH_DUMP
441         /*
442          * Re-add removed crash kernel memory as reserved memory. This makes
443          * sure it will be mapped with the identity mapping and struct pages
444          * will be created, so it can be resized later on.
445          * However add it later since the crash kernel resource should not be
446          * part of the System RAM resource.
447          */
448         if (crashk_res.end) {
449                 memblock_add_node(crashk_res.start, resource_size(&crashk_res), 0);
450                 memblock_reserve(crashk_res.start, resource_size(&crashk_res));
451                 insert_resource(&iomem_resource, &crashk_res);
452         }
453 #endif
454 }
455 
456 static void __init setup_memory_end(void)
457 {
458         unsigned long vmax, vmalloc_size, tmp;
459 
460         /* Choose kernel address space layout: 2, 3, or 4 levels. */
461         vmalloc_size = VMALLOC_END ?: (128UL << 30) - MODULES_LEN;
462         tmp = (memory_end ?: max_physmem_end) / PAGE_SIZE;
463         tmp = tmp * (sizeof(struct page) + PAGE_SIZE);
464         if (tmp + vmalloc_size + MODULES_LEN <= (1UL << 42))
465                 vmax = 1UL << 42;       /* 3-level kernel page table */
466         else
467                 vmax = 1UL << 53;       /* 4-level kernel page table */
468         /* module area is at the end of the kernel address space. */
469         MODULES_END = vmax;
470         MODULES_VADDR = MODULES_END - MODULES_LEN;
471         VMALLOC_END = MODULES_VADDR;
472         VMALLOC_START = vmax - vmalloc_size;
473 
474         /* Split remaining virtual space between 1:1 mapping & vmemmap array */
475         tmp = VMALLOC_START / (PAGE_SIZE + sizeof(struct page));
476         /* vmemmap contains a multiple of PAGES_PER_SECTION struct pages */
477         tmp = SECTION_ALIGN_UP(tmp);
478         tmp = VMALLOC_START - tmp * sizeof(struct page);
479         tmp &= ~((vmax >> 11) - 1);     /* align to page table level */
480         tmp = min(tmp, 1UL << MAX_PHYSMEM_BITS);
481         vmemmap = (struct page *) tmp;
482 
483         /* Take care that memory_end is set and <= vmemmap */
484         memory_end = min(memory_end ?: max_physmem_end, tmp);
485         max_pfn = max_low_pfn = PFN_DOWN(memory_end);
486         memblock_remove(memory_end, ULONG_MAX);
487 
488         pr_notice("The maximum memory size is %luMB\n", memory_end >> 20);
489 }
490 
491 static void __init setup_vmcoreinfo(void)
492 {
493         mem_assign_absolute(S390_lowcore.vmcore_info, paddr_vmcoreinfo_note());
494 }
495 
496 #ifdef CONFIG_CRASH_DUMP
497 
498 /*
499  * When kdump is enabled, we have to ensure that no memory from
500  * the area [0 - crashkernel memory size] and
501  * [crashk_res.start - crashk_res.end] is set offline.
502  */
503 static int kdump_mem_notifier(struct notifier_block *nb,
504                               unsigned long action, void *data)
505 {
506         struct memory_notify *arg = data;
507 
508         if (action != MEM_GOING_OFFLINE)
509                 return NOTIFY_OK;
510         if (arg->start_pfn < PFN_DOWN(resource_size(&crashk_res)))
511                 return NOTIFY_BAD;
512         if (arg->start_pfn > PFN_DOWN(crashk_res.end))
513                 return NOTIFY_OK;
514         if (arg->start_pfn + arg->nr_pages - 1 < PFN_DOWN(crashk_res.start))
515                 return NOTIFY_OK;
516         return NOTIFY_BAD;
517 }
518 
519 static struct notifier_block kdump_mem_nb = {
520         .notifier_call = kdump_mem_notifier,
521 };
522 
523 #endif
524 
525 /*
526  * Make sure that the area behind memory_end is protected
527  */
528 static void reserve_memory_end(void)
529 {
530 #ifdef CONFIG_CRASH_DUMP
531         if (ipl_info.type == IPL_TYPE_FCP_DUMP &&
532             !OLDMEM_BASE && sclp.hsa_size) {
533                 memory_end = sclp.hsa_size;
534                 memory_end &= PAGE_MASK;
535                 memory_end_set = 1;
536         }
537 #endif
538         if (!memory_end_set)
539                 return;
540         memblock_reserve(memory_end, ULONG_MAX);
541 }
542 
543 /*
544  * Make sure that oldmem, where the dump is stored, is protected
545  */
546 static void reserve_oldmem(void)
547 {
548 #ifdef CONFIG_CRASH_DUMP
549         if (OLDMEM_BASE)
550                 /* Forget all memory above the running kdump system */
551                 memblock_reserve(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);
552 #endif
553 }
554 
555 /*
556  * Make sure that oldmem, where the dump is stored, is protected
557  */
558 static void remove_oldmem(void)
559 {
560 #ifdef CONFIG_CRASH_DUMP
561         if (OLDMEM_BASE)
562                 /* Forget all memory above the running kdump system */
563                 memblock_remove(OLDMEM_SIZE, (phys_addr_t)ULONG_MAX);
564 #endif
565 }
566 
567 /*
568  * Reserve memory for kdump kernel to be loaded with kexec
569  */
570 static void __init reserve_crashkernel(void)
571 {
572 #ifdef CONFIG_CRASH_DUMP
573         unsigned long long crash_base, crash_size;
574         phys_addr_t low, high;
575         int rc;
576 
577         rc = parse_crashkernel(boot_command_line, memory_end, &crash_size,
578                                &crash_base);
579 
580         crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);
581         crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);
582         if (rc || crash_size == 0)
583                 return;
584 
585         if (memblock.memory.regions[0].size < crash_size) {
586                 pr_info("crashkernel reservation failed: %s\n",
587                         "first memory chunk must be at least crashkernel size");
588                 return;
589         }
590 
591         low = crash_base ?: OLDMEM_BASE;
592         high = low + crash_size;
593         if (low >= OLDMEM_BASE && high <= OLDMEM_BASE + OLDMEM_SIZE) {
594                 /* The crashkernel fits into OLDMEM, reuse OLDMEM */
595                 crash_base = low;
596         } else {
597                 /* Find suitable area in free memory */
598                 low = max_t(unsigned long, crash_size, sclp.hsa_size);
599                 high = crash_base ? crash_base + crash_size : ULONG_MAX;
600 
601                 if (crash_base && crash_base < low) {
602                         pr_info("crashkernel reservation failed: %s\n",
603                                 "crash_base too low");
604                         return;
605                 }
606                 low = crash_base ?: low;
607                 crash_base = memblock_find_in_range(low, high, crash_size,
608                                                     KEXEC_CRASH_MEM_ALIGN);
609         }
610 
611         if (!crash_base) {
612                 pr_info("crashkernel reservation failed: %s\n",
613                         "no suitable area found");
614                 return;
615         }
616 
617         if (register_memory_notifier(&kdump_mem_nb))
618                 return;
619 
620         if (!OLDMEM_BASE && MACHINE_IS_VM)
621                 diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));
622         crashk_res.start = crash_base;
623         crashk_res.end = crash_base + crash_size - 1;
624         memblock_remove(crash_base, crash_size);
625         pr_info("Reserving %lluMB of memory at %lluMB "
626                 "for crashkernel (System RAM: %luMB)\n",
627                 crash_size >> 20, crash_base >> 20,
628                 (unsigned long)memblock.memory.total_size >> 20);
629         os_info_crashkernel_add(crash_base, crash_size);
630 #endif
631 }
632 
633 /*
634  * Reserve the initrd from being used by memblock
635  */
636 static void __init reserve_initrd(void)
637 {
638 #ifdef CONFIG_BLK_DEV_INITRD
639         initrd_start = INITRD_START;
640         initrd_end = initrd_start + INITRD_SIZE;
641         memblock_reserve(INITRD_START, INITRD_SIZE);
642 #endif
643 }
644 
645 /*
646  * Check for initrd being in usable memory
647  */
648 static void __init check_initrd(void)
649 {
650 #ifdef CONFIG_BLK_DEV_INITRD
651         if (INITRD_START && INITRD_SIZE &&
652             !memblock_is_region_memory(INITRD_START, INITRD_SIZE)) {
653                 pr_err("The initial RAM disk does not fit into the memory\n");
654                 memblock_free(INITRD_START, INITRD_SIZE);
655                 initrd_start = initrd_end = 0;
656         }
657 #endif
658 }
659 
660 /*
661  * Reserve memory used for lowcore/command line/kernel image.
662  */
663 static void __init reserve_kernel(void)
664 {
665         unsigned long start_pfn = PFN_UP(__pa(&_end));
666 
667 #ifdef CONFIG_DMA_API_DEBUG
668         /*
669          * DMA_API_DEBUG code stumbles over addresses from the
670          * range [_ehead, _stext]. Mark the memory as reserved
671          * so it is not used for CONFIG_DMA_API_DEBUG=y.
672          */
673         memblock_reserve(0, PFN_PHYS(start_pfn));
674 #else
675         memblock_reserve(0, (unsigned long)_ehead);
676         memblock_reserve((unsigned long)_stext, PFN_PHYS(start_pfn)
677                          - (unsigned long)_stext);
678 #endif
679 }
680 
681 static void __init setup_memory(void)
682 {
683         struct memblock_region *reg;
684 
685         /*
686          * Init storage key for present memory
687          */
688         for_each_memblock(memory, reg) {
689                 storage_key_init_range(reg->base, reg->base + reg->size);
690         }
691         psw_set_key(PAGE_DEFAULT_KEY);
692 
693         /* Only cosmetics */
694         memblock_enforce_memory_limit(memblock_end_of_DRAM());
695 }
696 
697 /*
698  * Setup hardware capabilities.
699  */
700 static int __init setup_hwcaps(void)
701 {
702         static const int stfl_bits[6] = { 0, 2, 7, 17, 19, 21 };
703         struct cpuid cpu_id;
704         int i;
705 
706         /*
707          * The store facility list bits numbers as found in the principles
708          * of operation are numbered with bit 1UL<<31 as number 0 to
709          * bit 1UL<<0 as number 31.
710          *   Bit 0: instructions named N3, "backported" to esa-mode
711          *   Bit 2: z/Architecture mode is active
712          *   Bit 7: the store-facility-list-extended facility is installed
713          *   Bit 17: the message-security assist is installed
714          *   Bit 19: the long-displacement facility is installed
715          *   Bit 21: the extended-immediate facility is installed
716          *   Bit 22: extended-translation facility 3 is installed
717          *   Bit 30: extended-translation facility 3 enhancement facility
718          * These get translated to:
719          *   HWCAP_S390_ESAN3 bit 0, HWCAP_S390_ZARCH bit 1,
720          *   HWCAP_S390_STFLE bit 2, HWCAP_S390_MSA bit 3,
721          *   HWCAP_S390_LDISP bit 4, HWCAP_S390_EIMM bit 5 and
722          *   HWCAP_S390_ETF3EH bit 8 (22 && 30).
723          */
724         for (i = 0; i < 6; i++)
725                 if (test_facility(stfl_bits[i]))
726                         elf_hwcap |= 1UL << i;
727 
728         if (test_facility(22) && test_facility(30))
729                 elf_hwcap |= HWCAP_S390_ETF3EH;
730 
731         /*
732          * Check for additional facilities with store-facility-list-extended.
733          * stfle stores doublewords (8 byte) with bit 1ULL<<63 as bit 0
734          * and 1ULL<<0 as bit 63. Bits 0-31 contain the same information
735          * as stored by stfl, bits 32-xxx contain additional facilities.
736          * How many facility words are stored depends on the number of
737          * doublewords passed to the instruction. The additional facilities
738          * are:
739          *   Bit 42: decimal floating point facility is installed
740          *   Bit 44: perform floating point operation facility is installed
741          * translated to:
742          *   HWCAP_S390_DFP bit 6 (42 && 44).
743          */
744         if ((elf_hwcap & (1UL << 2)) && test_facility(42) && test_facility(44))
745                 elf_hwcap |= HWCAP_S390_DFP;
746 
747         /*
748          * Huge page support HWCAP_S390_HPAGE is bit 7.
749          */
750         if (MACHINE_HAS_HPAGE)
751                 elf_hwcap |= HWCAP_S390_HPAGE;
752 
753         /*
754          * 64-bit register support for 31-bit processes
755          * HWCAP_S390_HIGH_GPRS is bit 9.
756          */
757         elf_hwcap |= HWCAP_S390_HIGH_GPRS;
758 
759         /*
760          * Transactional execution support HWCAP_S390_TE is bit 10.
761          */
762         if (test_facility(50) && test_facility(73))
763                 elf_hwcap |= HWCAP_S390_TE;
764 
765         /*
766          * Vector extension HWCAP_S390_VXRS is bit 11. The Vector extension
767          * can be disabled with the "novx" parameter. Use MACHINE_HAS_VX
768          * instead of facility bit 129.
769          */
770         if (MACHINE_HAS_VX)
771                 elf_hwcap |= HWCAP_S390_VXRS;
772         get_cpu_id(&cpu_id);
773         add_device_randomness(&cpu_id, sizeof(cpu_id));
774         switch (cpu_id.machine) {
775         case 0x2064:
776         case 0x2066:
777         default:        /* Use "z900" as default for 64 bit kernels. */
778                 strcpy(elf_platform, "z900");
779                 break;
780         case 0x2084:
781         case 0x2086:
782                 strcpy(elf_platform, "z990");
783                 break;
784         case 0x2094:
785         case 0x2096:
786                 strcpy(elf_platform, "z9-109");
787                 break;
788         case 0x2097:
789         case 0x2098:
790                 strcpy(elf_platform, "z10");
791                 break;
792         case 0x2817:
793         case 0x2818:
794                 strcpy(elf_platform, "z196");
795                 break;
796         case 0x2827:
797         case 0x2828:
798                 strcpy(elf_platform, "zEC12");
799                 break;
800         case 0x2964:
801         case 0x2965:
802                 strcpy(elf_platform, "z13");
803                 break;
804         }
805 
806         /*
807          * Virtualization support HWCAP_INT_SIE is bit 0.
808          */
809         if (sclp.has_sief2)
810                 int_hwcap |= HWCAP_INT_SIE;
811 
812         return 0;
813 }
814 arch_initcall(setup_hwcaps);
815 
816 /*
817  * Add system information as device randomness
818  */
819 static void __init setup_randomness(void)
820 {
821         struct sysinfo_3_2_2 *vmms;
822 
823         vmms = (struct sysinfo_3_2_2 *) memblock_alloc(PAGE_SIZE, PAGE_SIZE);
824         if (stsi(vmms, 3, 2, 2) == 0 && vmms->count)
825                 add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count);
826         memblock_free((unsigned long) vmms, PAGE_SIZE);
827 }
828 
829 /*
830  * Find the correct size for the task_struct. This depends on
831  * the size of the struct fpu at the end of the thread_struct
832  * which is embedded in the task_struct.
833  */
834 static void __init setup_task_size(void)
835 {
836         int task_size = sizeof(struct task_struct);
837 
838         if (!MACHINE_HAS_VX) {
839                 task_size -= sizeof(__vector128) * __NUM_VXRS;
840                 task_size += sizeof(freg_t) * __NUM_FPRS;
841         }
842         arch_task_struct_size = task_size;
843 }
844 
845 /*
846  * Setup function called from init/main.c just after the banner
847  * was printed.
848  */
849 
850 void __init setup_arch(char **cmdline_p)
851 {
852         /*
853          * print what head.S has found out about the machine
854          */
855         if (MACHINE_IS_VM)
856                 pr_info("Linux is running as a z/VM "
857                         "guest operating system in 64-bit mode\n");
858         else if (MACHINE_IS_KVM)
859                 pr_info("Linux is running under KVM in 64-bit mode\n");
860         else if (MACHINE_IS_LPAR)
861                 pr_info("Linux is running natively in 64-bit mode\n");
862 
863         /* Have one command line that is parsed and saved in /proc/cmdline */
864         /* boot_command_line has been already set up in early.c */
865         *cmdline_p = boot_command_line;
866 
867         ROOT_DEV = Root_RAM0;
868 
869         /* Is init_mm really needed? */
870         init_mm.start_code = PAGE_OFFSET;
871         init_mm.end_code = (unsigned long) &_etext;
872         init_mm.end_data = (unsigned long) &_edata;
873         init_mm.brk = (unsigned long) &_end;
874 
875         parse_early_param();
876 #ifdef CONFIG_CRASH_DUMP
877         /* Deactivate elfcorehdr= kernel parameter */
878         elfcorehdr_addr = ELFCORE_ADDR_MAX;
879 #endif
880 
881         os_info_init();
882         setup_ipl();
883         setup_task_size();
884 
885         /* Do some memory reservations *before* memory is added to memblock */
886         reserve_memory_end();
887         reserve_oldmem();
888         reserve_kernel();
889         reserve_initrd();
890         memblock_allow_resize();
891 
892         /* Get information about *all* installed memory */
893         detect_memory_memblock();
894 
895         remove_oldmem();
896 
897         /*
898          * Make sure all chunks are MAX_ORDER aligned so we don't need the
899          * extra checks that HOLES_IN_ZONE would require.
900          *
901          * Is this still required?
902          */
903         memblock_trim_memory(1UL << (MAX_ORDER - 1 + PAGE_SHIFT));
904 
905         setup_memory_end();
906         setup_memory();
907         dma_contiguous_reserve(memory_end);
908 
909         check_initrd();
910         reserve_crashkernel();
911 #ifdef CONFIG_CRASH_DUMP
912         /*
913          * Be aware that smp_save_dump_cpus() triggers a system reset.
914          * Therefore CPU and device initialization should be done afterwards.
915          */
916         smp_save_dump_cpus();
917 #endif
918 
919         setup_resources();
920         setup_vmcoreinfo();
921         setup_lowcore();
922         smp_fill_possible_mask();
923         cpu_detect_mhz_feature();
924         cpu_init();
925         numa_setup();
926         smp_detect_cpus();
927         topology_init_early();
928 
929         /*
930          * Create kernel page tables and switch to virtual addressing.
931          */
932         paging_init();
933 
934         /* Setup default console */
935         conmode_default();
936         set_preferred_console();
937 
938         /* Setup zfcpdump support */
939         setup_zfcpdump();
940 
941         /* Add system specific data to the random pool */
942         setup_randomness();
943 }
944 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp