md_vm.h

Go to the documentation of this file.

/*
 * /phoenix/kernel/sys/arch/x86_64/vm_md.h
 *
 * This file is a part of Phoenix operating system.
 * Copyright (c) 2011-2012, Artyom Lebedev <artyom.lebedev@gmail.com>
 * All rights reserved.
 * See COPYING file for copyright details.
 */

#ifndef MD_VM_H_
#define MD_VM_H_

namespace vm {

enum {
    PAGE_SHIFT =            12,

    NUM_LAT_TABLES =        4,
};

typedef u64 PageIdx;

typedef u32 LatEntryIdx;

typedef u32 ProcCtxId;

class VaddrDecoder {
public:
    inline VaddrDecoder(vaddr_t va = 0) { _va.va = va; }

    static inline u32 GetTableSize(u32 UNUSED tableLvl) {
        ASSERT(tableLvl < NUM_LAT_TABLES);
        /* 512 entries in eachLatEntrytable. */
        return 512;
    }

    inline LatEntryIdx GetEntryIndex(u32 tableLvl) {
        switch (tableLvl) {
        case 0:
            return _va.fields.tblIdx0;
        case 1:
            return _va.fields.tblIdx1;
        case 2:
            return _va.fields.tblIdx2;
        case 3:
            return _va.fields.tblIdx3;
        }
        FAULT("Table index is out of range: %d", tableLvl);
        return 0;
    }

    inline vaddr_t GetPageOffset() {
        return _va.fields.pageOffset;
    }

private:
    struct VaFields {
        vaddr_t     pageOffset:PAGE_SHIFT,
                    tblIdx0:9, /* Page table */
                    tblIdx1:9, /* Page directory */
                    tblIdx2:9, /* Page directory pointers table */
                    tblIdx3:9, /* PML4 */
                    :16;
    };

    volatile union {
        vaddr_t va;
        VaFields fields;
    } _va;
};

class LatEntry {
public:
    inline LatEntry() {
        _ptr.raw = 0;
        _tableLvl = 0;
    }

    inline LatEntry(vaddr_t va, void *table, u32 tableLvl = 0) {
        Set(va, table, tableLvl);
    }

    inline LatEntry(void *entry, u32 tableLvl = 0) {
        Set(entry, tableLvl);
    }

    inline void Set(vaddr_t va, void *table, u32 tableLvl = 0) {
        ASSERT(tableLvl <= NUM_LAT_TABLES);
        _tableLvl = tableLvl;
        _ptr.ptr = table;
        VaddrDecoder dec(va);
        _ptr.raw += dec.GetEntryIndex(tableLvl);
    }

    inline void Set(void *entry, u32 tableLvl = 0) {
        ASSERT(tableLvl <= NUM_LAT_TABLES);
        _tableLvl = tableLvl;
        _ptr.ptr = entry;
    }

    inline bool IsAccessed() {
        if (_tableLvl == NUM_LAT_TABLES) {
            /* CR3 does not have the flag. */
            return false;
        }
        return _ptr.entryPage->accessed;
    }

    inline bool SetAccessed(bool flag = true) {
        if (_tableLvl == NUM_LAT_TABLES) {
            /* CR3 does not have the flag. */
            return false;
        }
        bool curFlag = _ptr.entryPage->accessed;
        _ptr.entryPage->accessed = flag;
        return curFlag;
    }

    inline bool IsDirty() {
        if (_tableLvl == NUM_LAT_TABLES) {
            /* CR3 does not have the flag. */
            return false;
        }
        return _ptr.entryPage->dirty;
    }

    inline bool SetDirty(bool flag = true) {
        if (_tableLvl == NUM_LAT_TABLES) {
            /* CR3 does not have the flag. */
            return false;
        }
        bool curFlag = _ptr.entryPage->dirty;
        _ptr.entryPage->dirty = flag;
        return curFlag;
    }

