Lines Matching +full:short +full:- +full:descriptor
14 #include <asm/insn-eval.h>
29 * is_string_insn() - Determine if instruction is a string instruction
40 /* All string instructions have a 1-byte opcode. */ in is_string_insn()
41 if (insn->opcode.nbytes != 1) in is_string_insn()
44 switch (insn->opcode.bytes[0]) { in is_string_insn()
55 * insn_has_rep_prefix() - Determine if instruction has a REP prefix
78 * get_seg_reg_override_idx() - obtain segment register override index
89 * -EINVAL in case of error.
135 return -EINVAL; in get_seg_reg_override_idx()
141 * check_seg_overrides() - check if segment override prefixes are allowed
145 * For a particular register used in register-indirect addressing, determine if
163 * resolve_default_seg() - resolve default segment register index for an operand
177 * -EINVAL in case of error.
189 * + AX, CX and DX are not valid register operands in 16-bit address in resolve_default_seg()
190 * encodings but are valid for 32-bit and 64-bit encodings. in resolve_default_seg()
191 * + -EDOM is reserved to identify for cases in which no register in resolve_default_seg()
192 * is used (i.e., displacement-only addressing). Use DS. in resolve_default_seg()
202 if (insn->addr_bytes == 2) in resolve_default_seg()
203 return -EINVAL; in resolve_default_seg()
207 case -EDOM: in resolve_default_seg()
225 return -EINVAL; in resolve_default_seg()
230 * resolve_seg_reg() - obtain segment register index
238 * The segment register associated to an operand used in register-indirect
279 * -EINVAL in case of error.
299 return -EINVAL; in resolve_seg_reg()
325 * get_segment_selector() - obtain segment selector
341 * -EINVAL on error.
343 static short get_segment_selector(struct pt_regs *regs, int seg_reg_idx) in get_segment_selector()
345 unsigned short sel; in get_segment_selector()
352 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
354 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
368 return -EINVAL; in get_segment_selector()
376 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
378 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
380 return vm86regs->ds; in get_segment_selector()
382 return vm86regs->es; in get_segment_selector()
384 return vm86regs->fs; in get_segment_selector()
386 return vm86regs->gs; in get_segment_selector()
389 return -EINVAL; in get_segment_selector()
395 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
397 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
399 return (unsigned short)(regs->ds & 0xffff); in get_segment_selector()
401 return (unsigned short)(regs->es & 0xffff); in get_segment_selector()
403 return (unsigned short)(regs->fs & 0xffff); in get_segment_selector()
409 return -EINVAL; in get_segment_selector()
444 return -EDOM; in pt_regs_offset()
453 * Don't possibly decode a 32-bit instructions as in get_regno()
454 * reading a 64-bit-only register. in get_regno()
456 if (IS_ENABLED(CONFIG_X86_64) && !insn->x86_64) in get_regno()
457 nr_registers -= 8; in get_regno()
461 regno = X86_MODRM_RM(insn->modrm.value); in get_regno()
464 * ModRM.mod == 0 and ModRM.rm == 5 means a 32-bit displacement in get_regno()
467 if (!X86_MODRM_MOD(insn->modrm.value) && regno == 5) in get_regno()
468 return -EDOM; in get_regno()
470 if (X86_REX_B(insn->rex_prefix.value)) in get_regno()
475 regno = X86_MODRM_REG(insn->modrm.value); in get_regno()
477 if (X86_REX_R(insn->rex_prefix.value)) in get_regno()
482 regno = X86_SIB_INDEX(insn->sib.value); in get_regno()
483 if (X86_REX_X(insn->rex_prefix.value)) in get_regno()
492 if (X86_MODRM_MOD(insn->modrm.value) != 3 && regno == 4) in get_regno()
493 return -EDOM; in get_regno()
497 regno = X86_SIB_BASE(insn->sib.value); in get_regno()
500 * register-indirect addressing is 0. In this case, a in get_regno()
501 * 32-bit displacement follows the SIB byte. in get_regno()
503 if (!X86_MODRM_MOD(insn->modrm.value) && regno == 5) in get_regno()
504 return -EDOM; in get_regno()
506 if (X86_REX_B(insn->rex_prefix.value)) in get_regno()
512 return -EINVAL; in get_regno()
517 return -EINVAL; in get_regno()
534 * get_reg_offset_16() - Obtain offset of register indicated by instruction
541 * in @insn. This function is to be used with 16-bit address encodings. The
544 * referenced by the instruction, the value will be set to -EDOM.
548 * 0 on success, -EINVAL on error.
554 * 16-bit addressing can use one or two registers. Specifics of in get_reg_offset_16()
555 * encodings are given in Table 2-1. "16-Bit Addressing Forms with the in get_reg_offset_16()
574 -EDOM, in get_reg_offset_16()
575 -EDOM, in get_reg_offset_16()
576 -EDOM, in get_reg_offset_16()
577 -EDOM, in get_reg_offset_16()
581 return -EINVAL; in get_reg_offset_16()
584 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_reg_offset_16()
586 *offs2 = -EDOM; in get_reg_offset_16()
590 *offs1 = regoff1[X86_MODRM_RM(insn->modrm.value)]; in get_reg_offset_16()
591 *offs2 = regoff2[X86_MODRM_RM(insn->modrm.value)]; in get_reg_offset_16()
594 * If ModRM.mod is 0 and ModRM.rm is 110b, then we use displacement- in get_reg_offset_16()
600 if ((X86_MODRM_MOD(insn->modrm.value) == 0) && in get_reg_offset_16()
601 (X86_MODRM_RM(insn->modrm.value) == 6)) in get_reg_offset_16()
602 *offs1 = -EDOM; in get_reg_offset_16()
608 * get_desc() - Obtain contents of a segment descriptor
609 * @out: Segment descriptor contents on success
612 * Given a segment selector, obtain a pointer to the segment descriptor.
613 * Both global and local descriptor tables are supported.
621 static bool get_desc(struct desc_struct *out, unsigned short sel) in get_desc()
634 mutex_lock(¤t->active_mm->context.lock); in get_desc()
635 ldt = current->active_mm->context.ldt; in get_desc()
636 if (ldt && sel < ldt->nr_entries) { in get_desc()
637 *out = ldt->entries[sel]; in get_desc()
641 mutex_unlock(¤t->active_mm->context.lock); in get_desc()
650 * multiplied by 8 to obtain the memory offset of the desired descriptor in get_desc()
665 * insn_get_seg_base() - Obtain base address of segment descriptor.
667 * @seg_reg_idx: Index of the segment register pointing to seg descriptor
669 * Obtain the base address of the segment as indicated by the segment descriptor
676 * except when FS or GS are used. In virtual-8086 mode, the segment
679 * -1L in case of error.
684 short sel; in insn_get_seg_base()
688 return -1L; in insn_get_seg_base()
709 * MSR_KERNEL_GS_BASE will have the user-space GS base. in insn_get_seg_base()
723 return -1L; in insn_get_seg_base()
726 return -1L; in insn_get_seg_base()
732 * get_seg_limit() - Obtain the limit of a segment descriptor
734 * @seg_reg_idx: Index of the segment register pointing to seg descriptor
736 * Obtain the limit of the segment as indicated by the segment descriptor
742 * In protected mode, the limit of the segment descriptor in bytes.
743 * In long mode and virtual-8086 mode, segment limits are not enforced. Thus,
744 * limit is returned as -1L to imply a limit-less segment.
752 short sel; in get_seg_limit()
759 return -1L; in get_seg_limit()
781 * insn_get_code_seg_params() - Obtain code segment parameters
787 * descriptor. In virtual-8086 mode, the default is always two bytes for both
792 * An int containing ORed-in default parameters on success.
794 * -EINVAL on error.
799 short sel; in insn_get_code_seg_params()
802 /* Address and operand size are both 16-bit. */ in insn_get_code_seg_params()
810 return -EINVAL; in insn_get_code_seg_params()
813 * The most significant byte of the Type field of the segment descriptor in insn_get_code_seg_params()
818 return -EINVAL; in insn_get_code_seg_params()
823 * both 16-bit. in insn_get_code_seg_params()
828 * both 32-bit. in insn_get_code_seg_params()
832 * IA-32e 64-bit mode. CS.L=1, CS.D=0. Address size is 64-bit; in insn_get_code_seg_params()
833 * operand size is 32-bit. in insn_get_code_seg_params()
839 return -EINVAL; in insn_get_code_seg_params()
844 * insn_get_modrm_rm_off() - Obtain register in r/m part of the ModRM byte
852 * cases, the returned value can be -EDOM to indicate that the particular value
861 * insn_get_modrm_reg_off() - Obtain register in reg part of the ModRM byte
876 * insn_get_modrm_reg_ptr() - Obtain register pointer based on ModRM byte
896 * get_seg_base_limit() - obtain base address and limit of a segment
899 * @regoff: Operand offset, in pt_regs, used to resolve segment descriptor
914 * -EINVAL on error.
923 return -EINVAL; in get_seg_base_limit()
930 if (*base == -1L) in get_seg_base_limit()
931 return -EINVAL; in get_seg_base_limit()
938 return -EINVAL; in get_seg_base_limit()
944 * get_eff_addr_reg() - Obtain effective address from register operand
964 * -EINVAL on error.
975 if (X86_MODRM_MOD(insn->modrm.value) != 3) in get_eff_addr_reg()
976 return -EINVAL; in get_eff_addr_reg()
980 return -EINVAL; in get_eff_addr_reg()
983 if (insn->addr_bytes == 2) in get_eff_addr_reg()
985 else if (insn->addr_bytes == 4) in get_eff_addr_reg()
987 else /* 64-bit address */ in get_eff_addr_reg()
994 * get_eff_addr_modrm() - Obtain referenced effective address via ModRM
1001 * identifying the registers involved in the register-indirect memory reference,
1013 * -EINVAL on error.
1021 if (insn->addr_bytes != 8 && insn->addr_bytes != 4) in get_eff_addr_modrm()
1022 return -EINVAL; in get_eff_addr_modrm()
1028 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_modrm()
1029 return -EINVAL; in get_eff_addr_modrm()
1034 * -EDOM means that we must ignore the address_offset. In such a case, in get_eff_addr_modrm()
1035 * in 64-bit mode the effective address relative to the rIP of the in get_eff_addr_modrm()
1038 if (*regoff == -EDOM) { in get_eff_addr_modrm()
1040 tmp = regs->ip + insn->length; in get_eff_addr_modrm()
1044 return -EINVAL; in get_eff_addr_modrm()
1049 if (insn->addr_bytes == 4) { in get_eff_addr_modrm()
1050 int addr32 = (int)(tmp & 0xffffffff) + insn->displacement.value; in get_eff_addr_modrm()
1054 *eff_addr = tmp + insn->displacement.value; in get_eff_addr_modrm()
1061 * get_eff_addr_modrm_16() - Obtain referenced effective address via ModRM
1067 * Obtain the 16-bit effective address referenced by the ModRM byte of @insn.
1068 * After identifying the registers involved in the register-indirect memory
1080 * -EINVAL on error.
1083 int *regoff, short *eff_addr) in get_eff_addr_modrm_16()
1086 short addr1 = 0, addr2 = 0, displacement; in get_eff_addr_modrm_16()
1088 if (insn->addr_bytes != 2) in get_eff_addr_modrm_16()
1089 return -EINVAL; in get_eff_addr_modrm_16()
1093 if (!insn->modrm.nbytes) in get_eff_addr_modrm_16()
1094 return -EINVAL; in get_eff_addr_modrm_16()
1096 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_modrm_16()
1097 return -EINVAL; in get_eff_addr_modrm_16()
1101 return -EINVAL; in get_eff_addr_modrm_16()
1108 if (addr_offset1 != -EDOM) in get_eff_addr_modrm_16()
1111 if (addr_offset2 != -EDOM) in get_eff_addr_modrm_16()
1114 displacement = insn->displacement.value & 0xffff; in get_eff_addr_modrm_16()
1129 * get_eff_addr_sib() - Obtain referenced effective address via SIB
1136 * identifying the registers involved in the indexed, register-indirect memory
1157 if (insn->addr_bytes != 8 && insn->addr_bytes != 4) in get_eff_addr_sib()
1158 return -EINVAL; in get_eff_addr_sib()
1164 if (!insn->modrm.nbytes) in get_eff_addr_sib()
1165 return -EINVAL; in get_eff_addr_sib()
1167 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_sib()
1168 return -EINVAL; in get_eff_addr_sib()
1174 if (!insn->sib.nbytes) in get_eff_addr_sib()
1175 return -EINVAL; in get_eff_addr_sib()
1182 * decoding the SIB byte. Except -EDOM, which means that the registers in get_eff_addr_sib()
1185 if (*base_offset == -EDOM) in get_eff_addr_sib()
1188 return -EINVAL; in get_eff_addr_sib()
1192 if (indx_offset == -EDOM) in get_eff_addr_sib()
1195 return -EINVAL; in get_eff_addr_sib()
1199 if (insn->addr_bytes == 4) { in get_eff_addr_sib()
1205 addr32 = base32 + idx32 * (1 << X86_SIB_SCALE(insn->sib.value)); in get_eff_addr_sib()
1206 addr32 += insn->displacement.value; in get_eff_addr_sib()
1210 *eff_addr = base + indx * (1 << X86_SIB_SCALE(insn->sib.value)); in get_eff_addr_sib()
1211 *eff_addr += insn->displacement.value; in get_eff_addr_sib()
1218 * get_addr_ref_16() - Obtain the 16-bit address referred by instruction
1222 * This function is to be used with 16-bit address encodings. Obtain the memory
1232 * -1L on error.
1236 unsigned long linear_addr = -1L, seg_base, seg_limit; in get_addr_ref_16()
1238 short eff_addr; in get_addr_ref_16()
1244 if (insn->addr_bytes != 2) in get_addr_ref_16()
1247 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_16()
1265 * is within the limits of the segment. In virtual-8086 mode, segment in get_addr_ref_16()
1266 * limits are not enforced. In such a case, the segment limit is -1L to in get_addr_ref_16()
1283 * get_addr_ref_32() - Obtain a 32-bit linear address
1287 * This function is to be used with 32-bit address encodings to obtain the
1296 * -1L on error.
1300 unsigned long linear_addr = -1L, seg_base, seg_limit; in get_addr_ref_32()
1305 if (insn->addr_bytes != 4) in get_addr_ref_32()
1308 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_32()
1316 if (insn->sib.nbytes) { in get_addr_ref_32()
1338 * 32-bit addresses can be used in long and virtual-8086 modes if an in get_addr_ref_32()
1340 * not enforced. When in virtual-8086 mode, the segment limit is -1L in get_addr_ref_32()
1350 * Even though 32-bit address encodings are allowed in virtual-8086 in get_addr_ref_32()
1351 * mode, the address range is still limited to [0x-0xffff]. in get_addr_ref_32()
1357 * Data type long could be 64 bits in size. Ensure that our 32-bit in get_addr_ref_32()
1358 * effective address is not sign-extended when computing the linear in get_addr_ref_32()
1372 * get_addr_ref_64() - Obtain a 64-bit linear address
1376 * This function is to be used with 64-bit address encodings to obtain the
1384 * -1L on error.
1389 return (void __user *)-1L; in get_addr_ref_64()
1394 unsigned long linear_addr = -1L, seg_base; in get_addr_ref_64()
1398 if (insn->addr_bytes != 8) in get_addr_ref_64()
1401 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_64()
1407 if (insn->sib.nbytes) { in get_addr_ref_64()
1431 * insn_get_addr_ref() - Obtain the linear address referred by instruction
1443 * -1L on error.
1448 return (void __user *)-1L; in insn_get_addr_ref()
1451 return (void __user *)-1L; in insn_get_addr_ref()
1453 switch (insn->addr_bytes) { in insn_get_addr_ref()
1461 return (void __user *)-1L; in insn_get_addr_ref()
1470 * If not in user-space long mode, a custom code segment could be in in insn_get_effective_ip()
1472 * descriptor table), or virtual-8086 mode. In most of the cases in insn_get_effective_ip()
1477 if (seg_base == -1L) in insn_get_effective_ip()
1478 return -EINVAL; in insn_get_effective_ip()
1481 *ip = seg_base + regs->ip; in insn_get_effective_ip()
1487 * insn_fetch_from_user() - Copy instruction bytes from user-space memory
1496 * - number of instruction bytes copied.
1497 * - 0 if nothing was copied.
1498 * - -EINVAL if the linear address of the instruction could not be calculated
1506 return -EINVAL; in insn_fetch_from_user()
1510 return MAX_INSN_SIZE - not_copied; in insn_fetch_from_user()
1514 * insn_fetch_from_user_inatomic() - Copy instruction bytes from user-space memory
1524 * - number of instruction bytes copied.
1525 * - 0 if nothing was copied.
1526 * - -EINVAL if the linear address of the instruction could not be calculated.
1534 return -EINVAL; in insn_fetch_from_user_inatomic()
1538 return MAX_INSN_SIZE - not_copied; in insn_fetch_from_user_inatomic()
1542 * insn_decode_from_regs() - Decode an instruction
1564 * in the code segment descriptor. The instruction decoder only sets in insn_decode_from_regs()
1567 * have special cases where, for instance, a 16-bit code segment in insn_decode_from_regs()
1568 * descriptor is used. in insn_decode_from_regs()
1570 * correctly updates these values, even for 16-bit defaults. in insn_decode_from_regs()
1573 if (seg_defs == -EINVAL) in insn_decode_from_regs()
1576 insn->addr_bytes = INSN_CODE_SEG_ADDR_SZ(seg_defs); in insn_decode_from_regs()
1577 insn->opnd_bytes = INSN_CODE_SEG_OPND_SZ(seg_defs); in insn_decode_from_regs()
1582 if (buf_size < insn->length) in insn_decode_from_regs()
1589 * insn_decode_mmio() - Decode a MMIO instruction
1593 * Decodes instruction that used for Memory-mapped I/O.
1609 switch (insn->opcode.bytes[0]) { in insn_decode_mmio()
1615 *bytes = insn->opnd_bytes; in insn_decode_mmio()
1624 *bytes = insn->opnd_bytes; in insn_decode_mmio()
1633 *bytes = insn->opnd_bytes; in insn_decode_mmio()
1642 *bytes = insn->opnd_bytes; in insn_decode_mmio()
1646 case 0x0f: /* Two-byte instruction */ in insn_decode_mmio()
1647 switch (insn->opcode.bytes[1]) { in insn_decode_mmio()