proc_access.h

Go to the documentation of this file.

 
#pragma once
 
#include "stdint.h"
 
#define CR0_PE 0x00000001u 
#define CR0_MP 0x00000002u 
#define CR0_EM 0x00000004u 
#define CR0_TS 0x00000008u 
#define CR0_ET 0x00000010u 
#define CR0_PG 0x80000000u 
 
#define CR4_SEE      0x00008000u 
#define CR4_SMAP     0x00200000u 
#define CR4_SMEP     0x00100000u 
#define CR4_OSXSAVE  0x00040000u 
#define CR4_PCIDE    0x00020000u 
#define CR4_RDWRFSGS 0x00010000u 
#define CR4_SMXE     0x00004000u 
#define CR4_VMXE     0x00002000u 
#define CR4_OSXMM    0x00000400u 
#define CR4_OSFXS    0x00000200u 
#define CR4_PCE      0x00000100u 
#define CR4_PGE      0x00000080u 
#define CR4_MCE      0x00000040u 
#define CR4_PAE      0x00000020u 
#define CR4_PSE      0x00000010u 
#define CR4_DE       0x00000008u 
#define CR4_TSD      0x00000004u 
#define CR4_PVI      0x00000002u 
#define CR4_VME      0x00000001u 
 
static inline uint16_t get_es(void)
{
    uint16_t es;
    __asm__ __volatile__("mov %%es, %0"
                         : "=r"(es));
    return es;
}
 
static inline void set_es(uint16_t es)
{
    __asm__ __volatile__("mov %0, %%es"
                         :
                         : "r"(es));
}
 
static inline uint16_t get_ds(void)
{
    uint16_t ds;
    __asm__ __volatile__("mov %%ds, %0"
                         : "=r"(ds));
    return ds;
}
 
static inline void set_ds(uint16_t ds)
{
    __asm__ __volatile__("mov %0, %%ds"
                         :
                         : "r"(ds));
}
 
static inline uint16_t get_fs(void)
{
    uint16_t fs;
    __asm__ __volatile__("mov %%fs, %0"
                         : "=r"(fs));
    return fs;
}
 
static inline void set_fs(uint16_t fs)
{
    __asm__ __volatile__("mov %0, %%fs"
                         :
                         : "r"(fs));
}
 
static inline uint16_t get_gs(void)
{
    uint16_t gs;
    __asm__ __volatile__("mov %%gs, %0"
                         : "=r"(gs));
    return gs;
}
 
static inline void set_gs(uint16_t gs)
{
    __asm__ __volatile__("mov %0, %%gs"
                         :
                         : "r"(gs));
}
 
static inline uint16_t get_ss(void)
{
    uint16_t ss;
    __asm__ __volatile__("mov %%ss, %0"
                         : "=r"(ss));
    return ss;
}
 
static inline void set_ss(uint16_t ss)
{
    __asm__ __volatile__("mov %0, %%ss"
                         :
                         : "r"(ss));
}
 
static inline uintptr_t get_cr0(void)
{
    uintptr_t cr0;
    __asm__ __volatile__("mov %%cr0, %0"
                         : "=r"(cr0));
    return (cr0);
}
 
static inline void set_cr0(uintptr_t cr0)
{
    __asm__ __volatile__("mov %0, %%cr0"
                         :
                         : "r"(cr0));
}
 
 
static inline uintptr_t get_cr2(void)
{
    uintptr_t cr2;
    __asm__ __volatile__("mov %%cr2, %0"
                         : "=r"(cr2));
    return (cr2);
}
 
static inline void set_cr2(uintptr_t cr2)
{
    __asm__ __volatile__("mov %0, %%cr2"
                         :
                         : "r"(cr2));
}
 
static inline uintptr_t get_cr3(void)
{
    uintptr_t cr3;
    __asm__ __volatile__("mov %%cr3, %0"
                         : "=r"(cr3));
    return (cr3);
}
 
static inline void set_cr3(uintptr_t cr3)
{
    __asm__ __volatile__("mov %0, %%cr3"
                         :
                         : "r"(cr3));
}
 
static inline uintptr_t get_cr4(void)
{
    uintptr_t cr4;
    __asm__ __volatile__("mov %%cr4, %0"
                         : "=r"(cr4));
    return (cr4);
}
 
static inline void set_cr4(uintptr_t cr4)
{
    __asm__ __volatile__("mov %0, %%cr4"
                         :
                         : "r"(cr4)
                         : "memory");
}
 
static inline uintptr_t get_eflags(void)
{
    uintptr_t eflags;
    // "=rm" is safe here, because "pop" adjusts the stack before
    // it evaluates its effective address -- this is part of the
    // documented behavior of the "pop" instruction.
    __asm__ __volatile__("pushf; pop %0"
                         : "=rm"(eflags)
                         : // no input
                         : "memory");
    return eflags;
}
 
static inline void clear_ts(void)
{
    __asm__ __volatile__("clts");
}
 
static inline unsigned short get_tr(void)
{
    unsigned short seg;
    __asm__ __volatile__("str %0"
                         : "=rm"(seg));
    return (seg);
}
 
static inline void set_tr(unsigned short seg)
{
    __asm__ __volatile__("ltr %0"
                         :
                         : "rm"(seg));
}
 
static inline unsigned short sldt(void)
{
    unsigned short seg;
    __asm__ __volatile__("sldt %0"
                         : "=rm"(seg));
    return (seg);
}
 
static inline void lldt(unsigned short seg)
{
    __asm__ __volatile__("lldt %0"
                         :
                         : "rm"(seg));
}
 
static inline void lgdt(uintptr_t *desc)
{
    __asm__ __volatile__("lgdt %0"
                         :
                         : "m"(*desc));
}
 
static inline void lidt(uintptr_t *desc)
{
    __asm__ __volatile__("lidt %0"
                         :
                         : "m"(*desc));
}
 
static inline void sti(void)
{
    __asm__ __volatile__("sti"
                         :
                         :
                         : "memory");
}
 
static inline void cli(void)
{
    __asm__ __volatile__("cli"
                         :
                         :
                         : "memory");
}
 
static inline void swapgs(void)
{
    __asm__ __volatile__("swapgs");
}
 
static inline void hlt(void)
{
    __asm__ __volatile__("hlt");
}
 
static inline void pause(void)
{
    __asm__ __volatile__("pause");
}
 
// == Memory clobbers =========================================================
// Memory clobber implies a fence, and it also impacts how the compiler treats
// potential data aliases. A memory clobber says that the asm block modifies
// memory that is not otherwise mentioned in the asm instructions.
// So, for example, a correct use of memory clobbers would be when using an
// instruction that clears a cache line. The compiler will assume that
// virtually any data may be aliased with the memory changed by that
// instruction. As a result, all required data used after the asm block
// will be reloaded from memory after the asm completes. This is much more
// expensive than the simple fence implied by the "volatile" attribute.
 
// == Volatile Block ==========================================================
// Making an inline asm block "volatile" as in this example, ensures that,
// as it optimizes, the compiler does not move any instructions above or
// below the block of asm statements.
//  __asm__ __volatile__("  addic. %0,%1,%2\n" : "=r"(res): "=r"(a),"r"(a))
// This can be particularly important in cases when the code is accessing
// shared memory.