vm.h

Vai alla documentazione di questo file.

static const int MAX_LIV = 4;
static const int MAX_PS_LVL = 2;
static const natq VADDR_MSBIT = (1ULL << (12 + 9 * MAX_LIV - 1));
static const natq VADDR_MASK = VADDR_MSBIT - 1;

static inline constexpr vaddr norm(vaddr a)
{
        return (a & VADDR_MSBIT) ?   // se il bit più sign. è 1
                (a | ~VADDR_MASK) :  // setta tutti bit alti
                (a & VADDR_MASK);     // altrimenti resettali
}

static inline constexpr natq dim_region(int liv)
{
        natq v = 1ULL << (liv * 9 + 12);
        return v;
}

static inline constexpr vaddr base(vaddr v, int liv)
{
        natq mask = dim_region(liv) - 1;
        return v & ~mask;
}

static inline constexpr vaddr limit(vaddr v, int liv)
{
        natq dr = dim_region(liv);
        natq mask = dr - 1;
        return (v + dr - 1) & ~mask;
}

using tab_entry = natq;


const natq BIT_P    = 1U << 0;
const natq BIT_RW   = 1U << 1;
const natq BIT_US   = 1U << 2;
const natq BIT_PWT  = 1U << 3;
const natq BIT_PCD  = 1U << 4;
const natq BIT_A    = 1U << 5;
const natq BIT_D    = 1U << 6;
const natq BIT_PS   = 1U << 7;
const natq ACCB_MASK  = 0x00000000000000FF;
const natq ADDR_MASK  = 0x7FFFFFFFFFFFF000;

static inline constexpr paddr extr_IND_FISICO(tab_entry e)
{
        return e & ADDR_MASK;
}

static inline void  set_IND_FISICO(tab_entry& e, paddr f)
{
        e &= ~ADDR_MASK;
        e |= f & ADDR_MASK;
}

static inline constexpr int i_tab(vaddr v, int liv)
{
        int shift = 12 + (liv - 1) * 9;
        natq mask = 0x1ffULL << shift;
        return (v & mask) >> shift;
}

static inline tab_entry& get_entry(paddr tab, natl i)
{
        tab_entry *pd = ptr_cast<tab_entry>(tab);
        return  pd[i];
}

void set_entry(paddr tab, natl j, tab_entry se);

void copy_des(paddr src, paddr dst, natl i, natl n);

void set_des(paddr dst, natl i, natl n, tab_entry e);

class tab_iter {
        // ogni riga dello stack, partendo dalla 0, traccia la posizione
        // corrente all'interno dell'albero di traduzione.  La riga 0 traccia
        // la posizione nell'albero al livello massimo, la riga 1 nel livello
        // subito inferiore, e così via. Il livello corrente è contenuto
        // nella variabile 'l'.
        //
        // Ogni riga dello stack contiene l'indirizzo fisico (tab) della
        // tabella, del livello corrispondente, attualmente in corso di visita.
        // La riga contiene anche un intervallo [cur, end) di indirizzi ancora
        // da visitare in quella tabella. I campi cur e end della riga MAX_LIV,
        // altrimenti inutilizzati, vengono usati per contenere gli estremi
        // dell'intervallo completo passato al costruttore dell'iteratore.
        //
        // La terminazione della visita si riconosce da p->tab == 0.
 
        struct stack {
                vaddr cur, end;
                paddr tab;
        } s[MAX_LIV + 1];
 
        // livello corrente
        int l;
 
        // puntatore alla riga corrente dello stack
        stack *sp() { return &s[l - 1]; }
        stack const *sp() const { return &s[l - 1]; }
 
        // puntatore alla riga dello stack relativa al livello 'lvl'
        stack *sp(int lvl) { return &s[lvl - 1]; }
 
        // puntatore alla riga dello stack contenente gli estremi
        // dell'intervallo completo
        stack *pp() { return &s[MAX_LIV]; }
        stack const *pp() const { return &s[MAX_LIV]; }
 
        // true sse la visita è finita
        bool done() const { return !sp()->tab; }
 
public:
        static bool valid_interval(vaddr beg, natq dim)
        {
                // ultimo indirizzo interno all'intervallo (se dim > 0)
                vaddr end = beg + dim - 1;
                return !dim || (
                        // non inizia nel buco
                             norm(beg) == beg
                        // non termina nel buco
                        &&   norm(end) == end
                        // estremi entrambi dalla stessa parte rispetto al buco
                        &&   (beg & VADDR_MSBIT) == (end & VADDR_MSBIT)
                        // non fa wrap-around
                        &&   end >= beg);
        }

        tab_iter(paddr tab, vaddr beg, natq dim = 1);

        operator bool() const {
                return !done();
        }

