Eric Lee / smarc-fsl-linux-kernel

24 Sep, 2016

1 commit

  • 7a0b71dc8   ACPICA: Parser: Fix a regression in LoadTable support ... Browse Code »

    ACPICA commit a78506e0ce8ab1d20db2a055d99cf9143e89eb29

    LoadTable allows an alternative RootPathString than the default "\", while
    the new table execution support fails to keep this logic.

    This regression can be detected by ASLTS - TLT0.tst4, this patch fixes this
    regression.

    Linux upstream is not affected by this regression as we haven't enabled the
    new table execution support there. BZ 1326, Lv Zheng.

    Link: https://github.com/acpica/acpica/commit/a78506e0
    Link: https://bugs.acpica.org/show_bug.cgi?id=1326
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     

10 Sep, 2016

2 commits

  • 74f51b80a   ACPICA: Namespace: Fix dynamic table loading issues ... Browse Code »

    ACPICA commit 767ee53354e0c4b7e8e7c57c6dd7bf569f0d52bb

    There are issues related to the namespace/interpreter locks, which causes
    several ACPI functionalities not specification compliant. The lock issues
    were detectec when we were trying to fix the functionalities (please see
    Link # [1] for the details).

    What's the lock issues? Let's first look into the namespace/interpreter
    lock usages inside of the object evaluation and the table loading which are
    the key AML interpretion code paths:
    Table loading:
    acpi_ns_load_table
    L(Namespace)
    acpi_ns_parse_table
    acpi_ns_one_complete_parse(LOAD_PASS1/LOAD_PASS2)
    acpi_ds_load1_begion_op
    acpi_ds_load1_end_op
    acpi_ds_load2_begion_op
    acpi_ds_load2_end_op
    U(Namespace)
    Object evaluation:
    acpi_ns_evaluate
    L(Interpreter)
    acpi_ps_execute_method
    acpi_ds_exec_begin_op
    acpi_ds_exec_end_op
    U(Interpreter)
    acpi_ns_load_table
    L(Namespace)
    U(Namespace)
    acpi_ev_initialize_region
    L(Namespace)
    U(Namespace)
    address_space.Setup
    address_space.Handler
    acpi_os_wait_semaphore
    acpi_os_acquire_mutex
    acpi_os_sleep
    L(Interpreter)
    U(Interpreter)
    L(Interpreter)
    acpi_ex_resolve_node_to_value
    U(Interpreter)
    acpi_ns_check_return_value
    Where:
    1. L(Interpreter) means acquire(MTX_INTERPRETER);
    2. U(Interpreter) means release(MTX_INTERPRETER);
    3. L(Namespace) means acquire(MTX_NAMESPACE);
    4. U(Namespace) means release(MTX_NAMESPACE);

    We can see that acpi_ns_exec_module_code() (which invokes acpi_ns_evaluate) is
    implemented in a deferred way just in order to avoid to reacquire the
    namespace lock. This is in fact the root cause of many other ACPICA issues:
    1. We now know for sure that the module code should be executed right in
    place by the Windows AML interpreter. So in the current design, if
    the region initializations/accesses or the table loadings (where the
    namespace surely should be locked again) happening during the table
    loading period, dead lock could happen because ACPICA never unlocks the
    namespace during the AML interpretion.
    2. ACPICA interpreter just ensures that all static namespace nodes (named
    objects created during the acpi_load_tables()) are created
    (acpi_ns_lookup()) with the correct lock held, but doesn't ensure that
    the named objects created by the control method are created with the
    same correct lock held. It requires the control methods to be executed
    in a serial way after "loading a table", that's why ACPICA requires
    method auto serialization.

    This patch fixes these software design issues by extending interpreter
    enter/exit APIs to hold both interpreter/namespace locks to ensure the lock
    order correctness, so that we can get these code paths:
    Table loading:
    acpi_ns_load_table
    E(Interpreter)
    acpi_ns_parse_table
    acpi_ns_one_complete_parse
    acpi_ns_execute_table
    X(Interpreter)
    acpi_ns_load_table
    acpi_ev_initialize_region
    address_space.Setup
    address_space.Handler
    acpi_os_wait_semaphore
    acpi_os_acquire_mutex
    acpi_os_sleep
    E(Interpreter)
    X(Interpreter)
    Object evaluation:
    acpi_ns_evaluate
    E(Interpreter)
    acpi_ps_execute_method
    X(Interpreter)
    acpi_ns_load_table
    acpi_ev_initialize_region
    address_space.Setup
    address_space.Handler
    acpi_os_wait_semaphore
    acpi_os_acquire_mutex
    acpi_os_sleep
    E(Interpreter)
    X(Interpreter)
    Where:
    1. E(Interpreter) means acquire(MTX_INTERPRETER, MTX_NAMESPACE);
    2. X(Interpreter) means release(MTX_NAMESPACE, MTX_INTERPRETER);

    After this change, we can see:
    1. All namespace nodes creations are locked by the namespace lock.
    2. All namespace nodes referencing are locked with the same lock.
    3. But we also can notice a defact that, all namespace nodes deletions
    could be affected by this change. As a consequence,
    acpi_ns_delete_namespace_subtree() may delete a static namespace node that
    is still referenced by the interpreter (for example, the parser scopes).
    Currently, we needn't worry about the last defact because in ACPICA, table
    unloading is not fully functioning, its design strictly relies on the fact
    that when the namespace deletion happens, either the AML table or the OSPMs
    should have been notified and thus either the AML table or the OSPMs
    shouldn't reference deletion-related namespace nodes during the namespace
    deletion. And this change still works with the above restrictions applied.
    While making this a-step-forward helps us to correct the wrong grammar to
    pull many things back to the correct rail. And pulling things back to the
    correct rail in return makes it possible for us to support fully
    functioning table unloading after doing many cleanups.

    While this patch is generated, all namespace locks are examined to ensure
    that they can meet either of the following pattens:
    1. L(Namespace)
    U(Namespace)
    2. E(Interpreter)
    X(Interpreter)
    3. E(Interpreter)
    X(Interpreter)
    L(Namespace)
    U(Namespace)
    E(Interpreter)
    X(Interpreter)
    We ensure this by adding X(Interpreter)/E(Interpreter) or removing
    U(Namespace)/L(Namespace) for those currently are executed in the following
    order:
    E(Interpreter)
    L(Namespace)
    U(Namespace)
    X(Interpreter)
    And adding E(Interpreter)/X(Interpreter) for those currently are executed
    in the following order:
    X(Interpreter)
    E(Interpreter)

    Originally, the interpreter lock is held for the execution AML opcodes, the
    namespace lock is held for the named object creation AML opcodes. Since
    they are actually same in MS interpreter (can all be executed during the
    table loading), we can combine the 2 locks and tune the locking code better
    in this way. Lv Zheng.

    Link: https://bugzilla.kernel.org/show_bug.cgi?id=153541 # [1]
    Link: https://bugzilla.kernel.org/show_bug.cgi?id=121701 # [1]
    Link: https://bugs.acpica.org/show_bug.cgi?id=1323
    Link: https://github.com/acpica/acpica/commit/767ee533
    Reported-and-tested-by: Mika Westerberg
    Reported-and-tested-by: Greg White
    Reported-and-tested-by: Dutch Guy
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     
  • de56ba95e   ACPICA: Interpreter: Fix MLC issues by switching to new term_list grammar for table loading ... Browse Code »

    ACPICA commit 0e24fb67cde08d7df7671d7d7b183490dc79707e

    The MLC (Module Level Code) is an ACPICA terminology describing the AML
    code out of any control method, its support is an indication of the
    interpreter behavior during the table loading.

    The original implementation of MLC in ACPICA had several issues:
    1. Out of any control method, besides of the object creating opcodes, only
    the code blocks wrapped by "If/Else/While" opcodes were supported.
    2. The supported MLC code blocks were executed after loading the table
    rather than being executed right in place.
    ============================================================
    The demo of this order issue is as follows:
    Name (OBJ1, 1)
    If (CND1 == 1)
    {
    Name (OBJ2, 2)
    }
    Name (OBJ3, 3)
    The original MLC support created OBJ2 after OBJ3's creation.
    ============================================================
    Other than these limitations, MLC support in ACPICA looks correct. And
    supporting this should be easy/natural for ACPICA, but enabling of this was
    blocked by some ACPICA internal and OSPM specific initialization order
    issues we've fixed recently. The wrong support started from the following
    false bug fixing commit:
    Commit: 7f0c826a437157d2b19662977e9cf3b472cf24a6
    Subject: ACPICA: Add support for module-level executable AML code
    Commit: 9a884ab64a4d092b4c3bf24fd9a30f7fbd4591e7
    Subject: ACPICA: Add additional module-level code support
    ...

    We can confirm Windows interpreter behavior via reverse engineering means.
    It can be proven that not only If/Else/While wrapped code blocks, all
    opcodes can be executed at the module level, including operation region
    accesses. And it can be proven that the MLC should be executed right in
    place, not in such a deferred way executed after loading the table.

    And the above facts indeed reflect the spec words around ACPI definition
    block tables (DSDT/SSDT/...), the entire table and the Scope object is
    defined by the AML specification in BNF style as:
    AMLCode := def_block_header term_list
    def_scope := scope_op pkg_length name_string term_list
    The bodies of the scope opening terms (AMLCode/Scope) are all term_list,
    thus the table loading should be no difference than the control method
    evaluations as the body of the Method is also defined by the AML
    specification as term_list:
    def_method := method_op pkg_length name_string method_flags term_list
    The only difference is: after evaluating control method, created named
    objects may be freed due to no reference, while named objects created by
    the table loading should only be freed after unloading the table.

    So this patch follows the spec and the de-facto standard behavior, enables
    the new grammar (term_list) for the table loading.

    By doing so, beyond the fixes to the above issues, we can see additional
    differences comparing to the old grammar based table loading:
    1. Originally, beyond the scope opening terms (AMLCode/Scope),
    If/Else/While wrapped code blocks under the scope creating terms
    (Device/power_resource/Processor/thermal_zone) are also supported as
    deferred MLC, which violates the spec defined grammar where object_list
    is enforced. With MLC support improved as non-deferred, the interpreter
    parses such scope creating terms as term_list rather object_list like the
    scope opening terms.
    After probing the Windows behavior and proving that it also parses these
    terms as term_list, we submitted an ECR (Engineering Change Request) to
    the ASWG (ACPI Specification Working Group) to clarify this. The ECR is
    titled as "ASL Grammar Clarification for Executable AML Opcodes" and has
    been accepted by the ASWG. The new grammar will appear in ACPI
    specification 6.2.
    2. Originally, Buffer/Package/operation_region/create_XXXField/bank_field
    arguments are evaluated in a deferred way after loading the table. With
    MLC support improved, they are also parsed right in place during the
    table loading.
    This is also Windows compliant and the only difference is the removal
    of the debugging messages implemented before acpi_ds_execute_arguments(),
    see Link # [1] for the details. A previous commit should have ensured
    that acpi_check_address_range() won't regress.

    Note that enabling this feature may cause regressions due to long term
    Linux ACPI support on top of the wrong grammar. So this patch also prepares
    a global option to be used to roll back to the old grammar during the
    period between a regression is reported and the regression is
    root-cause-fixed. Lv Zheng.

    Link: https://bugzilla.kernel.org/show_bug.cgi?id=112911 # [1]
    Link: https://bugzilla.kernel.org/show_bug.cgi?id=117671 # [1]
    Link: https://bugzilla.kernel.org/show_bug.cgi?id=153541 # [1]
    Link: https://github.com/acpica/acpica/issues/122
    Link: https://bugs.acpica.org/show_bug.cgi?id=963
    Link: https://github.com/acpica/acpica/commit/0e24fb67
    Reported-and-tested-by: Chris Bainbridge
    Reported-by: Ehsan
    Reported-and-tested-by: Dutch Guy
    Tested-by: Mika Westerberg
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     

05 May, 2016

1 commit

  • f5c1e1c5a   ACPICA: Divergence: remove unwanted spaces for typedef ... Browse Code »

    ACPICA commit b2294cae776f5a66a7697414b21949d307e6856f

    This patch removes unwanted spaces for typedef. This solution doesn't cover
    function types.

    Note that the linuxize result of this commit is very giant and should have
    many conflicts against the current Linux upstream. Thus it is required to
    modify the linuxize result of this commit and the commits around it
    manually in order to have them merged to the Linux upstream. Since this is
    very costy, we should do this only once, and if we can't ensure to do this
    only once, we need to revert the Linux code to the wrong indentation result
    before merging the linuxize result of this commit. Lv Zheng.

    Link: https://github.com/acpica/acpica/commit/b2294cae
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     

16 Jan, 2016

1 commit

24 Jul, 2015

2 commits

  • ab6c57332   ACPICA: Executer: Add interpreter tracing mode for method tracing facility ... Browse Code »

    ACPICA commit 07fffd02607685b655ed92ee15c160e6a810b60b

    The acpi_debug_trace() is the mechanism known as ACPI method tracing that is
    used by Linux as ACPICA debugging message reducer. This facility can be
    controlled through Linux ACPI subsystem - /sys/module/acpi/parameters.
    This facility requires CONFIG_ACPI_DEBUG to be enabled to see ACPICA trace
    logs in the kernel dmesg output.

    This patch enhances acpi_debug_trace() to make it not only a message reducer,
    but a real tracer to trace AML interpreter execution. Note that in addition
    to the AML tracer enabling, this patch also updates the facility with the
    following enhancements:
    1. Allow a full path to be specified by the acpi_debug_trace() API.
    2. Allow any method rather than just the entrance of acpi_evaluate_object()
    to be traced.
    3. All interpreter ACPI_LV_TRACE_POINT messages are collected for
    ACPI_EXECUTER layer.

    The Makefile of drivers/acpi/acpica is also updated to include exdebug.o
    and the duplicated stubs are removed after that.

    Note that since this patch has enhanced the method tracing facility, Linux
    need also be updated after applying this patch. Lv Zheng.

    Link: https://github.com/acpica/acpica/commit/07fffd02
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     
  • 62eb935b7   ACPICA: Dispatcher: Cleanup union acpi_operand_object's AML address assignments ... Browse Code »

    ACPICA commit afb52611dbe7403551f93504d3798534f5c343f4

    This patch cleans up the code of assigning the AML address to the
    union acpi_operand_object.

    The idea behind this cleanup is:
    The AML address of the union acpi_operand_object should always be determined at
    the point where the object is encountered. It should be started from the
    first byte of the object. For example, the opcode of the object, the name
    string of the user_term object, or the first byte of the packaged object
    (where a pkg_length is prefixed). So it's not cleaner to have it assigned
    here and there in the entire ACPICA source tree.

    There are some special cases for the internal opcodes, before cleaning up
    the internal opcodes, we should also determine the rules for the AML
    addresses of the internal opcodes:
    1. INT_NAMEPATH_OP: the address of the first byte for the name_string.
    2. INT_METHODCALL_OP: the address of the first byte for the name_string.
    3. INT_BYTELIST_OP: the address of the first byte for the byte_data list.
    4. INT_EVAL_SUBTREE_OP: the address of the first byte for the
    Region/Package/Buffer/bank_field/Field arguments.
    5. INT_NAMEDFIELD_OP: the address to the name_seg.
    6. INT_RESERVEDFIELD_OP: the address to the 0x00 prefix.
    7. INT_ACCESSFIELD_OP: the address to the 0x01 prefix.
    8. INT_CONNECTION_OP: the address to the 0x02 prefix.
    9: INT_EXTACCESSFIELD_OP: the address to the 0x03 prefix.
    10.INT_RETURN_VALUE_OP: the address of the replaced operand.
    11.computational_data: the address to the
    Byte/Word/Dword/Qword/string_prefix.

    Before cleaning up the internal root scope of the aml_walk, turning it into
    the term_list, we need to remember the aml_start address as the "Aml"
    attribute for the union acpi_operand_object created by acpi_ps_create_scope_op().

    Finally, we can delete some redundant AML address assignment in psloop.c.

    Link: https://github.com/acpica/acpica/commit/afb52611
    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     

05 Feb, 2015

1 commit

11 Feb, 2014

1 commit

31 Oct, 2013

1 commit

  • 10622bf8c   ACPICA: Linuxize: Change indentation of C labels. ... Browse Code »

    It is reported by kernel build test systems that all ACPICA source
    files in the kernel tree have incorrect label indentation. This
    patch changes default indent option used in the release process to
    fix this bug. Lv Zheng.

    Signed-off-by: Lv Zheng
    Signed-off-by: Bob Moore
    Signed-off-by: Rafael J. Wysocki

    Lv Zheng
     

02 Jun, 2013

1 commit

25 Jan, 2013

1 commit

17 Jul, 2012

1 commit

17 Jan, 2012

1 commit

19 Jan, 2011

2 commits

  • b4e104eae   ACPICA: Update all ACPICA copyrights and signons to 2011 ... Browse Code »

    Signed-off-by: Bob Moore
    Signed-off-by: Lin Ming
    Signed-off-by: Len Brown

    Bob Moore
     
  • 262948428   ACPICA: Fix issues/fault with automatic "serialized" method support ... Browse Code »

    History: This support changes a method to "serialized" on the fly if the
    method generates an AE_ALREADY_EXISTS error, indicating the possibility
    that it cannot handle reentrancy.

    This fix repairs a couple of issues seen in the field, especially on
    machines with many cores.

    1) Delete method children only upon the exit of the last thread, so
    as to not delete objects out from under running threads.

    2) Set the "serialized" bit for the method only upon the exit of the
    last thread, so as to not cause deadlock when running threads attempt
    to exit.

    3) Cleanup the use of the AML "MethodFlags" and internal method flags
    so that there is no longer any confustion between the two.

    Reported-by: Dana Myers
    Signed-off-by: Lin Ming
    Signed-off-by: Bob Moore
    Signed-off-by: Len Brown

    Lin Ming
     

