desc.h

Go to the documentation of this file.

 
#ifndef XTF_X86_DESC_H
#define XTF_X86_DESC_H
 
#include <xtf/types.h>
#include <xtf/compiler.h>
 
#include <arch/x86-gate.h>
#include <arch/x86-tss.h>
 
#include <arch/segment.h>
 
struct __packed seg_desc32 {
    union {
        struct {
            uint32_t lo, hi;
        };
        struct {
            uint16_t limit0;
            uint16_t base0;
            uint8_t  base1;
            union {
                struct __packed {
                    unsigned int type:4;
 
                    bool s:1;
                    unsigned int dpl:2;
                    bool p:1;
 
                    unsigned int limit1:4;
 
                    bool avl:1, :1, :1, g:1;
                };
                struct __packed {
                    bool a:1, r:1, c:1, x:1;
                    unsigned int :4, :4;
                    bool :1, l:1, d:1, :1;
                };
                struct __packed {
                    bool :1, w:1, e:1, :1;
                    unsigned int :4, :4;
                    bool :1, :1, b:1, :1;
                };
            };
            uint8_t base2;
        };
        /* Full width backing integer. */
        uint64_t raw;
    };
};
 
/* GDT/LDT attribute flags for user segments */
 
/* Common */
#define SEG_ATTR_G      0x8000 
#define SEG_ATTR_AVL    0x1000 
#define SEG_ATTR_P      0x0080 
#define SEG_ATTR_S      0x0010 
#define SEG_ATTR_A      0x0001 
#define SEG_ATTR_COMMON 0x8091 
#define SEG_ATTR_DPL0   0x0000 
#define SEG_ATTR_DPL1   0x0020 
#define SEG_ATTR_DPL2   0x0040 
#define SEG_ATTR_DPL3   0x0060 
#define SEG_ATTR_CODE   0x0008 
#define SEG_ATTR_DATA   0x0000 
/* Code segments */
#define SEG_ATTR_D      0x4000 
#define SEG_ATTR_L      0x2000 
#define SEG_ATTR_C      0x0004 
#define SEG_ATTR_R      0x0002 
/* Data segments */
#define SEG_ATTR_B      0x4000 
#define SEG_ATTR_E      0x0004 
#define SEG_ATTR_W      0x0002 
#define INIT_GDTE(base, limit, attr) { { {                            \
     .lo = (((base) & 0xffff) << 16) | ((limit) & 0xffff),            \
     .hi = ((base) & 0xff000000) | ((limit) & 0xf0000) |              \
           (((attr) & 0xf0ff) << 8) | (((base) & 0xff0000) >> 16)     \
     } } }
 
#define GDTE(base, limit, attr) ((user_desc)INIT_GDTE(base, limit, attr))
 
struct __packed desc_ptr64 {
    uint16_t limit;
    uint64_t base;
};
 
struct __packed far_ptr64 {
    union {
        uint64_t offset_intel;
        struct {
            uint32_t :32;
            uint32_t offset_amd;
        };
    };
    uint16_t selector;
};
 
struct __packed desc_ptr32 {
    uint16_t limit;
    uint32_t base;
};
 
struct __packed far_ptr32 {
    uint32_t offset;
    uint16_t selector;
};
 
#if defined(__x86_64__)
 
typedef struct desc_ptr64 desc_ptr;
typedef struct seg_desc32 user_desc;
typedef struct seg_gate64 gate_desc;
typedef struct far_ptr64  far_ptr;
 
#elif defined(__i386__)
 
typedef struct desc_ptr32 desc_ptr;
typedef struct seg_desc32 user_desc;
typedef struct seg_gate32 gate_desc;
typedef struct far_ptr32  far_ptr;
 
#else
# error Bad architecture for descriptor infrastructure
#endif
 
extern user_desc gdt[NR_GDT_ENTRIES];
extern desc_ptr  gdt_ptr;
 
#if defined(CONFIG_HVM)
extern env_gate idt[256];
extern desc_ptr  idt_ptr;
 
extern env_tss tss;
#endif
 
static inline unsigned long user_desc_base(const user_desc *d)
{
    unsigned long base = (d->base0 |
                          ((unsigned long)d->base1) << 16 |
                          ((unsigned long)d->base2) << 24 );
#ifdef __x86_64__
    /* Long mode system segments use adjacent slot. */
    if ( !d->s )
        base |= ((unsigned long)d[1].lo) << 32;
#endif
 
    return base;
}
 
static inline unsigned int user_desc_limit(const user_desc *d)
{
    unsigned int limit = (d->limit0 |
                          ((unsigned int)d->limit1) << 16);
    if ( d->g )
        limit = limit << 12 | 0xfff;
 
    return limit;
}
 
static inline void pack_tss_desc(user_desc *d, const env_tss *t)
{
    unsigned long base = (unsigned long)t;
 
    d[0] = GDTE(base, sizeof(*t) - 1, 0x89);
#ifdef __x86_64__
    d[1] = (user_desc){{{ .lo = base >> 32, .hi = 0 }}};
#endif
    barrier(); /* Force desc update before ltr. */
}
 
static inline void pack_ldt_desc(user_desc *d, const user_desc *ldt,
                                 unsigned int limit)
{
    unsigned long base = (unsigned long)ldt;
 
    d[0] = GDTE(base, limit, 0x82);
#ifdef __x86_64__
    d[1] = (user_desc){{{ .lo = base >> 32, .hi = 0 }}};
#endif
    barrier(); /* Force desc update before lldt. */
}
 
#endif /* XTF_X86_DESC_H */
 
/*
 * Local variables:
 * mode: C
 * c-file-style: "BSD"
 * c-basic-offset: 4
 * tab-width: 4
 * indent-tabs-mode: nil
 * End:
 */