Rneri/umip

meta-luv/classes/luv-efi.bbclass

@@ -42,7 +42,7 @@ def extra_initrd(d):
 
     target = d.getVar('TARGET_ARCH', True)
     if re.search('86', target):
-        return '/boot/bitsrd'
+        return ''
     else:
         return ''
 
@@ -85,9 +85,10 @@ efi_populate() {
 		install -m 0644 ${DEPLOY_DIR_IMAGE}/${EFI_LOADER_IMAGE} ${DEST}${EFIDIR}
     fi
 
-    if echo "${TARGET_ARCH}" | grep -q "i.86" || [ "${TARGET_ARCH}" = "x86_64" ]; then
-        efi_populate_bits ${DEST}
-    fi
+    # TODO: only populate bits if present in features
+    #if echo "${TARGET_ARCH}" | grep -q "i.86" || [ "${TARGET_ARCH}" = "x86_64" ]; then
+    #    efi_populate_bits ${DEST}
+    #fi
 
     # Install splash and grub.cfg files into EFI directory.
     install -m 0644 ${GRUBCFG} ${DEST}${EFIDIR}

meta-luv/recipes-core/images/core-image-efi-initramfs.bb

@@ -3,19 +3,18 @@ DESCRIPTION = "Small image capable of booting a device and running the suite of
 EFI tests."
 
 IMAGE_INSTALL = "\
-    base-files base-passwd netbase udev systemd luv-test-manager \
-    luv-test-crash luv-test-netconsole luv-test keymaps \
-    kernel-image fwts bash coreutils gawk grep util-linux-agetty \
-    util-linux-mount util-linux-umount kmod sed tar net-tools \
-    shadow util-linux procps efivarfs-test \
-    plymouth plymouth-set-default-theme kernel-efi-warnings linux-firmware kexec \
+    base-files base-passwd udev systemd \
+    keymaps \
+    kernel-image bash coreutils grep util-linux-agetty \
+    util-linux-mount util-linux-umount kmod \
+    shadow util-linux procps \
+    plymouth plymouth-set-default-theme \
     "
 
-X86_ADDITIONS = "chipsec python-codecs python-subprocess vmcore-dmesg bits \
-                 kernel-modules telemetrics"
+X86_ADDITIONS = ""
 
-IMAGE_INSTALL_append_qemux86 = "${X86_ADDITIONS}"
-IMAGE_INSTALL_append_qemux86-64 = "${X86_ADDITIONS} ndctl"
+IMAGE_INSTALL_append_qemux86 = "${X86_ADDITIONS} vm86-test umip-tests"
+IMAGE_INSTALL_append_qemux86-64 = "${X86_ADDITIONS} umip-tests lib32-umip-tests"
 
 export IMAGE_BASENAME = "core-image-efi-initramfs"
 

meta-luv/recipes-core/umip/files/Makefile

@@ -0,0 +1,92 @@
+cpuid: CFLAGS += -fno-omit-frame-pointer
+cpuid:
+	$(CC) $(CFLAGS) -o umip_cpuid cpuid.c
+
+x86_64_minimal: CFLAGS += -fno-omit-frame-pointer
+x86_64_minimal:
+	$(CC) $(CFLAGS) -c umip_utils.c -o umip_utils_64.o
+
+	$(CC) $(CFLAGS) -o umip_test_opnds_64 umip_utils_64.o umip_test_opnds.c
+	$(CC) $(CFLAGS) -o umip_test_basic_64 umip_utils_64.o umip_test_basic.c
+	$(CC) $(CFLAGS) -o umip_exceptions_64 umip_utils_64.o umip_exceptions.c
+
+	python umip_test_gen_64.py
+	$(CC) $(CFLAGS) -c test_umip_ldt_64.c
+	$(CC) $(CFLAGS) -c umip_ldt_64.c
+	$(CC) $(CFLAGS) -o umip_ldt_64 test_umip_ldt_64.o umip_ldt_64.o umip_utils_64.o
+
+x86_64_emul_all: CFLAGS += -DEMULATE_ALL -fno-omit-frame-pointer
+x86_64_emul_all: x86_64_minimal
+	$(CC) $(CFLAGS) -c umip_utils.c -o umip_utils_64.o
+
+	$(CC) $(CFLAGS) -o umip_test_opnds_64_emul_all umip_utils_64.o umip_test_opnds.c
+	$(CC) $(CFLAGS) -o umip_test_basic_64_emul_all umip_utils_64.o umip_test_basic.c
+	$(CC) $(CFLAGS) -o umip_exceptions_64_emul_all umip_utils_64.o umip_exceptions.c
+
+	python umip_test_gen_64.py --emulate-all
+	$(CC) $(CFLAGS) -c test_umip_ldt_64.c
+	$(CC) $(CFLAGS) -c umip_ldt_64.c
+	$(CC) $(CFLAGS) -o umip_ldt_64_emul_all test_umip_ldt_64.o umip_ldt_64.o umip_utils_64.o
+
+x86_64: x86_64_minimal x86_64_emul_all cpuid
+
+i686_minimal: CFLAGS += -fno-omit-frame-pointer -m32
+i686_minimal:
+	$(CC) $(CFLAGS) -c umip_utils.c -o umip_utils_32.o
+
+	$(CC) $(CFLAGS) -o umip_test_opnds_32 umip_utils_32.o umip_test_opnds.c
+	$(CC) $(CFLAGS) -o umip_test_basic_32 umip_utils_32.o umip_test_basic.c
+	$(CC) $(CFLAGS) -o umip_exceptions_32 umip_utils_32.o umip_exceptions.c
+
+	python umip_test_gen_32.py
+	$(CC) $(CFLAGS) -c test_umip_ldt_32.c
+	$(CC) $(CFLAGS) -c umip_ldt_32.c
+	$(CC) $(CFLAGS) -o umip_ldt_32 test_umip_ldt_32.o umip_ldt_32.o umip_utils_32.o
+
+	python umip_test_gen_16.py
+	$(CC) $(CFLAGS) -c test_umip_ldt_16.c
+	$(CC) $(CFLAGS) -c umip_ldt_16.c
+	$(CC) $(CFLAGS) -o umip_ldt_16 test_umip_ldt_16.o umip_ldt_16.o umip_utils_32.o
+
+i686_emul_all: CFLAGS += -DEMULATE_ALL -fno-omit-frame-pointer -m32
+i686_emul_all: i686_minimal
+	$(CC) $(CFLAGS) -c umip_utils.c -o umip_utils_32.o
+
+	$(CC) $(CFLAGS) -o umip_test_opnds_32_emul_all umip_utils_32.o umip_test_opnds.c
+	$(CC) $(CFLAGS) -o umip_test_basic_32_emul_all umip_utils_32.o umip_test_basic.c
+	$(CC) $(CFLAGS) -o umip_exceptions_32_emul_all umip_utils_32.o umip_exceptions.c
+
+	python umip_test_gen_32.py --emulate-all
+	$(CC) $(CFLAGS) -c test_umip_ldt_32.c
+	$(CC) $(CFLAGS) -c umip_ldt_32.c
+	$(CC) $(CFLAGS) -o umip_ldt_32_emul_all test_umip_ldt_32.o umip_ldt_32.o umip_utils_32.o
+
+	python umip_test_gen_16.py --emulate-all
+	$(CC) $(CFLAGS) -c test_umip_ldt_16.c
+	$(CC) $(CFLAGS) -c umip_ldt_16.c
+	$(CC) $(CFLAGS) -o umip_ldt_16_emul_all test_umip_ldt_16.o umip_ldt_16.o umip_utils_32.o
+
+i686: i686_minimal i686_emul_all cpuid
+i586: i686
+
+.PHONY: clean
+clean:
+	rm -f *.o
+	rm -f umip_test_basic_64
+	rm -f umip_test_basic_64_emul_all
+	rm -f umip_test_basic_32
+	rm -f umip_test_basic_32_emul_all
+	rm -f umip_test_opnds_64
+	rm -f umip_test_opnds_64_emul_all
+	rm -f umip_test_opnds_32
+	rm -f umip_test_opnds_32_emul_all
+	rm -f umip_exceptions_64
+	rm -f umip_exceptions_64_emul_all
+	rm -f umip_exceptions_32
+	rm -f umip_exceptions_32_emul_all
+	rm -f umip_ldt_64
+	rm -f umip_ldt_64_emul_all
+	rm -f umip_ldt_32
+	rm -f umip_ldt_32_emul_all
+	rm -f umip_ldt_16
+	rm -f umip_ldt_16_emul_all

meta-luv/recipes-core/umip/files/UMIP_README

@@ -0,0 +1,192 @@
+              A QUICK GUIDE FOR UMIP TESTING
+
+Contents
+
+  I. For the impatient
+ II. What is UMIP and how is supported in the Linux kernel?
+III. Testing UMIP
+     a) Overview
+     b) Testing full emulation
+     c) Testing 64-bit processes
+     d) Testing 32-bit processes
+     e) Testing output format
+     f) The test programs
+     g) Things to do
+
+       ============================================================
+I. For the impatient
+
+If all you have is 10 seconds, all you need to know is this:
+
+Assuming you have a 64-bit distro install, here is what you need to do:
+
+   1. If in Ubuntu:
+      $ sudo apt-get install ia32-libs
+      If in other distros, not sure; a similar package
+   2. $ make x86_64
+   3. $ CFLAGS=-m32 make i586
+   4. $ umip_test_basic_64
+   5. $ umip_test_basic_32
+   6. $ umip_test_opnds_64
+   7. $ umip_test_opnds_32
+   8. $ umip_exceptions_64
+   9. $ umip_exceptions_32
+  10. $ umip_ldt_64
+  11. $ umip_ldt_32
+  12. $ umip_ldt_16
+
+For each of the steps 4 through 12, look for this output
+
+  RESULTS: passed[X], failed[0], errors[0].
+
+You should have 0 failures and 0 errors.
+
+You are done.
+
+       ============================================================
+II. What is UMIP and how is supported in the Linux kernel?
+
+User-mode Instruction Prevention, UMIP is a feature present in new Intel
+processors that prevents the execution of the instructions SGDT, SIDT, SLDT,
+SMSW and STR while running in CLP>0. In such a case, a general protection fault
+exception is issued.
+
+Functionality has been put in the kernel to trap this general protection fault
+exception. When this happens, the kernel provides to the caller dummy values
+as the result for these instructions. However, emulation is not done in every
+case. It is done only for 32-bit processes and only for the instructions SGDT,
+SIDT and SMSW. For 64-bit processes no emulation is provideded. The instructions
+STR and SLDT are not emulated in any case.
+
+However, the Linux kernel can be patched to provide emulation in all cases.
+
+       ============================================================
+III. Testing UMIP
+
+a) == Overview ===
+
+I have written several programs to test the behavior described above. Each
+program can be built for 32-bit and 64-bit processes. The makefile builds both
+versions and adds _32 or _64 suffixes to the executable test programs.
+
+b) == Achieving emulation for everything
+
+Also, each program can be built to test emulation for all the instructions in
+both 64 and 32-bits and for all the instructions. The makefile achieves this by
+adding -DEMULATE_ALL to the CFLAGS; the python scripts that generate code are
+run with the option --emulate-all. Test programs built with this configuration
+are added the suffix _emul_all.
+
+Hence, the naming convention for the test programs is:
+
+    test_program_32/64_[emul_all]
+
+c) == Testing 64-bit processes
+
+The makefile can the test programs for all these configurations.
+
+To build the 64-bit test programs you can do
+
+    $ make x86_64
+
+This will build the programs umip_test_basic, umip_test_opnds, umip_exceptions,
+and umip_ldt_64; see section III.a) for the relevant naming convention.
+
+In its default version, these programs will verify a general protection fault
+is seen when executing the UMIP-protected instructions. In the _emul_all
+version, programs will verify that emulation is successful and no exceptions are
+generated in the process (please see the umip_exceptions special case below).
+
+Both the default and _emul_all versions are built with the aforementioned
+command.
+
+d) == Testing 32-bit processes
+
+In a 64-bit distro, you will need to install the 32-bit compatibility libraries.
+In Ubuntu, this is done with:
+
+    $ sudo apt-get install ia32-libs
+
+In other distros, a similar procedure can be followed.
+
+Then, the 32-bit test programs can be built as:
+
+    $ CFLAGS=-m32 make i586
+
+This will build the programs umip_test_basic, umip_test_opnds, umip_exceptions,
+umip_ldt_32, and umip_ldt_16; see section III.a) for the relevant naming
+convention.
+
+In its default version, these programs will verify that emulation is successful
+for the instructions SGDT, SIDT and SMSW. They will also verify that a general
+proctection fault is seen for the instructions SLDT and STR.
+
+Both the default and _emul_all versions are built with the aforementioned
+commans.
+
+e) == The testing output format
+
+Test programs use the following output format
+
+[info] To print information about a test case.
+[pass] To inform that a test case passed.
+[FAIL] To inform that a test case failed.
+
+RESULTS: passed[X], failed[Y], error[Z]
+
+Ideally, you should see all test case passed. This means that you should see
+0 failures and 0 errors.
+
+f) The test programs
+
+Refer to section III.a) for the naming convention.
+
+* umip_est_basic. Use umip_test for a very basic test that exercises the
+  instructions smsw, str, sidt, sldt and sgdt from protected mode using the
+  global descriptortable.
+
+* umip_test_opnds. Use umip_test_opnds for a collection of tests that
+  exercises the instructions str, sldt and smsw for register and memory
+  operands. For registers, operand sizes are of 16 and 32 bits. Memory operands
+  are always 16-bits long. Addresses in these tests are computed using only the
+  ModRM  byte. Also, these tests use the normal __USER_DS segment with a base
+  address of zero.
+
+* umip_exceptions. Use umip_exceptions that the emulation code issues the
+  exceptions for each of the UMIP-instructions as described in the Intel
+  Software Development Manual. Priority of the exceptions should be that
+  mentioned in the Volume 3, Section 16.9 of the aforementioned manual. That is,
+  for instance, if the instructions can lead to a general protection fault
+  exception and an illegal operand exception, verify that the latter is seen.
+
+* umip_ldt_64. Use umip_ldt_64 to verify all the possible 64-bit address
+  encodings in the UMIP-protected instructions. This includes all the ModRM,
+  and SiB displacement combinations. Furthermore, this test configures a Local
+  Descriptor Table whose segments have base addresses that are different from
+  the __USER_DS segment. Since this program runs in long mode, segmentation is
+  implemented using the FS and GS registers. The purpose of this test is to
+  verify that the emulation code is capable of succesfully computing linear
+  address out of the instruction operand and segment descriptor.
+
+* umip_ldt_32. Use umip_ldt_32 to verify all the possible 32-bit address
+  encodings in the UMIP-protected instructions. This includes all the ModRM,
+  and SiB displacement combinations. Furthermore, this test configures a Local
+  Descriptor Table whose segments have base addresses that are different from
+  the __USER_DS segment. The purpose of this test is to verify that the
+  emulation code is capable of succesfully computing linear address out of the
+  instruction operand and segment descriptor.
+
+* umip_ldt_16. Use umip_ldt_16 to verify all the possible 16-bit address
+  encodings in the UMIP-protected instructions. This includes all the ModRM and
+  displacement combinations. Furthermore, this test configure a Local Descriptor
+  Table with segments that have base addresses different than the __USER_DS
+  segment. Also, the code segment is configured for 16-bit addresses. The
+  purpose of this test is to verify that the emulation code is capable of
+  succesfully computing linear address out of the instruction operand and
+  segment descriptor.
+
+g) Things to do
+
+* In umip_ldt_64, test %rsp and %r12
+* Add tests for address size override prefixes
+* Add test to include more than one segment override prefix