20 Apr, 2010

2 commits

  • 69ec87efa   ACPICA: Add subsystem option to force copy of DSDT to local memory ... Browse Code »

    Optionally copy the entire DSDT to local memory (instead of
    simply mapping it.) There are some BIOSs that corrupt or replace
    the original DSDT, creating the need for this option. Default is
    FALSE, do not copy the DSDT.

    https://bugzilla.kernel.org/show_bug.cgi?id=14679

    Signed-off-by: Lin Ming
    Signed-off-by: Bob Moore
    Signed-off-by: Len Brown

    Lin Ming
     
  • 729df0f84   ACPICA: Add detection of corrupted/replaced DSDT ... Browse Code »

    This change adds support to detect a DSDT that has been corrupted
    and/or replaced from outside the OS (by firmware). This is
    typically catastrophic for the system, but has been seen on
    some machines.

    https://bugzilla.kernel.org/show_bug.cgi?id=14679

    Signed-off-by: Lin Ming
    Signed-off-by: Bob Moore
    Signed-off-by: Len Brown

    Lin Ming
     

23 Jan, 2010

1 commit

16 Dec, 2009

1 commit

25 Nov, 2009

1 commit

29 Aug, 2009

1 commit

  • 7f0c826a4   ACPICA: Add support for module-level executable AML code ... Browse Code »

    Add limited support for executable AML code that exists outside
    of any control method. This type of code has been illegal since
    ACPI 2.0. The code must exist in an If/Else/While block. All AML
    tables are supported, including tables that are dynamically loaded.
    ACPICA BZ 762.

    http://acpica.org/bugzilla/show_bug.cgi?id=762

    Signed-off-by: Lin Ming
    Signed-off-by: Bob Moore
    Signed-off-by: Len Brown

    Lin Ming
     

09 Jan, 2009

2 commits