| // SPDX-License-Identifier: GPL-2.0 | |
| #include <linux/bitfield.h> | |
| #include <linux/extable.h> | |
| #include <linux/string.h> | |
| #include <linux/errno.h> | |
| #include <linux/panic.h> | |
| #include <asm/asm-extable.h> | |
| #include <asm/extable.h> | |
| #include <asm/fpu.h> | |
| const struct exception_table_entry *s390_search_extables(unsigned long addr) | |
| { | |
| const struct exception_table_entry *fixup; | |
| size_t num; | |
| fixup = search_exception_tables(addr); | |
| if (fixup) | |
| return fixup; | |
| num = __stop_amode31_ex_table - __start_amode31_ex_table; | |
| return search_extable(__start_amode31_ex_table, num, addr); | |
| } | |
| static bool ex_handler_fixup(const struct exception_table_entry *ex, struct pt_regs *regs) | |
| { | |
| regs->psw.addr = extable_fixup(ex); | |
| return true; | |
| } | |
| static bool ex_handler_ua_fault(const struct exception_table_entry *ex, struct pt_regs *regs) | |
| { | |
| unsigned int reg_err = FIELD_GET(EX_DATA_REG_ERR, ex->data); | |
| regs->gprs[reg_err] = -EFAULT; | |
| regs->psw.addr = extable_fixup(ex); | |
| return true; | |
| } | |
| static bool ex_handler_ua_load_reg(const struct exception_table_entry *ex, | |
| bool pair, struct pt_regs *regs) | |
| { | |
| unsigned int reg_zero = FIELD_GET(EX_DATA_REG_ADDR, ex->data); | |
| unsigned int reg_err = FIELD_GET(EX_DATA_REG_ERR, ex->data); | |
| regs->gprs[reg_err] = -EFAULT; | |
| regs->gprs[reg_zero] = 0; | |
| if (pair) | |
| regs->gprs[reg_zero + 1] = 0; | |
| regs->psw.addr = extable_fixup(ex); | |
| return true; | |
| } | |
| static bool ex_handler_zeropad(const struct exception_table_entry *ex, struct pt_regs *regs) | |
| { | |
| unsigned int reg_addr = FIELD_GET(EX_DATA_REG_ADDR, ex->data); | |
| unsigned int reg_data = FIELD_GET(EX_DATA_REG_ERR, ex->data); | |
| unsigned long data, addr, offset; | |
| addr = regs->gprs[reg_addr]; | |
| offset = addr & (sizeof(unsigned long) - 1); | |
| addr &= ~(sizeof(unsigned long) - 1); | |
| data = *(unsigned long *)addr; | |
| data <<= BITS_PER_BYTE * offset; | |
| regs->gprs[reg_data] = data; | |
| regs->psw.addr = extable_fixup(ex); | |
| return true; | |
| } | |
| static bool ex_handler_fpc(const struct exception_table_entry *ex, struct pt_regs *regs) | |
| { | |
| fpu_sfpc(0); | |
| regs->psw.addr = extable_fixup(ex); | |
| return true; | |
| } | |
| struct insn_ssf { | |
| u64 opc1 : 8; | |
| u64 r3 : 4; | |
| u64 opc2 : 4; | |
| u64 b1 : 4; | |
| u64 d1 : 12; | |
| u64 b2 : 4; | |
| u64 d2 : 12; | |
| } __packed; | |
| static bool ex_handler_ua_mvcos(const struct exception_table_entry *ex, | |
| bool from, struct pt_regs *regs) | |
| { | |
| unsigned long uaddr, remainder; | |
| struct insn_ssf *insn; | |
| /* | |
| * If the faulting user space access crossed a page boundary retry by | |
| * limiting the access to the first page (adjust length accordingly). | |
| * Then the mvcos instruction will either complete with condition code | |
| * zero, or generate another fault where the user space access did not | |
| * cross a page boundary. | |
| * If the faulting user space access did not cross a page boundary set | |
| * length to zero and retry. In this case no user space access will | |
| * happen, and the mvcos instruction will complete with condition code | |
| * zero. | |
| * In both cases the instruction will complete with condition code | |
| * zero (copying finished), and the register which contains the | |
| * length, indicates the number of bytes copied. | |
| */ | |
| regs->psw.addr = extable_fixup(ex); | |
| insn = (struct insn_ssf *)regs->psw.addr; | |
| if (from) | |
| uaddr = (insn->b2 ? regs->gprs[insn->b2] : 0) + insn->d2; | |
| else | |
| uaddr = (insn->b1 ? regs->gprs[insn->b1] : 0) + insn->d1; | |
| remainder = PAGE_SIZE - (uaddr & (PAGE_SIZE - 1)); | |
| if (regs->gprs[insn->r3] <= remainder) | |
| remainder = 0; | |
| regs->gprs[insn->r3] = remainder; | |
| return true; | |
| } | |
| bool fixup_exception(struct pt_regs *regs) | |
| { | |
| const struct exception_table_entry *ex; | |
| ex = s390_search_extables(instruction_pointer(regs)); | |
| if (!ex) | |
| return false; | |
| switch (ex->type) { | |
| case EX_TYPE_FIXUP: | |
| return ex_handler_fixup(ex, regs); | |
| case EX_TYPE_BPF: | |
| return ex_handler_bpf(ex, regs); | |
| case EX_TYPE_UA_FAULT: | |
| return ex_handler_ua_fault(ex, regs); | |
| case EX_TYPE_UA_LOAD_REG: | |
| return ex_handler_ua_load_reg(ex, false, regs); | |
| case EX_TYPE_UA_LOAD_REGPAIR: | |
| return ex_handler_ua_load_reg(ex, true, regs); | |
| case EX_TYPE_ZEROPAD: | |
| return ex_handler_zeropad(ex, regs); | |
| case EX_TYPE_FPC: | |
| return ex_handler_fpc(ex, regs); | |
| case EX_TYPE_UA_MVCOS_TO: | |
| return ex_handler_ua_mvcos(ex, false, regs); | |
| case EX_TYPE_UA_MVCOS_FROM: | |
| return ex_handler_ua_mvcos(ex, true, regs); | |
| } | |
| panic("invalid exception table entry"); | |
| } |