        int get_l() const {
                return l;
        }

        bool is_leaf() const {
                tab_entry e = get_e();
                return !(e & BIT_P) || (e & BIT_PS) || l == 1;
        }

        vaddr get_v() const {
                return max(pp()->cur, sp()->cur);
        }

        tab_entry& get_e() const {
                return get_entry(sp()->tab, i_tab(sp()->cur, l));
        }

        paddr get_tab() const {
                return sp()->tab;
        }

        bool down();
        bool up();
        bool right();

        void next();

        void post();

        void next_post();
};

paddr trasforma(paddr root_tab, vaddr v);

extern "C" void loadCR3(paddr dir);

extern "C" paddr readCR3();

extern "C" void invalida_TLB();

extern "C" void invalida_entrata_TLB(vaddr v);

extern "C" vaddr readCR2();


extern paddr alloca_tab();
extern void rilascia_tab(paddr);
extern void inc_ref(paddr);
extern void dec_ref(paddr);
extern natl get_ref(paddr);

template<typename T>
vaddr map(paddr tab, vaddr begin, vaddr end, natl flags, T& getpaddr, int ps_lvl = 1)
{
/*
 * Lo schema generale della funzione, escludendo i controlli sugli errori e
 * la gestione dei flag, è il seguente:
 *     new_f = 0;
 *     for (tutto il sotto-albero visitato in pre-ordine)
 *         tab_entry& e = riferimento all'entrata corrente
 *         vaddr v = indirizzo virtuale corrente
 *         if (livello non foglia)
 *             if (tabella assente)
 *                 new_f = alloca_tab();
 *         else
 *             new_f = getpaddr(v);
 *         if (new_f)
 *             inizializza 'e' in modo che punti a 'new_f'
 */
        vaddr v;   /* indirizzo virtuale corrente */
        int l;          /* livello (del TRIE) corrente */
        natq dr;    /* dimensione delle regioni di livello ps_lvl */
        const char* err_msg = "";
        static const natq allowed_flags = BIT_RW | BIT_US | BIT_PWT | BIT_PCD;
 
        // controlliamo che ps_lvl abbia uno dei valori consentiti
        if (ps_lvl < 1 || ps_lvl > MAX_PS_LVL) {
                fpanic("map: ps_lvl %d non ammesso (deve essere compreso tra 1 e %d)",
                                ps_lvl, MAX_PS_LVL);
        }
        // il mapping coinvolge sempre almeno pagine, quindi consideriamo come
        // erronei dei parametri beg, end che non sono allineati alle pagine
        // (di livello ps_lvl)
        dr = dim_region(ps_lvl - 1);
        if (begin & (dr - 1)) {
                fpanic("map: begin=%llx non allineato alle pagine di livello %d",
                                static_cast<unsigned long long>(begin), ps_lvl);
        }
        if (end & (dr - 1)) {
                fpanic("map: end=%llx non allineato alle pagine di livello %d",
                                static_cast<unsigned long long>(end), ps_lvl);
        }
        // controlliamo che flags contenga solo i flag che possiamo gestire
        if (flags & ~allowed_flags) {
                fpanic("map: flags contiene bit non validi: %llx",
                                static_cast<unsigned long long>(flags & ~allowed_flags));
        }
 
        // usiamo un tab_iter per percorrere tutto il sottoalbero.  Si noti che
        // il sottoalbero verrà costruito man mano che lo visitiamo.
        //
        // Si noti che tab_iter fa ulteriori controlli sulla validità
        // dell'intervallo (si veda tab_iter::valid_interval in libce)
        //
        // mentre percorriamo l'albero controlliamo che non esistano già
        // traduzioni per qualche indirizzo in [begin, end). In caso contrario
        // ci fermiamo restituendo errore.
        tab_iter it(tab, begin, end - begin);
        for ( /* niente */ ; it; it.next()) {
                tab_entry& e = it.get_e();
                l = it.get_l();
                v = it.get_v();
                // new_f diventerà diverso da 0 se dobbiamo settare a 1 il bit
                // P di 'e'
                paddr new_f = 0;
 
                if (l > ps_lvl) {
                        // per tutti i livelli non "foglia" allochiamo la
                        // tabella di livello inferiore e facciamo in modo che
                        // il descrittore corrente la punti (Si noti che la
                        // tabella potrebbe esistere già, e in quel caso non
                        // facciamo niente)
                        if (!(e & BIT_P)) {
                                new_f = alloca_tab(); // [1]
                                if (!new_f) {
                                        err_msg = "impossibile allocare tabella";
                                        goto error;
                                }
                        } else if (e & BIT_PS) {
                                // se PS==1 questo descrittore non contiene un
                                // puntatore alla prossima tabella, ma è già
                                // una traduzione. La traduzione è di livello
                                // più alto di quella richiesta e dunque è
                                // sicuramente preesistente.
                                err_msg = "gia' mappato";
                                goto error;
                        }
                } else {
                        // arrivati ai descrittori di livello ps_lvl creiamo la
                        // traduzione vera e propria, salvo errori.
                        if (e & BIT_P) {
                                err_msg = "gia' mappato";
                                goto error;
                        }
                        // otteniamo il corrispondente indirizzo fisico
                        // chiedendolo all'oggetto getpaddr
                        new_f = getpaddr(v);    // [2]
                        if (!new_f) {
                                err_msg = "getpaddr() ha restituito 0";
                                goto error;
                        }
 
                        // se la pagina è di livello maggiore di 1 dobbiamo
                        // settare il bit PS
                        if (l > 1)
                                e |= BIT_PS;
 
                        // settiamo anche i bit PWT e PCD, se richiesto
                        e |= (flags & (BIT_PWT|BIT_PCD));
                }
                if (new_f) {
                        // siamo qui perché c'è da allocare una tabella (punto
                        // [1] qui sopra) o installare una traduzione (punto
                        // [2]). Le cose da fare sono le stesse in entrambi i
                        // casi:
 
                        // 'e' non puntava a niente e ora deve puntare a new_f
                        set_IND_FISICO(e, new_f);
                        e |= BIT_P;
 
                        // dobbiamo incrementare il contatore delle entrate
                        // valide della tabella a cui 'e' appartiene
                        inc_ref(it.get_tab());
                }
 
                // se sono stati richiesti i bit RW e/o US, questi vanno
                // settati su tutti i livelli (anche su eventuali entrate di
                // livello > ps_lvl già esistenti), altrimenti non hanno
                // effetto.
                e |= (flags & (BIT_RW|BIT_US));
        }
        return end;
 
error:
        flog(LOG_WARN, "map: indirizzo %llx, livello %d: %s", static_cast<unsigned long long>(v), l, err_msg);
        // it punta all'ultima entrata visitata. Se si tratta di una tabella
        // dobbiamo provare a deallocare tutto il percorso che abbiamo creato
        // fino a quel punto. Una chiamata ad unmap() non è sufficiente, in
        // quanto queste tabelle potrebbero non contenere traduzioni complete.
        paddr p = it.get_tab();
        for (;;) {
                if (get_ref(p))
                        break;
                rilascia_tab(p);
                if (!it.up())
                        break;
                it.get_e() = 0;
                p = it.get_tab();
                dec_ref(p);
        }
        return max(v, begin);
}

