// 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 = regs->gprs[insn->b2] + insn->d2;
 else
  uaddr = regs->gprs[insn->b1] + 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");
}