vm.h

Go to the documentation of this file.

/*
 * /phoenix/kernel/sys/vm.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 VM_H_
#define VM_H_

#ifdef AUTONOMOUS_LINKING
namespace {
#endif /* AUTONOMOUS_LINKING */

namespace vm {

enum LatEntryFlags {
    LAT_EF_PRESENT =        0x1,
    LAT_EF_WRITE =          0x2,
    LAT_EF_USER =           0x4,
    LAT_EF_WRITE_THROUGH =  0x8,
    LAT_EF_CACHE_DISABLE =  0x10,
    LAT_EF_EXECUTE =        0x20,
    LAT_EF_GLOBAL =         0x40,
};

#ifndef AUTONOMOUS_LINKING
extern
#endif /* AUTONOMOUS_LINKING */
struct VmCaps {
    bool    valid:1,    
            pge:1,      
            pat:1,      
            pcid:1,     
            smep:1,     
            nx:1,       
            oneGb:1;    
    short   width_phys; 
    short   width_lin;  
    inline bool IsValid() {
        if (!valid) {
            Initialize();
        }
        return true;
    }

    void Initialize() {
        cpu::CpuCaps caps;

        pge = caps.GetCapability(cpu::CPU_CAP_PG_PGE) ? true : false;
        pat = caps.GetCapability(cpu::CPU_CAP_PG_PAT) ? true : false;
        pcid = caps.GetCapability(cpu::CPU_CAP_PG_PCID) ? true : false;
        smep = caps.GetCapability(cpu::CPU_CAP_PG_SMEP) ? true : false;
        nx = caps.GetCapability(cpu::CPU_CAP_PG_NX) ? true : false;
        oneGb = caps.GetCapability(cpu::CPU_CAP_PG_1GB) ? true : false;
        width_phys = caps.GetCapability(cpu::CPU_CAP_PG_WIDTH_PHYS);
        width_lin = caps.GetCapability(cpu::CPU_CAP_PG_WIDTH_LIN);

        valid = true;
    }

} vmCaps;

} /* namespace vm */

#include <md_vm.h>

namespace vm {

enum {
    PAGE_SIZE =             (1 << PAGE_SHIFT),
    NUM_QUICK_MAP =         4,

    SYS_DATA_SIZE =         static_cast<vaddr_t>(4) * 1024 * 1024 * 1024,
    GATE_AREA_SIZE =        64 * 1024,

    VMA_CNTR_TEXT =         PAGE_SIZE,
    VMA_KERNEL_TEXT =       KERNEL_ADDRESS,
    VMA_SYS_DATA =          static_cast<vaddr_t>(2) * 1024 * 1024 * 1024,
    VMA_KERNEL_PUBLIC =     VMA_SYS_DATA - GATE_AREA_SIZE,
    VMA_GLOBAL_DATA =       VMA_SYS_DATA + SYS_DATA_SIZE
};

template <typename AddrType>
class Addr {
public:
    inline Addr(AddrType addr = 0) { _addr.addr = addr; }
    template <typename T>
    inline Addr(T addr) { _addr.addr = addr; }
    template <typename T>
    inline Addr(T *ptr) { _addr.ptr = ptr; }

    inline Addr &operator=(AddrType addr) { _addr.addr = addr; return *this; }
    inline Addr &operator=(void *ptr) { _addr.ptr = ptr; return *this; }

    inline Addr &operator+=(const Addr &addr) { _addr.addr += addr._addr.addr; return *this; }
    inline Addr &operator+=(const AddrType addr) { _addr.addr += addr; return *this; }

    inline Addr &operator-=(const Addr &addr) { _addr.addr -= addr._addr.addr; return *this; }
    inline Addr &operator-=(const AddrType addr) { _addr.addr -= addr; return *this; }

    inline bool operator==(const Addr &addr) { return _addr.addr == addr._addr.addr; }
    inline bool operator==(void *ptr) { return _addr.ptr == ptr; }
    inline bool operator==(AddrType addr) { return _addr.addr == addr; }
    inline bool operator==(int addr) { return _addr.addr == static_cast<AddrType>(addr); }

    inline bool operator!=(const Addr &addr) { return _addr.addr != addr._addr.addr; }
    inline bool operator!=(void *ptr) { return _addr.ptr != ptr; }
    inline bool operator!=(AddrType addr) { return _addr.addr != addr; }
    inline bool operator!=(int addr) { return _addr.addr != static_cast<AddrType>(addr); }

