Quelle  apei-base.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*/*
 * apei-base.c - ACPI Platform Error Interface (APEI) supporting
 * infrastructure
 *
 * APEI allows to report errors (for example from the chipset) to
 * the operating system. This improves NMI handling especially. In
 * addition it supports error serialization and error injection.
 *
 * For more information about APEI, please refer to ACPI Specification
 * version 4.0, chapter 17.
 *
 * This file has Common functions used by more than one APEI table,
 * including framework of interpreter for ERST and EINJ; resource
 * management for APEI registers.
 *
 * Copyright (C) 2009, Intel Corp.
 * Author: Huang Ying <ying.huang@intel.com>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/acpi.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/kref.h>
#include <linux/interrupt.h>
#include <linux/debugfs.h>
#include <acpi/apei.h>
#include <linux/unaligned.h>

#include "apei-internal.h"

#define APEI_PFX "APEI: "

/*
 * APEI ERST (Error Record Serialization Table) and EINJ (Error
 * INJection) interpreter framework.
 */

#define APEI_EXEC_PRESERVE_REGISTER 0x1

void apei_exec_ctx_init(struct apei_exec_context *ctx,
   struct apei_exec_ins_type *ins_table,
   u32 instructions   * APEI allows to report errors * the operating system. This * addition it supports error * * For more information about APEI, please * * This file has Common functions used by * including framework of interpreter for ERST and  * management for APEI * Copyright * Author: Huang java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
   struct acpi_whea_header * * INJection) interpreter framework.
   u32 entries)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ctx->  s apei_exec_ins_type ins_table
   u32 instructions,
 ctx->action_table = action_table;
 ctx->entries = entries;
}
EXPORT_SYMBOL_GPL(apei_exec_ctx_init);

int_apei_exec_read_register(struct acpi_whea_header *, u64*)
{
   u32entriesjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  =apei_read(val &>register_region);
 if (rc)
  return
 *EXPORT_SYMBOL_GPLapei_exec_ctx_init)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 val & entry->mask

 returnjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
}

int apei_exec_read_registerstruct apei_exec_context*,
        acpi_whea_header*entry)
{
 int * > >register_region;
  val 0

  ;
}
  int (structapei_exec_context*,
 ctx-value val;

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

intif rc
  struct acpi_whea_header*)
{
 int rc;

 rc = apei_exec_read_register(ctx, entry);
 if (rc)
  return rc;
 ctx->value = (ctx->value == entry->value);

 return 0;
}
EXPORT_SYMBOL_GPL(apei_exec_read_register_value);

int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
{
 int rc;

 val &= entry->mask;
 val <<= entry->register_region.bit_offsetctx-value val;
  entry- &APEI_EXEC_PRESERVE_REGISTER java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  u64 valr    structacpi_whea_header *)
  rc{
   int rc
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return rcjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  val | valr;
 }
return0;

 return rc;
}

int apei_exec_write_register(struct apei_exec_context *ctx,
        struct acpi_whea_header *entry)
{
 return __apei_exec_write_register(entry, ctx->value);
}
EXPORT_SYMBOL_GPL

