// SPDX-License-Identifier: GPL-2.0
 /*
  * functions to patch RO kernel text during runtime
  *
  * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>
  */

#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/kprobes.h>
#include <linux/mm.h>
#include <linux/stop_machine.h>

#include <asm/cacheflush.h>
#include <asm/fixmap.h>
#include <asm/text-patching.h>

struct patch {
 void *addr;
 u32 *insn;
 unsigned int len;
};

static DEFINE_RAW_SPINLOCK(patch_lock);

static void __kprobes *patch_map(void *addr, int fixmap, unsigned long *flags,
     int *need_unmap)
{
 unsigned long uintaddr = (uintptr_t) addr;
 bool module = !core_kernel_text(uintaddr);
 struct page *page;

 *need_unmap = 0;
 if (module && IS_ENABLED(CONFIG_STRICT_MODULE_RWX))
  page = vmalloc_to_page(addr);
 else if (!module && IS_ENABLED(CONFIG_STRICT_KERNEL_RWX))
  page = virt_to_page(addr);
 else
  return addr;

 *need_unmap = 1;
 set_fixmap(fixmap, page_to_phys(page));
 raw_spin_lock_irqsave(&patch_lock, *flags);

 return (void *) (__fix_to_virt(fixmap) + (uintaddr & ~PAGE_MASK));
}

static void __kprobes patch_unmap(int fixmap, unsigned long *flags)
{
 clear_fixmap(fixmap);

 raw_spin_unlock_irqrestore(&patch_lock, *flags);
}

void __kprobes __patch_text_multiple(void *addr, u32 *insn, unsigned int len)
{
 unsigned long start = (unsigned long)addr;
 unsigned long end = (unsigned long)addr + len;
 unsigned long flags;
 u32 *p, *fixmap;
 int mapped;

 /* Make sure we don't have any aliases in cache */
 flush_kernel_dcache_range_asm(start, end);
 flush_kernel_icache_range_asm(start, end);
 flush_tlb_kernel_range(start, end);

 p = fixmap = patch_map(addr, FIX_TEXT_POKE0, &flags, &mapped);

 while (len >= 4) {
  *p++ = *insn++;
  addr += sizeof(u32);
  len -= sizeof(u32);
  if (len && offset_in_page(addr) == 0) {
   /*
    * We're crossing a page boundary, so
    * need to remap
 */
   flush_kernel_dcache_range_asm((unsigned long)fixmap,
            (unsigned long)p);
   flush_tlb_kernel_range((unsigned long)fixmap,
            (unsigned long)p);
   if (mapped)
    patch_unmap(FIX_TEXT_POKE0, &flags);
   p = fixmap = patch_map(addr, FIX_TEXT_POKE0, &flags,
      &mapped);
  }
 }

 flush_kernel_dcache_range_asm((unsigned long)fixmap, (unsigned long)p);
 flush_tlb_kernel_range((unsigned long)fixmap, (unsigned long)p);
 if (mapped)
  patch_unmap(FIX_TEXT_POKE0, &flags);
}

void __kprobes __patch_text(void *addr, u32 insn)
{
 __patch_text_multiple(addr, &insn, sizeof(insn));
}

static int __kprobes patch_text_stop_machine(void *data)
{
 struct patch *patch = data;

 __patch_text_multiple(patch->addr, patch->insn, patch->len);
 return 0;
}

void __kprobes patch_text(void *addr, unsigned int insn)
{
 struct patch patch = {
  .addr = addr,
  .insn = &insn,
  .len = sizeof(insn),
 };

 stop_machine_cpuslocked(patch_text_stop_machine, &patch, NULL);
}

void __kprobes patch_text_multiple(void *addr, u32 *insn, unsigned int len)
{

 struct patch patch = {
  .addr = addr,
  .insn = insn,
  .len = len
 };

 stop_machine_cpuslocked(patch_text_stop_machine, &patch, NULL);
}