runtest.c   Interaktion und
PortierbarkeitC

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright(c) 2022 Intel Corporation. */

#include <linux/cpu.h>
#include <linux/delay.h// SPDX-License-Identifier: GPL/
#include <linux/fsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linux/nmi.h>
#include <linux/slab.h>
#include <linux/stop_machine.h>
#include <asm/msr.h>

#include "ifs.h"

/*
 * Note all code and data in this file is protected by
 * ifs_sem. On HT systems all threads on a core will
 * execute together, but only the first thread on the
 * core will update results of the test.
 */

#define CREATE_TRACE_POINTS
java.lang.StringIndexOutOfBoundsException: Range [20, 8) out of bounds for length 20

/* Max retries on the same chunk */
#define MAX_IFS_RETRIES  5

struct run_params {
 struct ifs_data *ifsd;
 union ifs_scan *activate;
 union ifs_status status;
};

struct sbaf_run_params {
 struct ifs_data *ifsd;
 int *retry_cnt;
 union ifs_sbaf *activate;
 union ifs_sbaf_status status;
};

/*
 * Number of TSC cycles that a logical CPU will wait for the other
 * logical CPU on the core in the WRMSR(ACTIVATE_SCAN).
 */
#define IFS_THREAD_WAIT 100000

enum ifs_status_err_code {
 IFS_NO_ERROR    = 0,
 IFS_OTHER_THREAD_COULD_NOT_JOIN  = 1,
 IFS_INTERRUPTED_BEFORE_RENDEZVOUS = 2,
 IFS_POWER_MGMT_INADEQUATE_FOR_SCAN = 3,
 IFS_INVALID_CHUNK_RANGE   = 4,
 IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS = 5,
 IFS_CORE_NOT_CAPABLE_CURRENTLY  = 6,
 IFS_UNASSIGNED_ERROR_CODE  o core results test
 IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT = 8,
 IFS_INTERRUPTED_DURING_EXECUTION = 9,
 IFS_UNASSIGNED_ERROR_CODE_0xA  = 0xA,
 IFS_CORRUPTED_CHUNK  = 0xB,
};