    bool CheckFlag(LatEntryFlags flag) {
        ASSERT(_tableLvl <= NUM_LAT_TABLES);
        if (_tableLvl == NUM_LAT_TABLES) {
            switch (flag) {
            case LAT_EF_WRITE_THROUGH:
                return _ptr.cr3->pwt;
            case LAT_EF_CACHE_DISABLE:
                return _ptr.cr3->pcd;
            default:
                return false;
            }
        }
        switch (flag) {
        case LAT_EF_PRESENT:
            return _ptr.entryPage->present;
        case LAT_EF_WRITE:
            return _ptr.entryPage->write;
        case LAT_EF_USER:
            return _ptr.entryPage->user;
        case LAT_EF_WRITE_THROUGH:
            return _ptr.entryPage->writeThrough;
        case LAT_EF_CACHE_DISABLE:
            return _ptr.entryPage->cacheDisable;
        case LAT_EF_EXECUTE:
            return !_ptr.entryPage->executeDisable;
        case LAT_EF_GLOBAL:
            return _ptr.entryPage->global;
        }
        FAULT("Invalid flag specified: %d", flag);
        return false;
    }

    bool SetFlag(LatEntryFlags flag, bool setIt = true) {
        bool prev;
        ASSERT(_tableLvl <= NUM_LAT_TABLES);
        if (_tableLvl == NUM_LAT_TABLES) {
            switch (flag) {
            case LAT_EF_WRITE_THROUGH:
                prev = _ptr.cr3->pwt;
                _ptr.cr3->pwt = setIt ? 1 : 0;
                break;
            case LAT_EF_CACHE_DISABLE:
                prev = _ptr.cr3->pcd;
                _ptr.cr3->pcd = setIt ? 1 : 0;
                break;
            default:
                prev = false;
                break;
            }
            return prev;
        }
        switch (flag) {
        case LAT_EF_PRESENT:
            prev = _ptr.entryPage->present;
            _ptr.entryPage->present = setIt ? 1 : 0;
            break;
        case LAT_EF_WRITE:
            prev = _ptr.entryPage->write;
            _ptr.entryPage->write = setIt ? 1 : 0;
            break;
        case LAT_EF_USER:
            prev = _ptr.entryPage->user;
            _ptr.entryPage->user = setIt ? 1 : 0;
            break;
        case LAT_EF_WRITE_THROUGH:
            prev = _ptr.entryPage->writeThrough;
            _ptr.entryPage->writeThrough = setIt ? 1 : 0;
            break;
        case LAT_EF_CACHE_DISABLE:
            prev = _ptr.entryPage->cacheDisable;
            _ptr.entryPage->cacheDisable = setIt ? 1 : 0;
            break;
        case LAT_EF_EXECUTE:
            prev = !_ptr.entryPage->executeDisable;
            if (vmCaps.IsValid() && vmCaps.nx) {
                _ptr.entryPage->executeDisable = setIt ? 0 : 1;
            }
            break;
        case LAT_EF_GLOBAL:
            prev = _ptr.entryPage->global;
            if (_tableLvl == 0 && vmCaps.IsValid() && vmCaps.pge) {
                _ptr.entryPage->global = setIt ? 1 : 0;
            }
            break;
        default:
            FAULT("Invalid flag specified: %d", flag);
            break;
        }
        return prev;
    }

    long SetFlags(long flags) {
        static const LatEntryFlags allFlags[] = {
            LAT_EF_PRESENT,
            LAT_EF_WRITE,
            LAT_EF_USER,
            LAT_EF_WRITE_THROUGH,
            LAT_EF_CACHE_DISABLE,
            LAT_EF_EXECUTE,
            LAT_EF_GLOBAL
        };
        long prev;

        for (auto flag: allFlags) {
            if (SetFlag(flag, flags & flag)) {
                prev |= flag;
            }
        }
        return prev;
    }

