xen/arm64: io: Decode ldr/str post-indexing instruction
v7 cover xen/arm64: io: Decode ldr/str post-indexing instruction
Hi All,
The patch series introduces support to decode instructions by Xen when ISS is invalid. Currently, when the guest executes post indexing ldr/str instructions on emulated MMIO, these instruction was trapped into Xen as a data abort. Xen reads hsr_dabt.isv = 0, so ISS is invalid. Therefore, it reads the faulting instruction's opcode from guest's PC. It decodes and executes the instruction on the emulated region.
Ayan Kumar Halder (2):
xen/arm64: Decode ldr/str post increment operations xen/arm64: io: Support instructions (for which ISS is not valid) on
emulated MMIO region using MMIO/ioreq handler
xen/arch/arm/arm32/traps.c | 7 ++ xen/arch/arm/arm64/traps.c | 47 +++++++++++++ xen/arch/arm/decode.c | 81 +++++++++++++++++++++- xen/arch/arm/decode.h | 48 +++++++++++-- xen/arch/arm/include/asm/domain.h | 4 ++ xen/arch/arm/include/asm/ioreq.h | 1 + xen/arch/arm/include/asm/mmio.h | 20 +++++- xen/arch/arm/include/asm/traps.h | 2 + xen/arch/arm/io.c | 108 ++++++++++++++++++++---------- xen/arch/arm/ioreq.c | 12 ++-- xen/arch/arm/traps.c | 85 ++++++++++++++++++++--- xen/arch/x86/include/asm/ioreq.h | 3 + xen/include/xen/sched.h | 2 + 13 files changed, 362 insertions(+), 58 deletions(-)
Changelog :-
v2 - 1. Updated the rn register after reading from it. (Pointed by Julien,
Stefano)
2. Used a union to represent the instruction opcode (Suggestd by Bertrand)
3. Fixed coding style issues (Pointed by Julien)
4. In the previous patch, I was updating dabt->sign based on the signedness of imm9. This was incorrect. As mentioned in ARMv8 ARM DDI 0487G.b, Page 3221, SSE indicates the signedness of the data item loaded. In our case, the data item loaded is always unsigned.
v3- 1. Handled all the variants of ldr/str (ie 64, 32, 16, 8 bit variants).
Thus, I have removed the check for "instr->code.opc == 0" (Suggested by Andre)
2. Handled the scenario when rn = SP, rt = XZR (Suggested by Jan, Andre)
3. Added restriction for "rt != rn" (Suggested by Andre)
4. Moved union ldr_str_instr_class {} to decode.h. This is the header included by io.c and decode.c (where the union is referred). (Suggested by Jan)
5. Indentation and typo fixes (Suggested by Jan)
v4- 1. Fixed the patch as per Stefano's comments on v3. They are as follows :-
1.1 Use macros to determine the fixed values in the instruction opcode 1.2 Checked if instr != NULL
1.3 Changed some data types and added #define ARM_64 for AArch64 specific
code
1.4 Moved post_increment_register() to decode.c so that the decoding
logic is confined to a single file.
1.5 Moved some checks from post_increment_register() to
decode_loadstore_postindexing()
1.6 Removed a duplicate check
2. Updated the commit message as per Andre's comments.
3. Changed the names of a label and some comments. *32bit* was erroneously mentioned in a label and comments in decode_loadstore_postindexing() although the function handled all variants of ldr/str post indexing.
v5- 1. Renamed decode_loadstore_postindexing() to decode_arm64(). The reason
being this will be extended in future to support more instructions for which hsr_badt.isv = 0
2. Introduce a function try_decode_instruction_invalid_iss() to determine if the instruction needs to be decoded before invoking decode_instruction().
It checks :-
2.1 dabt->s1ptw - Returns IO_UNHANDLED
2.2 dabt->cache - Returns IO_IGNORED. (new enum instroduced to let the
caller know that the instruction needs to be ignored by Xen. Thus the caller needs to increment the PC and return to the guest.
3. Invoked try_decode_instruction_invalid_iss() from the following 2 places :- 3.a - try_handle_mmio() - When we have determined that there is a valid mmio handler.
3.b - try_fwd_ioserv()
When ioserver completes the io request, the acknowledgement is sent via handle_ioserv(). Here, we need to increment the register. As there is no common data shared between try_fwd_ioserv() and handle_ioserv(), we need to decode the instruction again in handle_ioserv() to determine rn, imm9.
(NOTE to Reviewers) - This does not feel correct. However, I could not think of a better approach. Please provide your inputs.
4. Augumented struct hsr_dabt{} with struct hsr_dabt_instr_details{} to hold rn and imm9. This is passed to post_increment_register() to update rn.
5. Other style changes as suggested in v4.
v6 - 1. Split the patch into three parts.
v7 - 1. Merged patch2 and patch3 into a single patch.
Signature · 1 line
2.17.1
PATCH v7 1/2 xen/arm64: Decode ldr/str post increment operations
At the moment, Xen does not decode any of the arm64 instructions. This means that hsr_dabt.isv = 0, Xen cannot handle those instructions. This will lead to Xen abort the guests (from which those instructions originated).
With this patch, Xen is able to decode ldr/str post indexing instructions. These are a subset of instructions for which hsr_dabt.isv = 0
The following instructions are now supported by Xen :-
1. ldr x2, [x1], #8 2. ldr w2, [x1], #-4 3. ldr x2, [x1], #-8 4. ldr w2, [x1], #4 5. ldrh w2, [x1], #2 6. ldrb w2, [x1], #1 7. str x2, [x1], #8 8. str w2, [x1], #-4 9. strh w2, [x1], #2 10. strb w2, [x1], #1
In the subsequent patches, decode_arm64() will get invoked when hsr_dabt.isv=0.
---
Changelog :-
v2..v5 - Mentioned in the cover letter.
v6 - 1. Fixed the code style issues as mentioned in v5.
v7 - No change.
xen/arch/arm/decode.c | 80 ++++++++++++++++++++++++++++++++- xen/arch/arm/decode.h | 49 +++++++++++++++++--- xen/arch/arm/include/asm/mmio.h | 4 ++ xen/arch/arm/io.c | 2 +- 4 files changed, 125 insertions(+), 10 deletions(-)
xen/arch/arm/decode.c +78 -2
@@ -23,6 +23,7 @@#include <xen/types.h> #include <asm/current.h> +#include <asm/mmio.h> #include "decode.h"
@@ -84,6 +85,78 @@ bad_thumb2:return 1 ; } +static int decode_arm64 (register_t pc,mmio_info_t *info) +{ +union instr opcode = {0 }; +struct hsr_dabt *dabt = &info->dabt; +struct instr_details *dabt_instr = &info->dabt_instr; + +if (raw_copy_from_guest (&opcode.value, (void *__user )pc,sizeof (opcode)) ) + { +gprintk (XENLOG_ERR ,"Could not copy the instruction from PC\n" ); + goto bad_loadstore; + } + +/* +* Refer Arm v8 ARM DDI 0487G.b, Page - C6-1107 +* "Shared decode for all encodings" (under ldr immediate) +* If n == t && n != 31, then the return value is implementation defined +* (can be WBSUPPRESS, UNKNOWN, UNDEFINED or NOP). Thus, we do not support +* this. This holds true for ldrb/ldrh immediate as well. +* +* Also refer, Page - C6-1384, the above described behaviour is same for +* str immediate. This holds true for strb/strh immediate as well +*/ +if ( (opcode.ldr_str.rn == opcode.ldr_str.rt) && (opcode.ldr_str.rn !=31 ) ) + { +gprintk (XENLOG_ERR ,"Rn should not be equal to Rt except for r31\n" ); + goto bad_loadstore; + } + +/* First, let's check for the fixed values */ +if ( (opcode.value &POST_INDEX_FIXED_MASK ) !=POST_INDEX_FIXED_VALUE ) + { +gprintk (XENLOG_ERR , +"Decoding instruction 0x%x is not supported" , opcode.value); + goto bad_loadstore; + } + +if ( opcode.ldr_str.v !=0 ) + { +gprintk (XENLOG_ERR , +"ldr/str post indexing for vector types are not supported\n" ); + goto bad_loadstore; + } + +/* Check for STR (immediate) */ +if ( opcode.ldr_str.opc ==0 ) + dabt->write =1 ; +/* Check for LDR (immediate) */ +else if ( opcode.ldr_str.opc ==1 ) + dabt->write =0 ; +else + { +gprintk (XENLOG_ERR , +"Decoding ldr/str post indexing is not supported for this variant\n" ); + goto bad_loadstore; + } + +gprintk (XENLOG_INFO , +"opcode->ldr_str.rt = 0x%x, opcode->ldr_str.size = 0x%x, opcode->ldr_str.imm9 = %d\n" , + opcode.ldr_str.rt, opcode.ldr_str.size, opcode.ldr_str.imm9); + +update_dabt (dabt, opcode.ldr_str.rt, opcode.ldr_str.size, false); + + dabt_instr->rn = opcode.ldr_str.rn; + dabt_instr->imm9 = opcode.ldr_str.imm9; + +return 0 ; + + bad_loadstore: +gprintk (XENLOG_ERR ,"unhandled Arm instruction 0x%x\n" , opcode.value); +return 1 ; +} +static int decode_thumb (register_t pc,struct hsr_dabt *dabt) {uint16_t instr;
@@ -150,10 +223,13 @@ bad_thumb:return 1 ; } -int decode_instruction (const struct cpu_user_regs *regs,struct hsr_dabt *dabt) +int decode_instruction (const struct cpu_user_regs *regs,mmio_info_t *info) {if (is_32bit_domain (current->domain) && regs->cpsr &PSR_THUMB ) -return decode_thumb (regs->pc, dabt); +return decode_thumb (regs->pc, &info->dabt); + +if ( !psr_mode_is_32bit (regs) ) +return decode_arm64 (regs->pc, info);/* TODO: Handle ARM instruction */ gprintk (XENLOG_ERR ,"unhandled ARM instruction\n" );
xen/arch/arm/decode.h +42 -7
61 lines not on this page · raw message
xen/arch/arm/include/asm/mmio.h +4 -0
@@ -29,6 +29,10 @@typedef struct {struct hsr_dabt dabt; +struct instr_details { +unsigned long rn:5 ; +signed int imm9:9 ; + } dabt_instr;paddr_t gpa; }mmio_info_t ;
xen/arch/arm/io.c +1 -1
@@ -134,7 +134,7 @@ enum io_state try_handle_mmio(struct cpu_user_regs *regs, {int rc; - rc =decode_instruction (regs, &info.dabt); + rc =decode_instruction (regs, &info);if ( rc ) {gprintk (XENLOG_DEBUG ,"Unable to decode instruction\n" );
Signature · 1 line
2.17.1
Re: [XEN v7 1/2] xen/arm64: Decode ldr/str post increment operations
Quoted 20 lines · Ayan Kumar Halder
At the moment, Xen does not decode any of the arm64 instructions. This means that hsr_dabt.isv = 0, Xen cannot handle those instructions. This will lead to Xen abort the guests (from which those instructions originated).
With this patch, Xen is able to decode ldr/str post indexing instructions. These are a subset of instructions for which hsr_dabt.isv = 0
The following instructions are now supported by Xen :-
1. ldr x2, [x1], #8 2. ldr w2, [x1], #-4 3. ldr x2, [x1], #-8 4. ldr w2, [x1], #4 5. ldrh w2, [x1], #2 6. ldrb w2, [x1], #1 7. str x2, [x1], #8 8. str w2, [x1], #-4 9. strh w2, [x1], #2 10. strb w2, [x1], #1
Quoted 4 lines
In the subsequent patches,
decode_arm64()will get invoked when hsr_dabt.isv=0.Signed-off-by Ayan Kumar Halder <[email protected]>
This patch looks good to me. Only minor comments below.
Quoted 21 lines
---
Changelog :-
v2..v5 - Mentioned in the cover letter.
v6 - 1. Fixed the code style issues as mentioned in v5.
v7 - No change.
xen/arch/arm/decode.c | 80 ++++++++++++++++++++++++++++++++- xen/arch/arm/decode.h | 49 +++++++++++++++++--- xen/arch/arm/include/asm/mmio.h | 4 ++ xen/arch/arm/io.c | 2 +- 4 files changed, 125 insertions(+), 10 deletions(-)xen/arch/arm/decode.c +0
-0
xen/arch/arm/decode.c line 26
Quoted 4 lines
xen/arch/arm/decode.c +1
-0@@ -23,6 +23,7 @@#include <xen/types.h> #include <asm/current.h> +#include <asm/mmio.h>
it doesn't look like this is needed
Quoted 6 lines
xen/arch/arm/decode.c +0
-0#include "decode.h" @@ -84,6 +85,78 @@ bad_thumb2:return 1 ; }
xen/arch/arm/decode.c bad_thumb2: · line 97
Quoted 10 lines
xen/arch/arm/decode.c +10
-0+static int decode_arm64 (register_t pc,mmio_info_t *info) +{ +union instr opcode = {0 }; +struct hsr_dabt *dabt = &info->dabt; +struct instr_details *dabt_instr = &info->dabt_instr; + +if (raw_copy_from_guest (&opcode.value, (void *__user )pc,sizeof (opcode)) ) + { +gprintk (XENLOG_ERR ,"Could not copy the instruction from PC\n" ); + goto bad_loadstore;
this should just return 1 (no need to print the other error message after the label bad_loadstore).
Quoted 113 lines
xen/arch/arm/decode.c +67
-2+ } + +/* +* Refer Arm v8 ARM DDI 0487G.b, Page - C6-1107 +* "Shared decode for all encodings" (under ldr immediate) +* If n == t && n != 31, then the return value is implementation defined +* (can be WBSUPPRESS, UNKNOWN, UNDEFINED or NOP). Thus, we do not support +* this. This holds true for ldrb/ldrh immediate as well. +* +* Also refer, Page - C6-1384, the above described behaviour is same for +* str immediate. This holds true for strb/strh immediate as well +*/ +if ( (opcode.ldr_str.rn == opcode.ldr_str.rt) && (opcode.ldr_str.rn !=31 ) ) + { +gprintk (XENLOG_ERR ,"Rn should not be equal to Rt except for r31\n" ); + goto bad_loadstore; + } + +/* First, let's check for the fixed values */ +if ( (opcode.value &POST_INDEX_FIXED_MASK ) !=POST_INDEX_FIXED_VALUE ) + { +gprintk (XENLOG_ERR , +"Decoding instruction 0x%x is not supported" , opcode.value); + goto bad_loadstore; + } + +if ( opcode.ldr_str.v !=0 ) + { +gprintk (XENLOG_ERR , +"ldr/str post indexing for vector types are not supported\n" ); + goto bad_loadstore; + } + +/* Check for STR (immediate) */ +if ( opcode.ldr_str.opc ==0 ) + dabt->write =1 ; +/* Check for LDR (immediate) */ +else if ( opcode.ldr_str.opc ==1 ) + dabt->write =0 ; +else + { +gprintk (XENLOG_ERR , +"Decoding ldr/str post indexing is not supported for this variant\n" ); + goto bad_loadstore; + } + +gprintk (XENLOG_INFO , +"opcode->ldr_str.rt = 0x%x, opcode->ldr_str.size = 0x%x, opcode->ldr_str.imm9 = %d\n" , + opcode.ldr_str.rt, opcode.ldr_str.size, opcode.ldr_str.imm9); + +update_dabt (dabt, opcode.ldr_str.rt, opcode.ldr_str.size, false); + + dabt_instr->rn = opcode.ldr_str.rn; + dabt_instr->imm9 = opcode.ldr_str.imm9; + +return 0 ; + + bad_loadstore: +gprintk (XENLOG_ERR ,"unhandled Arm instruction 0x%x\n" , opcode.value); +return 1 ; +} +static int decode_thumb (register_t pc,struct hsr_dabt *dabt) {uint16_t instr;@@ -150,10 +223,13 @@ bad_thumb:return 1 ; } -int decode_instruction (const struct cpu_user_regs *regs,struct hsr_dabt *dabt) +int decode_instruction (const struct cpu_user_regs *regs,mmio_info_t *info) {if (is_32bit_domain (current->domain) && regs->cpsr &PSR_THUMB ) -return decode_thumb (regs->pc, dabt); +return decode_thumb (regs->pc, &info->dabt); + +if ( !psr_mode_is_32bit (regs) ) +return decode_arm64 (regs->pc, info);/* TODO: Handle ARM instruction */ gprintk (XENLOG_ERR ,"unhandled ARM instruction\n" );xen/arch/arm/decode.h +20
-4@@ -23,19 +23,54 @@#include <asm/regs.h> #include <asm/processor.h> -/** -* Decode an instruction from pc -* /!\ This function is not intended to fully decode an instruction. It -* considers that the instruction is valid. +/* +* Refer to the ARMv8 ARM (DDI 0487G.b), Section C4.1.4 Loads and Stores +* Page 318 specifies the following bit pattern for +* "load/store register (immediate post-indexed)". +* +* 31 30 29 27 26 25 23 21 20 11 9 4 0 +* ___________________________________________________________________ +* |size|1 1 1 |V |0 0 |opc |0 | imm9 |0 1 | Rn | Rt | +* |____|______|__|____|____|__|_______________|____|_________|_______| +*/ +union instr { +uint32_t value; +struct { +unsigned int rt:5 ;/* Rt register */ +unsigned int rn:5 ;/* Rn register */ +unsigned int fixed1:2 ;/* value == 01b */ +signed int imm9:9 ;/* imm9 */ +unsigned int fixed2:1 ;/* value == 0b */ +unsigned int opc:2 ;/* opc */ +unsigned int fixed3:2 ;/* value == 00b */
xen/arch/arm/decode.h line 55
Quoted 10 lines
xen/arch/arm/decode.h +10
-0+ unsigned int v:1; /* vector */ + unsigned int fixed4:3; /* value == 111b */ + unsigned int size:2; /* size */ + } ldr_str; +}; + +#define POST_INDEX_FIXED_MASK 0x3B200C00 +#define POST_INDEX_FIXED_VALUE 0x38000400 + +/* Decode an instruction from pc
code style:
/*
* Decode an instruction from pc
Quoted 55 lines
xen/arch/arm/decode.h +12
-3+* /!\ This function is intended to decode an instruction. It considers that the +* instruction is valid. * -* This function will get: -* - The transfer register +* In case of thumb mode, this function will get: +* - The transfer register (ie Rt) * - Sign bit * - Size +* +* In case of arm64 mode, this function will get: +* - The transfer register (ie Rt) +* - The source register (ie Rn) +* - Size +* - Immediate offset +* - Read or write */ int decode_instruction (const struct cpu_user_regs *regs, -struct hsr_dabt *dabt); +mmio_info_t *info);#endif /* __ARCH_ARM_DECODE_H_ */ xen/arch/arm/include/asm/mmio.h +4
-0@@ -29,6 +29,10 @@typedef struct {struct hsr_dabt dabt; +struct instr_details { +unsigned long rn:5 ; +signed int imm9:9 ; + } dabt_instr;paddr_t gpa; }mmio_info_t ;xen/arch/arm/io.c +1
-1@@ -134,7 +134,7 @@ enum io_state try_handle_mmio(struct cpu_user_regs *regs, {int rc; - rc =decode_instruction (regs, &info.dabt); + rc =decode_instruction (regs, &info);if ( rc ) {gprintk (XENLOG_DEBUG ,"Unable to decode instruction\n" );Signature · 1 line
2.17.1
PATCH v7 2/2 xen/arm64: io: Support instructions (for which ISS is not valid) on emulated MMIO region using MMIO/ioreq handler
In reply to Ayan Kumar HalderWhen an instruction is trapped in Xen due to translation fault, Xen checks if the ISS is valid. If not, Xen tries to resolve the translation fault using p2m page tables. In case if it is a data abort, Xen will try to map the mmio region to the guest (ie tries to emulate the mmio region).
If the ISS is not valid, then Xen tries to decode the instruction. In case of ioreq, Xen saves the decoding state, rn and imm9 to vcpu_io. Whenever the vcpu handles the ioreq successfully, it will read the decoding state to determine if the instruction decoded was a ldr/str post indexing (ie INSTR_LDR_STR_POSTINDEXING). If so, it uses these details to post increment rn.
In case of mmio handler, if the mmio operation was successful, then Xen retrives the decoding state, rn and imm9. For state == INSTR_LDR_STR_POSTINDEXING, Xen will update rn.
If there is an error encountered while decoding the instruction, Xen will issue an abort to the guest. If the instruction was related to cache maintenance, Xen will not decode the instruction or do any MMIO operation. Rather it simply increments the PC and returns to the guest. If the instruction was trapped due to stage1 page translation table walk, Xen will update the page tables and will return to the guest so that it can retry the instruction. To handle all these different states, we have introduced 'enum instr_decode_state'.
---
Changelog :-
v2..v5 - Mentioned in the cover letter.
v6 - 1. Mantained the decoding state of the instruction. This is used by the caller to either abort the guest or retry or ignore or perform read/write on the mmio region.
2. try_decode() invokes decoding for both aarch64 and thumb state. (Previously it used to invoke decoding only for aarch64 state). Thus, it handles all the checking of the registers before invoking any decoding of instruction. try_decode_instruction_invalid_iss() has thus been removed.
3. Introduced a new field('enum instr_decode_state state') inside 'struct instr_details'. This holds the decoding state of the instruction. This is later read by the post_increment_register() to determine if rn needs to be incremented. Also, this is read by the callers of try_decode_instruction() to determine if the instruction was valid or ignored or to be retried or error or decoded successfully.
4. Also stored 'instr_details' inside 'struct ioreq'. This enables arch_ioreq_complete_mmio() to invoke post_increment_register() without decoding the instruction again.
5. Check hsr.dabt.valid in do_trap_stage2_abort_guest(). If it is not valid, then decode the instruction. This ensures that try_handle_mmio() is invoked only when the instruction is either valid or decoded successfully.
6. Inside do_trap_stage2_abort_guest(), if hsr.dabt.valid is not set, then resolve the translation fault before trying to decode the instruction. If translation fault is resolved, then return to the guest to execute the instruction again.
v7 - 1. Moved the decoding instruction details ie instr_details from 'struct ioreq' to 'struct vcpu_io'.
2. The instruction is decoded only when we get a data abort.
3. Replaced ASSERT_UNREACHABLE() with domain_crash(). The reason being asserts can be disabled in some builds. In this scenario when the guest's cpsr is in an erroneous state, Xen should crash the guest.
4. Introduced check_p2m() which invokes p2m_resolve_translation_fault() and try_map_mmio() to resolve translation fault by configuring the page tables. This gets invoked first if ISS is invalid and it is an instruction abort. If it is a data abort and hsr.dabt.s1ptw is set or try_handle_mmio() returns IO_UNHANDLED, then check_p2m() gets invoked again.
xen/arch/arm/arm32/traps.c | 7 ++ xen/arch/arm/arm64/traps.c | 47 +++++++++++++ xen/arch/arm/decode.c | 1 + xen/arch/arm/decode.h | 3 +- xen/arch/arm/include/asm/domain.h | 4 ++ xen/arch/arm/include/asm/ioreq.h | 1 + xen/arch/arm/include/asm/mmio.h | 16 ++++- xen/arch/arm/include/asm/traps.h | 2 + xen/arch/arm/io.c | 108 ++++++++++++++++++++---------- xen/arch/arm/ioreq.c | 12 ++-- xen/arch/arm/traps.c | 85 ++++++++++++++++++++--- xen/arch/x86/include/asm/ioreq.h | 3 + xen/include/xen/sched.h | 2 + 13 files changed, 240 insertions(+), 51 deletions(-)
xen/arch/arm/arm32/traps.c +7 -0
@@ -18,9 +18,11 @@#include <xen/lib.h> #include <xen/kernel.h> +#include <xen/sched.h> #include <public/xen.h> +#include <asm/mmio.h> #include <asm/processor.h> #include <asm/traps.h>
@@ -82,6 +84,11 @@ void do_trap_data_abort(struct cpu_user_regs *regs)do_unexpected_trap ("Data Abort" , regs); } +void post_increment_register (const struct instr_details *instr) +{ +domain_crash (current->domain); +} +/* * Local variables: * mode: C
xen/arch/arm/arm64/traps.c +47 -0
59 lines not on this page · raw message
xen/arch/arm/decode.c +1 -0
@@ -147,6 +147,7 @@ static int decode_arm64(register_t pc, mmio_info_t *info)update_dabt (dabt, opcode.ldr_str.rt, opcode.ldr_str.size, false); + dabt_instr->state =INSTR_LDR_STR_POSTINDEXING ; dabt_instr->rn = opcode.ldr_str.rn; dabt_instr->imm9 = opcode.ldr_str.imm9;
xen/arch/arm/decode.h +2 -1
@@ -52,7 +52,8 @@ union instr {#define POST_INDEX_FIXED_MASK 0x3B200C00#define POST_INDEX_FIXED_VALUE 0x38000400 -/* Decode an instruction from pc +/* +* Decode an instruction from pc * /!\ This function is intended to decode an instruction. It considers that the * instruction is valid. *
xen/arch/arm/include/asm/domain.h +4 -0
@@ -266,6 +266,10 @@ static inline void arch_vcpu_block(struct vcpu *v) {}/* vPCI is not available on Arm */ #define has_vpci (d) ({ (void)(d); false; }) +struct arch_vcpu_io { +struct instr_details *dabt_instr;/* when the instruction is decoded */ +}; +#endif /* __ASM_DOMAIN_H__ */ /*
xen/arch/arm/include/asm/ioreq.h +1 -0
@@ -52,6 +52,7 @@ static inline void msix_write_completion(struct vcpu *v) { } +/* This correlation must not be altered */ #define IOREQ_STATUS_HANDLED IO_HANDLED#define IOREQ_STATUS_UNHANDLED IO_UNHANDLED
xen/arch/arm/include/asm/mmio.h +14 -2
@@ -26,12 +26,23 @@#define MAX_IO_HANDLER 16 +enum instr_decode_state +{ +INSTR_ERROR ,/* Error encountered while decoding instr */ +INSTR_VALID ,/* ISS is valid, so no need to decode */ +INSTR_LDR_STR_POSTINDEXING ,/* Instruction is decoded successfully. +It is ldr/str post indexing */ +INSTR_IGNORE ,/* Instruction is to be ignored (ie NOP) */ +INSTR_RETRY /* Instruction is to be retried */ +}; +typedef struct {struct hsr_dabt dabt;struct instr_details {unsigned long rn:5 ;signed int imm9:9 ; +enum instr_decode_state state; } dabt_instr;paddr_t gpa; }mmio_info_t ;
@@ -69,14 +80,15 @@ struct vmmio { };enum io_state try_handle_mmio (struct cpu_user_regs *regs, -const union hsr hsr, -paddr_t gpa); +mmio_info_t *info);void register_mmio_handler (struct domain *d,const struct mmio_handler_ops *ops,paddr_t addr,paddr_t size,void *priv);int domain_io_init (struct domain *d,int max_count);void domain_io_free (struct domain *d); +void try_decode_instruction (const struct cpu_user_regs *regs, +mmio_info_t *info);#endif /* __ASM_ARM_MMIO_H__ */
xen/arch/arm/include/asm/traps.h +2 -0
@@ -109,6 +109,8 @@ static inline register_t sign_extend(const struct hsr_dabt dabt, register_t r) return r; } +void post_increment_register (const struct instr_details *instr); +#endif /* __ASM_ARM_TRAPS__ */ /* * Local variables:
xen/arch/arm/io.c +74 -34
131 lines not on this page · raw message
xen/arch/arm/ioreq.c +8 -4
@@ -26,7 +26,8 @@enum io_state handle_ioserv (struct cpu_user_regs *regs,struct vcpu *v) {const union hsr hsr = { .bits = regs->hsr }; -const struct hsr_dabt dabt = hsr.dabt; +struct hsr_dabt dabt = hsr.dabt; +/* Code is similar to handle_read */ register_t r = v->io.req.data;
@@ -47,6 +48,7 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, struct vcpu *v, mmio_info_t *info) { struct vcpu_io *vio = &v->io; +struct dabt_instr *instr = &info->dabt_instr; ioreq_t p = { .type = IOREQ_TYPE_COPY, .addr = info->gpa,
@@ -65,6 +67,8 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, };struct ioreq_server *s =NULL ;enum io_state rc; +bool instr_decoded = false; +const union hsr hsr = { .bits = regs->hsr };if ( vio->req.state !=STATE_IOREQ_NONE ) {
@@ -76,10 +80,8 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs,if ( !s )return IO_UNHANDLED ; -if ( !info->dabt.valid ) -return IO_ABORT ; - vio->req = p; + vio->info.dabt_instr = instr; rc =ioreq_send (s, &p,0 );if ( rc !=IO_RETRY || v->domain->is_shutting_down )
@@ -95,6 +97,7 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs,bool arch_ioreq_complete_mmio (void ) {struct vcpu *v = current; +struct instr_details *dabt_instr = v->io.info.dabt_instr;struct cpu_user_regs *regs =guest_cpu_user_regs ();const union hsr hsr = { .bits = regs->hsr };
@@ -106,6 +109,7 @@ bool arch_ioreq_complete_mmio(void)if (handle_ioserv (regs, v) ==IO_HANDLED ) { +post_increment_register (dabt_instr);advance_pc (regs, hsr);return true; }
xen/arch/arm/traps.c +75 -10
124 lines not on this page · raw message
xen/arch/x86/include/asm/ioreq.h +3 -0
@@ -26,6 +26,9 @@#include <asm/hvm/ioreq.h> #endif +struct arch_vcpu_io { +}; +#endif /* __ASM_X86_IOREQ_H__ */ /*
xen/include/xen/sched.h +2 -0
@@ -160,6 +160,8 @@ struct vcpu_io {/* I/O request in flight to device model. */ enum vio_completion completion;ioreq_t req; +/* Arch specific info pertaining to the io request */ +struct arch_vcpu_io info; };struct vcpu
Signature · 1 line
2.17.1
Re: [XEN v7 2/2] xen/arm64: io: Support instructions (for which ISS is not valid) on emulated MMIO region using MMIO/ioreq handler
Hi All,
I had a discussion with Julien on IRC and this patch need a correction (based on my understanding):-
Quoted 3 lines · Ayan Kumar Halder
If the instruction was related to cache maintenance, Xen
will not decode the instruction or do any MMIO operation. Rather it simply increments the PC and returns to the guest.
This is not entirely correct :-
If the instruction is cache maintenance and the address is emulated, then Xen needs to ignore the ignore the instruction ie increment the PC and return to the guest.
However, if the address is not emulated, then Xen will get invoked only if the translation table entry corresponding to the address is set invalid. In this case, Xen will need to iterate through the translation tables and mark the entry as valid and return to the guest to retry the instruction.
As of today, we do not handle cache condition (ie dabt.cache == 1) in Xen. Thus, I will drop this logic in my patch and will resend the current series (unless there are any objections).
I will send out a separate patch to handle the cache condition.
Quoted 7 lines
If the instruction was trapped due
to stage1 page translation table walk, Xen will update the page tables and will return to the guest so that it can retry the instruction. To handle all these different states, we have introduced 'enuminstr_decode_state'.Signed-off-by Ayan Kumar Halder <[email protected]>---
<snip>
Quoted 5 lines
xen/arch/arm/include/asm/mmio.h +0
-0
xen/arch/arm/include/asm/mmio.h line 35
Quoted 10 lines
xen/arch/arm/include/asm/mmio.h +7
-0@@ -26,12 +26,23 @@#define MAX_IO_HANDLER 16 +enum instr_decode_state +{ +INSTR_ERROR ,/* Error encountered while decoding instr */ +INSTR_VALID ,/* ISS is valid, so no need to decode */ +INSTR_LDR_STR_POSTINDEXING ,/* Instruction is decoded successfully. +It is ldr/str post indexing */ +INSTR_IGNORE ,/* Instruction is to be ignored (ie NOP) */
Drop this entry.
Quoted 4 lines
xen/arch/arm/include/asm/mmio.h +3
-0+ INSTR_RETRY /* Instruction is to be retried */ +}; +
<snip>
xen/arch/arm/include/asm/mmio.h
Quoted 9 lines
xen/arch/arm/include/asm/mmio.h +9
-0+/* +* If the fault occurred due to cache maintenance or address translation +* instructions, then Xen needs to ignore these instructions. +*/ +if ( info->dabt.cache ) + { + info->dabt_instr.state =INSTR_IGNORE ; +return ; + }
I need to drop this. As stated before, this needs to be done in a separate patch.
<snip>
xen/arch/arm/include/asm/mmio.h
Quoted 13 lines
xen/arch/arm/include/asm/mmio.h +13
-0+ +try_decode_instruction (regs, &info); + +/* +* If the instruction was to be ignored by Xen, then it should return +* to the caller which will increment the PC, so that the guest can +* execute the next instruction. +*/ +if ( info.dabt_instr.state ==INSTR_IGNORE ) + { +advance_pc (regs, hsr); +return ; + }
Drop this.
<snip>
- Ayan
Re: [XEN v7 2/2] xen/arm64: io: Support instructions (for which ISS is not valid) on emulated MMIO region using MMIO/ioreq handler
In reply to Ayan Kumar HalderQuoted 200 lines · Ayan Kumar Halder
When an instruction is trapped in Xen due to translation fault, Xen checks if the ISS is valid. If not, Xen tries to resolve the translation fault using p2m page tables. In case if it is a data abort, Xen will try to map the mmio region to the guest (ie tries to emulate the mmio region).
If the ISS is not valid, then Xen tries to decode the instruction. In case of ioreq, Xen saves the decoding state, rn and imm9 to
vcpu_io. Whenever the vcpu handles the ioreq successfully, it will read the decoding state to determine if the instruction decoded was a ldr/str post indexing (ieINSTR_LDR_STR_POSTINDEXING). If so, it uses these details to post increment rn.In case of mmio handler, if the mmio operation was successful, then Xen retrives the decoding state, rn and imm9. For state ==
INSTR_LDR_STR_POSTINDEXING, Xen will update rn.If there is an error encountered while decoding the instruction, Xen will issue an abort to the guest. If the instruction was related to cache maintenance, Xen will not decode the instruction or do any MMIO operation. Rather it simply increments the PC and returns to the guest. If the instruction was trapped due to stage1 page translation table walk, Xen will update the page tables and will return to the guest so that it can retry the instruction. To handle all these different states, we have introduced 'enum
instr_decode_state'.Signed-off-by Ayan Kumar Halder <[email protected]>---
Changelog :-
v2..v5 - Mentioned in the cover letter.
v6 - 1. Mantained the decoding state of the instruction. This is used by the caller to either abort the guest or retry or ignore or perform read/write on the mmio region.
2.
try_decode()invokes decoding for both aarch64 and thumb state. (Previously it used to invoke decoding only for aarch64 state). Thus, it handles all the checking of the registers before invoking any decoding of instruction.try_decode_instruction_invalid_iss()has thus been removed.3. Introduced a new
field('enum instr_decode_state state')inside 'structinstr_details'. This holds the decoding state of the instruction. This is later read by thepost_increment_register()to determine if rn needs to be incremented. Also, this is read by the callers oftry_decode_instruction()to determine if the instruction was valid or ignored or to be retried or error or decoded successfully.4. Also stored '
instr_details' inside 'struct ioreq'. This enablesarch_ioreq_complete_mmio()to invokepost_increment_register()without decoding the instruction again.5. Check hsr.dabt.valid in
do_trap_stage2_abort_guest(). If it is not valid, then decode the instruction. This ensures thattry_handle_mmio()is invoked only when the instruction is either valid or decoded successfully.6. Inside
do_trap_stage2_abort_guest(), if hsr.dabt.valid is not set, then resolve the translation fault before trying to decode the instruction. If translation fault is resolved, then return to the guest to execute the instruction again.v7 - 1. Moved the decoding instruction details ie
instr_detailsfrom 'struct ioreq' to 'structvcpu_io'.2. The instruction is decoded only when we get a data abort.
3. Replaced
ASSERT_UNREACHABLE()withdomain_crash(). The reason being asserts can be disabled in some builds. In this scenario when the guest's cpsr is in an erroneous state, Xen should crash the guest.4. Introduced
check_p2m()which invokesp2m_resolve_translation_fault()andtry_map_mmio()to resolve translation fault by configuring the page tables. This gets invoked first if ISS is invalid and it is an instruction abort. If it is a data abort and hsr.dabt.s1ptw is set ortry_handle_mmio()returnsIO_UNHANDLED, thencheck_p2m()gets invoked again.xen/arch/arm/arm32/traps.c | 7 ++ xen/arch/arm/arm64/traps.c | 47 +++++++++++++ xen/arch/arm/decode.c | 1 + xen/arch/arm/decode.h | 3 +- xen/arch/arm/include/asm/domain.h | 4 ++ xen/arch/arm/include/asm/ioreq.h | 1 + xen/arch/arm/include/asm/mmio.h | 16 ++++- xen/arch/arm/include/asm/traps.h | 2 + xen/arch/arm/io.c | 108 ++++++++++++++++++++---------- xen/arch/arm/ioreq.c | 12 ++-- xen/arch/arm/traps.c | 85 ++++++++++++++++++++--- xen/arch/x86/include/asm/ioreq.h | 3 + xen/include/xen/sched.h | 2 + 13 files changed, 240 insertions(+), 51 deletions(-)xen/arch/arm/arm32/traps.c +7
-0@@ -18,9 +18,11 @@#include <xen/lib.h> #include <xen/kernel.h> +#include <xen/sched.h> #include <public/xen.h> +#include <asm/mmio.h> #include <asm/processor.h> #include <asm/traps.h> @@ -82,6 +84,11 @@ void do_trap_data_abort(struct cpu_user_regs *regs)do_unexpected_trap ("Data Abort" , regs); } +void post_increment_register (const struct instr_details *instr) +{ +domain_crash (current->domain); +} +/* * Local variables: * mode: C xen/arch/arm/arm64/traps.c +47
-0@@ -23,6 +23,7 @@#include <asm/processor.h> #include <public/xen.h> +#include <xen/sched.h> static const char *handler[]= {"Synchronous Abort" ,@@ -44,6 +45,52 @@ void do_bad_mode(struct cpu_user_regs *regs, int reason)panic ("bad mode\n" ); } +void post_increment_register (const struct instr_details *instr) +{ +struct cpu_user_regs *regs =guest_cpu_user_regs (); +register_t val =0 ; + +/* Currently, we handle only ldr/str post indexing instructions */ +if ( instr->state !=INSTR_LDR_STR_POSTINDEXING ) +return ; + +/* +* Handle when rn = SP +* Refer ArmV8 ARM DDI 0487G.b, Page - D1-2463 "Stack pointer register +* selection" +* t = SP_EL0 +* h = SP_ELx +* and M[3:0] (Page - C5-474 "When exception taken from AArch64 state:") +*/ +if (instr->rn ==31 ) + { +if ( (regs->cpsr &PSR_MODE_MASK ) == PSR_MODE_EL1h ) + val = regs->sp_el1; +else if ( ((regs->cpsr &PSR_MODE_MASK ) == PSR_MODE_EL1t) || + ((regs->cpsr &PSR_MODE_MASK ) == PSR_MODE_EL0t) ) + val = regs->sp_el0; +else + { +domain_crash (current->domain); +return ; + } + } +else + val =get_user_reg (regs, instr->rn); + + val += instr->imm9; + +if ( instr->rn ==31 ) + { +if ( (regs->cpsr &PSR_MODE_MASK ) == PSR_MODE_EL1h ) + regs->sp_el1 = val; +else + regs->sp_el0 = val; + } +else +set_user_reg (regs, instr->rn, val); +} +/* * Local variables: * mode: C xen/arch/arm/decode.c +1
-0@@ -147,6 +147,7 @@ static int decode_arm64(register_t pc, mmio_info_t *info)update_dabt (dabt, opcode.ldr_str.rt, opcode.ldr_str.size, false); + dabt_instr->state =INSTR_LDR_STR_POSTINDEXING ; dabt_instr->rn = opcode.ldr_str.rn; dabt_instr->imm9 = opcode.ldr_str.imm9;xen/arch/arm/decode.h +0
-0
xen/arch/arm/decode.h union instr { · line 59
Quoted 9 lines
xen/arch/arm/decode.h +2
-1@@ -52,7 +52,8 @@ union instr {#define POST_INDEX_FIXED_MASK 0x3B200C00#define POST_INDEX_FIXED_VALUE 0x38000400 -/* Decode an instruction from pc +/* +* Decode an instruction from pc * /!\ This function is intended to decode an instruction. It considers that the * instruction is valid. *
Ah! It should have been in the previous patch
Quoted 20 lines
xen/arch/arm/include/asm/domain.h +4
-0@@ -266,6 +266,10 @@ static inline void arch_vcpu_block(struct vcpu *v) {}/* vPCI is not available on Arm */ #define has_vpci (d) ({ (void)(d); false; }) +struct arch_vcpu_io { +struct instr_details *dabt_instr;/* when the instruction is decoded */ +}; +#endif /* __ASM_DOMAIN_H__ */ /* xen/arch/arm/include/asm/ioreq.h +0
-0
xen/arch/arm/include/asm/ioreq.h static inline void msix_write_completion(struct vcpu *v) · line 55
Quoted 4 lines
xen/arch/arm/include/asm/ioreq.h +1
-0@@ -52,6 +52,7 @@ static inline void msix_write_completion(struct vcpu *v) { } +
Spurious change
Quoted 203 lines
xen/arch/arm/include/asm/ioreq.h +0
-0/* This correlation must not be altered */ #define IOREQ_STATUS_HANDLED IO_HANDLED#define IOREQ_STATUS_UNHANDLED IO_UNHANDLEDxen/arch/arm/include/asm/mmio.h +14
-2@@ -26,12 +26,23 @@#define MAX_IO_HANDLER 16 +enum instr_decode_state +{ +INSTR_ERROR ,/* Error encountered while decoding instr */ +INSTR_VALID ,/* ISS is valid, so no need to decode */ +INSTR_LDR_STR_POSTINDEXING ,/* Instruction is decoded successfully. +It is ldr/str post indexing */ +INSTR_IGNORE ,/* Instruction is to be ignored (ie NOP) */ +INSTR_RETRY /* Instruction is to be retried */ +}; +typedef struct {struct hsr_dabt dabt;struct instr_details {unsigned long rn:5 ;signed int imm9:9 ; +enum instr_decode_state state; } dabt_instr;paddr_t gpa; }mmio_info_t ;@@ -69,14 +80,15 @@ struct vmmio { };enum io_state try_handle_mmio (struct cpu_user_regs *regs, -const union hsr hsr, -paddr_t gpa); +mmio_info_t *info);void register_mmio_handler (struct domain *d,const struct mmio_handler_ops *ops,paddr_t addr,paddr_t size,void *priv);int domain_io_init (struct domain *d,int max_count);void domain_io_free (struct domain *d); +void try_decode_instruction (const struct cpu_user_regs *regs, +mmio_info_t *info);#endif /* __ASM_ARM_MMIO_H__ */ xen/arch/arm/include/asm/traps.h +2
-0@@ -109,6 +109,8 @@ static inline register_t sign_extend(const struct hsr_dabt dabt, register_t r) return r; } +void post_increment_register (const struct instr_details *instr); +#endif /* __ASM_ARM_TRAPS__ */ /* * Local variables: xen/arch/arm/io.c +74
-34@@ -95,57 +95,97 @@ static const struct mmio_handler *find_mmio_handler(struct domain *d,return handler; } +void try_decode_instruction (const struct cpu_user_regs *regs, +mmio_info_t *info) +{ +int rc; + +/* +* Erratum 766422: Thumb store translation fault to Hypervisor may +* not have correct HSR Rt value. +*/ +if (check_workaround_766422 () && (regs->cpsr &PSR_THUMB ) && + info->dabt.write ) + { + rc =decode_instruction (regs, info); +if ( rc ) + { +gprintk (XENLOG_DEBUG ,"Unable to decode instruction\n" ); + info->dabt_instr.state =INSTR_ERROR ; +return ; + } + } + +/* If ISS is valid, then no need to decode the instruction any further */ +if ( info->dabt.valid ) + { + info->dabt_instr.state =INSTR_VALID ; +return ; + } + +/* +* Xen should not decode the instruction when it was trapped due to +* translation fault. +*/ +if ( info->dabt.s1ptw ) + { + info->dabt_instr.state =INSTR_RETRY ; +return ; + } + +/* +* If the fault occurred due to cache maintenance or address translation +* instructions, then Xen needs to ignore these instructions. +*/ +if ( info->dabt.cache ) + { + info->dabt_instr.state =INSTR_IGNORE ; +return ; + } + +/* +* Armv8 processor does not provide a valid syndrome for decoding some +* instructions. So in order to process these instructions, Xen must +* decode them. +*/ + rc =decode_instruction (regs, info); +if ( rc ) + { +gprintk (XENLOG_ERR ,"Unable to decode instruction\n" ); + info->dabt_instr.state =INSTR_ERROR ; + } +} +enum io_state try_handle_mmio (struct cpu_user_regs *regs, -const union hsr hsr, -paddr_t gpa) +mmio_info_t *info) {struct vcpu *v = current;const struct mmio_handler *handler =NULL ; -const struct hsr_dabt dabt = hsr.dabt; -mmio_info_t info = { - .gpa = gpa, - .dabt = dabt - }; +int rc; -ASSERT (hsr.ec ==HSR_EC_DATA_ABORT_LOWER_EL ); +ASSERT (info->dabt.ec ==HSR_EC_DATA_ABORT_LOWER_EL ); - handler =find_mmio_handler (v->domain, info.gpa); + handler =find_mmio_handler (v->domain, info->gpa);if ( !handler ) { -int rc; - - rc =try_fwd_ioserv (regs, v, &info); + rc =try_fwd_ioserv (regs, v, info);if ( rc ==IO_HANDLED )return handle_ioserv (regs, v);return rc; } -/* All the instructions used on emulated MMIO region should be valid */ -if ( !dabt.valid ) -return IO_ABORT ; -/* -* Erratum 766422: Thumb store translation fault to Hypervisor may -* not have correct HSR Rt value. +* At this point, we know that the instruction is either valid or has been +* decoded successfully. Thus, Xen should be allowed to execute the +* instruction on the emulated MMIO region. */ -if (check_workaround_766422 () && (regs->cpsr &PSR_THUMB ) && - dabt.write ) - { -int rc; - - rc =decode_instruction (regs, &info); -if ( rc ) - { -gprintk (XENLOG_DEBUG ,"Unable to decode instruction\n" ); -return IO_ABORT ; - } - } - -if ( info.dabt.write ) -return handle_write (handler, v, &info); +if ( info->dabt.write ) + rc =handle_write (handler, v, info);else -return handle_read (handler, v, &info); + rc =handle_read (handler, v, info); + +return rc; } void register_mmio_handler(struct domain *d,xen/arch/arm/ioreq.c +0
-0
xen/arch/arm/ioreq.c line 29
Quoted 5 lines
xen/arch/arm/ioreq.c +1
-1@@ -26,7 +26,8 @@enum io_state handle_ioserv (struct cpu_user_regs *regs,struct vcpu *v) {const union hsr hsr = { .bits = regs->hsr }; -const struct hsr_dabt dabt = hsr.dabt; +struct hsr_dabt dabt = hsr.dabt;
This change is not needed, right?
Quoted 12 lines
xen/arch/arm/ioreq.c +1
-0/* Code is similar to handle_read */ register_t r = v->io.req.data;@@ -47,6 +48,7 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, struct vcpu *v, mmio_info_t *info) { struct vcpu_io *vio = &v->io; +struct dabt_instr *instr = &info->dabt_instr; ioreq_t p = { .type = IOREQ_TYPE_COPY, .addr = info->gpa,
xen/arch/arm/ioreq.c enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, · line 71
Quoted 5 lines
xen/arch/arm/ioreq.c +2
-0@@ -65,6 +67,8 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, };struct ioreq_server *s =NULL ;enum io_state rc; +bool instr_decoded = false; +const union hsr hsr = { .bits = regs->hsr };
It doesn't look like these two local variables are actually used anywhere
Quoted 15 lines
xen/arch/arm/ioreq.c +1
-3if ( vio->req.state !=STATE_IOREQ_NONE ) {@@ -76,10 +80,8 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs,if ( !s )return IO_UNHANDLED ; -if ( !info->dabt.valid ) -return IO_ABORT ; - vio->req = p; + vio->info.dabt_instr = instr; rc =ioreq_send (s, &p,0 );if ( rc !=IO_RETRY || v->domain->is_shutting_down )
xen/arch/arm/ioreq.c enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, · line 102
Quoted 6 lines
xen/arch/arm/ioreq.c +1
-0@@ -95,6 +97,7 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs,bool arch_ioreq_complete_mmio (void ) {struct vcpu *v = current; +struct instr_details *dabt_instr = v->io.info.dabt_instr;struct cpu_user_regs *regs =guest_cpu_user_regs ();const union hsr hsr = { .bits = regs->hsr };
I don't think that v->io.info.dabt_instr should be a pointer because at this point the original structure is long gone. The original field was a local variable mmio_info_t info in do_trap_stage2_abort_guest. So by the time arch_ioreq_complete_mmio is called, the original variable has been deallocated.
Instead, v->io.info.dabt_instr should be a "struct instr_details" (no pointer).
Quoted 171 lines
xen/arch/arm/ioreq.c +1
-0@@ -106,6 +109,7 @@ bool arch_ioreq_complete_mmio(void)if (handle_ioserv (regs, v) ==IO_HANDLED ) { +post_increment_register (dabt_instr);advance_pc (regs, hsr);return true; }xen/arch/arm/traps.c +75
-10@@ -1893,6 +1893,21 @@ static bool try_map_mmio(gfn_t gfn)return !map_regions_p2mt (d, gfn,1 , mfn, p2m_mmio_direct_c); } +static inline bool check_p2m (bool is_data,paddr_t gpa) +{ +/* +* First check if the translation fault can be resolved by the P2M subsystem. +* If that's the case nothing else to do. +*/ +if (p2m_resolve_translation_fault (current->domain,gaddr_to_gfn (gpa)) ) +return true; + +if ( is_data &&try_map_mmio (gaddr_to_gfn (gpa)) ) +return true; + +return false; +} +static void do_trap_stage2_abort_guest (struct cpu_user_regs *regs,const union hsr hsr) {@@ -1906,6 +1921,7 @@ static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs,paddr_t gpa;uint8_t fsc = xabt.fsc & ~FSC_LL_MASK ;bool is_data = (hsr.ec ==HSR_EC_DATA_ABORT_LOWER_EL ); +mmio_info_t info;/* * If this bit has been set, it means that this stage-2 abort is caused @@ -1959,6 +1975,25 @@ static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs,return ; }case FSC_FLT_TRANS : + { + info.gpa = gpa; + info.dabt = hsr.dabt; + +/* Check that the ISS is invalid and it is not data abort. */ +if ( !hsr.dabt.valid && !is_data ) + { + +/* +* Assumption :- Most of the times when we get a translation fault +* and the ISS is invalid, the underlying cause is that the page +* tables have not been set up correctly. +*/ +if (check_p2m (is_data, gpa) ) +return ; +else + goto inject_abt; + } +/* * Attempt first to emulate the MMIO as the data abort will * likely happen in an emulated region. @@ -1967,13 +2002,49 @@ static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs,*/ if ( is_data ) { -enum io_state state =try_handle_mmio (regs, hsr, gpa); +enum io_state state; + +try_decode_instruction (regs, &info); + +/* +* If the instruction was to be ignored by Xen, then it should return +* to the caller which will increment the PC, so that the guest can +* execute the next instruction. +*/ +if ( info.dabt_instr.state ==INSTR_IGNORE ) + { +advance_pc (regs, hsr); +return ; + } + +/* +* If Xen could not decode the instruction for any reason, then it +* should ask the caller to abort the guest. +*/ +else if ( info.dabt_instr.state ==INSTR_ERROR ) + goto inject_abt; + +/* +* When the instruction needs to be retried by the guest after +* resolving the translation fault. +*/ +else if ( info.dabt_instr.state ==INSTR_RETRY ) + goto set_page_tables; + + state =try_handle_mmio (regs, &info);switch ( state ) {case IO_ABORT : goto inject_abt;case IO_HANDLED : +/* +* If the instruction was decoded and has executed successfully +* on the MMIO region, then Xen should execute the next part of +* the instruction. (for eg increment the rn if it is a +* post-indexing instruction. +*/ +post_increment_register (&info.dabt_instr);advance_pc (regs, hsr);return ;case IO_RETRY :@@ -1985,18 +2056,12 @@ static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs, } } -/* -* First check if the translation fault can be resolved by the -* P2M subsystem. If that's the case nothing else to do. -*/ -if (p2m_resolve_translation_fault (current->domain, -gaddr_to_gfn (gpa)) ) -return ; - -if ( is_data &&try_map_mmio (gaddr_to_gfn (gpa)) ) + set_page_tables: +if (check_p2m (is_data, gpa) )return ;break ; + }default : gprintk(XENLOG_WARNING, "Unsupported FSC: HSR=%#"PRIregister" DFSC=%#x\n",xen/arch/x86/include/asm/ioreq.h +3
-0@@ -26,6 +26,9 @@#include <asm/hvm/ioreq.h> #endif +struct arch_vcpu_io { +}; +#endif /* __ASM_X86_IOREQ_H__ */ /* xen/include/xen/sched.h +2
-0@@ -160,6 +160,8 @@ struct vcpu_io {/* I/O request in flight to device model. */ enum vio_completion completion;ioreq_t req; +/* Arch specific info pertaining to the io request */ +struct arch_vcpu_io info; };struct vcpu Signature · 1 line
2.17.1
Re: [XEN v7 2/2] xen/arm64: io: Support instructions (for which ISS is not valid) on emulated MMIO region using MMIO/ioreq handler
Hi Stefano,
Thanks for your feedback.
Quoted 1 line · Stefano Stabellini
On Sat, 5 Feb 2022, Ayan Kumar Halder wrote:
<snip>
Quoted 13 lines
xen/arch/arm/ioreq.c enum io_state try_fwd_ioserv(struct cpu_user_regs *regs, · line 102
Quoted 7 lines
xen/arch/arm/ioreq.c +1
-0@@ -95,6 +97,7 @@ enum io_state try_fwd_ioserv(struct cpu_user_regs *regs,bool arch_ioreq_complete_mmio (void ) {struct vcpu *v = current; +struct instr_details *dabt_instr = v->io.info.dabt_instr;struct cpu_user_regs *regs =guest_cpu_user_regs ();const union hsr hsr = { .bits = regs->hsr };I don't think that
v->io.info.dabt_instrshould be a pointer because at this point the original structure is long gone. The original field was a local variablemmio_info_tinfo indo_trap_stage2_abort_guest. So by the timearch_ioreq_complete_mmiois called, the original variable has been deallocated.
Quoted 2 lines
Instead,
v->io.info.dabt_instrshould be a "structinstr_details" (no pointer).
I see what you mean.
arch_ioreq_complete_mmio() is called from leave_hypervisor_to_guest(). That is after do_trap_stage2_abort_guest
() has been invoked. So the original variable is no longer valid.
<snip>
xen/arch/arm/traps.c static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs, · line 2032
Quoted 7 lines
xen/arch/arm/traps.c +7
-0+ +/* +* When the instruction needs to be retried by the guest after +* resolving the translation fault. +*/ + else if ( info.dabt_instr.state == INSTR_RETRY ) + goto set_page_tables;
As discussed with Julien on IRC, when hsr_dabt.s1ptw == 1, Xen should only invoke p2m_resolve_translation_fault(). If it returns an error, it should send an abort to the guest. The reason being there is no need to invoke try_map_mmio() as the gpa is not a mmio address. Also, Xen does not support the use case when the guest places the page tables in the MMIO region.
I will wait for Julien's comments before sending out a v8 patch.
- Ayan
Quoted 70 lines
xen/arch/arm/traps.c +12
-9+ + state =try_handle_mmio (regs, &info);switch ( state ) {case IO_ABORT : goto inject_abt;case IO_HANDLED : +/* +* If the instruction was decoded and has executed successfully +* on the MMIO region, then Xen should execute the next part of +* the instruction. (for eg increment the rn if it is a +* post-indexing instruction. +*/ +post_increment_register (&info.dabt_instr);advance_pc (regs, hsr);return ;case IO_RETRY :@@ -1985,18 +2056,12 @@ static void do_trap_stage2_abort_guest(struct cpu_user_regs *regs, } } -/* -* First check if the translation fault can be resolved by the -* P2M subsystem. If that's the case nothing else to do. -*/ -if (p2m_resolve_translation_fault (current->domain, -gaddr_to_gfn (gpa)) ) -return ; - -if ( is_data &&try_map_mmio (gaddr_to_gfn (gpa)) ) + set_page_tables: +if (check_p2m (is_data, gpa) )return ;break ; + }default : gprintk(XENLOG_WARNING, "Unsupported FSC: HSR=%#"PRIregister" DFSC=%#x\n",xen/arch/x86/include/asm/ioreq.h +3
-0@@ -26,6 +26,9 @@#include <asm/hvm/ioreq.h> #endif +struct arch_vcpu_io { +}; +#endif /* __ASM_X86_IOREQ_H__ */ /* xen/include/xen/sched.h +2
-0@@ -160,6 +160,8 @@ struct vcpu_io {/* I/O request in flight to device model. */ enum vio_completion completion;ioreq_t req; +/* Arch specific info pertaining to the io request */ +struct arch_vcpu_io info; };struct vcpu Signature · 1 line
2.17.1