    inline bool operator <(Addr &addr) { return _addr.addr < addr._addr.addr; }
    template <typename T>
    inline bool operator <(T addr) { return _addr.addr < addr; }
    inline bool operator <=(Addr &addr) { return _addr.addr <= addr._addr.addr; }
    template <typename T>
    inline bool operator <=(T addr) { return _addr.addr <= addr; }
    inline bool operator >(Addr &addr) { return _addr.addr > addr._addr.addr; }
    template <typename T>
    inline bool operator >(T addr) { return _addr.addr > addr; }
    inline bool operator >=(Addr &addr) { return _addr.addr >= addr._addr.addr; }
    template <typename T>
    inline bool operator >=(T addr) { return _addr.addr >= addr; }

    inline Addr operator +(Addr &addr) {
        return Addr(_addr.addr + addr._addr.addr);
    }
    template <typename T>
    inline Addr operator +(T addr) {
        return Addr(_addr.addr + addr);
    }
    inline Addr operator -(Addr &addr) {
        return Addr(_addr.addr - addr._addr.addr);
    }
    template <typename T>
    inline Addr operator -(T addr) {
        return Addr(_addr.addr - addr);
    }

    inline operator AddrType() { return _addr.addr; }
    inline AddrType BaseAddr() { return _addr.addr; }
    inline operator void *() { return _addr.ptr; }
    template<typename T>
    inline operator T *() { return static_cast<T *>(_addr.ptr); }

    inline Addr &RoundUp(AddrType alignment = PAGE_SIZE) {
        _addr.addr = ::RoundUp2(_addr.addr, alignment);
        return *this;
    }

    inline Addr &RoundDown(AddrType alignment = PAGE_SIZE) {
        _addr.addr = ::RoundDown2(_addr.addr, alignment);
        return *this;
    }

    inline bool IsAligned(AddrType alignment = PAGE_SIZE) {
        ASSERT(IsPowerOf2(alignment));
        return !(_addr.addr & (alignment - 1));
    }

    inline PageIdx GetPageIdx() { return _addr.addr >> PAGE_SHIFT; }

    inline vaddr_t GetPageOffset() {
        VaddrDecoder dec(_addr.addr);
        return dec.GetPageOffset();
    }

    inline bool CheckFmtChar(char fmtChar) {
        return !fmtChar || fmtChar == 'd' ||  fmtChar == 'u' || fmtChar == 'p' ||
               fmtChar == 'x' || fmtChar == 'X' || fmtChar == 'o';
    }

    inline bool ToString(text_stream::OTextStreamBase &stream,
                         text_stream::OTextStreamBase::Context &ctx,
                         char fmtChar = 0) {

        if (fmtChar == 'p') {
            return stream.FormatValue(ctx,  _addr.ptr, fmtChar);
        } else if (!fmtChar) {
            fmtChar = 'x';
        }
        return stream.FormatValue(ctx, _addr.addr, fmtChar);
    }

protected:
    union {
        AddrType addr;
        void *ptr;
    } _addr;
};

class Vaddr : public Addr<vaddr_t> {
public:
    inline Vaddr(vaddr_t addr = 0) : Addr(addr) { }
    template <typename T>
    inline Vaddr(T addr) : Addr(addr) { }
    template <typename T>
    inline Vaddr(T *ptr) : Addr(ptr) { }
    inline Vaddr(Addr<vaddr_t> addr) : Addr(addr) { }

    inline paddr_t IdentityPaddr() { return static_cast<paddr_t>(_addr.addr); }
};

class Paddr : public Addr<paddr_t> {
public:
    inline Paddr(paddr_t addr = 0) : Addr(addr) { }
    template <typename T>
    inline Paddr(T addr) : Addr(addr) { }
    template <typename T>
    inline Paddr(T *ptr) : Addr(ptr) { }
    inline Paddr(Addr<paddr_t> addr) : Addr(addr) { }

    inline vaddr_t IdentityVaddr() { return static_cast<vaddr_t>(_addr.addr); }
};

} /* namespace vm */

#include <vm_mm.h>

#ifdef AUTONOMOUS_LINKING
}
#endif /* AUTONOMOUS_LINKING */

#endif /* VM_H_ */