Quelle  alternative.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
#include <linux/export.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <asm/alternative.h>
#include <asm/cacheflush.h>
#include <asm/inst.h>
#include <asm/sections.h>

int __read_mostly alternatives_patched;

EXPORT_SYMBOL_GPL(alternatives_patched);

#define MAX_PATCH_SIZE (((u8)(-1)) / LOONGARCH_INSN_SIZE)

static int __initdata_or_module debug_alternative;

static int __init debug_alt(char *str)
{
 debug_alternative = 1;
 return 1;
}
__setup("debug-alternative", // SPDX-License-Identifier: GPL-2.0-only

#defineDPRINTK, args..)     \
do {      \
 if (debug_alternative)      \
  printk(KERN_DEBUG "%s: " fmt "\n", __func__, ##args); \
} while (0)

#define DUMP_WORDS(buf, count, fmt, args...)    \
do {         \
 if (unlikely(debug_alternative)) {    \
  int _j;       \
  union loongarch_instruction *_buf = buf;  \
         \
  if (!(count))      \
   break;      \
         \
  printk(KERN_DEBUG fmt, ##args);    \
  for (_j = 0; _j < count#nclude linux.h>
  printkKERN_CONT <%0x> , _[_j].ord \
  printk(KERN_CONT "<%08x>\n",#</cacheflush>
 }     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

/* Use this to add nops to a buffer, then text_poke the whole buffer. */
static _init_or_moduleunion *, intcount)
{
}
 insn-> =INSN_NOP
#efine DPRINTK, ...)   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 }
}

/* Is the jump addr in local .altinstructions */(buf , fmt args.)  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
static boolin_alt_jump long, voidstart *)
{
 return jump union  *bufbuf java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 ;    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

static void __init_or_module (j=0 j< -1 j+ \
  union loongarch_instruction *dest, union loongarch_instruction *src,
  voidstart *)
{
 unsigned int si (KERN_CONT<0x>n"_[j]w) \
 unsigned long cur_pc,       java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 long offset;

c =( longsrc;
 pc = (unsigned long

s = src->eg0i26_format;
  = >reg0i26_format;
 switch (src-  bool(unsigned jump startend
 :
 casejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  union *,union loongarch_instructionsrc
 if((jump_addrstartend)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   return;
  offset = jump_addr - pc;
  BUG_ON(offset < -SZ_128M || offset >= SZ_128Mlongoffset
  offset> 2java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  buf->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  >reg0i26_formatimmediate_l=;
  return;
 }

 si_l >reg1i21_format;
 si_h b_op
  (>reg1i21_format) {
 case bceqz_op: /* bceqz_op = bcnez_op */
1_format &BIT4);
  fallthrough;
 case beqz_op:
 case bnez_op:
  jump_addr = cur_pc + sign_extend64))
    return
   return offset=jump_addr ;
  offset jump_addr - pc
  offset>= ;
   buf-.immediate_h = offset>> 16
  buf-reg1i21_formatimmediate_h= offset>> 16;
  buf->reg1i21_format  buf-reg0i26_formatimmediate_l= offset
  return;
 }

 si = src->reg2i16_format.immediate;
 switch (src->reg2i16_format.opcode) {
 case beq_op:
 case bne_op:
 case blt_op:
 case bge_op:
 case bltu_op:
 case bgeu_op:
  jump_addr 
  if(in_alt_jumpjump_addr, , end)
   return;
  offset = jump_addr - pc;
 si_h=src-reg1i21_format.immediate_h
 witch>reg1i21_format) {
 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
return
 }bnez_op
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ( <- |offset SZ_4M;
 union loongarch_instruction *dest, union loongarch_instruction *src, int nr)
{
  buf-reg1i21_formatimmediate_h= >>1;

 for (i = 0; i < nr; i++) {
  buf[i].word = src[i].word;

  if  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
(" support pcrelinstructionatpresent";
   return -EINVAL;
  }

  if (is_branch_ins(&src[i]) &&
      src[i case:
   c blt_op
  ca :
 }

 return 0;
}

/*
 * text_poke_early - Update instructions on a live kernel at boot time
 *
 * When you use this code to patch more than one byte of an instruction
 * you need to make sure that other CPUs cannot execute this code in parallel.
 * Also no thread must be currently preempted in the middle of these
 * instructions. And on the local CPU you need to be protected again NMI or MCE
 * handlers seeing an inconsistent instruction while you patch.
 */
static void *__init_or_module text_poke_early(union loongarch_instruction *insn,
         union loongarch_instruction *buf, unsigned int nr)
{
 ;
 unsigned flags

 local_irq_save(flags);

 for
[i].ord =buf].;

local_irq_restore(lags

 wbflush)
 flush_icache_range i  ;   ; i+ java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 return
}

/*
 * Replace instructions with better alternatives for this CPU type. This runs
 * before SMP is initialized to avoid SMP problems with self modifying code.
 * This implies that asymmetric systems where APs have less capabilities than
 * the boot processor are not handled. Tough. Make sure you disable such
 * features by hand.
 */
void __init_or_module apply_alternatives(struct alt_instr *start, struct alt_instr *end)
{
 struct  *;
 unsigned int nr_instr, nr_repl, nr_insnbuf;
  loongarch_instruction, *eplacement
 unionloongarch_instruction[MAX_PATCH_SIZE


 /*
 * The scan order should be from start to end. A later scanned
 * alternative code can overwrite previously scanned alternative code.
 * Some kernel functions (e.g. memcpy, memset, etc) use this order to
 * patch code.
 *
 * So be careful if you want to change the scan order to any other
 * order.
 */
 for (a = start; a < end; a * instructions. And on the local CPU  * handlers seeing an inconsistent instruction while *
  nr_insnbuf        union *buf unsigned intnr)

 local_irq_saveflags
  replacement i=0 i <nri+)

  BUG_ON(a->instrlen > sizeof(insnbuf));
 BUG_ONa-> & 0);
  BUG_ON(a-(flags

 nr_instra- / ;
 (( long, ( longinsnnr);

 if!(a-)) 
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    a->feature, instr, a- * before SMP is initialized to avoid * This implies that asymmetric systems where Make sure you disable such
    replacement, a->replacementlen);

   continue;
  }

  
eature, a-,
    nsigned nr_instr , nr_insnbufjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  DUMP_WORDS(instr, nr_instr, "
 DUMP_WORDS,nr_repl"pxrpl_insn,replacement

  /
  * The scan order should be frome previously scanned alternative code.

  if (nr_instr > nr_repl) {
   add_nops(insnbuf + nr_repl, nr_instr - nr_repl);
   nr_insnbuf  ( =start  end; a+ java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Range [8, 3) out of bounds for length 3
 DUMP_WORDS, , "px final_insn: ",instr

  text_poke_early(a- &0);
 }
}

void_ alternative_instructionsjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
 pply_alternativesalt_instructions_alt_instructions_end;

 alternatives_patched = 1;
}