How to access the control registers cr0,cr2,cr3 from a program? Getting segmentation fault

by

Quoting from Intel® 64 and IA-32 Architectures Software Developer Manuals 3-650 Vol. 2A
 on moving to and from control registers:

This instruction can be executed only when the current privilege level is 0.

Which means the instruction can only be executed in kernel mode.

A minimal kernel module, that logs the contents of cr0, cr2 and cr3 could look something like this (32-bit code path untested):

/* hello.c */
#include <linux/module.h>
#include <linux/kernel.h>

int init_module(void)
{
#ifdef __x86_64__
    u64 cr0, cr2, cr3;
    __asm__ __volatile__ (
        "mov %%cr0, %%rax\n\t"
        "mov %%eax, %0\n\t"
        "mov %%cr2, %%rax\n\t"
        "mov %%eax, %1\n\t"
        "mov %%cr3, %%rax\n\t"
        "mov %%eax, %2\n\t"
    : "=m" (cr0), "=m" (cr2), "=m" (cr3)
    : /* no input */
    : "%rax"
    );
#elif defined(__i386__)
    u32 cr0, cr2, cr3;
    __asm__ __volatile__ (
        "mov %%cr0, %%eax\n\t"
        "mov %%eax, %0\n\t"
        "mov %%cr2, %%eax\n\t"
        "mov %%eax, %1\n\t"
        "mov %%cr3, %%eax\n\t"
        "mov %%eax, %2\n\t"
    : "=m" (cr0), "=m" (cr2), "=m" (cr3)
    : /* no input */
    : "%eax"
    );
#endif
    printk(KERN_INFO "cr0 = 0x%8.8X\n", cr0);
    printk(KERN_INFO "cr2 = 0x%8.8X\n", cr2);
    printk(KERN_INFO "cr3 = 0x%8.8X\n", cr3);
    return 0;
}

void cleanup_module(void)
{
}

 

# Makefile

obj-m += hello.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

test: all
    sudo insmod ./hello.ko
    sudo rmmod hello
    dmesg | tail

More Related Contents:

  1. Why can’t you set the instruction pointer directly?
  2. x86 registers: MBR/MDR and instruction registers
  3. Assembly code fsqrt and fmul instructions
  4. Why do x86-64 instructions on 32-bit registers zero the upper part of the full 64-bit register?
  5. Using base pointer register in C++ inline asm
  6. Are loads and stores the only instructions that gets reordered?
  7. Which cache mapping technique is used in intel core i7 processor?
  8. How does x86 paging work?
  9. is there an inverse instruction to the movemask instruction in intel avx2?
  10. How can I accurately benchmark unaligned access speed on x86_64?
  11. What exactly happens when a skylake CPU mispredicts a branch?
  12. x86 assembler: floating point compare
  13. Why do Compilers put data inside .text(code) section of the PE and ELF files and how does the CPU distinguish between data and code?
  14. If I don’t use fences, how long could it take a core to see another core’s writes?
  15. int 13h 42h doesn’t load anything in Bochs
  16. How to determine if the registers are loaded right to left or vice versa
  17. x86 Calculating AX given AH and AL?
  18. How to set gcc or clang to use Intel syntax permanently for inline asm() statements?
  19. Inline assembly that clobbers the red zone
  20. Fastest way to unpack 32 bits to a 32 byte SIMD vector
  21. Why are x86 registers named the way they are?
  22. What is the default register state when program launches (asm, linux)?
  23. Is there hardware support for 128bit integers in modern processors?
  24. Load address calculation when using AVX2 gather instructions
  25. What is the purpose of segment registers in x86 protected mode?
  26. Why can I access lower dword/word/byte in a register but not higher?
  27. Why did Intel change the static branch prediction mechanism over these years?
  28. Counting machine instructions using gdb
  29. What specifically marks an x86 cache line as dirty – any write, or is an explicit change required?
  30. Are two store buffer entries needed for split line/page stores on recent Intel?

Leave a Comment