meta-luv/recipes-core/umip/files/cpuid.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define UMIP_MASK 0x4
+
+void usage(void)
+{
+	printf("Usage:\n");
+	printf("cpuid [eax] [ecx]\n");
+	printf("Example:\n");
+	printf("cpuid 0x4 0x0\n");
+}
+
+void print_umip(unsigned int ecx)
+{
+	printf("CPU has UMIP? %s\n", ecx & UMIP_MASK ? "yes" : "no");
+}
+
+void get_cpuid_leaf(unsigned int eax, unsigned int ecx, unsigned int *new_eax,
+		    unsigned int *new_ecx, unsigned *new_edx)
+{
+	printf("Getting CPUID leaf for eax=0x%x ecx=0x%x\n", eax, ecx);
+
+	asm volatile("mov %3, %%eax\n"
+		     "mov %4, %%ecx\n"
+		     "cpuid\n"
+		     "mov %%eax, %0\n"
+		     "mov %%ecx, %1\n"
+		     "mov %%edx, %2\n"
+		     : "=m"(*new_eax), "=m"(*new_ecx), "=m"(*new_edx)
+		     : "m"(eax), "m"(ecx)
+		     : "eax", "ecx", "edx");
+}
+
+int main(int argc, char **argv)
+{
+	unsigned int eax, ecx, edx;
+	unsigned int new_eax = 0xabababab, new_ecx = 0xcbcbcbcb;
+	unsigned int new_edx = 0xefefefef;
+
+	if (argc != 3) {
+		usage();
+		return 1;
+	}
+
+	eax = strtoul(argv[1], NULL, 0);
+	ecx = strtoul(argv[2], NULL, 0);
+
+	get_cpuid_leaf(eax, ecx, &new_eax, &new_ecx, &new_edx);
+
+        printf("CPUID Result:\n");
+        printf("eax = 0x%x\n", new_eax);
+        printf("ecx = 0x%x\n", new_ecx);
+        printf("edx = 0x%x\n", new_edx);
+
+	print_umip(new_ecx);
+}