template<typename T>
vaddr map(paddr tab, vaddr begin, vaddr end, natl flags, const T& getpaddr, int ps_lvl = 1)
{
        T tmp = getpaddr;
        return map(tab, begin, end, flags, tmp, ps_lvl);
}

template<typename T>
void unmap(paddr tab, vaddr begin, vaddr end, T& putpaddr)
{
        tab_iter it(tab, begin, end - begin);
        // eseguiamo una visita in ordine posticipato
        for (it.post(); it; it.next_post()) {
                tab_entry& e = it.get_e();
 
                if (!(e & BIT_P))
                        continue;
 
                paddr p = extr_IND_FISICO(e);
                if (!it.is_leaf()) {
                        // l'entrata punta a una tabella.
                        if (!get_ref(p)) {
                                // Se la tabella non contiene più entrate
                                // valide la deallochiamo
                                rilascia_tab(p);
                        } else {
                                // altrimenti non facciamo niente
                                // (la tabella serve per traduzioni esterne
                                // all'intervallo da eliminare)
                                continue;
                        }
                } else {
                        // l'entrata punta ad una pagina (di livello it.get_l())
                        vaddr v = it.get_v();
                        int l = it.get_l();
                        // Tutta la pagina deve essere inclusa nell'intervallo da eliminare
                        if (v < begin || v + dim_region(l - 1) - 1 > end - 1) {
                                fpanic("unmap: tentativo di riumuovere traduzione esterna a [%lx, %lx)",
                                                begin, end);
                        }
                        // lasciamo al chiamante decidere cosa fare
                        putpaddr(v, p, l);
                }
 
                // per tutte le pagine, e per le tabelle che abbiamo
                // deallocato, azzeriamo l'entrata 'e' e decrementiamo il
                // contatore delle entrate valide nella tabella che la contiene
                e = 0;
                dec_ref(it.get_tab());
        }
}

template<typename T>
void unmap(paddr tab, vaddr begin, vaddr end, const T& putpaddr)
{
        // adattatore nel caso in cui putpaddr non sia un lvalue
        T tmp = putpaddr;
        unmap(tab, begin, end, tmp);
}