s390/boot/pgm_check_info.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <linux/kernel.h>
0003 #include <linux/stdarg.h>
0004 #include <linux/string.h>
0005 #include <linux/ctype.h>
0006 #include <asm/stacktrace.h>
0007 #include <asm/boot_data.h>
0008 #include <asm/lowcore.h>
0009 #include <asm/setup.h>
0010 #include <asm/sclp.h>
0011 #include <asm/uv.h>
0012 #include "boot.h"
0013
0014 const char hex_asc[] = "0123456789abcdef";
0015
0016 static char *as_hex(char *dst, unsigned long val, int pad)
0017 {
0018     char *p, *end = p = dst + max(pad, (int)__fls(val | 1) / 4 + 1);
0019
0020     for (*p-- = 0; p >= dst; val >>= 4)
0021         *p-- = hex_asc[val & 0x0f];
0022     return end;
0023 }
0024
0025 static char *symstart(char *p)
0026 {
0027     while (*p)
0028         p--;
0029     return p + 1;
0030 }
0031
0032 static noinline char *findsym(unsigned long ip, unsigned short *off, unsigned short *len)
0033 {
0034     /* symbol entries are in a form "10000 c4 startup\0" */
0035     char *a = _decompressor_syms_start;
0036     char *b = _decompressor_syms_end;
0037     unsigned long start;
0038     unsigned long size;
0039     char *pivot;
0040     char *endp;
0041
0042     while (a < b) {
0043         pivot = symstart(a + (b - a) / 2);
0044         start = simple_strtoull(pivot, &endp, 16);
0045         size = simple_strtoull(endp + 1, &endp, 16);
0046         if (ip < start) {
0047             b = pivot;
0048             continue;
0049         }
0050         if (ip > start + size) {
0051             a = pivot + strlen(pivot) + 1;
0052             continue;
0053         }
0054         *off = ip - start;
0055         *len = size;
0056         return endp + 1;
0057     }
0058     return NULL;
0059 }
0060
0061 static noinline char *strsym(void *ip)
0062 {
0063     static char buf[64];
0064     unsigned short off;
0065     unsigned short len;
0066     char *p;
0067
0068     p = findsym((unsigned long)ip, &off, &len);
0069     if (p) {
0070         strncpy(buf, p, sizeof(buf));
0071         /* reserve 15 bytes for offset/len in symbol+0x1234/0x1234 */
0072         p = buf + strnlen(buf, sizeof(buf) - 15);
0073         strcpy(p, "+0x");
0074         p = as_hex(p + 3, off, 0);
0075         strcpy(p, "/0x");
0076         as_hex(p + 3, len, 0);
0077     } else {
0078         as_hex(buf, (unsigned long)ip, 16);
0079     }
0080     return buf;
0081 }
0082
0083 void decompressor_printk(const char *fmt, ...)
0084 {
0085     char buf[1024] = { 0 };
0086     char *end = buf + sizeof(buf) - 1; /* make sure buf is 0 terminated */
0087     unsigned long pad;
0088     char *p = buf;
0089     va_list args;
0090
0091     va_start(args, fmt);
0092     for (; p < end && *fmt; fmt++) {
0093         if (*fmt != '%') {
0094             *p++ = *fmt;
0095             continue;
0096         }
0097         pad = isdigit(*++fmt) ? simple_strtol(fmt, (char **)&fmt, 10) : 0;
0098         switch (*fmt) {
0099         case 's':
0100             p = buf + strlcat(buf, va_arg(args, char *), sizeof(buf));
0101             break;
0102         case 'p':
0103             if (*++fmt != 'S')
0104                 goto out;
0105             p = buf + strlcat(buf, strsym(va_arg(args, void *)), sizeof(buf));
0106             break;
0107         case 'l':
0108             if (*++fmt != 'x' || end - p <= max(sizeof(long) * 2, pad))
0109                 goto out;
0110             p = as_hex(p, va_arg(args, unsigned long), pad);
0111             break;
0112         case 'x':
0113             if (end - p <= max(sizeof(int) * 2, pad))
0114                 goto out;
0115             p = as_hex(p, va_arg(args, unsigned int), pad);
0116             break;
0117         default:
0118             goto out;
0119         }
0120     }
0121 out:
0122     va_end(args);
0123     sclp_early_printk(buf);
0124 }
0125
0126 static noinline void print_stacktrace(void)
0127 {
0128     struct stack_info boot_stack = { STACK_TYPE_TASK, (unsigned long)_stack_start,
0129                      (unsigned long)_stack_end };
0130     unsigned long sp = S390_lowcore.gpregs_save_area[15];
0131     bool first = true;
0132
0133     decompressor_printk("Call Trace:\n");
0134     while (!(sp & 0x7) && on_stack(&boot_stack, sp, sizeof(struct stack_frame))) {
0135         struct stack_frame *sf = (struct stack_frame *)sp;
0136
0137         decompressor_printk(first ? "(sp:%016lx [<%016lx>] %pS)\n" :
0138                         " sp:%016lx [<%016lx>] %pS\n",
0139                     sp, sf->gprs[8], (void *)sf->gprs[8]);
0140         if (sf->back_chain <= sp)
0141             break;
0142         sp = sf->back_chain;
0143         first = false;
0144     }
0145 }
0146
0147 void print_pgm_check_info(void)
0148 {
0149     unsigned long *gpregs = (unsigned long *)S390_lowcore.gpregs_save_area;
0150     struct psw_bits *psw = &psw_bits(S390_lowcore.psw_save_area);
0151
0152     decompressor_printk("Linux version %s\n", kernel_version);
0153     if (!is_prot_virt_guest() && early_command_line[0])
0154         decompressor_printk("Kernel command line: %s\n", early_command_line);
0155     decompressor_printk("Kernel fault: interruption code %04x ilc:%x\n",
0156                 S390_lowcore.pgm_code, S390_lowcore.pgm_ilc >> 1);
0157     if (kaslr_enabled)
0158         decompressor_printk("Kernel random base: %lx\n", __kaslr_offset);
0159     decompressor_printk("PSW : %016lx %016lx (%pS)\n",
0160                 S390_lowcore.psw_save_area.mask,
0161                 S390_lowcore.psw_save_area.addr,
0162                 (void *)S390_lowcore.psw_save_area.addr);
0163     decompressor_printk(
0164         "      R:%x T:%x IO:%x EX:%x Key:%x M:%x W:%x P:%x AS:%x CC:%x PM:%x RI:%x EA:%x\n",
0165         psw->per, psw->dat, psw->io, psw->ext, psw->key, psw->mcheck,
0166         psw->wait, psw->pstate, psw->as, psw->cc, psw->pm, psw->ri,
0167         psw->eaba);
0168     decompressor_printk("GPRS: %016lx %016lx %016lx %016lx\n",
0169                 gpregs[0], gpregs[1], gpregs[2], gpregs[3]);
0170     decompressor_printk("      %016lx %016lx %016lx %016lx\n",
0171                 gpregs[4], gpregs[5], gpregs[6], gpregs[7]);
0172     decompressor_printk("      %016lx %016lx %016lx %016lx\n",
0173                 gpregs[8], gpregs[9], gpregs[10], gpregs[11]);
0174     decompressor_printk("      %016lx %016lx %016lx %016lx\n",
0175                 gpregs[12], gpregs[13], gpregs[14], gpregs[15]);
0176     print_stacktrace();
0177     decompressor_printk("Last Breaking-Event-Address:\n");
0178     decompressor_printk(" [<%016lx>] %pS\n", (unsigned long)S390_lowcore.pgm_last_break,
0179                 (void *)S390_lowcore.pgm_last_break);
0180 }