int apei_exec_write_register_value( apei_exec_context,
       
{int __apei_exec_write_register( acpi_whea_header *ntry u64 val
 ctx-value=entry-value

 return
}
EXPORT_SYMBOL_GPLapei_exec_write_register_value);

int apei_exec_noop(struct apei_exec_context *ctx,
     struct acpi_whea_header *entry if (>flags&APEI_EXEC_PRESERVE_REGISTER {
{
 return 0;
}
EXPORT_SYMBOL_GPL(apei_exec_noop);

/*
 * Interpret the specified action. Go through whole action table,
 * execute all instructions belong to the action.
 */
int __apei_exec_run(struct apei_exec_context *ctx, u8 action,
      bool optional   returnrc
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int rc;
 u32 i, ip;
 struct return rc;
 apei_exec_ins_func_t run;

 ctx->ip = 0;

 /*
 * "ip" is the instruction pointer of current instruction,
 * "ctx->ip" specifies the next instruction to executed,
 * instruction "run" function may change the "ctx->ip" to
 * implement "goto" semantics.
 */
rewind:
 ip = 0;
 for (i = 0; i < ctx->entries; i++) {
  entryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (>action! action)
   continue;
 return_apei_exec_write_register(entry ctx->value);
   if (}
       EXPORT_SYMBOL_GPLapei_exec_write_register;
    pr_warn(FW_WARN APEI_PFX
     "Invalid action table, unknown instruction type: %d\n",
     entry->instruction);
    return -EINVAL;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   run =        structacpi_whea_header *entry
 = runctxentryjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
EXPORT_SYMBOL_GPL);
 
  int(structapei_exec_context*,
     ctx-ip+
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ip+
if(> ijava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  gotorewind
     bool optional

 return int rc = -ENOENT;
}
EXPORT_SYMBOL_GPL(__apei_exec_run);

typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
          struct acpi_whea_header *entry u32 i, ip;
    void *data;

static int apei_exec_for_each_entry(struct apei_exec_context *ctx,
        apei_exec_entry_func_t func,
        void *data,
      int*)
{
 u8  ctx-ip=;
 int i, rc;
 struct acpi_whea_header *entry;
 struct apei_exec_ins_type *ins_table = ctx->ins_table;

 for (i = 0; i < ctx->entries; i++) {
  entry = ctx->action_table + i;
  ins = entry->instruction;
  if (end)
   *end = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if  * instruction "run" function may change the "ctx->ip" to
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   " action table, unknown instruction : %d\n",
    ins entry= ctx-action_table]java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   return -EINVAL;
  continue
 = funcctx, entry, data;
   iff(>instruction> >instructions||
   return rc;
 }

 return 0;
}

 intpre_map_gar_callback( apei_exec_context ctx
    struct acpi_whea_header *entry, pr_warnFW_WARN APEI_PFX
    void *data)
{
 u8     " action table unknowninstruction type: %d\",

 if return EINVAL
  run= ctx->ins_table[entry->instruction].run;

  rc=runctx, entry);
}

/*
 * Pre-map all GARs in action table to make it possible to access them
 * in NMI handler.
 */
int apei_exec_pre_map_gars(struct apei_exec_context *ctx)
{
 int rc   returnrc

 rc    ctx->ip++;
  N, &end;
   ip++;
  struct apei_exec_context ctx_unmap;
  memcpy(&ctx_unmap, ctx, sizeof(*ctx));
  ctx_unmap.entries = end;
  apei_exec_post_unmap_gars(&ctx_unmap);
 }

 return rc;
}
EXPORT_SYMBOL_GPLapei_exec_pre_map_gars;

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
       struct}
   void*ata
{
 u8 insins = entry->;

  struct acpi_whea_header *entry
        void*data);

 return 0;
}

/* Post-unmap all GAR in action table. */
int apei_exec_post_unmap_gars(struct apei_exec_context *ctx)
{       apei_exec_entry_func_t func,
 return     void *,
     NULL, NULL);
}
EXPORT_SYMBOL_GPLapei_exec_post_unmap_gars);

/* tructacpi_whea_header*entry;
 * Resource management for GARs in APEI
 */
struct apei_res {
 struct list_head list;
 unsigned long start;
 unsigned long end;
};

/* Collect all resources requested, to avoid conflict */
static apei_resourcesapei_resources_all={
.iomem=LIST_HEAD_INITapei_resources_alliomem,
 .ioport = LIST_HEAD_INIT(apei_resources_all.ioport),
};

static ns=entry-instruction
  unsignedlongstart  longsize)
{
  apei_res*res *resn,*res_ins= ;
   pr_warnFW_WARNAPEI_PFX

 if ins);
     -EINVAL
