//*********************************| C_ROUTINE_PF |********************************
//***********************************(sistema.cpp)*********************************
bool c_routine_pf()
{
    vaddr ind_virt = readCR2();
    natl proc = esecuzione->id;

    stat();

    for (int i = 3; i >= 0; i--) {
        tab_entry d = get_des(proc, i + 1, ind_virt);
        bool bitP = extr_P(d);
        if (!bitP) {
            des_frame *df = swap(proc, i, ind_virt);
            if (!df)
                return false;
        }
    }
    return true;
}

//*************************************| SWAP |************************************
//***********************************(sistema.cpp)*********************************

// carica l'entita' del livello specificato, relativa all'indirizzo virtuale
// ind_virt nello spazio di indirizzamento di proc
des_frame* swap(natl proc, int livello, vaddr ind_virt)
{
    tab_entry e = get_des(proc, livello + 1, ind_virt);
    natq m = extr_IND_MASSA(e);
    if (!m) {
        flog(LOG_WARN,
             "indirizzo %p fuori dallo spazio virtuale allocato",
             ind_virt);
        return 0;
    }
    des_frame* df = alloca_frame(proc, livello, ind_virt);
    if (!df) {
        flog(LOG_WARN, "memoria esaurita");
        return 0;
    }
    df->livello = livello;
    df->residente = 0;
    df->processo = proc;
    df->ind_virtuale = ind_virt;
    df->ind_massa = m;
    df->contatore = 0;
    carica(df);
    collega(df);
    return df;
}

//*********************************| ALLOCA_FRAME |********************************
//***********************************(sistema.cpp)*********************************

// alloca un frame destinato a contenere l'entita' del
// livello specificato, relativa all'indirizzo virtuale ind_virt
// nello spazio di indirizzamento di proc
des_frame* alloca_frame(natl proc, int livello, vaddr ind_virt)
{
    des_frame *df = alloca_frame_libero();
    if (df == 0) {
        df = scegli_vittima(proc, livello, ind_virt);
        if (df == 0)
            return 0;
        bool occorre_salvare = scollega(df);
        if (occorre_salvare)
            scarica(df);
    }
    return df;
}

// indice del descrittore del primo frame libero
des_frame* frame_liberi;
// estrea un frame libero dalla lista, se non vuota
des_frame* alloca_frame_libero()
{
    des_frame* p = frame_liberi;
    if (frame_liberi != 0)
        frame_liberi = frame_liberi->prossimo_libero;
    return p;
}

//********************************| SCEGLI_VITTIMA |*******************************
//***********************************(sistema.cpp)*********************************

bool vietato(des_frame* df, natl proc, int liv, vaddr ind_virt)
{
    if (df->livello > liv && df->processo == proc &&
        base(df->ind_virtuale, df->livello) == base(ind_virt, df->livello))
        return true;
    return false;
}

des_frame* scegli_vittima(natl proc, int liv, vaddr ind_virt)
{
    des_frame *df, *df_vittima;
    df = &vdf[0];
    while ( df < &vdf[N_DF] &&
        (df->residente ||
         vietato(df, proc, liv, ind_virt)))
        df++;
    if (df == &vdf[N_DF]) return 0;
    df_vittima = df;
    for (df++; df < &vdf[N_DF]; df++) {
        if (df->residente ||
            vietato(df, proc, liv, ind_virt))
            continue;
        if (df->contatore < df_vittima->contatore ||
            (df->contatore == df_vittima->contatore &&
             df_vittima->livello > df->livello))
            df_vittima = df;
    }
    return df_vittima;
}

//*************************************| STAT |************************************
//***********************************(sistema.cpp)*********************************
void stat()
{
    des_frame *df1, *df2;
    faddr f1, f2;
    bool bitA;

    for (natq i = 0; i < N_DF; i++) {
        df1 = &vdf[i];
        if (df1->livello < 1)
            continue;
        f1 = indirizzo_frame(df1);
        for (int j = 0; j < 512; j++) {
            tab_entry& des = get_entry(f1, j);
            if (!extr_P(des))
                continue;
            bitA = extr_A(des);
            set_A(des, false);
            f2 = extr_IND_FISICO(des);
            df2 = descrittore_frame(f2);
            if (!df2 || df2->residente)
                continue;
            df2->contatore >>= 1;
            if (bitA)
                df2->contatore |= 0x80000000;
        }
    }
    invalida_TLB();
}

//*********************************| C_ACTIVATE_PE |*******************************
//***********************************(sistema.cpp)*********************************

extern "C" void c_activate_pe(void f(int), int a, natl prio, natl liv, natb type)
{
    proc_elem   *p;         // proc_elem per il nuovo processo
    des_proc *self = des_p(esecuzione->id);

    if (prio < MIN_PRIORITY) {
        flog(LOG_WARN, "priorita' non valida: %d", prio);
        c_abort_p();
        return;
    }

    p = crea_processo(f, a, prio, liv, true);
    if (p == 0)
        goto error1;

    if (!aggiungi_pe(p, type) )
        goto error2;

    flog(LOG_INFO, "estern=%d entry=%p(%d) prio=%d liv=%d type=%d",
            p->id, f, a, prio, liv, type);

    self->contesto[I_RAX] = p->id;
    return;

error2: distruggi_processo(p);
error1:
    self->contesto[I_RAX] = 0xFFFFFFFF;
    return;
}