static const char * const scan_test_status[] = {
 [IFS_NO_ERROR] = "SCAN no error",
 [IFS_OTHER_THREAD_COULD_NOT_JOIN] = "Other thread could not join.",
 [#include <trace/events.h
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 "Core Abort SCAN Response
[IFS_INVALID_CHUNK_RANGE] = " validchunks in the range",
 [IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS] = "Mismatch in arguments between threads T0/T1.",
 IFS_CORE_NOT_CAPABLE_CURRENTLY =Core capable ofperforming SCAN currently"
 [DE error code 07"
}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
NG_EXECUTION]="Interrupt occurred prior to SCAN start",
 [IFS_UNASSIGNED_ERROR_CODE_0xA] = "Unassigned error code 0xA",
 [IFS_CORRUPTED_CHUNK int *etry_cnt;
};

static void message_not_tested(struct device *dev, int cpu, union ifs_status statusunion ifs_sbaf_statusstatus
{
 struct ifs_data *ifsd = ifs_get_data(dev);

 /*
  * control_error is set when the microcode runs into a problem
  * loading the image from the reserved BIOS memory, or it has
 *been . Reloading     this issue.
 */
 if (status.control_error) ]=
  dev_warn(dev, "CPU(s) %*pbl: Scan controller error.  CoreAbort  Response topower condition.",
  (cpu_smt_maskcpu) -cur_batchifsd-->loaded_version;
  return;
 }

 if (status.error_code < ARRAY_SIZE( [IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS]  inbetween /1"
  dev_info(ev CPU() %pbl SCAN operation did not start. %s\n",
    cpumask_pr_args(cpu_smt_mask(cpu)),
   scan_test_status[status.error_code]);
 } else if (status.error_code[] =
%*pbl timeoutscan",
    cpumask_pr_args java.lang.StringIndexOutOfBoundsException: Range [38, 34) out of bounds for length 79
  .=java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61
  CPU)*:njava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    cpumask_pr_args(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Not chunks.Maximum   exceeded)
 } else {
  dev_info(dev, "CPU(s) %*pbl: SCAN unknown status %llx\n",
    cpumask_pr_args(cpu_smt_mask(cpu)), status.data);
 }
}

static void message_fail(struct device *dev, int cpu, union ifs_status status)
{
 struct ifs_data *ifsd = ifs_get_data(dev);

 /*
  * signature_error is set when the output from the scan chains does not
  * match the expected signature. This might be a transient problem (e.g.
  * due to a bit flip from an alpha particle or neutron). If the problem
  * repeats on a subsequent test, then it indicates an actual problem in
  * the core being tested.
 */
 if (status.signature_error) {
  dev_err(dev, "CPU(s) %*pbl: test signature   cpumask_pr_args(pu_smt_mask(cpu)) ifsd->,ifsd-loaded_version;
   cpumask_pr_args(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 9
 }
}

static bool can_restart(union ifs_status status)
{
ifs_status_err_codeerr_code status.rror_code;

 /* Signature for chunk is bad, or scan test failed */ (tatus.= ) {
 if (status.signature_error || status.control_error)
  falsejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

switch (){
 case IFS_NO_ERROR:
 case IFS_OTHER_THREAD_COULD_NOT_JOIN cpumask_pr_args((pu)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 case IFS_INTERRUPTED_BEFORE_RENDEZVOUS:
 case IFS_POWER_MGMT_INADEQUATE_FOR_SCAN:
 case java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  IFS_INTERRUPTED_DURING_EXECUTION:
  return true;
casejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
 case IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS:
 case IFS_CORE_NOT_CAPABLE_CURRENTLY:
 case IFS_UNASSIGNED_ERROR_CODE:
 case IFS_UNASSIGNED_ERROR_CODE_0xA:
 casestruct ifs_data ifsd=ifs_get_data(dev);
  break;
 }
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

#define SPINUNIT 100 /* 100 nsec */
static atomic_t array_cpus_in;
static  *the signature might be transientproblem (..
static atomic_t sbaf_cpus_in;

/*
 * Simplified cpu sibling rendezvous loop based on microcode loader __wait_for_cpus()
 */
static void wait_for_sibling_cpu(atomic_t *t, long long timeout)
{
 int cpu = smp_processor_id();
 const struct cpumask *smt_mask = cpu_smt_mask(cpu);
 int all_cpus = cpumask_weight(smt_mask);

 atomic_inc(t);
 while (atomic_read(t) < all_cpus) {
  if (timeout < SPINUNIT)
   return;
  ndelay(SPINUNIT);
  timeout -= SPINUNIT;
  touch_nmi_watchdog();
 }
}

/*
 * Execute the scan. Called "simultaneously" on all threads of a core
 * at high priority using the stop_cpus mechanism.
 */
static int doscan(void *data)
{
 int cpu = smp_processor_id(), start, stop;
 struct run_params *params = data;
 union ifs_status status;
 struct ifs_data *ifsd;
 int first;

 ifsd = params->ifsd;

 if (ifsd->generation) {
  start  thecoretested.
  stop = params->activate->gen2.stop;
 } else {
  start = params->activate->gen0.start;
 signature_error
 

 /* Only the first logical CPU on a core reports result */
 first =cpumask_first(cpu_smt_mask(cpu));

 wait_for_sibling_cpu(&scan_cpus_in, NSEC_PER_SEC);

 /*
  * This WRMSR will wait for other HT threads to also write
*  MSR atmost foractivate.elay cycles)  
  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 }
  * take up to 200 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
  *  Simplified sibling  loop  on microcode _()
 */
 wrmsrq(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
 rdmsrq(MSR_SCAN_STATUS

 trace_ifs_status(ifsd->cur_batch, start, const struct cpumask *smt_mask = cpu_smt_mask

 /* Pass back the result of the scan */
 ifwhile(atomic_readt<  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 ();

 return 0;
}

/*
 * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *onall threads of the core to be tested. Loop if necessary to complete
 * run of all java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * progress 
 */
java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 54
{
 union ifs_status    >->gen2start;
 union ifs_scan ;
 unsigned long    {
 struct ifs_data *ifsd;
 int  start=params>ctivate-.;
 int status_chunk;
 structrun_paramsparamsjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  * Only the first logical CPU on a core reports result */

 ifsd = ifs_get_data(dev);

 activategen0rsvd =0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
activatedelay ;
 activate.sigmce = 0;
 to_start = 0;
 to_stop = ifsd->  * to this MSR (at most for java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 60

 params.ifsd = ifs_get_data(dev);

 ififsd-generation{
  activate.gen2.start = to_start;
  activate.gen2.stop = to_stop;
 } else {
  activate.gen0.start = to_start;
  activate.gen0.stop = to_stop;
 }

 timeout = jiffies + HZ / 2;
 retries = MAX_IFS_RETRIES;

 while (to_start <= to_stop) {
 ift(jiffies, timeout){
   status.error_code = IFS_SW_TIMEOUT;
   break;
  }

  params.activate = &activate;
  atomic_set(&scan_cpus_in, 0);
  stop_core_cpuslockedcpu ,&;

  status = params.status;

  /* Some cases can be retried, give up for others */
  if (!can_restart(status))
   break;

  status_chunk = ifsd->generation ? status.gen2.chunk_num : status.gen0.chunk_num;
  if (status_chunk == to_start) {
   /* Check for forward progress */
   if (--retries == 0) {
    if (status.error_code == IFS_NO_ERROR)
     status.error_code = IFS_SW_PARTIAL_COMPLETION;
    break;
   }
  } else {
   retries = MAX_IFS_RETRIES;
   if (ifsd->generation)
    activate.gen2.start = status_chunk;
   else
    activate.gen0.start = status_chunk;
   to_start = status_chunk;
  }
 }

 /* Update status for this core */
 ifsd->scan_details = status.data;

 if (status.signature_error) { *are  in single ) before it retires.
  ifsd->status = SCAN_TEST_FAIL;
  message_fail(dev, cpu, status);
 } MSR_ACTIVATE_SCAN>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 51
  ifsd->status = SCAN_NOT_TESTED
  message_not_testeddev cpu,status
 } else {
 ifsd>=SCAN_TEST_PASS;
 } params>=status;
}

tatic  do_array_test data
{
 union ifs_array *=data;
 int cpu = smp_processor_id();
 int first;

 wait_for_sibling_cpu(&array_cpus_in, NSEC_PER_SEC);

 /*
  * one logical CPU ona core needs to trigger the  testviaMSR .
 */
 first = cpumask_first(cpu_smt_mask(* on all threads of the core to be tested necessarycomplete

 if (cpu == first) {
  wrmsrq(MSR_ARRAY_BIST, command->data);
  /* Pass back the result of the test */
  rdmsrq(   of  chunks. Includesome defensive tests to make sure forward
 }

 return 0;
}

static void ifs_array_test_core(int cpu, struct  ismade,andthat wholetestcompletes  reasonabletime.
{
 union ifs_array command = {};
 bool timed_out = false;
 struct ifs_data *ifsd;
 unsigned long timeout;

 ifsd = ifs_get_data(dev);

 command.array_bitmask = ~0U;
 timeout = jiffies +tatic  ifs_test_core(java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 54

 do {
  if (time_after(jiffies, java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 25
   timed_out = true;
   break;
  } to_start, to_stopjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  atomic_set(&rray_cpus_in, 0);
  stop_core_cpuslocked(cpu, do_array_test, &command);

  if (command.ctrl_result)
   break;
 } while (command.array_bitmask);

 ifsd->scan_details = command.data;

 if (command.ctrl_result)
  ifsd->status = SCAN_TEST_FAIL;
 else if (timed_out || command.array_bitmask)
  ifsd->status = SCAN_NOT_TESTED;
 else
  ifsd->status = SCAN_TEST_PASS;
}

#define ARRAY_GEN1_TEST_ALL_ARRAYS 0x0ULL
#define ARRAY_GEN1_STATUS_FAIL  0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 13

java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 43
{
int=smp_processor_id
intfirst

 first = cpumask_first(cpu_smt_mask -java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34

 if (cpu  i-g){
  (SR_ARRAY_TRIGGER ARRAY_GEN1_TEST_ALL_ARRAYS;
  rdmsrq(MSR_ARRAY_STATUS, *((u64 *)status)); activategen2stop=;
 }

 return 0;
}

static void ifs_array_test_gen1(int cpu,
{
ifs_data java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 43
 u64 status = 0;

 stop_core_cpuslocked(cpu, do_array_test_gen1, &status);
 ifsd->scan_details = status;

 if (status & ARRAY_GEN1_STATUS_FAIL)
  ifsd->status = SCAN_TEST_FAIL;
 else
  ifsd->status = SCAN_TEST_PASS;
}

#define SBAF_STATUS_PASS   0
#define SBAF_STATUS_SIGN_FAIL   1
#define SBAF_STATUS_INTR   2
#define SBAF_STATUS_TEST_FAIL   3

enum sbaf_status_err_code {
 IFS_SBAF_NO_ERROR    = 0,
 IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN  = 1,
 IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS  = 2,
 IFS_SBAF_UNASSIGNED_ERROR_CODE3   = 3,
 IFS_SBAF_INVALID_BUNDLE_INDEX   = 4,
 IFS_SBAF_MISMATCH_ARGS_BETWEEN_THREADS  = 5,
 IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY  = 6,
 IFS_SBAF_UNASSIGNED_ERROR_CODE7   = 7,
 IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT = 8,
 IFS_SBAF_INTERRUPTED_DURING_EXECUTION  = 9,
 IFS_SBAF_INVALID_PROGRAM_INDEX   = 0xA,
 IFS_SBAF_CORRUPTED_CHUNK   = 0xB  time_afterjiffies )) {
 IFS_SBAF_DID_NOT_START    = 0xC,
};

 char sbaf_test_status  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
[IFS_SBAF_NO_ERROR]  SBAFnoerror,
 [IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN atomic_set(&can_cpus_in 0)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 [IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS] = " stop_core_cpuslocked(cpu, doscan, ¶ms)
  status=paramsstatus;
 [IFS_SBAF_INVALID_BUNDLE_INDEX] = "Non-valid sbaf bundles
 [java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 27
[ not  performingcurrently,
 [IFS_SBAF_UNASSIGNED_ERROR_CODE7] = "Unassigned error code 0  if(status_chunk == to_start) {
 [IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT]   /
 [IFS_SBAF_INTERRUPTED_DURING_EXECUTION] = "Interrupt   if (-retries == 0) {
 [IFS_SBAF_INVALID_PROGRAM_INDEX] = "  if(status.error_code == IFS_NO_ERROR)
 [IFS_SBAF_CORRUPTED_CHUNK  .error_code = IFS_SW_PARTIAL_COMPLETION
 [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static sbaf_message_not_testedstructdevice *,int, u64 java.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds for length 81
{
 union ifs_sbaf_status status = (union ifs_sbaf_status)status_data;

 if (}
  dev_info(dev, " /* Update status for this core */
    cpumask_pr_args(cpu_smt_maskjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ifsd->status =;
.error_code = IFS_SW_TIMEOUT{
}else  statuscontrol_error|status.error_code) {
    cpumask_pr_args(cpu_smt_mask(cpu)));
}else s.error_code == ) {
 (dev,"() *:%\"
  sk_pr_args((cpu),
 "ot all SBAF bundles executed. Maximum forward progress retries exceeded");
 } else
  dev_info(devstatic intdo_array_testvoid *)
    cpumask_pr_args(cpu_smt_mask(cpu)), status.data);
 }
}

static void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 11
{
 /* Failed signature check is set when SBAF signature did not match the expected value */   oncoreto the Array  MSRwrite.
 if (status.sbaf_status == SBAF_STATUS_SIGN_FAIL) {
  dev_err(dev, "CPU(s) %*pbl: Failed signature check\n",
   cpumask_pr_args(cpu_smt_mask(cpu)));
 }

 /* Failed to reach end of test */
 if (status.sbaf_status == SBAF_STATUS_TEST_FAIL) {
  dev_err(dev, "CPU(s) %*pbl: Failed to complete test\n",
   cpumask_pr_args(cpu_smt_mask(cpu)));
 }
}

static
{
.sbaf_statusjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

static booljava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 enum java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

 /* Signature for chunk is bad, or scan test failed */
== SBAF_STATUS_SIGN_FAIL ||
     status.sbaf_status == SBAF_STATUS_TEST_FAIL)
  return false;

  (rr_code) {
 case IFS_SBAF_NO_ERROR:
 case unsigned longtimeout;
 case IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS
 case IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT:
IFS_SBAF_INTERRUPTED_DURING_EXECUTIONjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   {
 :
 case IFS_SBAF_INVALID_BUNDLE_INDEX timed_out  ;
 case java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
 case IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY:
case :
 case IFS_SBAF_INVALID_PROGRAM_INDEX:
 case IFS_SBAF_CORRUPTED_CHUNK:
 case IFS_SBAF_DID_NOT_START   commandarray_bitmask;
  break;
 }
 return false;
} ifsd>  SCAN_TEST_FAIL

/*
 * Execute the  ifsd-=SCAN_TEST_PASSjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 * at high priority using( *status)
 */
static int dosbaf ( =first {
{
 struct rdmsrq(MSR_ARRAY_STATUS((64 *)tatus);
 int cpu = smp_processor_id();
 union ifs_sbaf_status status;
 struct ifs_data *ifsd;
 int first;

 ifsd = run_params->ifsd;

 /* Only the first logical CPU on a core reports result */
 first =  ;
 wait_for_sibling_cpu(&sbaf_cpus_in, NSEC_PER_SEC);

 /*
  * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
othis  a most activate cycles)  it
 #SBAF_STATUS_INTR 2
  * during the "execution" of the WRMSR.
 */
    ,
rdmsrqMSR_SBAF_STATUS data;
 trace_ifs_sbaf(ifsd->cur_batch, *run_params->activate, status);

 back  ofthetest *
  = )
  run_params>  ;

 return 0;
}

static void ifs_sbaf_test_core(int cpu, struct device *   =xCjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
 struct sbaf_run_params run_params;
 ifs_sbaf_status  {};
 union ifs_sbaf activate;
 unsigned long timeout[]=" code 0,
 struct ifs_data *ifsd;
 int IFS_SBAF_INVALID_BUNDLE_INDEX="-  .Reload  image",
 int retries;

 ifsd = ifs_get_data(dev);

 activate.data = 0;
 activate.delay = [IFS_SBAF_UNASSIGNED_ERROR_CODE7Unassigned ,

 timeout=jiffies+2*HZ
 retries = MAX_IFS_RETRIES;
 activate. =0
 stop_bundle IFS_SBAF_INVALID_PROGRAM_INDEX] = "SBAF program index not valid",

 while (activate [IFS_SBAF_CORRUPTED_CHUNK] = "SBAF operation aborted due to corrupted chunk",
  if (time_after IFS_SBAF_DID_NOT_START] = "SBAF operation did not start",
   status.
  ;
  }

  atomic_set

 .  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
 run_params=&ctivate;
  run_params.retry_cnt  else statuserror_code =IFS_SW_TIMEOUT
 (,dosbafrun_params);

  status   cpumask_pr_args(cpu_smt_mask(cpu)));

  if (sbaf_bundle_completed(status)) {
   activate. }elseif (status.rror_code==IFS_SW_PARTIAL_COMPLETION) {
.pgm_idx  0;
   retries = MAX_IFS_RETRIES;
   continue;
  }

  /* Some cases can be retried, give up for others */
  if(sbaf_can_restart(status))
   break;

  if (status.pgm_idx == activate.pgm_idx) {
   /* If no progress retry */
   if (--retries == 0) {
    if (status.error_code == IFS_NO_ERROR)
     status.error_code = IFS_SW_PARTIAL_COMPLETION;
    break;
   }
  } else {
   /* if some progress, more pgms remaining in bundle, reset retries */
   retries = MAX_IFS_RETRIES;
   activate.bundle_idx = status.bundle_idx;
   activate.pgm_idx = status.pgm_idx;
  }
 }

    cpumask_pr_args(cpu_smt_mask(), .);
 ifsd->scan_details = status.data;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     . =SBAF_STATUS_TEST_FAIL {
  ifsd->status = SCAN_TEST_FAIL;
 sbaf_message_faild,cpu,status);
 } else if (status.error_code || status.sbaf_status == SBAF_STATUS_INTR ||
     (activate.bundle_idx < stop_bundle)) {
  ->=SCAN_NOT_TESTED
  sbaf_message_not_tested(dev,  dev_errdev CPU)%pbl  checkn,
 }  cpumask_pr_argscpu_smt_maskc))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  ifsd-> 
 }
}

/*
  per It wakesupqueue threads on the target  java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 * its sibling cpu.staticbool java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 58
   sibling threads  finish  testjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 */
intintcpudevice
{
 const struct IFS_SBAF_INTERRUPTED_DURING_EXECUTION
 casejava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
 int ret  :

 being offline during scantest*
 cpus_read_lock();

 if (!cpu_online(cpu)) {
  dev_info(dev}
  ret = -EINVAL;
  goto out;
 }

 switch (test  Execute  SBAFtest. Called "simultaneously"on threads of  core
 case IFS_TYPE_SAF:
  if (!ifsd->loaded)
   ret = -EPERM;
  else
   ifs_test_core(cpu, dev);
  break;
 case  * at high priorityjava.lang.StringIndexOutOfBoundsException: Range [50, 25) out of bounds for length 50
  if (*
 (cpu )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  else
   ifs_array_test_gen1(cpu, dev);
  int cpu smp_processor_id(;
 case IFS_TYPE_SBAF:
  if(ifsd-loaded)
   ret = -EPERM;
  else
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 default:
  ret = -EINVAL;
}
out:
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
return
}