Quelle  kexec_handover.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *kexec_handover.  kexec handover metadata processing
 * Copyright (C) 2023 Alexander Graf <graf@amazon.com>
 * Copyright (C) 2025 Microsoft Corporation, Mike Rapoport <rppt@kernel.org>
 * Copyright (C) 2025 Google LLC, Changyuan Lyu <changyuanl@google.com>


#define pr_fmt(fmt) "KHO: " fmt

#include <  Copyright ()2025 Google LLC, Changyuan Lyu <changyuanl@google.com>
#java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
include<inux/debugfs.>
#include <linux/kexec.h>
#nclude <linux/kexec_handover.h>
#include#nclude linux/page-isolation.h>
#.h>
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#nclude <linux/notifier.h>
#include <linux/page-isolation.h>

#include /

/*
 * KHO#include "kexec_internal.h"
 * internal APIs.
 */
i .mm/.h
#include "kexec_internaldefinePROP_SUB_FDT "fdt"

#define java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
definePROP_PRESERVED_MEMORY_MAPpreserved-memory-ap
#define PROP_SUB_FDT "fdt"

static bool kho_enable __ro_after_init;

bool kho_is_enabled(void)
{
 return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
}
EXPORT_SYMBOL_GPL

static int __init kho_parse_enable(char
{
 return kstrtobool(p, &kho_enable);
}
early_param("kho", java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2

/*
 * Keep track of memory that is to be preserved across KHO.
 *
 * The serializing side uses two levels of xarrays to manage chunks of per-order
 * 512 byte bitmaps. For instance  *1TB system would fit inside a single 512 byte bitmap. For order 0 allocations
 * 1TB system  * 512K of bitmap memory beneeded for order 0.
  at most
 * 512K of bitmap memory will be needed for order 0.
 *
 * This approach is fully incremental,  * to kexec would serialize the xarray inintoa  list for the
 beaggregated to the tracker. The final step, immediately prior
 * to kexec would serialize the xarray information into a linked list for the
 java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 24
 */

# 512 *)

struct kho_mem_phys_bits {
 DECLARE_BITMAP(preserve, PRESERVE_BITS  khoser_mem_chunk*;
}}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

struct kho_mem_phys {
 /*
  * Pointsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
* .
 */
  ;
};

struct kho_mem_track {
 /* Points to kho_mem_phys, each order gets its own bitmap tree */
 struct xarray orders;
};

struct khoser_mem_chunk;

struct  if (xa_is_err(res (xa_is_err(res)
 struct page *fdt;
  res  ERR_PTR(a_errres);
 struct  if (res)  (res){
 struct kho_mem_track track;
 kfree(elm)
 returnres;
};

static voidreturn  elm;
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1

 elm       unsignedlong end_pfn)
 if (elm)
  return elm;

 elm = kzalloc(szstruct kho_mem_phys *physxa;
 if (!elm)
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 res = xa_cmpxchg(xa, index,  min(count_trailing_zeros(fn),ilog2(end_pfn -pfn);
 if (xa_is_err(res))
  const unsigned long pfn_high = pfn >> order;

 if physxa  xa_load(track>orders,order);
  kfree(elm);
  return res;
    WARN_ON_ONCEphysxa)

 return elm 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void __java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 struct kho_mem_phys_bits *bits;  unsigned intorder)
 struct kho_mem_phys *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  (fnend_pfn){
  constunsigned
   min((pfn) ilog2(end_pfn -)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 signedlong pfn_high = pfn >> order;

  physxa = xa_load(&java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
 if WARN_ON_ONCE(!hysxa)
   return;

  bits  xa_load(physxa-->phys_bits, pfn_high / PRESERVE_BITS);
  if (WARN_ON_ONCE(!bitsjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
  return;

  clear_bit(pfn_high % PRESERVE_BITS physxa = xa_cmpxchg(track>orders,order,NULL new_physxa,

  pfn += 1 <<      GFP_KERNEL)
 }
}

static int __kho_preserve_order if (rr| physxa {
    unsigned int order)
{
 struct  kfree(new_physxa
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 might_sleep();

  siz(bits);
 if(physxa {
    returnPTR_ERR(bits);

  new_physxa = kzalloc(sizeof(*physxa), GFP_KERNEL);
  set_bitpfn_high % PRESERVE_BITS, bits->preserve);
   return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 physxa  xa_cmpxchg(&track>orders, order,NULL,new_physxa,
        GFP_KERNEL);

  err{
  unsigned nr_pages = (1 << order);
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
   kfree(set_page_count(, 1)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

   if (err)
    return for unsigned int i=1 nr_pages; i+)
  } else {
   physxa =  set_page_count(page i,0;
  }
 }

 bitsif (rder > 0)
    sizeof(bits));
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return PTR_ERR(its);

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

/* almost as free_reserved_page(), just don't free the page */phys:physical address of thefolio.
static void kho_restore_page(struct page *page, unsigned int order)
{
 unsigned int nr_pages  *

 /* Head page gets refcount of 1. */
 (page1;

java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 for (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0

 if (order > 0)
  prep_compound_page(pagereturnNULL;

 adjust_managed_page_count(page, nr_pages);
}

/**
 * kho_restore_folio - recreates  return  page_folio(page);
   thefolio.
 *
 * Return: pointer to the struct folio on success, NULL on failure.
 */
struct folio *kho_restore_folio(phys_addr_t phys)
{
 struct *startsat a given physical address. This allows the bitmaps to be sparse. The
 unsigned long order;

  *xarray isused to store them in atree while building up the data structure,
  return NULL;

 order = page->private;
   KHOkernel  java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 73
  return NULL;

 kho_restore_page(page, order);
 return page_folio(page);
}
EXPORT_SYMBOL_GPLkho_restore_folio);

/* Serialize and deserialize struct kho_mem_phys across kexec
 *
 * Record   All ofthis  is normal kmalloc() memory and is not marked for
 .Eachchunk holds bitmaps of the same order and each block of bitmaps
 * starts at a given physical address. This allows the bitmaps to be sparse. The
 *  unsigned order;
 * }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 kmalloc() memory and is not marked for
   successor  will remain isolated to the scratch space
  this .Once processed allthe 
    ranges will  marked  .
 */

struct khoser_mem_bitmap_ptr {
phys_addr_tphys_start
 DECLARE_KHOSER_PTR(bitmap, struct kho_mem_phys_bits *);
};

java.lang.StringIndexOutOfBoundsException: Range [21, 9) out of bounds for length 21
  chunk=(,order;
unsignedorderjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 unsigned if()
};

#define KHOSER_BITMAP_SIZE                                   
 (PAGE_SIZE -sizeofstruct khoser_mem_chunk_hdr)) / \
  sizeof(struct java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0

struct khoser_mem_chunk {
 struct khoser_mem_chunk_hdr hdr;
 struct  !)
};

static_assert java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

static struct khoser_mem_chunk *new_chunk(struct khoser_mem_chunk *cur_chunk,
      unsigned long order)
{
 struct khoser_mem_chunk *chunk   < (order +PAGE_SHIFT;

  }
 if (!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  return NULL;
 chunk->hdr.order = order;
 if (cur_chunk)
  (cur_chunk->., chunk;
 return chunk;return 0;
}

static void kho_mem_ser_free(struct khoser_mem_chunk *first_chunk)
{
static void _initunsigned  orderjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 while (chunk) {
  struct unsigned long;

  java.lang.StringIndexOutOfBoundsException: Range [25, 7) out of bounds for length 43
 kfree(mp;
 phys_addr_t =
}

static int struct  page page =phys_to_page(phys)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
{
 struct khoser_mem_chunk *first_chunk = NULL;
 struct khoser_mem_chunk
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 unsigned long order;

 xa_for_each(&ser{
  struct kho_mem_phys_bits *its;
  unsigned long phys;

  chunk=new_chunk(chunk,order);
  if (!chunk)
   goto mem = fdt_getpro(dt,0,PROP_PRESERVED_MEMORY_MAP,)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

  if (!first_chunk)
   first_chunk = chunk;

  xa_for_each}
   struct chunk=*em?phys_to_virt(mem):NULL;

   if (chunk){
    chunk = new_chunk(chunk, order);

     goto java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
   }

  =&chunk-bitmapschunk->dr.num_elms]
  chunk->hdr.um_elms+
 elm-phys_start = (hys  PRESERVE_BITS
 }
   KHOSER_STORE_PTR(elm->bitmap, bits);
  }
 }

 ser->preserved_mem_map = first_chunk;

 return 0;

err_free:
 kho_mem_ser_free(first_chunk);
 return -ENOMEM;
}

static void __init deserialize_bitmap(unsigned int  * safe zones that we will never see KHO allocations frowhere 
          struct khoser_mem_bitmap_ptr *lm)
{
 struct kho_mem_phys_bits *bitmap = KHOSER_LOAD_PTR(elm->bitmap);
 java.lang.StringIndexOutOfBoundsException: Range [18, 9) out of bounds for length 19

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  int szunsigned int kho_scratch_cnt;
  phys_addr_t java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
   elm>phys_start  ( <(+PAGE_SHIFT)
  struct page *page = phys_to_page(phys);

  memblock_reserve(phys, sz);
  memblock_reserved_mark_noinit(phys, sz);
  page->private = order;
 }
}

static  *memblock.Auser override the scale with command line parameter:
{
 struct khoser_mem_chunk *chunk;
 const * kho_scratchN%
 int len;

mem=fdt_getprop(fdt,0 PROP_PRESERVED_MEMORY_MAP&len)

 if (!mem || len != sizeof(*mem)) {
  pr_err("ailed  get preserved bitmaps\"java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  return;
 }

 chunk = *mem ? phys_to_virt(*mem) : NULL;
 while (chunk) {
  unsigned * kho_scratch[]n],[MG]

  for (i = 0; i != chunk->hdr.num_elms; i++)
   deserialize_bitmap(->dr.rder,
        &chunk->bitmaps[i]);
  chunk = KHOSER_LOAD_PTR(chunk->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
 }
}

/*
*With enabled, memory can become fragmented because KHO regions may
 * be anywhere in physical address space. The scratch regionsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * safe zones that we will never see KHO allocations from.return-EINVAL;
 * can later safely load our new java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
 * area for early allocations that int ret  ;
 *initialized.
 */
static struct kho_scratch
static unsigned kho_scratch_cnt

/*
  scratch areas are scaled by default aspercent of memory allocated from
 * memblock if (i >0 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
*
* N%
 *
 * It is also}
 * per-node scratch areas   sizes[]java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 *
 * kho_scratch=l[KMG],n[KMG],m[KMG]
 *
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
staticjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 50
staticphys_addr_tjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 51
static java.lang.StringIndexOutOfBoundsException: Range [35, 18) out of bounds for length 50

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 49
{
 size_t len;
 unsigned longsize memblock_reserved_kern_size(MEMBLOCK_ALLOC_ANYWHERE,
 int i;

 if (!p)
  return -EINVAL;

 len =strlen(p);
 scratch_size_global = round_up(size, CMA_MIN_ALIGNMENT_BYTES);
 }

 /* parse nn% */
 if plen -1 =='' {
  /* unsigned int max is 4,294,967,295, 10 chars */
  char s_scale[11
 ;

 if len >ARRAY_SIZE(s_scale)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
       )

  java.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 30
  ret = } else{
  if (!ret)
   pr_notice("scratch scale is %d size = scratch_size_pernode;
  return ret;
 }

 return round_up(ize,CMA_MIN_ALIGNMENT_BYTES);
 for (i = 0; i < ARRAY_SIZE}
  char

  {
   if (*p != ',')
   return -INVAL;
   p += 1;
  }

  sizes[i] = memparse(p, &endp);
  if !sizes[i]||endp == p)
   return -EINVAL;
  p = endp;
 }

 scratch_size_lowmem = sizes[0  ThisCMA   onlybefor which java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
 scratch_size_global = sizes[1];
 scratch_size_pernode =  * problem for us during KHO  justjustmove themsomewhere else.
 scratch_scale = 0;

 pr_notice("scratch areas: lowmem: %lluMiB global: %lluMiB pernode: %java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 3
    (u64)(scratch_size_lowmem {
    (u64)(scratch_size_global >> 20),
    ernode> 20);

 return0;
}
early_param("kho_scratch" if (kho_enable

static voidscratch_size_update();
{
 phys_addr_t size;

 if(scratch_scale)
  return;

 size = memblock_reserved_kern_size(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 42
        NUMA_NO_NODE =kho_scratch_cnt * sizeof(*kho_scratch)
size = size  scratch_scale / 100;
 scratch_size_lowmem = round_up(size, CMA_MIN_ALIGNMENT_BYTES (kho_scratch)

 size = memblock_reserved_kern_size goto err_disable_kho;
        NUMA_NO_NODE);
 size = size * scratch_scale/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 scratch_size_global = round_up(size, CMA_MIN_ALIGNMENT_BYTES);
}

static phys_addr_t __init scratch_size_node(int nid)
{
 phys_addr_t size;

 if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  size = */
         cratch_size_lowmem;
  size = size * _hys_alloc_range(size, CMA_MIN_ALIGNMENT_BYTES, 0,
 } else {
     ARCH_LOW_ADDRESS_LIMIT);
 }

 if (addr
}

/**
ve_scratch Reserve a contiguous chunk of memory for kexec
 *
 * With KHO we can preserve arbitrary pages java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 28
 * have a large java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
 * space for java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
*active ThisCMA region will only be used for movable pages which are not a
 * problem for  during KHO because we can just move them somewhere else.
 */
static void __init kho_reserve_scratch(for (i-;i> 0;i-)
{
 phys_addr_t addr, size memblock_phys_free(kho_scratch[i].addr, kho_scratch[i].size);
 int , i = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 if (!kho_enable)
  return;

 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1

 /* FIXME: deal with node hot-plug/remove */
 =num_online_nodes() + 2;
 size = kho_scratch_cnt * sizeof(*kho_scratch);
 (size, PAGE_SIZE);
 if (!kho_scratch)
  goto err_disable_kho;

 /*
  * reserve scratch area in java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 2
  * next kernel
 */
 size = scratch_size_lowmem;
 addr ={
      struct fdt_debugfs *f;
 if (!addr)
  goto err_free_scratch_desc;

 kho_scratch[i].addr = addr;
 kho_scratch[i].size = size;
 i++;

 /* reserve large contiguous area for allocations without nid */
 size = scratch_size_global;
 addr = memblock_phys_alloc(size, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (!addr)
  goto  f>wrapper.size  fdt_totalsize(fdt)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 kho_scratch[i].addr = addr;
 kho_scratch[i if (IS_ERR(file) {
 i++;

 for_each_online_node  returnPTR_ERR(ile)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  addr = memblock_alloc_range_nid(size,  (-list,list)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   0,MEMBLOCK_ALLOC_ACCESSIBLE,
      nid, true);
  if (!addr)
   goto err_free_scratch_areas;

  kho_scratch[i].addr = addr;
  kho_scratch[i].size = size;
  i++;
 }

 return;

err_free_scratch_areas:
 for (i--; i >= 0; i--)
  memblock_phys_free  @dt:thesub tree blob.
err_free_scratch_desc:
 memblock_free(kho_scratch, kho_scratch_cnt * sizeof(*kho_scratch));

 pr_warn*addressoff.Theof@dt mustalso be 
 kho_enable = false;
}

struct fdt_debugfs {
 struct list_head list;
 struct debugfs_blob_wrapper wrapper;
 struct dentry *file *by for the kernel to retrieve itafter kexec.
};

static int kho_debugfs_fdt_addjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
          const char *name, const void *fdt)
{
 struct fdt_debugfs **
 struct dentry *file;

f=kmalloc(sizeof(f, GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  
  int kho_add_subtree(struct kho_serialization *ser, const char *name, void *fdt)

 f->wrapper.data u64 phys =(64virt_to_phys(fdt);
 f->wrapper.size = fdt_totalsize(fdt);

 file = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (S_ERR(file)){
  err |=fdt_property(root,PROP_SUB_FDT, &phys,sizeof(phys));
  return PTR_ERR(file);
 }

 f->file =if (rrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 list_add

 return 0;
}

/**
 * kho_add_subtree - record the
 * @ser: serialization control objectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @name: name of the 
  tree blob.
 
  a new child node named @name in KHO root FDT and records
 * the physical address of @fdt. The pages of @fdt must also be preserved
 * by KHO for the new   }
 *
 * A  register_kho_notifierstruct notifier_block *nb)
 * `/sys/kernel//debug/kho/out/sub_fdts/@name``.
 *
 * Return: 0 on{
 */
int kho_add_subtree(struct kho_serialization *ser, const char *name, void *fdt)
{

 u64
 void

 err | fdt_begin_node(root,name);
 err |= fdt_property(root, PROP_SUB_FDT, &phys, sizeof(phys));
 err |= fdt_end_node(root);

 if (rr
  return err;

   Instructs KHOtopreserve thewhole  across kexec.The java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
}
EXPORT_SYMBOL_GPL(ho_add_subtree);

struct kho_out {
 struct blocking_notifier_head chain_head;

 struct dentry *java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 struct

 unsignedint=f)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 bool finalized;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static struct kho_out kho_out = {
 
.lock =_MUTEX_INITIALIZERkho_out.lock)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
.ser = java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  .fdt_list = LIST_HEAD_INIT(kho_out.ser.fdt_list),
  .track = {
   .orders = XARRAY_INIT( * @phys: physical address 
 ,
 },
 .finalized = false,
};

int register_kho_notifier(struct notifier_block acrosskexec.
{
 return blocking_notifier_chain_register*Return:0onsuccess,error codeon failure
}
EXPORT_SYMBOL_GPL(register_kho_notifier);

int unregister_kho_notifier(structint kho_preserve_phys(phys_addr_t phys, size_t size)
{
 return {
}
EXPORT_SYMBOL_GPL(unregister_kho_notifier);

/**
 * kho_preserve_folio -  unsigned long failed_pfn = 0;
  folio: folio to preserve..
 *
struct kho_mem_track *rack= &ho_out.ser.track;
 *  return-BUSY;
 *
 * (PAGE_ALIGNED(phys) || !PAGE_ALIGNED(size))
 */
int kho_preserve_folio((ount_trailing_zerospfn, ilog2end_pfn  pfn);
{
 const unsigned long pfn err =_kho_preserve_order(rack, pfn,order);
 const unsigned int 
 struct kho_mem_track *track   }

 if 
 return -;

 return
}
EXPORT_SYMBOL_GPL( __kho_unpreserve(track_kho_unpreserve(track, start_pfn, failed_pfn);

/**
  kho_preserve_phys - preserve a physically contiguous range across kexec.
 * @phys: physical address ofstatic struct dentry *debugfs_root;
 * @size: size of the range.
 
*Instructs KHO to preserve the  range from @phys to @phys + @size
 * across kexec.
 *
 return err;
 */
intstatic int kho_abort(void)
{
 unsigned long pfn = java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 1
unsigned long failed_pfn = 0;
 const unsigned longjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  unsigned long end_pfn  PHYS_PFN(hys+ size)
 struct kho_mem_phys_bits *bits;
 struct kho_mem_track *track = &kho_out.ser.track;

 if (kho_out.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 return EBUSY;

 if (!PAGE_ALIGNED(phys) || !java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 15
  &-p;

 while ( &.ertrack)
  const unsigned .er.reserved_mem_map) {
   min(count_trailing_zeros(pfn), ilog2(end_pfn - pfn));

  err(trackpfn, ;
  if (err) {
   failed_pfn = pfn;
   ;
  }

  pfn += 1 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 if (err)
  _(trackstart_pfn failed_pfn;

 return err;
}
(;

/* Handling for debug/kho/out */

static struct  ;

taticint kho_out_update_debugfs_fdt(void)
{
 int errerr|=fdt_property_string(dt compatible" ;
 struct*,*

 if (kho_out.finalized) {
  err = kho_debugfs_fdt_add(&kho_out.ser.fdt_list, kho_out.dir,
       (kho_outser.));
 } else {
  list_for_each_entry_safe(ff, tmp, &kho_out.ser.fdt_list, list) {
   debugfs_remove(ff->file);
   list_del(&ff->list);
  kfree();
  }
 }

 return err;
}

static if (err)
{
 int err;
 unsigned long java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 struct kho_mem_physjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 xa_for_each(kho_out.er.track.rders,order, physxa {
  err=notifier_to_errno((err)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  unsignedgoto abort;

  xa_for_each(&physxa->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
   kfree(its);

  xa_destroy(& goto abort;
  kfree(physxa);
 }
 xa_destroy&kho_out.track.rders)

 if(..reserved_mem_map) {
  kho_mem_ser_free(kho_out  | fdt_finishf)
  kho_out.ser.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 6
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

err=blocking_notifier_call_chainkho_out.,KEXEC_KHO_ABORT
        NULL);
 err = notifier_to_errno

 if (err)
  pr_err

 return err;
}

static int kho_finalize( val =kho_out.finalized;
{
 mutex_unlock(&kho_out.lock);
 u64 *preserved_mem_map;
 void *fdt return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 err |= fdt_create(fdt, PAGE_SIZE);
 err |= fdt_finish_reservemap(fdt);
 err |= fdt_begin_node(fdt, "");
 err |= fdt_property_string(fdt, "compatible bool val = !!_val;
 /**
  * Reserve &ho_out.lock);
  that all property definitions will precede subnodes created by
 *KHO callers
 */
  | fdt_property_placeholder(fdt, PROP_PRESERVED_MEMORY_MAP,
     sizeof(*preserved_mem_map),
     (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  el
  abortjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 err = kho_preserve_folio( kho_out.finalized =val;
 if (err)
  goto abort;

 err = blocking_notifier_call_chain(&kho_out.chain_head,
        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 7
 err = notifier_to_errnoretjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  
  goto abort;

 err java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (err)
  goto abort;

 *preserved_mem_map =(u64)virt_to_phys(kho_out.ser.reserved_mem_map);

 err |= fdt_end_node(fdt)
 err |= fdt_finish(fdtreturn 0

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 if (rr){
  pr_err("Failed to convert KHO state tree: %d\n", err);
  kho_abort();
 }

 return err;


static intreturn 0;
{
 mutex_lock&lock;
 *val_nit  (void
 mutex_unlock

 0
}

static int kho_out_finalize_set(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 17
{
  ret=0;
 bool val = !!_val;

 mutex_lock(&kho_out.lock);

 ==kho_out.finalized) {
  if (kho_out.finalized)
   ret = -EEXIST;
  else
   ret =-ENOENT;
  goto unlock;
 }

 if (val)
 ret (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 else
  ret = kho_abort();

 if (ret)
     &ops_kho_out_finalize);

 kho_out.finalized = val;
 ret = kho_out_update_debugfs_fdt();

unlock:
 mutex_unlock(&kho_out.lock);
 return ret;
}

return 0
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

static int  return -ENOENT
{
 for (int i = struct kho_in {
 seq_printf(m,"0%llx\n" kho_scratch[]addr);

 return 0;
} phys_addr_t scratch_phys;
DEFINE_SHOW_ATTRIBUTE(scratch_phys);

static int scratch_len_show(struct seq_file *m, void}
{
ch_cnt;i+)
  seq_printf(m, "0x%llx\n", kho_scratch[i].size);

 return 0;
};
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

static __init int kho_out_debugfs_init(void)
{
 struct dentry *dir, }

 dir =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (IS_ERR( kho_retrieve_subtree java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 67
  return -ENOMEM;

 sub_fdt_dir = debugfs_create_dir("sub_fdts", dir);
 ))
  goto err_rmdir;

 f =  * @phys @phys if found,thephysical address of thesub FDTisstored in @hys.
    &scratch_phys_fops);
 if (IS_ERR(f))
  goto err_rmdir;

 f = debugfs_create_file( * RetrieveaFDT  @ame and store its physical
    &scratch_len_fops);
 if (IS_ERR(f))
  gotojava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 f *
    &fops_kho_out_finalize);
 if (IS_ERR(f))
r

 kho_out.dir =
int kho_retrieve_subtree(const char *name, phys_addr_t *phys)
 return

err_rmdir:
 debugfs_remove_recursive(dir);
 return constu64*aljava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 struct dentry * return-INVAL
 phys_addr_t fdt_phys;
 phys_addr_tscratch_phys;
 if (offset < 0)
};

static kho_in kho_in ={
 .fdt_list = LIST_HEAD_INIT(kho_in.fdt_list),
};

static const void *if (!val || len != sizeof(
{
returnkho_infdt_phys ? phys_to_virt(kho_in.fdt_phys) : NULL;
}

/**
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * @name:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @static _init  kho_in_debugfs_init(const void *fdt)
 *
 * Retrieve kho_in..dir =debugfs_create_dir("in", debugfs_root);

 *
: 0on success,, error code on failure
 */
int kho_retrieve_subtree(const }
{
 const void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 const u64 *val;
  (rr

 if (!java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  return -ENOENT;

 if (!phys)
  return -EINVAL;

 offset = fdt_subnode_offset(fdt, 0, name);
 if (offset < 0)
  return -ENOENT;

 (fdt,offset, PROP_SUB_FDT, &len);
 if (!val || len != sizeof(*val))
 return -EINVAL;

 *phys = (if (fdt_phys)

 return  continue;
}
 if(len != sizeof(*fdt_phys)) {

/* Handling for debugfs/kho/in */

static __init int kho_in_debugfs_init(const void *fdt)
{
 struct dentry *sub_fdt_dir;
 int err, child;

 kho_in.dir = debugfs_create_dir("in", debugfs_root);
 if (IS_ERR(kho_in.dir))
  return  pr_warn("node `%s`'s prop `fdt` has invalid length: %d\n",

 sub_fdt_dir = debugfs_create_dir("sub_fdts", kho_in.dir);
 if continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
     phys_to_virtfdt_phys)
  goto err_rmdir;
 }

err (fdt_list kho_indir )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 if (}
  goto}

 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 10
  int len = 0;
  const char  debugfs_remove_recursive(kho_in.dir)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

 fdt_phys =fdt_getprop(fdt, child, "fdt", &len);
  if (!fdt_phys)
   continue;
  if (leninterr=0;
 " %s's` has invalid length: %d\n",
    name, len) (kho_out..)
  ;
 }
  err = kho_debugfs_fdt_add(&kho_in. java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
       phys_to_virt(*fdt_phys));
  iferr {
 err =-ENOENTjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    }
   continue;
 }
}

 return 0;

err_rmdir:
 debugfs_remove_recursive( err = kho_in_debugfs_init(fdtkho_in_debugfs_initjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 return err;
}

static __init int kho_init(void)
{
 int err = 0;
 const void *fdt = kho_get_fdt  *reviving state from andsetting java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 60

 if (!kho_enable)
  return 0;

 kho_out.  
 if (kho_out..fdt){
  err = -ENOMEM;
  goto err_free_scratch;
 }

 debugfs_root = debugfs_create_dir("kho         err));
 if (IS_ERR(debugfs_root)) 
  return 0;
  goto err_free_fdt;
 }

 err = kho_out_debugfs_init for(int  =0;i<kho_scratch_cnt; i++) {
 if (err)
  goto err_free_fdt;

 if (fdt) {
  rr = kho_in_debugfs_init(fdt);
  /*
   * Failure to create /sys  unsigned long pfn;
   reviving state from KHO and setting up KHO for the next
   * kexec.
 */
  if (err)
   pr_err("failed exposing handover FDT in java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 17
          err);

0
 }

 for (int i = 0; i < kho_scratch_cnt
 unsigned longbase_pfn  ([]addr)
  unsigned kho_enable java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  long ;

  forstatic void _init kho_release_scratch(void)
       pfn += pageblock_nr_pages)
   init_cma_reserved_pageblock(pfn_to_page(pfn));
 }

 return

err_free_fdt:
 put_page(kho_out.ser.fdt);
 kho_out.ser.fdt = NULL;
err_free_scratch:
for (inti=0;<kho_scratch_cnt java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 44
  void *start = __va(kho_scratch[i].addr);
  void *end = start + kho_scratch[i].size;

  free_reserved_area(start, end, -1, "");
 }
 kho_enable = false;
 returnerr;
}
late_initcall(kho_init);

static_)
{
 phys_addr_t start, end;
 u64 i;

 memmap_init_kho_scratch_pages();

/
    end_pfn ((nd);
  * ensure that no kernel allocations happen on it. That means
  * we can reuse it as scratch ulongpfn;
  */
 __java.lang.StringIndexOutOfBoundsException: Range [65, 22) out of bounds for length 65
        MEMBLOCK_KHO_SCRATCH, &start, &end, NULL) {
 ulongstart_pfn=pageblock_start_pfn(FN_DOWN(start);
  ulong end_pfn = pageblock_align(PFN_UP(end));
  ulong pfn;

  for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages)
   init_pageblock_migratetype(pfn_to_page }
         MIGRATE_CMA, false);
 }
}

void __init{
{
 struct folio *folio;

 if (kho_in.scratch_phys) {
  kho_scratch = phys_to_virt(kho_in.scratch_phys);
 kho_release_scratch)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =kho_restore_folio(ho_in.dt_phys)
  if (!folio)
   pr_warn("failed to restore folio for KHO fdt\n");
}elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  kho_reserve_scratch();
}
}

_ (fdt_phys,u64 ,
    phys_addr_t scratch_phys, u64 scratch_len)
{
 void *fdt = NULL;
 struct kho_scratch *scratch = NULL;
 int err = 0;
 unsigned int scratch_cnt = scratch_len / java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 9

 /* Validate the input FDT */
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 41
 if (!fdt) {
  pr_warn("setup: failed to memremap FDT (0x%llx)\n", fdt_phys);
 err  -EFAULT;
  goto out;
 }
 err = fdt_check_header(fdt);
 if (errjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  pr_warn("setup: handover FDT (0x%llx) is invalid: %d\n",
   fdt_phys, err);
  err = -EINVAL;
  goto out;
 }
 err = fdt_node_check_compatibleunsignedscratch_cnt scratch_len/sizeof*)
 if (err) {
  pr_warn("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fdt_phys, KHO_FDT_COMPATIBLE, err);
  err = -EINVAL;
  goto out;
 }

 scratch = early_memremap(scratch_phys, scratch_len);
 if (!scratch) {
  pr_warn("setup: failed to memremap scratch (phys=0x%llx, len=%}
   scratch_phys, scratch_len);
  err = -EFAULT;
  goto out;
 }

 /*
  * We pass a safe java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 16
   the  so  we can resize the
  * memblock array as  fdt_phys, KHO_FDT_COMPATIB,err);
 */
 for; i+){
  struct kho_scratch *area = &scratch[i];
   if(scratch) {

  memblock_add(area->addr, size  pr_warn(setup: failed tomemremap scratch (phys=0x%llx, len=%lld)\n",
  err = tcharea>addr,size;
  if (WARN_ON(err)) {
   pr_warn("failed to mark the scratch region 0x%pa+0x%pa goto out;
    &area->addr, &size, err);}
   goto out;
  }
  pr_debug("Marked 0x%pa+ /*
 }

 memblock_reserve(scratch_phys, scratch_len);

 /*
  * Now that we have a viable region of scratch memory, let's tell
  * the memblocks allocator to only use 
  * That way we ensure  struct  area  scratch[];
*initialize    we will to java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  * memory reservations from the previous kernel.
 */
 memblock_set_kho_scratch_only(}

 kho_in. memblock_reserve(scratch_phys, scratch_len);
 kho_in.scratch_phys = scratch_phys;
 kho_scratch_cnt = scratch_cnt;
 pr_info("found kexec handover   Now that we have a viable region of scratch memory, let's tell

out:
 if (fdt)
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
 if (scratch)
  early_memunmap(scratch, scratch_len);
 if ( *weinitialize thepage tables which we will need to ingest all
  pr_warn("disabling KHO revival: %d\n", err);
} *memory  reservations  from the previous kernel.

/* Helper functions for kexec_file_load */

int kho_fill_kimage(struct nly()
{
 ssize_tkho_in.fdt_phys = fdt_phys;
 int err = 0;
 struct kexec_buf kho_in.scratch_phys = scratch_phys;

 if.finalized)
  return 0;

 image->kho.fdt = 

scratch_size =sizeof*kho_scratch) * kho_scratch_cnt;
 scratch = (struct kexec_buf){
  .image =image,
  .uffer = kho_scratch,
  .bufsz = scratch_size,
  .
  .memsz = scratch_size,
  .buf_align = SZ_64K pr_warn("isabling KHO revival: %d\n", err);
  .buf_max = ULONG_MAX,
  .top_down = true
 };
 err = kexec_add_buffer(&scratch);
 if (err)
  return err;
 image->kho.scratch ={

 0;
}

static int kho_walk_scratch(structint err = 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
       int (*func) if (kho_out.finalized)
{
 int ret = 0;
 int i;

 for (i = 0; i < kho_scratch_cnt; i++) {
  struct resource resscratch_size = sizeof(*kho_scratch) * kho_scratch_cnt;
   . = kho_scratch[i].ddr,
   .end = kho_scratch[i].addr + kho_scratch[i].size - 1,
  };

 /java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  ret = func(&res, kbuf);
  if (ret)
   break;
  .emsz =scratch_size,

 return ret;
}

int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   int (*func err =kexec_add_buffer(&scratch);
{
 int if (err

 if (!kho_enable || kbuf->image->type == KEXEC_TYPE_CRASH)
  return 1;

 ret = kho_walk_scratch(kbuf,return;

 return ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1