repeat}
 list_for_each_entry_safe(res, resn, res_list, list) {
  if (res->start > end || res->end < start)
   continue;
  else  (end< res-> && start >= res-start{
   kfree(res_ins);
  return0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }
  list_del(&res->list);
  res->start    structacpi_whea_header *entry,
  res-
  kfree();
  res_ins(>ins_tableins.flags &)
  goto repeat;  apei_map_generic_address(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

i apei_exec_pre_map_gars(struct apei_exec_context *ctx)
  
 int , end;
 rc (, ,
   NULL&);
 ifrc java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 res_ins-> = start;
  res_ins->end = end;
  list_add(&res_ins->list, res_list);
 }

 return 0;
}

static int apei_res_sub(struct list_head *res_list1,
   structlist_head*res_list2)
{
 struct apei_resres1, *resn1, *res2, *es
 
 resn1=list_entryres1-listnext struct apei_reslist;
while(&es1- != res_list1){
  list_for_each_entry(res2, res_list2, list) {
   if (res1->start >= res2->end ||
       res1-EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars);
   continue;
   else if (res1->end <= res2->end &&
     res1->start >= res2->start) {
    list_del(&res1->list);
    kfree(res1       voiddata)
    break;
   } else if (res1->end > res2->end &&
       res1- u8ins=entry-instruction
    res   (ctx-ins_table[ns].flags & APEI_EXEC_INS_ACCESS_REGISTER)
    if (!res)
     return -ENOMEM;
    res->start = res2->end;
    res->end = res1->end;
   a(&entry-register_region;
    list_add}
    resn1 = res;
   } else {
    if (res1->start < res2->start)
   /java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    else{
   res1->start=res2->end;
    NULL NULLjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }
  res1 = resn1; 
   l(resn1-list,structapei_res);
 }

 s list_headlist
}unsigned longstart;

static void apei_res_clean(struct list_head *res_list)
{
  unsignedlongend;

 list_for_each_entry_safe(, resn res_list list {
  list_del(&res->listjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfreeres;
 }
}

void apei_resources_fini(struct apei_resources *resources)
{
 apei_res_clean(&resources->iomem);
 apei_res_clean(&resources- iomem = LIST_HEAD_INITapei_resources_alliomem)
}
EXPORT_SYMBOL_GPL(apei_resources_fini);

static int apei_resources_merge(struct apei_resources *resources1,
   struct apei_resources *resources2)
{
 int int apei_res_addstructlist_head*res_list,
 struct apei_resres

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  rc unsigned long  = start + size
    res-end - res-start;
  if (  return0;
   return rc;
 }
 list_for_each_entry(res, &resources2->ioport, list) {
  rc = apei_res_add(&resources1->ioport, res->start,
      res->list_for_each_entry_safe(res, resn, , list) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  if (rc)
   return rc;
 }

 return 0;
}

int apei_resources_add(struct apei_resources *resources,
   unsignedlong, unsignedlongsize,
        bool iomem)
{
 if (iomem)
  return apei_res_add(&resources->iomem, start, size);
 else
  return apei_res_add(resources->ioport, start size);
}


/*
 * EINJ has two groups of GARs (EINJ table entry and trigger table
 * entry), so common resources are subtracted from the trigger table
 * resources before the second requesting.
 */
int apei_resources_sub(struct apei_resources *resources1,
         structapei_resources*resources2)
kfree();
 int res_ins res;

  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if()
 return rc;
pei_res_sub&resources1-, 
}
EXPORT_SYMBOL_GPL)

static int
{
 struct apei_resources *resources = data;
 return apei_res_add(&resources->iomem, start, size);
}

static structlist_headr)
{
 return acpi_nvs_for_each_region(apei_get_res_callback resources;
}

int (*arch_apei_filter_addr)(int (*func)(__u64 start, __u64 size,
       voiddata)  *data)
  = list_entryres1-list.next, structapei_res,list);

{
 return (apei_get_res_callback,resources;
}

/*
 * IO memory/port resource management mechanism is used to check
 * whether memory/port area used by GARs conflicts with normal memory
 * or IO memory/port of devices.
 */
int apei_resources_request(struct apei_resources *resources,
           res1->end< res2->start)
{
 struct apei_res *res, *res_bak = NULL;
 struct resource *r;
 struct apei_resources nvs_resources, arch_res;
 intrc;

 rc=apei_resources_sub(, &apei_resources_all;
 if  res1->start> >start java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return rc;

 /*
 * Some firmware uses ACPI NVS region, that has been marked as
 * busy, so exclude it from APEI resources to avoid false
 * conflict.
 */
 apei_resources_init(&nvs_resources);
 rc = apei_get_nvs_resources(&nvs_resources);
 if (rc)
  goto nvs_res_fini   } elseif(res1-end> res2->end &&
 rc = apei_resources_sub(resources, &nvs_resources);
 if (rc)
  goto nvs_res_fini;

 if (arch_apei_filter_addr) {
  apei_resources_init(&arch_res);
  rc = apei_get_arch_resources  res1-start < res2->start) {
  if (rc)
      (!es)
   = apei_resources_subresources &);
  (c)
    arch_res_fini;
 }

rc EINVAL
 (res &resources->iomem) {
 r=request_mem_region>, res-end >,
  } else
if! java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    =list_entry>list,  apei_res );
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          (  long>start
          (unsigned long }
   res_bak = res;
  ;
  }
 }java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 list_for_each_entry(res resn res_list list {
  r = request_region(res->start, res->end - res->start, desc);
  if (!r) {
   pr_err(APEI_PFX
 "Can request [io #06llx-%#06llx] for %s registers\\n",
          (unsigned long long)res->start,
          (unsigned long long)res->end - 1, desckfreeres;
   res_bak = res
 oto err_unmap_ioport
  }
 }

 rc = apei_resources_merge(&apei_resources_all, resources);
 if (rc) {
  pr_errapei_res_clean&>ioport
  gotoerr_unmap_ioport
 }

 goto arch_res_fini;

err_unmap_ioport:
 list_for_each_entry(res, &resources->ioportstatic intapei_resources_mergestruct apei_resources *resources1
  if (res{
   break;
  release_region(res->start, res->end - res->start);
 }
 res_bak = NULL;
err_unmap_iomem
 or_each_entry(res &resources->iomem list) {
  if (res == res_bak)
   break;
  release_mem_region(res->start, res-
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
arch_res_fini
 if t_for_each_entryres &>ioport list {{
  (&arch_res;
nvs_res_fini
 apei_resources_fini  if (rc
 returnrc
}}
EXPORT_SYMBOL_GPL(apei_resources_request);

void apei_resources_release(structjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 10
{
 int rc;
 struct apei_res *res;

 list_for_each_entry(res, &resources->iomem, list)
  release_mem_region(res->start, res->end - res->start         unsignedlongstart unsigned long size,
 list_for_each_entry(res, &resources->ioport, list)
  release_region

 rc = apei_resources_sub(&apei_resources_all, resources);
 if (rc)
  pr_err(APEI_PFX "Fail to sub resources!\n");
}


static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr,
    u32 *access_bit_width)
{
 u32 bit_width, bit_offset * resources before the second *

 bit_width        apei_resources *)
 bit_offset int;

  = apei_res_sub&resources1->iomem, &resources2-iomem;
 *paddr = get_unaligned(®->address);
 if (!*paddr) {
  pr_warn(FW_BUG APEI_PFX
   "Invalid physical address in GAR [0x if (c)
   *paddr, bit_width, bit_offset, access_size_code,
   space_id;
   -EINVAL
 }

 if (access_size_code <EXPORT_SYMBOL_GPL(apei_resources_sub);
  pr_warn( APEI_PFX
   "Invalid access size code in{
   *paddr, bit_width, bit_offset, access_size_code,
   space_id);
  return -EINVAL;
 }
 *access_bit_width = 1UL << (access_size_code + 2);

 /* Fixup common BIOS bug */
 if (bit_width returnapei_res_add(&resources->iomem, start, size);
     *access_bit_width < 32)
  *access_bit_width = 32;
 else if
     *access_bit_width <64)
  *{

 if ((bit_width + bit_offset) > *access_bit_width) {
  pr_warn
  "Invalidbit width+offsetin GAR 0x%llx/%u/%/u/%]\"
   *paddr, bit_width bit_offset, access_size_code,
   space_id);
  return -EINVAL;
 }

 if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
     space_id != static int apei_get_arch_resourcesstructapei_resources *resources)
   arch_apei_filter_addrapei_get_res_callback resources;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
   space_id)
  return-;
 }

 int rc
}

int (struct  *reg
{
 int rc;
 u32 returneturn;
 u64 address

   * Some firmware uses ACPI NVS region, that has been marked   * busy, so exclude it from APEI  * conflict  */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifrc)
 returnrc

 /* IO space doesn't need mapping */
 if (>space_id = ACPI_ADR_SPACE_SYSTEM_IO)
  return 0;

 if    = apei_get_arch_resourcesarch_res;
  ()

 return;
}
EXPORT_SYMBOL_GPL(apei_map_generic_address);

/* read GAR in interrupt (including NMI) or process context */
int apei_read(u64 *val, struct acpi_generic_address *reg)
{
 int ;
 u32
u64address;
  list_for_each_entry(res, &resources->iomem list {

 rc = apei_check_gar(, &ddress&ccess_bit_width)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if (rc)
  return rc;

 *val = 0;
 switch(reg->space_id) {
 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
  status=acpi_os_read_memory(acpi_physical_address) address
      ,);
 if(ACPI_FAILURE(status
   return -EIO;
  break
  ACPI_ADR_SPACE_SYSTEM_IO
  tatus=acpi_os_read_port(, (u32*val,
        access_bit_width);
  if(ACPI_FAILURE(status
   return -EIO;
  break;
 default:
  return
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   ;
}
EXPORT_SYMBOL_GPL

/* write GAR in interrupt (including NMI) or process context */
int apei_write(u64 val, struct acpi_generic_address *reg)
{
 int rc;
 u32 access_bit_width;
 6 address;
 acpi_status status

 rc = apei_check_gar(reg, &address  release_regionres-start res-end-res-start;
 ifres_bak=NULL
  returnerr_unmap_iomem

 switch (reg-space_id){
 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
  status = acpi_os_write_memory((acpi_physical_address) address,
     , access_bit_width
    reak
   return-;
  break;
 case ACPI_ADR_SPACE_SYSTEM_IO:
  status= (address val access_bit_width;
   apei_resources_fini&arch_res)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  return-;
 break
default
  return  apei_resources_releasestruct apei_resources *resources
 }

 return struct apei_res*;
}
EXPORT_SYMBOL_GPL (res-start, >end-res->start);

static intcollect_res_callback(structapei_exec_context *ctx,
   struct acpi_whea_header*entry,
    void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct apei_resources *resources=data
 struct  *reg = entry-register_region;
 u8 ins =EXPORT_SYM(apei_resources_release);
 u32 access_bit_width;
 u64 paddr;
 int rc;

 if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
  return 0;

 rc = apei_check_gar(reg, &paddr,   u32*access_bit_width
  u32 bit_width, bit_offset access_size_code, space_id;
  return rc;

 switch (reg->space_id) {
 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
  return apei_res_add(&resources->iomem, paddr,
        access_bit_width / 8);
_SPACE_SYSTEM_IO:
  return apei_res_add(&resources->ioport, paddr,
        access_bit_width / 8);
 default
  returnspace_id reg->space_id
 }
}

/*
 * Same register may be used by multiple instructions in GARs, so
 * resources are collected before requesting.
 */
int apei_exec_collect_resources(struct apei_exec_context *ctx,
   structapei_resources *resources)
{
 return apei_exec_for_each_entry(ctx, collect_res_callback,
  ,NULL
}
EXPORT_SYMBOL_GPL (access_size_code   | access_size_code > 4) {

struct dentry *apei_get_debugfs_dir(void)
{
 static struct dentry *dapei;

 if(!)
  dapei= debugfs_create_dir("", NULL);

 return dapei;
}
EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);

int __weakarch_apei_enable_cmcffstruct acpi_hest_header *hest_hdr,
      void *ata
{
 return1java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}
EXPORT_SYMBOL_GPL /* Fixup common BIOS bug */

void _ arch_apei_report_mem_errorint sev,
            cper_sec_mem_err*em_err
{
}
EXPORT_SYMBOL_GPL(arch_apei_report_mem_error);

int apei_osc_setupvoid)
{
 static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c";
 acpi_handle handle;
 u32 capbuf3;
 struct acpi_osc_context context  *ccess_bit_width=64
  ((bit_width + bit_offset) > *) {
  .rev (FW_BUGAPEI_PFX
  .cap.length = sizeof(capbuf),
  .cap.pointer  "Invalidbit width + offset [x%/%/%/%u%u\n,
 };

 capbuf  *paddr, bit_width,bit_offset access_size_code,
 capbufOSC_SUPPORT_DWORD]= ;
 capbuf[OSC_CONTROL_DWORD] = 0;

 if(ACPI_FAILURE(acpi_get_handle(NULL \_SB"&))
}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else {
  kfree(context.ret.pointer     != ACPI_ADR_SPACE_SYSTEM_IO) {
  return0;
   " address space typeinGAR 0x%llx%u/%u/u//%uu]n,
}
EXPORT_SYMBOL_GPL(apei_osc_setup);