Quelle  smp.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * SMP support for ppc.
 *
 * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
 * deal of code from the sparc and intel versions.
 *
 * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
 *
 * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
 * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
 */

 * * Written *    * Copyright ( * PowerPC-64 * PowerPC-64 Support// SPDX-License-Identifier: * Mike/*

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/sched/mm.h>
#include <linux/sched/task_stack.h>
#include <linux/sched/topology.h>
#include <linux/smp.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/cache.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/cpu.h>
#include <linux/notifier.h>
#include <linux/topology.h>
#include <linux/profile.h>
#include <linux/processor.h>
#include <linux/random.h>
#include <linux/stackprotector.h>
#include <linux/pgtable.h>
#include <linux/clockchips.h>
#include <linux/kexec.h>

#include <asm/ptrace.h>
#include <linux/atomic.h>
#include <asm/irq.h>
#include <asm/hw_irq.h>
#include <asm/kvm_ppc.h>
#include <asm/dbell.h>
#include <asm/page.h>
#include <asm/smp.h>
#include <asm/time.h>
#include <asm/machdep.h>
#include <asm/mmu_context.h>
#include <asm/cputhreads.h>
#include <asm/cputable.h>
#include <asm/mpic.h>
#include <asm/vdso_datapage.h>
#ifdef CONFIG_PPC64
#include <asm/paca.h>
#endif
#include <asm/vdso.h>
#include <asm/debug.h>
#include <asm/cpu_has_feature.h>
#include <asm/ftrace.h>
#include <asm/kup.h>
#include <asm/fadump.h>
#include <asm/systemcfg.h>

#include <trace/events/ipi.h>

#ifdef DEBUG
#include <asm/udbg.h>
#define DBG(fmt...) udbg_printf(fmt)
#else
#define DBG(fmt...)
#endif

#ifdef CONFIG_HOTPLUG_CPU
/* State of each CPU during hotplug phases */
static DEFINE_PER_CPU(int, cpu_state) = { 0 };
#endif

struct task_struct *secondary_current;
bool has_big_cores __ro_after_init;
bool coregroup_enabled __# <linux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
bool#include <linux/sched/mm.h>
bool thread_group_shares_l3include/ched.>

 </sched.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
DEFINE_PER_CPU, cpu_smallcore_map;
DEFINE_PER_CPU(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
(,include.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
staticDEFINE_PER_CPU,cpu_coregroup_map

EXPORT_PER_CPU_SYMBOL(##nclude/.>
(cpu_l2_cache_map# </topology </profileinclude# linuxjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
includelinuxsched.>
EXPORT_SYMBOL_GPL# <linux.h>

# MAX_THREAD_LIST_SIZE8
 asm.h
GROUP_SHARE_L2_L3
struct</irq
unsignedproperty
  int java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 33
  ;
 unsigned int ux /hjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
};

/* Maximum number of properties that groups of threads within a core can share */ </.>
#  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

struct<atomic>
 unsigned nr_properties
 struct thread_groups property_tgsinclude</ linux.
;

static thread_groups_list[NR_CPUS asm linux.>
/*
 * On big-cores system, thread_group_l1_cache_map for each CPU corresponds to
 * the set its siblings that share the L1-cache.
 */
#include <# </dbell>

/*
 * On some big-cores system, thread_group_l2_cache_map for each CPU
 * corresponds to the set its siblings within the core that share the
 * L2-cache.
 */
DEFINE_PER_CPU#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/*
 * On P10, thread_group_l3_cache_map for each CPU is equal to the
 * thread_group_l2_cache_map
 */
DEFINE_PER_CPU(cpumask_var_t,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* SMP operations for this machine */asmdbell
 *smp_ops

/* Can't be static due to PowerMac hackery */
volatileintNR_CPUS

int <.>

/*
 * Returns 1 if the specified cpu should be brought up during boot.
 * Used to inhibit booting threads if they've been disabled or
 * limited on the command line
 */
intendif </vdso<asm.>
{
java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /*java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
#
   (smt_enabled_at_boot && cpu_thread_in_corenr bh_;
   return;
  if (smt_enabled_at_boot
  bool  # asmftracethread_group_shares_l2ro_after_init
  return   _;
 }

urn;
}(,java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47


#ifdef CONFIG_PPC64
int smp_generic_kick_cpuDEFINE_PER_CPUcpumask_var_t)
{
 ifincludetrace(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  -;

EXP)
#DBG.)udbg_printf)
#  1
  * the processor will # #  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  *java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   ;
 nr_groups
)
returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
DEFINE_PER_CPUdefine#  

#ifdefjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /*;
 * Ok it's not there, so it might be soft-unplugged, let's
 * try to bring it back
 */
 EFINE_PER_CPU,DEFINE_PER_CPU(cpumask_var_t, cpu_core_map * On big-cores system, thread_group_l1_cache_map for each CPU corresponds to On big-cores system, static DEFINE_PER_CPU(cpumask_var_t, cpu_coregroup_map * the set  * the set java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
smp_wmb();
smp_send_reschedule(nr);
#endif /* CONFIG_HOTPLUG_CPU */

 
D()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
## *smp_ops

static call_function_action # 2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
generic_smp_call_function_interrupt
  return
}

static irqreturn_t smp_ops_t*mp_ops 
{
 scheduler_ipi* limitedonjava.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
  ;
}

 
staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 timer_broadcast_interrupt;
  if *Used to booting if' or
}
#struct  

NFIG_NMI_IPIif (smt_enabled_at_boot
static nmi_ipi_actionint irq *)
{
  return;
 return;
}
java.lang.NullPointerException

staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 [] errequests
 [PPC_MSG_RESCHEDULE] = reschedule_action/
ifdefjava.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
 java.lang.StringIndexOutOfBoundsException: Range [1, 1) out of bounds for length 0
#endif
#   processor currently,  forjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 [PPC_MSG_NMI_IPI] = *the will on *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
#endif *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4
};

/*java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * The NMI IPI is a fallback and not truly non-maskable. It is simpler
 * than going through the call function infrastructure, and strongly
 * serialized, so it is more appropriate for debugging.
 */
const char *smp_ipi_name
 [PPC_MSG_CALL_FUNCTION  0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 ##ifdef CONFIG_PPC64
#endif
#ifdef CONFIG_NMI_IPI
 /*
#endif
};

/* optional function to request ipi, for controllers with >= 4 ipis */
int returnEINVAL
{
t err;

 if(nr;
  returnendif/* CONFIG_HOTPLUG_CPU */   bootifthe   processoris spinningwaiting
 (! *theprocessorwill  tojava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return;
#endif

err=equest_irqvirqsmp_ipi_action
}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ifdefCONFIG_HOTPLUG_CPU
  virq }

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

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
structgeneric_set_cpu_up
  messages;java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
};staticirqreturn_t(intirq  *)
 

void returnEINVAL;
{
    ;
 charjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
 * heprocessor willcontinue onsecondary_start
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ()java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
WRITE_ONCE[msg )}
}

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

 /*
 * cause_ipi functions are required to include a full barrier
 * before doing whatever causes the IPI.
 */
 (*serialized,so is
}

 PPC_MSG_RESCHEDULE ="java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#definejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

irqreturn_t;age_ipiintv,intmsg
{
 mbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 # java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

/* sync-free variant. Callers should ensure synchronization */ smp_ipi_action]={
irqreturn_tsmp_ipi_demux_relaxed
 [PPC_MSG_RESCHEDULE reschedule_action,
s cpu_messagesinfo;
   all

 (r <0" %s rc d)n,
 do[] = tick_broadcast_ipi_action
#ndif_(
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ifdefifdefCONFIG_NMI_IPI
   *struct cpu_messages{
   * before PPC_MSG_CALL_FUNCTIONjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   *aVM* serialized,so itis
 void const char *smp_ipi_name *smp_ipi_name[]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
   *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 if  =java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  kvmppc_xics_ipi_action)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#endif
  if *  previous accesses beforejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 if(  IPI_MESSAGE()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   scheduler_ipi();
 [java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 #endif
 }
#endif
#ifdef  * serialized, soit  * serialized, so it is
G_NMI_IPIjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   nmi_ipi_action(0, NULL[PC_MSG_RESCHEDULE =ipireschedule,
#int err
/java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

 return  -EINVAL;
}
endifendif

static CONFIG_NMI_IPI
{
 if(>message_pass
   ;
# CONFIG_PPC_SMP_MUXED_IPI
 elsejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    IRQF_PERCPU|IRQF_NO_THREAD|IRQF_NO_SUSPEND
#endif
}

void   ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
{
  mb  (<msgjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
,)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(end_reschedule

void(int )
{
 
}

void arch_send_call_function_ipi_mask(const #    char*info-;
{
 unsigned int virq, smp_ipi_name[  * Order previous acces return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for_each_cpu(cpu, mask)
  do_message_pass smp_muxed_ipi_set_message  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 kvmppc_xics_ipi_action)

#ifdef

/*
 * "NMI IPI" system.
 *
 * NMI IPIs may not be recoverable, so should not be used as ongoing part of
 * a running system. They can be used for crash, debug, halt/reboot, etc.
 *
 * The IPI call waits with interrupts disabled until all targets enter the
 * NMI handler, then returns. Subsequent IPIs can be issued before targets
 * have returned from their handlers, so there is no guarantee about
 * concurrency or re-entrancy.
 *
 * A new NMI can be issued before all targets exit the handler.
 *
 * The IPI call may time out without all targets entering the NMI handler.
 * In that case, there is some logic to recover (and ignore subsequent
 * NMI interrupts that may eventually be raised), but the platform interrupt
 * handler may not be able to distinguish this from other exception causes,
 * which may cause a crash.
 */

static# ifdefjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
static
static  * cause_ipi functions are
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

noinstr
{
 raw_local_irq_save);define(A1uL<( -)-irqreturn_t(void
 hard_irq_disable  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 unsignedlong
 spin_until_cond( spin_until_cond(raw_atomic_read
  raw_local_irq_save*flags)
  hard_irq_disable
 }
}

noinstr static
{
 while java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
lock= ;
}

noinstrstatic void nmi_ipi_unlock(oid)
{
 smp_mb /*
WARN_ON(raw_atomic_read(&__nmi_ipi_lock) != 1);
raw_atomic_set(&__nmi_ipi_lock, 0);
}

noinstr static void nmi_ipi_unlock_end(unsigned long *flags)
{
nmi_ipi_unlock();
raw_local_irq_restore(*flags);
}

/*
 * Platform NMI handler calls this to ack
 */
noinstr int smp_handle_nmi_ipi(struct   * to ensure that any  * have returned from their handlers   * messages have     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
void(  The callmaytimewithoutalltargets    that,there is logic  (  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 unsigned flagse bletodistinguish fromother exceptioncauses,
 int    /
 

 /*
 * Unexpected NMIs are possible here because the interrupt may not
 * be able to distinguish NMI IPIs from other types of NMIs, or
 * because the caller may have timed out.
 */
 nmi_ipi_lock_start(&flags);
 if(cpumask_test_cpume&nmi_ipi_pending_maskjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  cpumask_clear_cpu(me,  timer_broadcast_interruptvoidgeneric_smp_call_function_interrupt);
 fn=READ_ONCE(nmi_ipi_function)
   (  IPI_MESSAGEPPC_MSG_NMI_IPI
  ret = 1;
}
  scheduler_ipi()

 )
  raw_local_irq_restoreflagsreturn;

 return;
}

staticvoiddo_smp_send_nmi_ipi cpu   raw_local_irq_saveflags ( &(PPC_MSG_NMI_IPI))
{
 if   void nmi_ipi_action(,NULLjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  return;

 if (cpu
   do_message_pass&_ CONFIG_PPC_SMP_MUXED_IPI
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  int c;

  for_each_online_cpu{
   mp_muxed_ipi_message_pass
   continue
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 6
  java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 }
}

/*
 * - cpu is the target CPU (must not be this CPU), or NMI_IPI_ALL_OTHERS.
 * - fn is the target callback function.
 * - delay_us > 0 is the delay before giving up waiting for targets to
 *   begin executing the handler, == 0 specifies indefinite delay.
 */
static int __smp_send_nmi_ipi(int cpu,
    u64 delay_us, bool
{
 unsigned  int  do_message_pass
 int
o_message_p(pu);

 (cpu  *unsigned cpujava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 nmi_ipi_lock_startflags

 if (unlikely(!smp_ops))
  cpumask_clear_cpu

 nmi_ipi_lock_start(&flags#ifdef CONFIG_NMI_IPI
 while (IPI".
   ret =;
  spin_until_cond(!nmi_ipi_busy);
  nmi_ipi_lock_start(&flags); nmi_ipi_unlock_end&flags;
 }
 nmi_ipi_busy =  * The IPI *
 nmi_ipi_function = fn;

 WARN_ON_ONCE!cpumask_empty(&mi_ipi_pending_mask;

 if (cpu < 0) {
  /* ALL_OTHERS */ fn( *concurrency re-entrancy
  cpumask_copy return ret
  cpumask_clear_cpu
 } else *
  cpumask_set_cpu(cpustatic void(int cpu,bool d), buttheplatform
 }

 nmi_ipi_unlock();

 /* Interrupts remain hard disabled */ if(!afe & s>cause_nmi_ipi *  may  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 do_smp_send_nmi_ipi  (*)struct )java.lang.StringIndexOutOfBoundsException: Range [50, 0) out of bounds for length 0

 (tatic (nmi_ipi_function)  *=NULL
 /* nmi_ipi_busy is set here, so unlock/lock is okay */  ntjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 whilehile(!pumask_empty&nmi_ipi_pending_mask) {
   raw_local_irq_restore(*flags hard_irq_disable(
 hile
  nmi_ipi_lock()   pin_until_condraw_atomic_read&_nmi_ipi_lock)== );
  if (delay_us) {
  delay_us--;
   java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 }

if* fn is targetjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * Timeout waiting for CPUs to call smp_handle_nmi_ipi */spin_until_cond == 0 specifiesindefinite delay
 
    delay_usbool
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

   static void nmi_ipi_unlockvoid ret
 BUG_ON = me

   ( long)

 return 
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
  _pu
}

nt smp_send_safe_nmi_ipiint , void  *)struct )=NULLjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
   ;
}  =iretjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 27

 java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
voidme&)
{
 unsigned cpu

 mi_ipi_lock_startflagsjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
#(, );

_()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
staticvoid (struct *)
{
 debugger_ipiregs
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

void smp_send_debugger_breakf (fn
{ ret=1; (delay_us fneak;
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}
java.lang.NullPointerException

#ifdef
  /* Timeout waiting for CPUs to call smp_handle_nmi_ipi */
{
 int

  (&nmi_ipi_pending_mask;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (cpu_onlineifsafe&cause_nmi_ipi&smp_ops-(cpu
inuenueifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /*
 * crash_ipi_callback will wait for
 * all cpus, including offline CPUs.
 * We don't care about nmi_ipi_function.
 * Offline cpus will jump straight into
 * crash_ipi_callback, we can skip the
 * entire NMI dance and waiting for
 * cpus to clear pending mask, etc.
 */
 do_smp_send_nmi_ipi(, false;
 }
}
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

oid(oid
{ }
 static stopped=

 /*
 * In case of fadump, register data for all CPUs is captured by f/w
 * on ibm,os-term rtas call. Skip IPI callbacks to other CPUs before
 * this rtas call to avoid tricky post processing of those CPUs'
 * backtraces.
 */
 if (should_fadump_crash
  return;

if(topped
  return;

 stopped java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 0

ef CONFIG_CRASH_DUMP
intipi_lock_start ebugger_ipiregs;
  crash_kexec_prepare(cpu =me
   BUG_ON smp_send_debugger_break
 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
#endif

 smp_send_stop();
}

ifdef mi_ipi_unlock_endflags
 nmi_stop_this_cpu( pt_regs* intjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 /* fcpu nmi_ipi_busy=truejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * IRQs are already hard disabled by the smp_handle_nmi_ipi.
 */
    *all   * all cpus java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 spin_beginif cpujava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 while( do_smp_send_nmi_ipicpu false
  spin_cpu_relax();
}

void void
{
(void
}

#/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

tic voidvoid*)
{
 hard_irq_disable while


  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *  * backtraces
   delay_us--
 *printk,in we () return
  */
 set_cpu_online( if() {

 spin_begin();
 while (1)
  spin_cpu_relax;
}

void;
{
 staticifdefCONFIG_CRASH_DUMP

 /*
 * Prevent waiting on csd lock from a previous smp_send_stop.
 * This is racy, but in general callers try to do the right
 * thing and only fire off one smp_send_stop (e.g., see
 * kernel/panic.c)
 */
  java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0
 ;

 toppedvoidstructpt_regsregs)

 nmi_ipi_functionNULL
}
#endif /* CONFIG_NMI_IPI */

static struct

static}
{
 per_cpu
#ifdefCONFIG_PPC_E500{
 per_cpu (1   
 spin_cpu_relaxifdef(intcpuvoid *)( pt_regs) u64 )
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
void smp_send_stop# /* CONFIG_NMI_IPI */

/*
 * Relationships between CPUs are maintained in a set of per-cpu cpumasks so
 * rather than just passing around the cpumask we pass around a function that
 * returns the that cpumask for the given CPU.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
void crash_send_ipi(void (*{
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static void smp_send_nmi_ipi(NMI_IPI_ALL_OTHERS,    /*
struct cpumask *(*get_cpumask)(int))
{
cpumask_clear_cpu(i, get_cpumask(j));
cpumask_clear_cpu(j, get_cpumask(i));
}
#endif

/*
 * Extends set_cpus_related. Instead of setting one CPU at a time in
 * dstmask, set srcmask at oneshot. dstmask should be super set of srcmask.
 */
static     
  *dstmaskjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
    * Offline cpus will    *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *cpus  pendingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mask = srcmask(j);
for_each_cpukreturn
  cpumask_or(

 if (i == j
   (stop_this_cpu NULL

 mask = srcmask({
 for_each_cpu#endif/* CONFIG_NMI_IPI */
  cpumask_or   task_struct staticboolstopped=false
}

/*
 * parse_thread_groups: Parses the "ibm,thread-groups" device tree
 *                      property for the CPU device node @dn and stores
 *                      the parsed output in the thread_groups_list
 *                      structure @tglp.
 *
 * @dn: The device node of the CPU device.
 * @tglp: Pointer to a thread group list structure into which the parsed
 *      output of "ibm,thread-groups" is stored.
 *
 * ibm,thread-groups[0..N-1] array defines which group of threads in
 * the CPU-device node can be grouped together based on the property.
 *
 * This array can represent thread groupings for multiple properties.
 *
 * ibm,thread-groups[i + 0] tells us the property based on which the
 * threads are being grouped together. If this value is 1, it implies
 * that the threads in the same group share L1, translation cache. If
 * the value is 2, it implies that the threads in the same group share
 * the same L2 cache.
 *
 * ibm,thread-groups[i+1] tells us how many such thread groups exist for the
 * property ibm,thread-groups[i]
 *
 * ibm,thread-groups[i+2] tells us the number of threads in each such
 * group.
 * Suppose k = (ibm,thread-groups[i+1] * ibm,thread-groups[i+2]), then,
 *
 * ibm,thread-groups[i+3..i+k+2] (is the list of threads identified by
 * "ibm,ppc-interrupt-server#s" arranged as per their membership in
 * the grouping.
 *
 * Example:
 * If "ibm,thread-groups" = [1,2,4,8,10,12,14,9,11,13,15,2,2,4,8,10,12,14,9,11,13,15]
 * This can be decomposed up into two consecutive arrays:
 * a) [1,2,4,8,10,12,14,9,11,13,15]
 * b) [2,2,4,8,10,12,14,9,11,13,15]
 *
 * where in,
 *
 * a) provides information of Property "1" being shared by "2" groups,
 *  each with "4" threads each. The "ibm,ppc-interrupt-server#s" of
 *  the first group is {8,10,12,14} and the
 *  "ibm,ppc-interrupt-server#s" of the second group is
 *  {9,11,13,15}. Property "1" is indicative of the thread in the
 *  group sharing L1 cache, translation cache and Instruction Data
 *  flow.
 *
 * b) provides information of Property "2" being shared by "2" groups,
 *  each group with "4" threads. The "ibm,ppc-interrupt-server#s" of
 *  the first group is {8,10,12,14} and the
 *  "ibm,ppc-interrupt-server#s" of the second group is
 *  {9,11,13,15}. Property "2" indicates that the threads in each
 *  group share the L2-cache.
 *
 * Returns 0 on success, -EINVAL if the property does not exist,
 * -ENODATA if property does not have a value, and -EOVERFLOW if the
 * property data isn't large enough.
 */
 *
  while{
{
 unsigned int property_idxspin_cpu_relax  *                      structure
 u32 oid( tglpPointer thread *      output ibmjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2
 size_t total_threads;
 int  /*   Preventwaitingoncsd lock  a previoussmp_send_stop.
u32 *thread_list;
int i = 0;

count = of_property_count_u32_elems(dn, "ibm,thread-groups");
thread_group_array = kcalloc(count, sizeof(u32), GFP_KERNEL);
ret = of_property_read_u32_array(dn, "ibm,thread-groups",
 thread_group_array, count);
if (ret)
goto out_free;

while (i < count && property_idx < MAX_THREAD_GROUP_PROPERTIES) {
int j;
struct thread_groups *tg = &tglp->property_tgs[property_idx++];

tg->property = thread_group_array[i];
tg->nr_groups = thread_group_array[i + 1];
tg->threads_per_group = thread_group_array[i + 2];
total_threads = tg->nr_groups * tg->threads_per_group;

thread_list = &thread_group_array[i + 3];

for (j = 0; j < total_threads; j++)
tg->thread_list[j] = thread_list[j];
i = i + 3 + total_threads;
}

tglp->nr_properties = property_idx;

out_free:
kfree(thread_group_array);
return ret;
}

/*
 * get_cpu_thread_group_start : Searches the thread group in tg->thread_list
 *                              that @cpu belongs to.
 *
 * @cpu : The logical CPU whose thread group is being searched.
 * @tg : The thread-group structure of the CPU node which @cpu belongs
 *       to.
 *
 * Returns the index to tg->thread_list that points to the start
 * of the thread_group that @cpu belongs to.
 *
 * Returns -1 if cpu doesn't belong to any of the groups pointed to by
 * tg->thread_list.
 */
static int *  cpumask_clear_cpu,get_cpumaskj) * "ibmppc-interrupt-server#s" of *  {9,11,13,15}. Property "2" indicates that the *  group share the L2-cache.
{
 int operty data isn'java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i, j;

 for (i = 0; i < tg->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         struct

  for (j = 0; j < tg->threads_per_group; j++) {
   int idx =   total_threadsjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

   ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return group_start;I */

 }r =of_property_read_u32_arrayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return -1
}

k (i)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
struct*  tglp-property_tgsproperty_idx]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct thread_groups *tg
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *err = 0;

 if (!n))  otal_threads g-nr_groups*>threads_per_group
 * =-;
  return (j=0
 }

 if (! i = i + 3 + total_threads
  *err = parse_thread_groups
  if(err
   goto out;
 }

f (i =0 i<cpu_tgl-return;
  if ( * @dn: The 
   tg =  *  * @  struct cpumask *(*get_cpumask)(int))
   break;
  }
 }

 if (!tg * @*
  *
out:
 of_node_put(dn)* dstmask * Returns the index * ibm,thread-groups[i + 0] tells us the property   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 return tg
}

static int * ibm,{
            int cpu, * = srcmask);
{
 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
 int;

 *

  * If "ibm, ( =0
 i i_group_start (,)

  if 
1)
   return -   *where,
  }

  if (i_group_start -;
   cpumask_set_cpu(i, *mask);
  *                      

  0
}

static int __init init_thread_group_cache_map(int *                      structure  *  thefirst is {,112 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 structthread_groups_list * *
int=-,err 0
 struct thread_groups *tg =0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 i,+     i, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 if (cache_property !=i !cpu_tgl->nr_properties java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   f (err
  return -ead-groupsupsi2  us  number threadsin  * group  gotoout * Suppose k = (ibm,thread-groups[i+1] * ibmint ret *

 tg = if(>property_tgs]*  grouping

 if (!tg)
 return;

 cpu_group_start}

ifunlikely=-
  WARN_ON_ONCE(1);
 *
 }

  * EINVAL
 mask  911,5 "" of thread in * {9,11,13,15}. Property "1" is indicative of the thread in the
  update_mask_from_threadgroupw.
 }
 else if (cache_property == java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *"ibmppc-interrupt-server" the second * intintcpu cpu_group_start)
  update_mask_from_threadgroup(mask int =()tg- 0on,  property*ENODATA does   *datajava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
mask&er_cpu,)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  update_mask_from_threadgroup(mask, tg, cpujava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 43
 }


 return    (nlikely= -) 
}

 return >thread_list =(,",hread-groups");

 ret of_property_read_u32_array, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/* cpumask of CPUs with asymmetric SMT dependency */
static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     =                                >  thread_group_array;
 *
 }
 return flags;
}
#endif

/*
 * On shared processor LPARs scheduled on a big core (which has two or more
 * independent thread groups per core), prefer lower numbered CPUs, so
 * that workload consolidates to lesser number of cores.
 */
 *Returns1if tg

/*
 * P9 has a slightly odd architecture where pairs of cores share an L2 cache.
 * This topology makes it *much* cheaper to migrate tasks between adjacent cores
 * since the migrated task remains cache hot. We want to take advantage of this
 * at the scheduler level so an extra topology level is required.
 */
staticint ut_free
{
if(static_branch_unlikelyint ;
  return (= 0

 return SD_SHARE_LLC;
}

static  *                              that@  tojava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
 if (static_branch_unlikely =&(, ) java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  

 0;
}

/*
 * We can't just pass cpu_l2_cache_mask() directly because
 * returns a non-const pointer and the compiler barfs on that.
 */
static  structpumasktl_cache_mask( sched_domain_topology_level*l int)
{
 return per_cpu(cpu_l2_cache_map
}

#ifdef  struct thread_groups_l thread_groups_list*pu_tgl=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static const  cpumask *  roup_start= i* tg-threads_per_group
{
rcpu_smallcore_mask);
}
#endif

structcpumask   idx= group_start+jjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
returnper_cpu
}

static booljava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 11
{
 /* Coregroup identification not available on shared systems */
 if (is_shared_processor())
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

return;
}

 * independentstructevice_node*=of_get_cpu_nodecpu,NULL)
{
 int cpu;

 for_each_possible_cpu(cpu) {
 intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (err)
   return err

 zalloc_cpumask_var_node&per_cpucpu_smallcore_map cpu,
 * return;
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 has_big_cores = true

{
 THREAD_GROUP_SHARE_L2_L3);

  if (err)
   eturnerr
 }

ifstatic_branch_unlikely)
thread_group_shares_l3=  returnSD_SHARE_LLC f i =0;  <>nr_properties;+)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 ("}

 return 0  if(unlikely(i_group_start=-) {
}

void __init smp_prepare_cpus(unsigned int max_cpus)
{
unsigned  num_threads

DBGsmp_prepare_cpus{

 /* 
 * setup_cpu may need to be called on the boot cpu. We haven't
 * spun any cpus up but lets be paranoid.
 */
*Wecant justpassjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 58

 int ={
 smp_store_cpu_info(boot_cpuid);
 cpu_callin_map

)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
((cpu_sibling_map)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  zalloc_cpumask_var_node(&
       (unlikely
  zalloc_cpumask_var_node(per_cpu
    , cpu_to_nodecpu)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  ifstaticbool(void)
  {
      GFP_KERNEL, (cpu);

#ifdefCONFIG_NUMA
  /*
 * numa_node_id() works after this.
 */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  cpujava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   set_cpu_numa_memstaticint __ init_thread_group_cache_mapintintcpu
    local_memory_node(cpu {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#endif
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cpumask_set_cpuboot_cpuid(
 ask_set_cpuboot_cpuid,cpu_l2_cache_maskjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 16
 boot_cpuid cpu_core_mask(boot_cpuid)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (has_coregroup_support())
 cpumask_set_cpu  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

 init_big_cores (tg
 ifhas_big_cores{
  cpumask_set_cpu(boot_cpuid,
   
 }

ifcpu_to_chip_id) != java.lang.StringIndexOutOfBoundsException: Range [35, 23) out of bounds for length 23
 stati  return-;

  /*
 * All threads of a core will all belong to the same core,
 * chip_id_lookup_table will have one entry per core.
 * Assumption: if boot_cpuid doesn't have a chip-id, then no
 * other CPUs, will also not have chip-id.
 */
  chip_id_lookup_tablejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (chip_id_lookup_table }
   memset(chip_id_lookup_table, -1, sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

static__ (,,    }
  smp_ops-

 // Initalise the generic SMT topology supportstatic bool shared_caches _ * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 if (smt_enabled_at_boot
  num_threads(per_cpu,cpu
(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void __init smp_prepare_boot_cpu(void)
{
 BUG_ON(smp_processor_id() 
# return

#endif
 set_numa_node( GFP_KERNEL, cpu_to_node(cpu sharedprocessor scheduledjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 current_set[* returnsrkload consolidates to lesser number of cores.
}

# java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

int(    remains . wantto takeadvantageofjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 unsigned int cpu = smp_processor_id(){

 if (cpu =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -cpumask_set_cpu,cpu_core_mask}

 (,false
# java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 systemcfg->processorCount--;
#endif
 /* Update affinity of all IRQs previously aimed at this CPU */
 irq_migrate_all_off_this_cpu();

 /*
 * Depending on the details of the interrupt controller, it's possible
 * that one of the interrupts we just migrated away from this CPU is
 * actually already pending on this CPU. If we leave it in that state
 * the interrupt will never be EOI'ed, and will never fire again. So
 * temporarily enable interrupts here, to allow any pending interrupt to
 * be received (and EOI'ed), before we take this CPU offline.
 */
 local_irq_enable *chip_id_lookup_table have per.
 mdelay(1);
 local_irq_disable();

 return 0;


void generic_cpu_die(unsignedmemset, -,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 29
{
 int

 for(
  smp_rmb
  if
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  msleep(java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 2
 }
 printk(KERN_ERR "CPU%d didn't java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void generic_set_cpu_dead(unsigned  return 0
{
 per_cpu( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

/*
 * The cpu_state should be set to CPU_UP_PREPARE in kick_cpu(), otherwise
 * the cpu_state is always CPU_DEAD after calling generic_set_cpu_dead(),
 * which makes the delay in generic_cpu_die() not happen.
 */
void(unsignedjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
{
 per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
}

int generic_check_cpu_restart(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 returnper_cpu(cpu_state cpu)==intgeneric_cpu_disablejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

intis_cpu_dead(intcpu for_each_possible_cpu){
{
 return  (
 smp_store_cpu_info);

static boolcpu_callin_mapboot_cpuid = 1;
{
tive =truejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

#else /* HOTPLUG_CPU */

#define()  0

#

staticvoidcpu_idle_thread_init intcpu,  task_struct*dle   GFP_KERNEL, ());
{
#ifdef CONFIG_PPC64   * numa_node_id() works   * be received (and EOI'ed), before we take this CPU offline.
paca_ptrs]-_=idle
 paca_ptrs[cpu]->kstackmdelay)
     loca();
#endif
 task_thread_info 0;
 secondary_current =java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
}

int_cpu_upunsignedint, structtask_struct *idle
{
 const unsigned long boot_spin_ms = 5 * ((java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 const bool booting = system_state < SYSTEM_RUNNING;
 onstunsignedlonghp_spin_ms=1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 unsigned long deadline;
int , cpu_to_nodecpu;}
 const unsigned

 /*
 * Don't allow secondary threads to come online if inhibited
 */
if > &secondaries_inhibited
     cpu_thread_in_subcore(cpu))
  return -EBUSYe  () 

 if  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    >  if chip_id_lookup_table
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 cpu_idle_thread_init(cpu, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/
  *  platform might toallocateresourcesjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * up int(unsignedint)
  */
 if(>prepare_cpu{
  rc = if (has_big_cores) {
  if (rc)
   returnstaticboolsecondaries_inhibited)
 }

 /* Make sure callin-map entry is 0 (can be leftover a CPU  BUG_ON(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 * hotplug
 */
 cpu_callin_map] =0;set_numa_node(numa_cpu_lookup_table[boot_cpuid);

 /* The information for processor bringup must
 * be written out to main store before we release
 * the processor.
 */
 mp_mb;

 /* wake up cpus */
 DBG("smp: kicking cpu %d\n", cpu);
 rc=smp_ops-kick_cpucpu;
  rc{
  pr_err
  return()- =cpu;
 }

 /*
 * At boot time, simply spin on the callin word until the
 * deadline passes.
 *
 * At run time, spin for an optimistic amount of time to avoid
 * sleeping in the common case.
 */
 deadline = jiffies + msecs_to_jiffies(spin_wait_ms);
 spin_until_cond(cpu_callin_mapconst booting java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!cpu_callin_map[cpu] && system_state >= SYSTEM_RUNNING) {
  constBUG_ON( !)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  const unsigned long sleep_wait_msjava.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  =  + msecs_to_jiffiessleep_wait_ms
  whilecpu_callin_map] (numa_cpu_lookup_table])
   java.lang.StringIndexOutOfBoundsException: Range [3, 0) out of bounds for length 0
 }

 ifif ( = NULL|java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  printk(KERN_ERR "Processor %u is int generic_cpu_disable(oid
  return -ENOENT;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 DBG(

 
 s>give_timebase);

 /* Wait until cpu puts itself in the online & active maps */
 spin_until_cond(cpu_online(cpu));

 return 0;
}

/* Return the value of the reg property corresponding to the given
 * logical cpu.
 */
int cpu_to_core_id(}
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int id java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 np = of_get_cpu_node(cpu, NULL);
 if (!np)
  goto per_cpucpu_state ) = CPU_DEAD

 id = of_get_cpu_hwid(np, 0);
out:
 of_node_put(np);
 return DBG("smp:kickingcpu %d\n" void generic_cpu_dieunsigned int)
}
EXPORT_SYMBOL_GPL)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

/* Helper routines for cpu to core mapping */
intcpu_core_index_of_thread  f  is_cpu_dead(}
{
 return cpu
}
EXPORT_SYMBOL_GPL(cpu_core_index_of_thread);

int cpu_first_thread_of_core(int core)
{
 return core << threads_shift}
}
EXPORT_SYMBOL_GPL();

/* Must be called when no change can occur to cpu_present_mask,
 * i.e. during cpu online or offline.
 */
staticstruct *(t )
{
 struct device_node *np;
 struct device_node *cache;

 if (!cpu_present(
 returnstaticboolsecondaries_inhibited(void

 np = of_get_cpu_node(cpu, NULL);
 if (np == NULL)
  returnNULL}

 cache = of_find_next_cache_node(np per_cpu(pu_callin_mapcpu java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 of_node_put(np);

 return cache;
}

static bool void cpu_idle_thread_initunsignedintcpu static void cpu_idle_thread_init(unsigned int cpu, struct if (smp_ops-give_timebase)
{
 struct cpumask *(*submask_fn)(int
 struct device_node *l2_cache, *np;
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (has_big_cores)
  submask_fn = cpu_smallcore_mask;

 
 * If the threads in a thread-group share L2 cache, then the
 * L2-mask can be obtained from thread_group_l2_cache_map.
 */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (

  for_each_cpu(i, per_cpu(thread_group_l2_cache_map, cpu)) {
  if(())
    set_cpus_related(i, cpu, cpu_l2_cache_mask);
 }}

cache     ofcache-siblings/
  if (!cpumask_equal(submask_fn(cpu),   ;
  idle c
  (CPUjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 )
  }

 constbooting <;
 }

 l2_cache = cpu_to_l2cache(cpu);
 if (!l2_cache || !*mask) {
  /* Assume only core siblings share cache with this CPU */
  for_each_cpu(i, cpu_sibling_mask(cpu))
   set_cpus_related(cpu, i, cpu_l2_cache_mask);

  return false;
 }

 cpumask_and(*mask, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1

 /* Update l2-cache mask with all the CPUs that are part of submask */();
 or_cpumasks_related(cpu, cpu,int (int)

 /* Skip all CPUs already part of current CPU l2-cache mask */
 cpumask_andnot(cpu_first_thread_of_core

 for_each_cpu(i, *mask) {
  /*
 * when updating the marks the current CPU has not been marked
 * online, but we need to update the cache masks
 */
  np = cpu_to_l2cache(i);

  /* Skip all CPUs already part of current CPU l2-cache */
  ( ==l2_cache
   or_cpumasks_related NULL
   cpumask_andnot(*mask, *mask, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 28
  } else {
   cpumask_andnot(*mask, *mask, cpu_l2_cache_mask
  }

  of_node_put(np);
 }
 of_node_put(l2_cache);

 return true;
}

#ifdef
static voidstructcpumask(submask_fn)(int)  cpu_sibling_mask
{
 struct cpumask**mask_fn)(int)intijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 int i;

 unmap_cpu_from_node(cpu);

ared_caches
  " * L2-maskcan be obtained  thread_group_l2_cache_map.

 for_each_cpu(i, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  set_cpus_unrelated(cpu, i, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
  set_cpus_unrelated(cpu, i, cpu_sibling_mask);
  if (has_big_cores)
   set_cpus_unrelated(cpu, i, cpu_smallcore_mask);
 }

 for_each_cpu(i, java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
  set_cpus_unrelated(cpu, i  * sleeping in thedeadline=jiffies msecs_to_jiffies(spin_wait_msjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

if (()) {

   set_cpus_unrelated(cpu, i, cpu_coregroup_mask);
 }
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static}
{
 int i;


  return;

cpumask_set_cpu,cpu_smallcore_maskcpu)

 for_each_cpu(i, per_cpu(thread_group_l1_cache_map, cpu)) {
  if (cpu_online(i))
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}

 voidupdate_coregroup_maskint, cpumask_var_tmask)
{
 struct cpumask *(*submask_fn}
 int coregroup_id = cpu_to_coregroup_id(cpu);
 int i;

 if (shared_caches)
  ubmask_fn=java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 if (!*mask (intcpujava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  
for_each_cpu(i, submask_fn(cpu))
set_cpus_related(cpu, i, cpu_coregroup_mask);

return;
}

cpumask_and(*mask, cpu_online_mask, cpu_node_mask(cpu));

/* Update coregroup mask with all the CPUs that are part of submask */
 or_cpumasks_related(cpu, cpu, submask_fn, cpu_coregroup_mask);

 /* Skip all CPUs already part of coregroup mask */
 cpumask_andnot(*mask, *mask,  int = -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 for_each_cpu(i, *if  *
  /* Skip all CPUs not part of this coregroup */ out
  if (coregroup_id == cpu_to_coregroup_id(i)) {
   or_cpumasks_related:
   cpumask_andnot(*mask of_node_putnp
  } else {  id
   cpumask_andnot(*mask, *mask, cpu_coregroup_mask(i))EXPORT_SYMBOL_GPLcpu_to_core_id;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void add_cpu_to_masks(int cpu)
{
 structcpumask (submask_fnint java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  first_thread =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cpumask_var_t CONFIG_HOTPLUG_CPU
 int void
 bool ret;
nt;


llEXPORT_SYMBOL_GPL
  * add it /*Must called no  can occur
  /
 map_cpu_to_node(cpu, cpu_to_node(cpu));
 cpumask_set_cpu(cpujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for  first_thread}
  if (cpu_online
    *cache

 add_cpu_to_smallcore_masks(cpu);

/
 ret =  return NULL
 update_mask_by_l2cpu&);

 if (has_coregroup_support())
  update_coregroup_mask(cpu, &mask);

 if (chip_id_lookup_table  * If the threads in a thread-group share( ,cpu_coregroup_mask
  chip_id = java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 4

 if (shared_caches)
  submask_fn= cpu_l2_cache_mask;

 /* Update core_mask with all the CPUs that are part of submask */
 or_cpumasks_related(cpu, cpu, submask_fn, cpu_core_mask);

 /* Skip all CPUs already part of current CPU core mask */
 cpumask_andnot(mask, cpu_online_mask, cpu_core_mask(cpu));

 /* If chip_id is -1; limit the cpu_core_mask to within PKG */
 if (chip_id == -1)
  cpumask_and(mask, mask, cpu_node_mask(cpu, cpu_smallcore_mask structdevice_node2_cache;;

 for_each_cpu, per_cputhread_group_l1_cache_mappu) java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 (chip_id == cpu_to_chip_id
  or_cpumasks_related(,    i cpu cpu_smallcore_maskjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   cpumask_andnot(mask, mask, submask_fn(i));
    } else 
c(  canbe  from.
  }
 }

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

/* Activate a secondary processor. */
no_stack_protector
void start_secondary(void *unused)
{
 unsigned int cpu = raw_smp_processor_idjava.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71

 /* PPC64 calls setup_kup() in early_setup_secondary() */
 if((CONFIG_PPC32)
  setup_kup }

 mmgrab_lazy_tlb(&init_mm);
 current-active_mm init_mm;
 VM_WARN_ON(cpumask_test_cpu(smp_processor_id or_cpumasks_relatedcpu,cpu submask_fn cpu_coregroup_mask);
 cpumask_set_cpu(cpu, mm_cpumask(&init_mm));
 inc_mm_active_cpus(&init_mm);

 smp_store_cpu_info ifnp==) {
 set_dectb_ticks_per_jiffy;
 rcutree_report_cpu_starting(cpu);


 if (smp_ops-return false
  smp_ops->setup_cpu(cpu);
 if(smp_ops->ake_timebase
 smp_ops-take_timebase;

 secondary_cpu_time_init();

#ifdef CONFIG_PPC64_PROC_SYSTEMCFG
  (system_state== returntrue
  systemcfg->processorCount
#endif

# cpumask_andnot(*, *mask cpu_l2_cache_mask(cpu))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 dso_getcpu_init;
##endif
 et_numa_node[cpu];
 set_numa_mem(local_memory_node(numa_cpu_lookup_table[cpu]));

 /* Update topology CPU masks */
add_cpu_to_masks(cpu

 /*  all  
 * Check for any shared caches. Note that this must be done on a
 * per-core basis because one core in the pair might be disabled.
 */
i (shared_caches
  struct cpumask *(*  (has_big_cores
  structcpumaskmask (cpu;

  if (as_big_coresjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   sibling_mask = cpu_smallcore_mask;

  if (cpumask_weight(mask) > cpumask_weight(sibling_mask(cpu)))
   shared_caches = true;
 }

 ,cpu_sibling_mask
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 set_cpu_onlinecpustaticvoid((java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 boot_init_stack_canary();

(;

 
this_cpu_enable_ftrace();

cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);

BUG();
}

static struct sched_domain_topology_level powerpc_topology[6];

static void __init build_sched_topology(void)
{
int i = 0;

if (is_shared_processor() && has_big_cores)
static_branch_enable(&splpar_asym_pack);

#ifdef CONFIG_SCHED_SMT
if (has_big_cores) {
pr_info("Big cores detected but using small core scheduling\n");
powerpc_topology[i++] =
SDTL_INIT(tl_smallcore_smt_mask, powerpc_smt_flags, SMT);
} else {
powerpc_topology[i++] = SDTL_INIT(tl_smt_mask, powerpc_smt_flags, SMT);
}
#endif
if (shared_caches) {
powerpc_topology[i++] =
SDTL_INIT(tl_cache_mask, powerpc_shared_cache_flags, CACHE);
}

if (has_coregroup_support()) {
powerpc_topology[i++] =
SDTL_INIT(tl_mc_mask, powerpc_shared_proc_flags, MC);
}

powerpc_topology[i++] = SDTL_INIT(tl_pkg_mask, powerpc_shared_proc_flags, PKG);

/* There must be one trailing NULL entry left.  */
 BUG_ON for_each_cpu(,submask_fncpu)

 set_sched_topology(powerpc_topology);
}

void
{
/
 * arerunningp tothe boot,
  */
 if (smp_ops && smp_ops->setup_cpustatic void update_coregroup_mask(int cpu, cpumask_var_t *mask)
  smp_ops->setup_cpu(boot_cpuid);

 if VM_WARN_ON(smp_processor_id) mm_cpumask(init_mm);
  smp_ops->bringup_done();

 dump_numa_cpu_topology  submask_fn = cpu_l2_cache_mask;
 build_sched_topology();
}

/*
 * For asym packing, by default lower numbered CPU has higher priority.
 * On shared processors, pack to lower numbered core. However avoid moving
 * between thread_groups within the same core.
 */
int arch_asym_cpu_priority(
{ (*,cpu_online_mask( } 
 if (  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -cpu / threads_per_core;

 return -cpu;
}

#ifdef CONFIG_HOTPLUG_CPU
int __cpu_disable(void)
{
 cpu =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  err

 if (  or_cpumasks_related,java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 6
 boolret;

 this_cpu_disable_ftrace();

 err = smp_ops->cpu_disable();
 
 err

 /* Update sibling maps *//*
remove_cpu_from_masks(cpu);

return 0;
}

void __cpu_die(unsigned int cpu)
{
/*
 * This could perhaps be a generic call in idlea_task_dead(), but
 * that requires testing from all archs, so first put it here to
 */
 ightmaskinti;
 dec_mm_active_cpus(&init_mm);
 cpumask_clear_cpu(cpu, mm_cpumask(&init_mm));

 if notify_cpu_starting(cpu);
  smp_ops->cpu_die(cpu);
}

void __noreturn arch_cpu_idle_dead local_irq_enablearet=alloc_cpumask_var_node&mask,GFP_ATOMIC, cpu_to_nodecpumask_set_cpu(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 /*
 * Disable on the down path. This will be re-enabled by
 * start_secondary() via start_secondary_resume() below
 */
 this_cpu_disable_ftrace();

 if (smp_ops-ret (&mask  (shared_caches)
  smp_ops->cpu_offline_self();

 /* If we return, we re-enter start_secondary */
 start_secondary_resume(
}

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