    inline paddr_t GetAddress() {
        return _ptr.entryPage->pa << PAGE_SHIFT;
    }

    inline paddr_t SetAddress(paddr_t pa) {
        ASSERT((pa & ((1 << PAGE_SHIFT) - 1)) == 0);
        paddr_t prevPa = _ptr.entryPage->pa << PAGE_SHIFT;
        _ptr.entryPage->pa = pa >> PAGE_SHIFT;
        return prevPa;
    }

    inline void Clear() { *_ptr.raw = 0; }

    inline operator paddr_t() { return GetAddress(); }

    inline LatEntry &operator=(paddr_t pa) { SetAddress(pa); return *this; }

    inline operator void *() { return _ptr.ptr; }

    inline ProcCtxId GetProcCtxId() {
        ENSURE(_tableLvl == NUM_LAT_TABLES);
        return _ptr.cr3->pcid;
    }

    inline ProcCtxId SetProcCtxId(ProcCtxId pcid) {
        ENSURE(_tableLvl == NUM_LAT_TABLES);
        ProcCtxId oldPcid = _ptr.cr3->pcid;
        if (vmCaps.IsValid() && vmCaps.pcid) {
            _ptr.cr3->pcid = pcid;
        }
        return oldPcid;
    }

    inline void Activate() {
        ENSURE(_tableLvl == NUM_LAT_TABLES);
        cpu::wcr3(*_ptr.raw);
    }

private:

    struct EntryCr3 {
        union {
            /* CR4.PCIDE = 0 */
            paddr_t :3,
                    pwt:1,
                    pcd:1,
                    :7,
                    pa:40,
                    :12;
            /* CR4.PCIDE = 1 */
            paddr_t pcid:12;
        };
    };

    struct EntryPage {
        paddr_t     
                    present:1,
                    write:1,
                    user:1,
                    writeThrough:1,
                    cacheDisable:1,
                    accessed:1,
                    dirty:1,
                    pat:1,
                    global:1,
                    :3,
                    pa:40,
                    :11,
                    executeDisable:1;
    };

    struct EntryTable {
        paddr_t     
                    present:1,
                    write:1,
                    user:1,
                    writeThrough:1,
                    cacheDisable:1,
                    accessed:1,
                    :1,
                    pageSize:1,
                    :4,
                    pa:40,
                    :11,
                    executeDisable:1;
    };

    volatile union EntryPtr {
        void *ptr;
        paddr_t *raw;
        EntryCr3 *cr3;
        EntryPage *entryPage;
        EntryTable *entryTable;
    } _ptr;

    u32 _tableLvl;
};

inline void
InvalidateVaddr(vaddr_t va)
{
    cpu::invlpg(va);
}

inline void
InitPaging(bool enablePaging)
{
    if (enablePaging) {
        u64 cr0 = cpu::rcr0();
        if (!(cr0 & cpu_reg::CR0_PG)) {
            cpu::wcr0(cr0 | cpu_reg::CR0_PG);
        }
    } else {
        cpu::CpuCaps caps;

        /* Enable "execute-disable" feature if available. */
        if (caps.GetCapability(cpu::CPU_CAP_PG_NX)) {
            cpu::wrmsr(cpu_reg::MSR_IA32_EFER,
                       cpu::rdmsr(cpu_reg::MSR_IA32_EFER) | cpu_reg::IA32_EFER_NXE);
        }

        u64 features = cpu::rcr4();
        /* Enable global pages if available. */
        if (caps.GetCapability(cpu::CPU_CAP_PG_PGE)) {
            features |= cpu_reg::CR4_PGE;
        }
        /* Enable process context identification if available. */
        if (caps.GetCapability(cpu::CPU_CAP_PG_PCID)) {
            features |= cpu_reg::CR4_PCDIE;
        }
        cpu::wcr4(features);
    }
}

} /* namespace vm */

#endif /* MD_VM_H_ */