From df4a6aee81dff45552f02434406ac394513421eb Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Wed, 10 Mar 2021 12:13:28 +0100 Subject: [PATCH] Remove global variables, make it compile. --- acpid/src/acpi.rs | 11 +- acpid/src/aml/mod.rs | 24 ++-- acpid/src/aml/namedobj.rs | 90 ++++++------- acpid/src/aml/namespace.rs | 40 +++--- acpid/src/aml/namespacemodifier.rs | 12 +- acpid/src/aml/parser.rs | 129 +++++++++--------- acpid/src/aml/termlist.rs | 4 +- acpid/src/aml/type1opcode.rs | 30 ++--- acpid/src/aml/type2opcode.rs | 208 ++++++++++++++--------------- 9 files changed, 276 insertions(+), 272 deletions(-) diff --git a/acpid/src/acpi.rs b/acpid/src/acpi.rs index 10ece8899f..40082226e3 100644 --- a/acpid/src/acpi.rs +++ b/acpid/src/acpi.rs @@ -6,6 +6,7 @@ use std::sync::Arc; use syscall::flag::PhysmapFlags; +use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard}; use thiserror::Error; use super::aml::AmlValue; @@ -194,7 +195,8 @@ pub struct AcpiContext { tables: Vec, dsdt: Option, fadt: Option, - namespace: Option>, + namespace: RwLock>>, + pub next_ctx: RwLock, } impl AcpiContext { pub fn dsdt(&self) -> Option<&Dsdt> { @@ -221,8 +223,11 @@ impl AcpiContext { pub fn take_single_sdt(&mut self, signature: [u8; 4]) -> Option { self.find_single_sdt_pos(signature).map(|pos| self.tables[pos].clone()) } - pub fn namespace(&self) -> Option<&HashMap> { - self.namespace.as_ref() + pub fn namespace(&self) -> RwLockReadGuard<'_, Option>> { + self.namespace.read() + } + pub fn namespace_mut(&self) -> RwLockWriteGuard<'_, Option>> { + self.namespace.write() } pub fn fadt(&self) -> Option<&Fadt> { self.fadt.as_ref() diff --git a/acpid/src/aml/mod.rs b/acpid/src/aml/mod.rs index 903597afe2..c56cc1dbcc 100644 --- a/acpid/src/aml/mod.rs +++ b/acpid/src/aml/mod.rs @@ -36,13 +36,13 @@ pub enum AmlError { AmlHardFatal } -pub fn parse_aml_table(sdt: impl AmlContainingTable) -> Result, AmlError> { - parse_aml_with_scope(sdt, "\\".to_owned()) +pub fn parse_aml_table(acpi_ctx: &AcpiContext, sdt: impl AmlContainingTable) -> Result, AmlError> { + parse_aml_with_scope(acpi_ctx, sdt, "\\".to_owned()) } -pub fn parse_aml_with_scope(sdt: impl AmlContainingTable, scope: String) -> Result, AmlError> { +pub fn parse_aml_with_scope(acpi_ctx: &AcpiContext, sdt: impl AmlContainingTable, scope: String) -> Result, AmlError> { let data = sdt.aml(); - let mut ctx = AmlExecutionContext::new(scope); + let mut ctx = AmlExecutionContext::new(acpi_ctx, scope); parse_term_list(data, &mut ctx)?; @@ -57,8 +57,8 @@ pub fn is_aml_table(sdt: &SdtHeader) -> bool { } } -fn init_aml_table(sdt: impl AmlContainingTable) { - match parse_aml_table(sdt) { +fn init_aml_table(acpi_ctx: &AcpiContext, sdt: impl AmlContainingTable) { + match parse_aml_table(acpi_ctx, sdt) { Ok(_) => println!(": Parsed"), Err(AmlError::AmlParseError(e)) => println!(": {}", e), Err(AmlError::AmlInvalidOpCode) => println!(": Invalid opcode"), @@ -80,13 +80,13 @@ fn init_namespace(context: &AcpiContext) -> HashMap { let dsdt = context.dsdt().expect("could not find any DSDT"); log::info!("Found DSDT."); - init_aml_table(dsdt); + init_aml_table(context, dsdt); let ssdts = context.ssdts(); for ssdt in ssdts { print!("Found SSDT."); - init_aml_table(ssdt); + init_aml_table(context, ssdt); } todo!() @@ -107,7 +107,9 @@ pub fn set_global_s_state(context: &AcpiContext, state: u8) { let port = fadt.pm1a_control_block as u16; let mut val = 1 << 13; - let namespace = match context.namespace() { + let namespace_guard = context.namespace(); + + let namespace = match &*namespace_guard { Some(namespace) => namespace, None => { log::error!("Cannot set global S-state due to missing ACPI namespace"); @@ -130,8 +132,8 @@ pub fn set_global_s_state(context: &AcpiContext, state: u8) { } }; - let slp_typa = p[0].get_as_integer().expect("SLP_TYPa is not an integer"); - let slp_typb = p[1].get_as_integer().expect("SLP_TYPb is not an integer"); + let slp_typa = p[0].get_as_integer(context).expect("SLP_TYPa is not an integer"); + let slp_typb = p[1].get_as_integer(context).expect("SLP_TYPb is not an integer"); log::info!("Shutdown SLP_TYPa {:X}, SLP_TYPb {:X}", slp_typa, slp_typb); val |= slp_typa as u16; diff --git a/acpid/src/aml/namedobj.rs b/acpid/src/aml/namedobj.rs index 01e272e492..40659b2c77 100644 --- a/acpid/src/aml/namedobj.rs +++ b/acpid/src/aml/namedobj.rs @@ -155,8 +155,8 @@ fn parse_def_bank_field(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResu }; let selector = FieldSelector::Bank { - region: region_name.val.get_as_string()?, - bank_register: bank_name.val.get_as_string()?, + region: region_name.val.get_as_string(ctx.acpi_context())?, + bank_register: bank_name.val.get_as_string(ctx.acpi_context())?, bank_selector: Box::new(bank_value.val) }; @@ -188,9 +188,9 @@ fn parse_def_create_bit_field(data: &[u8], ctx: &mut AmlExecutionContext) -> Par let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(1)) @@ -221,9 +221,9 @@ fn parse_def_create_byte_field(data: &[u8], ctx: &mut AmlExecutionContext) -> Pa let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(8)) @@ -254,9 +254,9 @@ fn parse_def_create_word_field(data: &[u8], ctx: &mut AmlExecutionContext) -> Pa let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(16)) @@ -287,9 +287,9 @@ fn parse_def_create_dword_field(data: &[u8], ctx: &mut AmlExecutionContext) -> P let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - let _ = ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + let _ = ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(32)) @@ -320,9 +320,9 @@ fn parse_def_create_qword_field(data: &[u8], ctx: &mut AmlExecutionContext) -> P let bit_index = parse_term_arg(&data[2 + source_buf.len..], ctx)?; let name = parse_name_string(&data[1 + source_buf.len + bit_index.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(AmlValue::IntegerConstant(64)) @@ -354,9 +354,9 @@ fn parse_def_create_field(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseRe let num_bits = parse_term_arg(&data[2 + source_buf.len + bit_index.len..], ctx)?; let name = parse_name_string(&data[2 + source_buf.len + bit_index.len + num_bits.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::BufferField(BufferField { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::BufferField(BufferField { source_buf: Box::new(source_buf.val), index: Box::new(bit_index.val), length: Box::new(num_bits.val) @@ -389,9 +389,9 @@ fn parse_def_data_region(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseRes let oem_id = parse_term_arg(&data[2 + name.len + signature.len..], ctx)?; let oem_table_id = parse_term_arg(&data[2 + name.len + signature.len + oem_id.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::OperationRegion(OperationRegion { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::OperationRegion(OperationRegion { region: RegionSpace::SystemMemory, offset: Box::new(AmlValue::IntegerConstant(0)), len: Box::new(AmlValue::IntegerConstant(0)), @@ -425,8 +425,8 @@ fn parse_def_event(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult { let name = parse_name_string(&data[2..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Event(0))?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Event(0))?; Ok(AmlParseType { val: AmlValue::None, @@ -453,12 +453,12 @@ fn parse_def_device(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult { let (pkg_length, pkg_length_len) = parse_pkg_length(&data[2..])?; let name = parse_name_string(&data[2 + pkg_length_len .. 2 + pkg_length], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; - let mut local_ctx = AmlExecutionContext::new(local_scope_string.clone()); + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; + let mut local_ctx = AmlExecutionContext::new(ctx.acpi_context(), local_scope_string.clone()); parse_object_list(&data[2 + pkg_length_len + name.len .. 2 + pkg_length], &mut local_ctx)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Device(Device { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Device(Device { obj_list: local_ctx.namespace_delta.clone(), notify_methods: BTreeMap::new() }))?; @@ -503,9 +503,9 @@ fn parse_def_op_region(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResul let offset = parse_term_arg(&data[3 + name.len..], ctx)?; let len = parse_term_arg(&data[3 + name.len + offset.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::OperationRegion(OperationRegion { - region: region, + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::OperationRegion(OperationRegion { + region, offset: Box::new(offset.val), len: Box::new(len.val), accessor: Accessor { @@ -559,7 +559,7 @@ fn parse_def_field(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult { } }; - let selector = FieldSelector::Region(name.val.get_as_string()?); + let selector = FieldSelector::Region(name.val.get_as_string(ctx.acpi_context())?); parse_field_list(&data[3 + pkg_length_len + name.len .. 2 + pkg_length], ctx, selector, &mut flags)?; @@ -609,8 +609,8 @@ fn parse_def_index_field(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseRes }; let selector = FieldSelector::Index { - index_selector: idx_name.val.get_as_string()?, - data_selector: data_name.val.get_as_string()? + index_selector: idx_name.val.get_as_string(ctx.acpi_context())?, + data_selector: data_name.val.get_as_string(ctx.acpi_context())? }; parse_field_list(&data[3 + pkg_length_len + idx_name.len + data_name.len .. 2 + pkg_length], @@ -673,9 +673,9 @@ fn parse_field_element(data: &[u8], } let length = if let Ok(field) = parse_named_field(data, ctx) { - let local_scope_string = get_namespace_string(ctx.scope.clone(), AmlValue::String(field.val.name.clone()))?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), AmlValue::String(field.val.name.clone()))?; - ctx.add_to_namespace(local_scope_string, AmlValue::FieldUnit(FieldUnit { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::FieldUnit(FieldUnit { selector: selector.clone(), connection: Box::new(connection.clone()), flags: flags.clone(), @@ -813,7 +813,7 @@ fn parse_connect_field(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResul } else { let name = parse_name_string(&data[1..], ctx)?; Ok(AmlParseType { - val: AmlValue::Alias(name.val.get_as_string()?), + val: AmlValue::Alias(name.val.get_as_string(ctx.acpi_context())?), len: name.len + 1 }) } @@ -844,8 +844,8 @@ fn parse_def_method(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult { let term_list = &data[2 + pkg_len_len + name.len .. 1 + pkg_len]; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Method(Method { + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Method(Method { arg_count, serialized, sync_level, @@ -877,8 +877,8 @@ fn parse_def_mutex(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult { let flags = data[2 + name.len]; let sync_level = flags & 0x0F; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Mutex((sync_level, None)))?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Mutex((sync_level, None)))?; Ok(AmlParseType { val: AmlValue::None, @@ -905,16 +905,16 @@ fn parse_def_power_res(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResul let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; let name = parse_name_string(&data[2 + pkg_len_len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; let system_level = data[2 + pkg_len_len + name.len]; let resource_order: u16 = (data[3 + pkg_len_len + name.len] as u16) + ((data[4 + pkg_len_len + name.len] as u16) << 8); - let mut local_ctx = AmlExecutionContext::new(local_scope_string.clone()); + let mut local_ctx = AmlExecutionContext::new(ctx.acpi_context(), local_scope_string.clone()); parse_object_list(&data[5 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; - ctx.add_to_namespace(local_scope_string, AmlValue::PowerResource(PowerResource { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::PowerResource(PowerResource { system_level, resource_order, obj_list: local_ctx.namespace_delta.clone() @@ -944,7 +944,7 @@ fn parse_def_processor(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResul let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; let name = parse_name_string(&data[2 + pkg_len_len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; let proc_id = data[2 + pkg_len_len + name.len]; let p_blk_addr: u32 = (data[3 + pkg_len_len + name.len] as u32) + @@ -953,11 +953,11 @@ fn parse_def_processor(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResul ((data[6 + pkg_len_len + name.len] as u32) << 24); let p_blk_len = data[7 + pkg_len_len + name.len]; - let mut local_ctx = AmlExecutionContext::new(local_scope_string.clone()); + let mut local_ctx = AmlExecutionContext::new(ctx.acpi_context(), local_scope_string.clone()); parse_object_list(&data[8 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Processor(Processor { - proc_id: proc_id, + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Processor(Processor { + proc_id, p_blk: if p_blk_len > 0 { Some(p_blk_addr) } else { None }, obj_list: local_ctx.namespace_delta.clone(), notify_methods: BTreeMap::new() @@ -987,12 +987,12 @@ fn parse_def_thermal_zone(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseRe let (pkg_len, pkg_len_len) = parse_pkg_length(&data[2..])?; let name = parse_name_string(&data[2 + pkg_len_len .. 2 + pkg_len], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; let mut local_ctx = AmlExecutionContext::new(ctx.acpi_context(), local_scope_string.clone()); parse_object_list(&data[2 + pkg_len_len + name.len .. 2 + pkg_len], &mut local_ctx)?; - ctx.add_to_namespace(local_scope_string, AmlValue::ThermalZone(ThermalZone { + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::ThermalZone(ThermalZone { obj_list: local_ctx.namespace_delta.clone(), notify_methods: BTreeMap::new() }))?; @@ -1022,7 +1022,7 @@ fn parse_def_external(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult let object_type = data[1 + object_name.len]; let argument_count = data[2 + object_name.len]; - let local_scope_string = get_namespace_string(ctx.scope.clone(), object_name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), object_name.val)?; let obj = match object_type { 8 => AmlValue::Method(Method { @@ -1034,7 +1034,7 @@ fn parse_def_external(data: &[u8], ctx: &mut AmlExecutionContext) -> ParseResult _ => AmlValue::Uninitialized }; - ctx.add_to_namespace(local_scope_string, obj)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, obj)?; Ok(AmlParseType { val: AmlValue::None, diff --git a/acpid/src/aml/namespace.rs b/acpid/src/aml/namespace.rs index 9b3e12b2ba..94938dcce9 100644 --- a/acpid/src/aml/namespace.rs +++ b/acpid/src/aml/namespace.rs @@ -157,7 +157,7 @@ impl AmlValue { } } - pub fn get_as_type(&self, t: AmlValue) -> Result { + pub fn get_as_type(&self, ctx: &AcpiContext, t: AmlValue) -> Result { match t { AmlValue::None => Ok(AmlValue::None), AmlValue::Uninitialized => Ok(self.clone()), @@ -165,9 +165,9 @@ impl AmlValue { AmlValue::Alias(_) => Ok(self.clone()), _ => Err(AmlError::AmlValueError) }, - AmlValue::Buffer(_) => Ok(AmlValue::Buffer(self.get_as_buffer()?)), - AmlValue::BufferField(_) => Ok(AmlValue::BufferField(self.get_as_buffer_field()?)), - AmlValue::DDBHandle(_) => Ok(AmlValue::DDBHandle(self.get_as_ddb_handle()?)), + AmlValue::Buffer(_) => Ok(AmlValue::Buffer(self.get_as_buffer(ctx)?)), + AmlValue::BufferField(_) => Ok(AmlValue::BufferField(self.get_as_buffer_field(ctx)?)), + AmlValue::DDBHandle(_) => Ok(AmlValue::DDBHandle(self.get_as_ddb_handle(ctx)?)), AmlValue::DebugObject => match *self { AmlValue::DebugObject => Ok(self.clone()), _ => Err(AmlError::AmlValueError) @@ -175,7 +175,7 @@ impl AmlValue { AmlValue::Device(_) => Ok(AmlValue::Device(self.get_as_device()?)), AmlValue::Event(_) => Ok(AmlValue::Event(self.get_as_event()?)), AmlValue::FieldUnit(_) => Ok(AmlValue::FieldUnit(self.get_as_field_unit()?)), - AmlValue::Integer(_) => Ok(AmlValue::Integer(self.get_as_integer()?)), + AmlValue::Integer(_) => Ok(AmlValue::Integer(self.get_as_integer(ctx)?)), AmlValue::IntegerConstant(_) => Ok(AmlValue::IntegerConstant(self.get_as_integer_constant()?)), AmlValue::Method(_) => Ok(AmlValue::Method(self.get_as_method()?)), AmlValue::Mutex(_) => Ok(AmlValue::Mutex(self.get_as_mutex()?)), @@ -185,7 +185,7 @@ impl AmlValue { _ => Err(AmlError::AmlValueError) }, AmlValue::Package(_) => Ok(AmlValue::Package(self.get_as_package()?)), - AmlValue::String(_) => Ok(AmlValue::String(self.get_as_string()?)), + AmlValue::String(_) => Ok(AmlValue::String(self.get_as_string(ctx)?)), AmlValue::PowerResource(_) => Ok(AmlValue::PowerResource(self.get_as_power_resource()?)), AmlValue::Processor(_) => Ok(AmlValue::Processor(self.get_as_processor()?)), AmlValue::RawDataBuffer(_) => Ok(AmlValue::RawDataBuffer(self.get_as_raw_data_buffer()?)), @@ -193,7 +193,7 @@ impl AmlValue { } } - pub fn get_as_buffer(&self) -> Result, AmlError> { + pub fn get_as_buffer(&self, ctx: &AcpiContext) -> Result, AmlError> { match *self { AmlValue::Buffer(ref b) => Ok(b.clone()), AmlValue::Integer(ref i) => { @@ -215,9 +215,9 @@ impl AmlValue { Ok(s.clone().into_bytes()) }, AmlValue::BufferField(ref b) => { - let buf = b.source_buf.get_as_buffer()?; - let idx = b.index.get_as_integer()? as usize; - let len = b.length.get_as_integer()? as usize; + let buf = b.source_buf.get_as_buffer(ctx)?; + let idx = b.index.get_as_integer(ctx)? as usize; + let len = b.length.get_as_integer(ctx)? as usize; if idx + len > buf.len() { return Err(AmlError::AmlValueError); @@ -229,11 +229,11 @@ impl AmlValue { } } - pub fn get_as_buffer_field(&self) -> Result { + pub fn get_as_buffer_field(&self, acpi_ctx: &AcpiContext) -> Result { match *self { AmlValue::BufferField(ref b) => Ok(b.clone()), _ => { - let raw_buf = self.get_as_buffer()?; + let raw_buf = self.get_as_buffer(acpi_ctx)?; let buf = Box::new(AmlValue::Buffer(raw_buf.clone())); let idx = Box::new(AmlValue::IntegerConstant(0)); let len = Box::new(AmlValue::Integer(raw_buf.len() as u64)); @@ -300,7 +300,7 @@ impl AmlValue { Ok(i) }, AmlValue::BufferField(_) => { - let mut b = self.get_as_buffer()?; + let mut b = self.get_as_buffer(acpi_ctx)?; if b.len() > 8 { return Err(AmlError::AmlValueError); } @@ -382,14 +382,14 @@ impl AmlValue { } } - pub fn get_as_string(&self) -> Result { + pub fn get_as_string(&self, ctx: &AcpiContext) -> Result { match *self { AmlValue::String(ref s) => Ok(s.clone()), AmlValue::Integer(ref i) => Ok(format!("{:X}", i)), AmlValue::IntegerConstant(ref i) => Ok(format!("{:X}", i)), AmlValue::Buffer(ref b) => Ok(String::from_utf8(b.clone()).expect("Invalid UTF-8")), AmlValue::BufferField(_) => { - let b = self.get_as_buffer()?; + let b = self.get_as_buffer(ctx)?; Ok(String::from_utf8(b).expect("Invalid UTF-8")) }, _ => Err(AmlError::AmlValueError) @@ -426,12 +426,12 @@ impl AmlValue { } impl Method { - pub fn execute(&self, scope: String, parameters: Vec) -> AmlValue { - let mut ctx = AmlExecutionContext::new(scope); + pub fn execute(&self, acpi_ctx: &AcpiContext, scope: String, parameters: Vec) -> AmlValue { + let mut ctx = AmlExecutionContext::new(acpi_ctx, scope); ctx.init_arg_vars(parameters); let _ = parse_term_list(&self.term_list[..], &mut ctx); - ctx.clean_namespace(); + ctx.clean_namespace(acpi_ctx); match ctx.state { ExecutionState::RETURN(v) => v, @@ -440,8 +440,8 @@ impl Method { } } -pub fn get_namespace_string(current: String, modifier_v: AmlValue) -> Result { - let mut modifier = modifier_v.get_as_string()?; +pub fn get_namespace_string(ctx: &AcpiContext, current: String, modifier_v: AmlValue) -> Result { + let mut modifier = modifier_v.get_as_string(ctx)?; if current.len() == 0 { return Ok(modifier); diff --git a/acpid/src/aml/namespacemodifier.rs b/acpid/src/aml/namespacemodifier.rs index 77fa1406b0..3c3a31465c 100644 --- a/acpid/src/aml/namespacemodifier.rs +++ b/acpid/src/aml/namespacemodifier.rs @@ -41,10 +41,10 @@ fn parse_alias_op(data: &[u8], let source_name = parse_name_string(&data[1..], ctx)?; let alias_name = parse_name_string(&data[1 + source_name.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), source_name.val)?; - let local_alias_string = get_namespace_string(ctx.scope.clone(), alias_name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), source_name.val)?; + let local_alias_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), alias_name.val)?; - ctx.add_to_namespace(local_scope_string, AmlValue::Alias(local_alias_string))?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, AmlValue::Alias(local_alias_string))?; Ok(AmlParseType { val: AmlValue::None, @@ -67,9 +67,9 @@ fn parse_name_op(data: &[u8], let name = parse_name_string(&data[1..], ctx)?; let data_ref_obj = parse_data_ref_obj(&data[1 + name.len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val)?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?; - ctx.add_to_namespace(local_scope_string, data_ref_obj.val)?; + ctx.add_to_namespace(ctx.acpi_context(), local_scope_string, data_ref_obj.val)?; Ok(AmlParseType { val: AmlValue::None, @@ -92,7 +92,7 @@ fn parse_scope_op(data: &[u8], let (pkg_length, pkg_length_len) = parse_pkg_length(&data[1..])?; let name = parse_name_string(&data[1 + pkg_length_len..], ctx)?; - let local_scope_string = get_namespace_string(ctx.scope.clone(), name.val.clone())?; + let local_scope_string = get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val.clone())?; let containing_scope_string = ctx.scope.clone(); ctx.scope = local_scope_string; diff --git a/acpid/src/aml/parser.rs b/acpid/src/aml/parser.rs index aff1aaa158..be0a349f2e 100644 --- a/acpid/src/aml/parser.rs +++ b/acpid/src/aml/parser.rs @@ -1,7 +1,4 @@ -use std::string::String; -use std::collections::BTreeMap; -use std::vec::Vec; -use std::boxed::Box; +use std::collections::HashMap; use parking_lot::RwLockWriteGuard; @@ -39,13 +36,13 @@ pub struct AmlExecutionContext<'a> { impl<'a> AmlExecutionContext<'a> { pub fn new(acpi_context: &'a AcpiContext, scope: String) -> AmlExecutionContext<'_> { - let mut idptr = ACPI_TABLE.next_ctx.write(); + let mut idptr = acpi_context.next_ctx.write(); let id: u64 = *idptr; *idptr += 1; AmlExecutionContext { - scope: scope, + scope, local_vars: [AmlValue::Uninitialized, AmlValue::Uninitialized, AmlValue::Uninitialized, @@ -74,8 +71,8 @@ impl<'a> AmlExecutionContext<'a> { self.acpi_context } - pub fn wait_for_event(&mut self, event_ptr: AmlValue) -> Result { - let mut namespace_ptr = self.prelock(); + pub fn wait_for_event(&mut self, ctx: &AcpiContext, event_ptr: AmlValue) -> Result { + let mut namespace_ptr = self.prelock(ctx); let namespace = match *namespace_ptr { Some(ref mut n) => n, None => return Err(AmlError::AmlHardFatal) @@ -108,8 +105,8 @@ impl<'a> AmlExecutionContext<'a> { Ok(false) } - pub fn signal_event(&mut self, event_ptr: AmlValue) -> Result<(), AmlError> { - let mut namespace_ptr = self.prelock(); + pub fn signal_event(&mut self, ctx: &AcpiContext, event_ptr: AmlValue) -> Result<(), AmlError> { + let mut namespace_ptr = self.prelock(ctx); let namespace = match *namespace_ptr { Some(ref mut n) => n, None => return Err(AmlError::AmlHardFatal) @@ -140,10 +137,10 @@ impl<'a> AmlExecutionContext<'a> { Ok(()) } - pub fn release_mutex(&mut self, mutex_ptr: AmlValue) -> Result<(), AmlError> { + pub fn release_mutex(&mut self, ctx: &AcpiContext, mutex_ptr: AmlValue) -> Result<(), AmlError> { let id = self.ctx_id; - let mut namespace_ptr = self.prelock(); + let mut namespace_ptr = self.prelock(ctx); let namespace = match *namespace_ptr { Some(ref mut n) => n, None => return Err(AmlError::AmlHardFatal) @@ -197,10 +194,10 @@ impl<'a> AmlExecutionContext<'a> { Ok(()) } - pub fn acquire_mutex(&mut self, mutex_ptr: AmlValue) -> Result { + pub fn acquire_mutex(&mut self, ctx: &AcpiContext, mutex_ptr: AmlValue) -> Result { let id = self.ctx_id; - let mut namespace_ptr = self.prelock(); + let mut namespace_ptr = self.prelock(ctx); let namespace = match *namespace_ptr { Some(ref mut n) => n, None => return Err(AmlError::AmlHardFatal) @@ -247,8 +244,8 @@ impl<'a> AmlExecutionContext<'a> { Ok(false) } - pub fn add_to_namespace(&mut self, name: String, value: AmlValue) -> Result<(), AmlError> { - let mut namespace = ACPI_TABLE.namespace.write(); + pub fn add_to_namespace(&mut self, ctx: &AcpiContext, name: String, value: AmlValue) -> Result<(), AmlError> { + let mut namespace = ctx.namespace_mut(); if let Some(ref mut namespace) = *namespace { if let Some(obj) = namespace.get(&name) { @@ -272,8 +269,8 @@ impl<'a> AmlExecutionContext<'a> { } } - pub fn clean_namespace(&mut self) { - let mut namespace = ACPI_TABLE.namespace.write(); + pub fn clean_namespace(&mut self, ctx: &AcpiContext) { + let mut namespace = ctx.namespace_mut(); if let Some(ref mut namespace) = *namespace { for k in &self.namespace_delta { @@ -294,17 +291,17 @@ impl<'a> AmlExecutionContext<'a> { } } - pub fn prelock(&mut self) -> RwLockWriteGuard<'static, Option>> { - ACPI_TABLE.namespace.write() + pub fn prelock<'ctx>(&mut self, ctx: &'ctx AcpiContext) -> RwLockWriteGuard<'ctx, Option>> { + ctx.namespace_mut() } - fn modify_local_obj(&mut self, local: usize, value: AmlValue) -> Result<(), AmlError> { - self.local_vars[local] = value.get_as_type(self.local_vars[local].clone())?; + fn modify_local_obj(&mut self, ctx: &AcpiContext, local: usize, value: AmlValue) -> Result<(), AmlError> { + self.local_vars[local] = value.get_as_type(ctx, self.local_vars[local].clone())?; Ok(()) } - fn modify_object(&mut self, name: String, value: AmlValue) -> Result<(), AmlError> { - if let Some(ref mut namespace) = *ACPI_TABLE.namespace.write() { + fn modify_object(&mut self, ctx: &AcpiContext, name: String, value: AmlValue) -> Result<(), AmlError> { + if let Some(ref mut namespace) = *ctx.namespace_mut() { let coercion_obj = { let obj = namespace.get(&name); @@ -315,22 +312,22 @@ impl<'a> AmlExecutionContext<'a> { } }; - namespace.insert(name, value.get_as_type(coercion_obj)?); + namespace.insert(name, value.get_as_type(ctx, coercion_obj)?); Ok(()) } else { Err(AmlError::AmlHardFatal) } } - fn modify_index_final(&mut self, name: String, value: AmlValue, indices: Vec) -> Result<(), AmlError> { - if let Some(ref mut namespace) = *ACPI_TABLE.namespace.write() { + fn modify_index_final(&mut self, ctx: &AcpiContext, name: String, value: AmlValue, indices: Vec) -> Result<(), AmlError> { + if let Some(ref mut namespace) = *ctx.namespace_mut() { let mut obj = if let Some(s) = namespace.get(&name) { s.clone() } else { return Err(AmlError::AmlValueError); }; - obj = self.modify_index_core(obj, value, indices)?; + obj = self.modify_index_core(ctx, obj, value, indices)?; namespace.insert(name, obj); Ok(()) @@ -339,7 +336,7 @@ impl<'a> AmlExecutionContext<'a> { } } - fn modify_index_core(&mut self, obj: AmlValue, value: AmlValue, indices: Vec) -> Result { + fn modify_index_core(&mut self, ctx: &AcpiContext, obj: AmlValue, value: AmlValue, indices: Vec) -> Result { match obj { AmlValue::String(ref string) => { if indices.len() != 1 { @@ -347,7 +344,7 @@ impl<'a> AmlExecutionContext<'a> { } let mut bytes = string.clone().into_bytes(); - bytes[indices[0] as usize] = value.get_as_integer()? as u8; + bytes[indices[0] as usize] = value.get_as_integer(ctx)? as u8; let string = String::from_utf8(bytes).unwrap(); @@ -359,7 +356,7 @@ impl<'a> AmlExecutionContext<'a> { } let mut b = b.clone(); - b[indices[0] as usize] = value.get_as_integer()? as u8; + b[indices[0] as usize] = value.get_as_integer(ctx)? as u8; Ok(AmlValue::Buffer(b)) }, @@ -369,9 +366,9 @@ impl<'a> AmlExecutionContext<'a> { } let mut idx = indices[0]; - idx += b.index.get_as_integer()?; + idx += b.index.get_as_integer(ctx)?; - let _ = self.modify(AmlValue::ObjectReference(ObjectReference::Index(b.source_buf.clone(), Box::new(AmlValue::Integer(idx.clone())))), value); + let _ = self.modify(ctx, AmlValue::ObjectReference(ObjectReference::Index(b.source_buf.clone(), Box::new(AmlValue::Integer(idx.clone())))), value); Ok(AmlValue::BufferField(b.clone())) }, @@ -385,7 +382,7 @@ impl<'a> AmlExecutionContext<'a> { if indices.len() == 1 { p[indices[0] as usize] = value; } else { - p[indices[0] as usize] = self.modify_index_core(p[indices[0] as usize].clone(), value, indices[1..].to_vec())?; + p[indices[0] as usize] = self.modify_index_core(ctx, p[indices[0] as usize].clone(), value, indices[1..].to_vec())?; } Ok(AmlValue::Package(p)) @@ -394,20 +391,20 @@ impl<'a> AmlExecutionContext<'a> { } } - pub fn modify_index(&mut self, name: AmlValue, value: AmlValue, indices: Vec) -> Result<(), AmlError>{ + pub fn modify_index(&mut self, ctx: &AcpiContext, name: AmlValue, value: AmlValue, indices: Vec) -> Result<(), AmlError>{ match name { AmlValue::ObjectReference(r) => match r { - ObjectReference::Object(s) => self.modify_index_final(s, value, indices), + ObjectReference::Object(s) => self.modify_index_final(ctx, s, value, indices), ObjectReference::Index(c, v) => { let mut indices = indices.clone(); - indices.push(v.get_as_integer()?); + indices.push(v.get_as_integer(ctx)?); - self.modify_index(*c, value, indices) + self.modify_index(ctx, *c, value, indices) }, ObjectReference::ArgObj(_) => Err(AmlError::AmlValueError), ObjectReference::LocalObj(i) => { let v = self.local_vars[i as usize].clone(); - self.local_vars[i as usize] = self.modify_index_core(v, value, indices)?; + self.local_vars[i as usize] = self.modify_index_core(ctx, v, value, indices)?; Ok(()) } @@ -416,15 +413,15 @@ impl<'a> AmlExecutionContext<'a> { } } - pub fn modify(&mut self, name: AmlValue, value: AmlValue) -> Result<(), AmlError> { + pub fn modify(&mut self, ctx: &AcpiContext, name: AmlValue, value: AmlValue) -> Result<(), AmlError> { match name { AmlValue::ObjectReference(r) => match r { ObjectReference::ArgObj(_) => Err(AmlError::AmlValueError), - ObjectReference::LocalObj(i) => self.modify_local_obj(i as usize, value), - ObjectReference::Object(s) => self.modify_object(s, value), - ObjectReference::Index(c, v) => self.modify_index(*c, value, vec!(v.get_as_integer()?)) + ObjectReference::LocalObj(i) => self.modify_local_obj(ctx, i as usize, value), + ObjectReference::Object(s) => self.modify_object(ctx, s, value), + ObjectReference::Index(c, v) => self.modify_index(ctx, *c, value, vec!(v.get_as_integer(ctx)?)) }, - AmlValue::String(s) => self.modify_object(s, value), + AmlValue::String(s) => self.modify_object(ctx, s, value), _ => Err(AmlError::AmlValueError) } } @@ -434,8 +431,8 @@ impl<'a> AmlExecutionContext<'a> { Ok(()) } - fn copy_object(&mut self, name: String, value: AmlValue) -> Result<(), AmlError> { - if let Some(ref mut namespace) = *ACPI_TABLE.namespace.write() { + fn copy_object(&mut self, ctx: &AcpiContext, name: String, value: AmlValue) -> Result<(), AmlError> { + if let Some(ref mut namespace) = *ctx.namespace_mut() { namespace.insert(name, value); Ok(()) } else { @@ -443,34 +440,34 @@ impl<'a> AmlExecutionContext<'a> { } } - pub fn copy(&mut self, name: AmlValue, value: AmlValue) -> Result<(), AmlError> { + pub fn copy(&mut self, ctx: &AcpiContext, name: AmlValue, value: AmlValue) -> Result<(), AmlError> { match name { AmlValue::ObjectReference(r) => match r { ObjectReference::ArgObj(_) => Err(AmlError::AmlValueError), ObjectReference::LocalObj(i) => self.copy_local_obj(i as usize, value), - ObjectReference::Object(s) => self.copy_object(s, value), - ObjectReference::Index(c, v) => self.modify_index(*c, value, vec!(v.get_as_integer()?)) + ObjectReference::Object(s) => self.copy_object(ctx, s, value), + ObjectReference::Index(c, v) => self.modify_index(ctx, *c, value, vec!(v.get_as_integer(ctx)?)) }, - AmlValue::String(s) => self.copy_object(s, value), + AmlValue::String(s) => self.copy_object(ctx, s, value), _ => Err(AmlError::AmlValueError) } } - fn get_index_final(&self, name: String, indices: Vec) -> Result { - if let Some(ref namespace) = *ACPI_TABLE.namespace.read() { + fn get_index_final(&self, ctx: &AcpiContext, name: String, indices: Vec) -> Result { + if let Some(ref namespace) = *ctx.namespace() { let obj = if let Some(s) = namespace.get(&name) { s.clone() } else { return Err(AmlError::AmlValueError); }; - self.get_index_core(obj, indices) + self.get_index_core(ctx, obj, indices) } else { Err(AmlError::AmlValueError) } } - fn get_index_core(&self, obj: AmlValue, indices: Vec) -> Result { + fn get_index_core(&self, ctx: &AcpiContext, obj: AmlValue, indices: Vec) -> Result { match obj { AmlValue::String(ref string) => { if indices.len() != 1 { @@ -493,9 +490,9 @@ impl<'a> AmlExecutionContext<'a> { } let mut idx = indices[0]; - idx += b.index.get_as_integer()?; + idx += b.index.get_as_integer(ctx)?; - Ok(AmlValue::Integer(b.source_buf.get_as_buffer()?[idx as usize] as u64)) + Ok(AmlValue::Integer(b.source_buf.get_as_buffer(ctx, )?[idx as usize] as u64)) }, AmlValue::Package(ref p) => { if indices.len() == 0 { @@ -505,48 +502,48 @@ impl<'a> AmlExecutionContext<'a> { if indices.len() == 1 { Ok(p[indices[0] as usize].clone()) } else { - self.get_index_core(p[indices[0] as usize].clone(), indices[1..].to_vec()) + self.get_index_core(ctx, p[indices[0] as usize].clone(), indices[1..].to_vec()) } }, _ => Err(AmlError::AmlValueError) } } - pub fn get_index(&self, name: AmlValue, indices: Vec) -> Result{ + pub fn get_index(&self, ctx: &AcpiContext, name: AmlValue, indices: Vec) -> Result{ match name { AmlValue::ObjectReference(r) => match r { - ObjectReference::Object(s) => self.get_index_final(s, indices), + ObjectReference::Object(s) => self.get_index_final(ctx, s, indices), ObjectReference::Index(c, v) => { let mut indices = indices.clone(); - indices.push(v.get_as_integer()?); + indices.push(v.get_as_integer(ctx)?); - self.get_index(*c, indices) + self.get_index(ctx, *c, indices) }, ObjectReference::ArgObj(_) => Err(AmlError::AmlValueError), ObjectReference::LocalObj(i) => { let v = self.local_vars[i as usize].clone(); - self.get_index_core(v, indices) + self.get_index_core(ctx, v, indices) } }, _ => Err(AmlError::AmlValueError) } } - pub fn get(&self, name: AmlValue) -> Result { + pub fn get(&self, ctx: &AcpiContext, name: AmlValue) -> Result { Ok(match name { AmlValue::ObjectReference(r) => match r { ObjectReference::ArgObj(i) => self.arg_vars[i as usize].clone(), ObjectReference::LocalObj(i) => self.local_vars[i as usize].clone(), - ObjectReference::Object(ref s) => if let Some(ref namespace) = *ACPI_TABLE.namespace.read() { + ObjectReference::Object(ref s) => if let Some(ref namespace) = *ctx.namespace() { if let Some(o) = namespace.get(s) { o.clone() } else { AmlValue::None } } else { AmlValue::None }, - ObjectReference::Index(c, v) => self.get_index(*c, vec!(v.get_as_integer()?))?, + ObjectReference::Index(c, v) => self.get_index(ctx, *c, vec!(v.get_as_integer(ctx)?))?, }, - AmlValue::String(ref s) => if let Some(ref namespace) = *ACPI_TABLE.namespace.read() { + AmlValue::String(ref s) => if let Some(ref namespace) = *ctx.namespace() { if let Some(o) = namespace.get(s) { o.clone() } else { diff --git a/acpid/src/aml/termlist.rs b/acpid/src/aml/termlist.rs index c382a7c5c0..036036f1eb 100644 --- a/acpid/src/aml/termlist.rs +++ b/acpid/src/aml/termlist.rs @@ -123,7 +123,7 @@ pub fn parse_method_invocation(data: &[u8], } let name = parse_name_string(data, ctx)?; - let method = ctx.get(name.val.clone())?; + let method = ctx.get(ctx.acpi_context(), name.val.clone())?; let method = match method { AmlValue::None => return Err(AmlError::AmlDeferredLoad), @@ -145,7 +145,7 @@ pub fn parse_method_invocation(data: &[u8], } Ok(AmlParseType { - val: method.execute(get_namespace_string(ctx.scope.clone(), name.val)?, params), + val: method.execute(ctx.acpi_context(), get_namespace_string(ctx.acpi_context(), ctx.scope.clone(), name.val)?, params), len: current_offset }) } diff --git a/acpid/src/aml/type1opcode.rs b/acpid/src/aml/type1opcode.rs index fe5b8256ba..cd61a78d71 100644 --- a/acpid/src/aml/type1opcode.rs +++ b/acpid/src/aml/type1opcode.rs @@ -153,7 +153,7 @@ fn parse_def_load(data: &[u8], let name = parse_name_string(&data[2..], ctx)?; let ddb_handle_object = parse_super_name(&data[2 + name.len..], ctx)?; - let tbl = ctx.get(name.val)?.get_as_buffer()?; + let tbl = ctx.get(ctx.acpi_context(), name.val)?.get_as_buffer(ctx.acpi_context())?; // TODO let sdt = plain::from_bytes::(&tbl[..mem::size_of::()]).unwrap(); @@ -163,8 +163,8 @@ fn parse_def_load(data: &[u8], }; if let Some(aml_sdt) = PossibleAmlTables::try_new(table.clone()) { - let delta = parse_aml_table(aml_sdt)?; - let _ = ctx.modify(ddb_handle_object.val, AmlValue::DDBHandle((delta, sdt.signature()))); + let delta = parse_aml_table(ctx.acpi_context(), aml_sdt)?; + let _ = ctx.modify(ctx.acpi_context(), ddb_handle_object.val, AmlValue::DDBHandle((delta, sdt.signature()))); Ok(AmlParseType { val: AmlValue::None, @@ -190,9 +190,9 @@ fn parse_def_notify(data: &[u8], let object = parse_super_name(&data[1..], ctx)?; let value = parse_term_arg(&data[1 + object.len..], ctx)?; - let number = value.val.get_as_integer()? as u8; + let number = value.val.get_as_integer(ctx.acpi_context())? as u8; - match ctx.get(object.val)? { + match ctx.get(ctx.acpi_context(), object.val)? { AmlValue::Device(d) => { if let Some(methods) = d.notify_methods.get(&number) { for method in methods { @@ -236,7 +236,7 @@ fn parse_def_release(data: &[u8], parser_opcode_extended!(data, 0x27); let obj = parse_super_name(&data[2..], ctx)?; - let _ = ctx.release_mutex(obj.val); + let _ = ctx.release_mutex(ctx.acpi_context(), obj.val); Ok(AmlParseType { val: AmlValue::None, @@ -257,9 +257,9 @@ fn parse_def_reset(data: &[u8], parser_opcode_extended!(data, 0x26); let object = parse_super_name(&data[2..], ctx)?; - ctx.get(object.val.clone())?.get_as_event()?; + ctx.get(ctx.acpi_context(), object.val.clone())?.get_as_event()?; - let _ = ctx.modify(object.val.clone(), AmlValue::Event(0)); + let _ = ctx.modify(ctx.acpi_context(), object.val.clone(), AmlValue::Event(0)); Ok(AmlParseType { val: AmlValue::None, @@ -280,7 +280,7 @@ fn parse_def_signal(data: &[u8], parser_opcode_extended!(data, 0x24); let object = parse_super_name(&data[2..], ctx)?; - ctx.signal_event(object.val)?; + ctx.signal_event(ctx.acpi_context(), object.val)?; Ok(AmlParseType { val: AmlValue::None, len: 2 + object.len @@ -300,7 +300,7 @@ fn parse_def_sleep(data: &[u8], parser_opcode_extended!(data, 0x22); let time = parse_term_arg(&data[2..], ctx)?; - let timeout = time.val.get_as_integer()?; + let timeout = time.val.get_as_integer(ctx.acpi_context())?; let (seconds, nanoseconds) = monotonic(); let starting_time_ns = nanoseconds + (seconds * 1_000_000_000); @@ -333,7 +333,7 @@ fn parse_def_stall(data: &[u8], parser_opcode_extended!(data, 0x21); let time = parse_term_arg(&data[2..], ctx)?; - let timeout = time.val.get_as_integer()?; + let timeout = time.val.get_as_integer(ctx.acpi_context())?; let (seconds, nanoseconds) = monotonic(); let starting_time_ns = nanoseconds + (seconds * 1_000_000_000); @@ -367,8 +367,8 @@ fn parse_def_unload(data: &[u8], let object = parse_super_name(&data[2..], ctx)?; - let delta = ctx.get(object.val)?.get_as_ddb_handle()?; - let mut namespace = ctx.prelock(); + let delta = ctx.get(ctx.acpi_context(), object.val)?.get_as_ddb_handle(ctx.acpi_context())?; + let mut namespace = ctx.prelock(ctx.acpi_context()); if let Some(ref mut ns) = *namespace { for o in delta.0 { @@ -403,7 +403,7 @@ fn parse_def_if_else(data: &[u8], (0 as usize, 0 as usize) }; - if if_condition.val.get_as_integer()? > 0 { + if if_condition.val.get_as_integer(ctx.acpi_context())? > 0 { parse_term_list(&data[1 + pkg_length_len + if_condition.len .. 1 + pkg_length], ctx)?; } else if else_length > 0 { parse_term_list(&data[2 + pkg_length + else_length_len .. 2 + pkg_length + else_length], ctx)?; @@ -431,7 +431,7 @@ fn parse_def_while(data: &[u8], loop { let predicate = parse_term_arg(&data[1 + pkg_length_len..], ctx)?; - if predicate.val.get_as_integer()? == 0 { + if predicate.val.get_as_integer(ctx.acpi_context())? == 0 { break; } diff --git a/acpid/src/aml/type2opcode.rs b/acpid/src/aml/type2opcode.rs index 846d44a658..ec137cdeb3 100644 --- a/acpid/src/aml/type2opcode.rs +++ b/acpid/src/aml/type2opcode.rs @@ -180,7 +180,7 @@ pub fn parse_def_var_package(data: &[u8], let mut elements = parse_package_elements_list(&data[1 + pkg_length_len + num_elements.len .. 1 + pkg_length], ctx)?.val.get_as_package()?; - let numelements = num_elements.val.get_as_integer()? as usize; + let numelements = num_elements.val.get_as_integer(ctx.acpi_context())? as usize; if elements.len() > numelements { elements = elements[0 .. numelements].to_vec(); @@ -215,7 +215,7 @@ fn parse_package_elements_list(data: &[u8], } else { let d = parse_name_string(&data[current_offset..], ctx)?; AmlParseType { - val: AmlValue::ObjectReference(ObjectReference::Object(d.val.get_as_string()?)), + val: AmlValue::ObjectReference(ObjectReference::Object(d.val.get_as_string(ctx.acpi_context())?)), len: d.len } }; @@ -246,7 +246,7 @@ pub fn parse_def_buffer(data: &[u8], let buffer_size = parse_term_arg(&data[1 + pkg_length_len..], ctx)?; let mut byte_list = data[1 + pkg_length_len + buffer_size.len .. 1 + pkg_length].to_vec().clone(); - byte_list.truncate(buffer_size.val.get_as_integer()? as usize); + byte_list.truncate(buffer_size.val.get_as_integer(ctx.acpi_context())? as usize); Ok(AmlParseType { val: AmlValue::Buffer(byte_list), @@ -269,7 +269,7 @@ fn parse_def_ref_of(data: &[u8], let obj = parse_super_name(&data[1..], ctx)?; let res = match obj.val { AmlValue::String(ref s) => { - match ctx.get(AmlValue::String(s.clone()))? { + match ctx.get(ctx.acpi_context(), AmlValue::String(s.clone()))? { AmlValue::None => return Err(AmlError::AmlValueError), _ => ObjectReference::Object(s.clone()) } @@ -297,7 +297,7 @@ fn parse_def_deref_of(data: &[u8], parser_opcode!(data, 0x83); let obj = parse_term_arg(&data[1..], ctx)?; - let res = ctx.get(obj.val)?; + let res = ctx.get(ctx.acpi_context(), obj.val)?; match res { AmlValue::None => Err(AmlError::AmlValueError), @@ -327,7 +327,7 @@ fn parse_def_acquire(data: &[u8], let starting_time_ns = nanoseconds + (seconds * 1_000_000_000); loop { - match ctx.acquire_mutex(obj.val.clone()) { + match ctx.acquire_mutex(ctx.acpi_context(), obj.val.clone()) { Err(e) => return Err(e), Ok(b) => if b { return Ok(AmlParseType { @@ -366,9 +366,9 @@ fn parse_def_increment(data: &[u8], let obj = parse_super_name(&data[1..], ctx)?; - let _namespace = ctx.prelock(); - let value = AmlValue::Integer(ctx.get(obj.val.clone())?.get_as_integer()? + 1); - let _ = ctx.modify(obj.val, value.clone()); + let _namespace = ctx.prelock(ctx.acpi_context()); + let value = AmlValue::Integer(ctx.get(ctx.acpi_context(), obj.val.clone())?.get_as_integer(ctx.acpi_context())? + 1); + let _ = ctx.modify(ctx.acpi_context(), obj.val, value.clone()); Ok(AmlParseType { val: value, @@ -393,7 +393,7 @@ fn parse_def_index(data: &[u8], let target = parse_target(&data[1 + obj.len + idx.len..], ctx)?; let reference = AmlValue::ObjectReference(ObjectReference::Index(Box::new(obj.val), Box::new(idx.val))); - let _ = ctx.modify(target.val, reference.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, reference.clone()); Ok(AmlParseType { val: reference, @@ -416,7 +416,7 @@ fn parse_def_land(data: &[u8], let lhs = parse_term_arg(&data[1..], ctx)?; let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; - let result = if lhs.val.get_as_integer()? > 0 && rhs.val.get_as_integer()? > 0 { 1 } else { 0 }; + let result = if lhs.val.get_as_integer(ctx.acpi_context())? > 0 && rhs.val.get_as_integer(ctx.acpi_context())? > 0 { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -439,7 +439,7 @@ fn parse_def_lequal(data: &[u8], let lhs = parse_term_arg(&data[1..], ctx)?; let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; - let result = if lhs.val.get_as_integer()? == rhs.val.get_as_integer()? { 1 } else { 0 }; + let result = if lhs.val.get_as_integer(ctx.acpi_context())? == rhs.val.get_as_integer(ctx.acpi_context())? { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -462,7 +462,7 @@ fn parse_def_lgreater(data: &[u8], let lhs = parse_term_arg(&data[1..], ctx)?; let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; - let result = if lhs.val.get_as_integer()? > rhs.val.get_as_integer()? { 1 } else { 0 }; + let result = if lhs.val.get_as_integer(ctx.acpi_context())? > rhs.val.get_as_integer(ctx.acpi_context())? { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -485,7 +485,7 @@ fn parse_def_lless(data: &[u8], let lhs = parse_term_arg(&data[1..], ctx)?; let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; - let result = if lhs.val.get_as_integer()? < rhs.val.get_as_integer()? { 1 } else { 0 }; + let result = if lhs.val.get_as_integer(ctx.acpi_context())? < rhs.val.get_as_integer(ctx.acpi_context())? { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -506,7 +506,7 @@ fn parse_def_lnot(data: &[u8], parser_opcode!(data, 0x92); let operand = parse_term_arg(&data[1..], ctx)?; - let result = if operand.val.get_as_integer()? == 0 { 1 } else { 0 }; + let result = if operand.val.get_as_integer(ctx.acpi_context())? == 0 { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -529,7 +529,7 @@ fn parse_def_lor(data: &[u8], let lhs = parse_term_arg(&data[1..], ctx)?; let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; - let result = if lhs.val.get_as_integer()? > 0 || rhs.val.get_as_integer()? > 0 { 1 } else { 0 }; + let result = if lhs.val.get_as_integer(ctx.acpi_context())? > 0 || rhs.val.get_as_integer(ctx.acpi_context())? > 0 { 1 } else { 0 }; Ok(AmlParseType { val: AmlValue::IntegerConstant(result), @@ -554,14 +554,14 @@ fn parse_def_to_hex_string(data: &[u8], let res = match operand.val { AmlValue::Integer(_) => { - let result: String = format!("{:X}", operand.val.get_as_integer()?); + let result: String = format!("{:X}", operand.val.get_as_integer(ctx.acpi_context())?); AmlValue::String(result) }, AmlValue::String(s) => AmlValue::String(s), AmlValue::Buffer(_) => { let mut string: String = String::new(); - for b in operand.val.get_as_buffer()? { + for b in operand.val.get_as_buffer(ctx.acpi_context())? { string.push_str(&format!("{:X}", b)); } @@ -570,7 +570,7 @@ fn parse_def_to_hex_string(data: &[u8], _ => return Err(AmlError::AmlValueError) }; - let _ = ctx.modify(target.val, res.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, res.clone()); Ok(AmlParseType { val: res, @@ -593,8 +593,8 @@ fn parse_def_to_buffer(data: &[u8], let operand = parse_term_arg(&data[2..], ctx)?; let target = parse_target(&data[2 + operand.len..], ctx)?; - let res = AmlValue::Buffer(operand.val.get_as_buffer()?); - let _ = ctx.modify(target.val, res.clone()); + let res = AmlValue::Buffer(operand.val.get_as_buffer(ctx.acpi_context())?); + let _ = ctx.modify(ctx.acpi_context(), target.val, res.clone()); Ok(AmlParseType { val: res, @@ -617,7 +617,7 @@ fn parse_def_to_bcd(data: &[u8], let operand = parse_term_arg(&data[2..], ctx)?; let target = parse_target(&data[2 + operand.len..], ctx)?; - let mut i = operand.val.get_as_integer()?; + let mut i = operand.val.get_as_integer(ctx.acpi_context())?; let mut result = 0; while i != 0 { @@ -627,7 +627,7 @@ fn parse_def_to_bcd(data: &[u8], } let result = AmlValue::Integer(result); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -651,14 +651,14 @@ fn parse_def_to_decimal_string(data: &[u8], let target = parse_target(&data[2 + operand.len..], ctx)?; let res = match operand.val { AmlValue::Integer(_) => { - let result: String = format!("{}", operand.val.get_as_integer()?); + let result: String = format!("{}", operand.val.get_as_integer(ctx.acpi_context())?); AmlValue::String(result) }, AmlValue::String(s) => AmlValue::String(s), AmlValue::Buffer(_) => { let mut string: String = String::new(); - for b in operand.val.get_as_buffer()? { + for b in operand.val.get_as_buffer(ctx.acpi_context())? { string.push_str(&format!("{}", b)); } @@ -667,7 +667,7 @@ fn parse_def_to_decimal_string(data: &[u8], _ => return Err(AmlError::AmlValueError) }; - let _ = ctx.modify(target.val, res.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, res.clone()); Ok(AmlParseType { val: res, @@ -690,9 +690,9 @@ fn parse_def_to_integer(data: &[u8], let operand = parse_term_arg(&data[2..], ctx)?; let target = parse_target(&data[2 + operand.len..], ctx)?; - let res = AmlValue::Integer(operand.val.get_as_integer()?); + let res = AmlValue::Integer(operand.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, res.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, res.clone()); Ok(AmlParseType { val: res, @@ -716,16 +716,16 @@ fn parse_def_to_string(data: &[u8], let length = parse_term_arg(&data[1 + operand.len..], ctx)?; let target = parse_target(&data[1 + operand.len + length.len..], ctx)?; - let buf = operand.val.get_as_buffer()?; + let buf = operand.val.get_as_buffer(ctx.acpi_context())?; let mut string = match String::from_utf8(buf) { Ok(s) => s, Err(_) => return Err(AmlError::AmlValueError) }; - string.truncate(length.val.get_as_integer()? as usize); + string.truncate(length.val.get_as_integer(ctx.acpi_context())? as usize); let res = AmlValue::String(string); - let _ = ctx.modify(target.val, res.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, res.clone()); Ok(AmlParseType { val: res, @@ -749,9 +749,9 @@ fn parse_def_subtract(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? - rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? - rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -772,7 +772,7 @@ fn parse_def_size_of(data: &[u8], parser_opcode!(data, 0x87); let name = parse_super_name(&data[1..], ctx)?; - let obj = ctx.get(name.val)?; + let obj = ctx.get(ctx.acpi_context(), name.val)?; let res = match obj { AmlValue::Buffer(ref v) => v.len(), @@ -802,7 +802,7 @@ fn parse_def_store(data: &[u8], let operand = parse_term_arg(&data[1..], ctx)?; let target = parse_super_name(&data[1 + operand.len..], ctx)?; - let _ = ctx.modify(target.val.clone(), operand.val); + let _ = ctx.modify(ctx.acpi_context(), target.val.clone(), operand.val); Ok(AmlParseType { val: target.val, @@ -826,9 +826,9 @@ fn parse_def_or(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? | rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? | rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -852,9 +852,9 @@ fn parse_def_shift_left(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? >> rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? >> rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -878,9 +878,9 @@ fn parse_def_shift_right(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? << rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? << rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -904,9 +904,9 @@ fn parse_def_add(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? + rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? + rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -930,9 +930,9 @@ fn parse_def_and(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? & rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? & rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -956,9 +956,9 @@ fn parse_def_xor(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? ^ rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? ^ rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -982,8 +982,8 @@ fn parse_def_concat_res(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let mut buf1 = lhs.val.get_as_buffer()?.clone(); - let mut buf2 = rhs.val.get_as_buffer()?.clone(); + let mut buf1 = lhs.val.get_as_buffer(ctx.acpi_context())?.clone(); + let mut buf2 = rhs.val.get_as_buffer(ctx.acpi_context())?.clone(); if buf1.len() == 1 || buf2.len() == 1 { return Err(AmlError::AmlValueError); @@ -1010,7 +1010,7 @@ fn parse_def_concat_res(data: &[u8], buf1.push(checksum); let res = AmlValue::Buffer(buf1); - ctx.modify(target.val, res.clone())?; + ctx.modify(ctx.acpi_context(), target.val, res.clone())?; Ok(AmlParseType { val: res, @@ -1033,13 +1033,13 @@ fn parse_def_wait(data: &[u8], let obj = parse_super_name(&data[2..], ctx)?; let timeout_obj = parse_term_arg(&data[2 + obj.len..], ctx)?; - let timeout = timeout_obj.val.get_as_integer()?; + let timeout = timeout_obj.val.get_as_integer(ctx.acpi_context())?; let (seconds, nanoseconds) = monotonic(); let starting_time_ns = nanoseconds + (seconds * 1_000_000_000); loop { - match ctx.wait_for_event(obj.val.clone()) { + match ctx.wait_for_event(ctx.acpi_context(), obj.val.clone()) { Err(e) => return Err(e), Ok(b) => if b { return Ok(AmlParseType { @@ -1080,7 +1080,7 @@ fn parse_def_cond_ref_of(data: &[u8], let res = match obj.val { AmlValue::String(ref s) => { - match ctx.get(AmlValue::String(s.clone()))? { + match ctx.get(ctx.acpi_context(), AmlValue::String(s.clone()))? { AmlValue::None => return Ok(AmlParseType { val: AmlValue::Integer(0), len: 1 + obj.len + target.len @@ -1092,7 +1092,7 @@ fn parse_def_cond_ref_of(data: &[u8], _ => return Err(AmlError::AmlValueError) }; - let _ = ctx.modify(target.val, AmlValue::ObjectReference(res)); + let _ = ctx.modify(ctx.acpi_context(), target.val, AmlValue::ObjectReference(res)); Ok(AmlParseType { val: AmlValue::Integer(1), @@ -1117,7 +1117,7 @@ fn parse_def_copy_object(data: &[u8], let source = parse_term_arg(&data[1..], ctx)?; let destination = parse_simple_name(&data[1 + source.len..], ctx)?; - ctx.copy(destination.val, source.val.clone())?; + ctx.copy(ctx.acpi_context(), destination.val, source.val.clone())?; Ok(AmlParseType { val: source.val, @@ -1143,17 +1143,17 @@ fn parse_def_concat(data: &[u8], let result = match lhs.val { AmlValue::Integer(_i) => { - let j = AmlValue::Integer(rhs.val.get_as_integer()?); + let j = AmlValue::Integer(rhs.val.get_as_integer(ctx.acpi_context())?); - let mut first = lhs.val.get_as_buffer()?.clone(); - let mut second = j.get_as_buffer()?.clone(); + let mut first = lhs.val.get_as_buffer(ctx.acpi_context())?.clone(); + let mut second = j.get_as_buffer(ctx.acpi_context())?.clone(); first.append(&mut second); AmlValue::Buffer(first) }, AmlValue::String(s) => { - let t = if let Ok(t) = rhs.val.get_as_string() { + let t = if let Ok(t) = rhs.val.get_as_string(ctx.acpi_context()) { t } else { rhs.val.get_type_string() @@ -1163,10 +1163,10 @@ fn parse_def_concat(data: &[u8], }, AmlValue::Buffer(b) => { let mut b = b.clone(); - let mut c = if let Ok(c) = rhs.val.get_as_buffer() { + let mut c = if let Ok(c) = rhs.val.get_as_buffer(ctx.acpi_context()) { c.clone() } else { - AmlValue::String(rhs.val.get_type_string()).get_as_buffer()?.clone() + AmlValue::String(rhs.val.get_type_string()).get_as_buffer(ctx.acpi_context())?.clone() }; b.append(&mut c); @@ -1175,7 +1175,7 @@ fn parse_def_concat(data: &[u8], }, _ => { let first = lhs.val.get_type_string(); - let second = if let Ok(second) = rhs.val.get_as_string() { + let second = if let Ok(second) = rhs.val.get_as_string(ctx.acpi_context()) { second } else { rhs.val.get_type_string() @@ -1185,7 +1185,7 @@ fn parse_def_concat(data: &[u8], } }; - ctx.modify(target.val, result.clone())?; + ctx.modify(ctx.acpi_context(), target.val, result.clone())?; Ok(AmlParseType { val: result, @@ -1207,9 +1207,9 @@ fn parse_def_decrement(data: &[u8], let obj = parse_super_name(&data[1..], ctx)?; - let _namespace = ctx.prelock(); - let value = AmlValue::Integer(ctx.get(obj.val.clone())?.get_as_integer()? - 1); - let _ = ctx.modify(obj.val, value.clone()); + let _namespace = ctx.prelock(ctx.acpi_context()); + let value = AmlValue::Integer(ctx.get(ctx.acpi_context(), obj.val.clone())?.get_as_integer(ctx.acpi_context())? - 1); + let _ = ctx.modify(ctx.acpi_context(), obj.val, value.clone()); Ok(AmlParseType { val: value, @@ -1234,14 +1234,14 @@ fn parse_def_divide(data: &[u8], let target_remainder = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; let target_quotient = parse_target(&data[1 + lhs.len + rhs.len + target_remainder.len..], ctx)?; - let numerator = lhs.val.get_as_integer()?; - let denominator = rhs.val.get_as_integer()?; + let numerator = lhs.val.get_as_integer(ctx.acpi_context())?; + let denominator = rhs.val.get_as_integer(ctx.acpi_context())?; let remainder = numerator % denominator; let quotient = (numerator - remainder) / denominator; - let _ = ctx.modify(target_remainder.val, AmlValue::Integer(remainder)); - let _ = ctx.modify(target_quotient.val, AmlValue::Integer(quotient)); + let _ = ctx.modify(ctx.acpi_context(), target_remainder.val, AmlValue::Integer(remainder)); + let _ = ctx.modify(ctx.acpi_context(), target_quotient.val, AmlValue::Integer(quotient)); Ok(AmlParseType { val: AmlValue::Integer(quotient), @@ -1265,7 +1265,7 @@ fn parse_def_find_set_left_bit(data: &[u8], let target = parse_target(&data[2 + operand.len..], ctx)?; let mut first_bit = 32; - let mut test = operand.val.get_as_integer()?; + let mut test = operand.val.get_as_integer(ctx.acpi_context())?; while first_bit > 0{ if test & 0x8000_0000_0000_0000 > 0 { @@ -1277,7 +1277,7 @@ fn parse_def_find_set_left_bit(data: &[u8], } let result = AmlValue::Integer(first_bit); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1301,7 +1301,7 @@ fn parse_def_find_set_right_bit(data: &[u8], let target = parse_target(&data[2 + operand.len..], ctx)?; let mut first_bit = 1; - let mut test = operand.val.get_as_integer()?; + let mut test = operand.val.get_as_integer(ctx.acpi_context())?; while first_bit <= 32 { if test & 1 > 0 { @@ -1317,7 +1317,7 @@ fn parse_def_find_set_right_bit(data: &[u8], } let result = AmlValue::Integer(first_bit); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1346,15 +1346,15 @@ fn parse_def_load_table(data: &[u8], let parameter_data = parse_term_arg(&data[2 + signature.len + oem_id.len + oem_table_id.len + root_path.len + parameter_path.len..], ctx)?; let signature = { - <[u8; 4]>::try_from(&*signature.val.get_as_buffer()?) + <[u8; 4]>::try_from(&*signature.val.get_as_buffer(ctx.acpi_context())?) .expect("expected 'load table' def to have a signature that is 4 bytes long") }; let oem_id = { - <[u8; 6]>::try_from(&*oem_id.val.get_as_buffer()?) + <[u8; 6]>::try_from(&*oem_id.val.get_as_buffer(ctx.acpi_context())?) .expect("expected 'load table' def to have an OEM ID that is 6 bytes long") }; let oem_table_id = { - <[u8; 8]>::try_from(&*oem_table_id.val.get_as_buffer()?) + <[u8; 8]>::try_from(&*oem_table_id.val.get_as_buffer(ctx.acpi_context())?) .expect("expected 'load table' def to have an OEM table ID that is 8 bytes long") }; @@ -1369,8 +1369,8 @@ fn parse_def_load_table(data: &[u8], let sdt = ctx.acpi_context().sdt_from_signature(&sdt_signature); Ok(if let Some(sdt) = sdt.and_then(|sdt| PossibleAmlTables::try_new(sdt.clone())) { - let hdl = parse_aml_with_scope(sdt, root_path.val.get_as_string()?)?; - let _ = ctx.modify(parameter_path.val, parameter_data.val); + let hdl = parse_aml_with_scope(ctx.acpi_context(), sdt, root_path.val.get_as_string(ctx.acpi_context())?)?; + let _ = ctx.modify(ctx.acpi_context(), parameter_path.val, parameter_data.val); AmlParseType { val: AmlValue::DDBHandle((hdl, sdt_signature)), @@ -1423,14 +1423,14 @@ fn parse_def_match(data: &[u8], let start_index = parse_term_arg(&data[3 + search_pkg.len + first_operand.len + second_operand.len..], ctx)?; let pkg = search_pkg.val.get_as_package()?; - let mut idx = start_index.val.get_as_integer()? as usize; + let mut idx = start_index.val.get_as_integer(ctx.acpi_context())? as usize; match first_operand.val { AmlValue::Integer(i) => { - let j = second_operand.val.get_as_integer()?; + let j = second_operand.val.get_as_integer(ctx.acpi_context())?; while idx < pkg.len() { - let val = if let Ok(v) = pkg[idx].get_as_integer() { v } else { idx += 1; continue; }; + let val = if let Ok(v) = pkg[idx].get_as_integer(ctx.acpi_context()) { v } else { idx += 1; continue; }; idx += 1; match first_operation { @@ -1458,10 +1458,10 @@ fn parse_def_match(data: &[u8], } }, AmlValue::String(i) => { - let j = second_operand.val.get_as_string()?; + let j = second_operand.val.get_as_string(ctx.acpi_context())?; while idx < pkg.len() { - let val = if let Ok(v) = pkg[idx].get_as_string() { v } else { idx += 1; continue; }; + let val = if let Ok(v) = pkg[idx].get_as_string(ctx.acpi_context()) { v } else { idx += 1; continue; }; idx += 1; match first_operation { @@ -1489,11 +1489,11 @@ fn parse_def_match(data: &[u8], } }, _ => { - let i = first_operand.val.get_as_buffer()?; - let j = second_operand.val.get_as_buffer()?; + let i = first_operand.val.get_as_buffer(ctx.acpi_context())?; + let j = second_operand.val.get_as_buffer(ctx.acpi_context())?; while idx < pkg.len() { - let val = if let Ok(v) = pkg[idx].get_as_buffer() { v } else { idx += 1; continue; }; + let val = if let Ok(v) = pkg[idx].get_as_buffer(ctx.acpi_context()) { v } else { idx += 1; continue; }; idx += 1; match first_operation { @@ -1543,7 +1543,7 @@ fn parse_def_from_bcd(data: &[u8], let operand = parse_term_arg(&data[2..], ctx)?; let target = parse_target(&data[2 + operand.len..], ctx)?; - let mut i = operand.val.get_as_integer()?; + let mut i = operand.val.get_as_integer(ctx.acpi_context())?; let mut result = 0; while i != 0 { @@ -1558,7 +1558,7 @@ fn parse_def_from_bcd(data: &[u8], let result = AmlValue::Integer(result); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1583,8 +1583,8 @@ fn parse_def_mid(data: &[u8], let length = parse_term_arg(&data[1 + source.len + index.len..], ctx)?; let target = parse_target(&data[1 + source.len + index.len + length.len..], ctx)?; - let idx = index.val.get_as_integer()? as usize; - let mut len = length.val.get_as_integer()? as usize; + let idx = index.val.get_as_integer(ctx.acpi_context())? as usize; + let mut len = length.val.get_as_integer(ctx.acpi_context())? as usize; let result = match source.val { AmlValue::String(s) => { @@ -1606,7 +1606,7 @@ fn parse_def_mid(data: &[u8], // implicitly. // Additionally, any type that can be converted to a buffer can also be converted to a // string, so no information is lost - let b = source.val.get_as_buffer()?; + let b = source.val.get_as_buffer(ctx.acpi_context())?; if idx > b.len() { AmlValue::Buffer(vec!()) @@ -1620,7 +1620,7 @@ fn parse_def_mid(data: &[u8], } }; - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1644,13 +1644,13 @@ fn parse_def_mod(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - if rhs.val.get_as_integer()? == 0 { + if rhs.val.get_as_integer(ctx.acpi_context())? == 0 { return Err(AmlError::AmlValueError); } - let result = AmlValue::Integer(lhs.val.get_as_integer()? % rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? % rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1675,9 +1675,9 @@ fn parse_def_multiply(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(lhs.val.get_as_integer()? * rhs.val.get_as_integer()?); + let result = AmlValue::Integer(lhs.val.get_as_integer(ctx.acpi_context())? * rhs.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1701,9 +1701,9 @@ fn parse_def_nand(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(!(lhs.val.get_as_integer()? & rhs.val.get_as_integer()?)); + let result = AmlValue::Integer(!(lhs.val.get_as_integer(ctx.acpi_context())? & rhs.val.get_as_integer(ctx.acpi_context())?)); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1727,9 +1727,9 @@ fn parse_def_nor(data: &[u8], let rhs = parse_term_arg(&data[1 + lhs.len..], ctx)?; let target = parse_target(&data[1 + lhs.len + rhs.len..], ctx)?; - let result = AmlValue::Integer(!(lhs.val.get_as_integer()? | rhs.val.get_as_integer()?)); + let result = AmlValue::Integer(!(lhs.val.get_as_integer(ctx.acpi_context())? | rhs.val.get_as_integer(ctx.acpi_context())?)); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result, @@ -1752,9 +1752,9 @@ fn parse_def_not(data: &[u8], let operand = parse_term_arg(&data[1..], ctx)?; let target = parse_target(&data[1 + operand.len..], ctx)?; - let result = AmlValue::Integer(!operand.val.get_as_integer()?); + let result = AmlValue::Integer(!operand.val.get_as_integer(ctx.acpi_context())?); - let _ = ctx.modify(target.val, result.clone()); + let _ = ctx.modify(ctx.acpi_context(), target.val, result.clone()); Ok(AmlParseType { val: result,