source: trunk/kernel/mm/page.c @ 1

/*
 * page.c - physical page related operations implementation
 *
 * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
 *          Alain Greiner    (2016)
 *
 * Copyright (c) UPMC Sorbonne Universites
 *
 * This file is part of ALMOS-MKH.
 *
 * ALMOS-MKH is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2.0 of the License.
 *
 * ALMOS-MKH is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <hal_types.h>
#include <hal_special.h>
#include <hal_atomic.h>
#include <list.h>
#include <xlist.h>
#include <memcpy.h>
#include <thread.h>
#include <scheduler.h>
#include <cluster.h>
#include <ppm.h>
#include <mapper.h>
#include <printk.h>
#include <vfs.h>
#include <process.h>
#include <page.h>



////////////////////////////////////////
inline void page_init( page_t   * page )
{
        page->flags    = 0;
        page->order    = 0;
        page->index    = 0;
        page->mapper   = NULL;
        page->private  = 0;
    page->refcount = 0;
        spinlock_init( &page->lock );
        list_entry_init( &page->list );
}

////////////////////////////////////////////
inline void page_set_flag( page_t   * page,
                           uint16_t   value )
{
    hal_atomic_or( (uint32_t *)&page->flags , (uint32_t)value );
}

//////////////////////////////////////////////
inline void page_clear_flag( page_t   * page,
                             uint16_t   value )
{
    hal_atomic_and( (uint32_t *)&page->flags , ~((uint32_t)value) );
}

//////////////////////////////////////////////
inline bool_t page_is_flag( page_t   * page,
                            uint16_t   value )
{
    return (bool_t)(page->flags & value);
}

//////////////////////////////////////
bool_t page_do_dirty( page_t * page )
{
        bool_t done = false;

    ppm_t * ppm = &LOCAL_CLUSTER->ppm;

    // lock the PPM dirty_list
        spinlock_lock( &ppm->dirty_lock );

        if( !page_is_flag( page , PG_DIRTY ) )
        {
        // set dirty flag in page descriptor
                page_set_flag( page , PG_DIRTY );
  
        // register page in PPM dirty list
                list_add_first( &ppm->dirty_root , &page->list );
                done = true;
        }

    // unlock the PPM dirty_list
        spinlock_unlock( &ppm->dirty_lock );
  
        return done;
}

////////////////////////////////////////
bool_t page_undo_dirty( page_t * page )
{
        bool_t done = false;

    ppm_t * ppm = &LOCAL_CLUSTER->ppm;

    // lock the dirty_list
        spinlock_lock( &ppm->dirty_lock );

        if( page_is_flag( page , PG_DIRTY) )
        {
        // clear dirty flag in page descriptor
                page_clear_flag( page , PG_DIRTY );

        // remove page from PPM dirty list
                list_unlink( &page->list );
                done = true;
        }

    // unlock the dirty_list
        spinlock_unlock( &ppm->dirty_lock );

        return done;
}

/////////////////////
void sync_all_pages() 
{
        page_t   * page;
        mapper_t * mapper;
    uint32_t   index;
    ppm_t    * ppm = &LOCAL_CLUSTER->ppm;

    // lock the dirty_list
        spinlock_lock( &ppm->dirty_lock );

        while( !list_is_empty( &ppm->dirty_root ) ) 
        {
                page = LIST_FIRST( &ppm->dirty_root ,  page_t , list );

        // unlock the dirty_list
            spinlock_unlock( &ppm->dirty_lock );

                mapper = page->mapper;
        index  = page->index;
 
        // lock the page
                page_lock( page );

        // sync the page
                mapper_sync_page( mapper , index , page );

        // unlock the page
                page_unlock( page );

        // lock the dirty_list
            spinlock_lock( &ppm->dirty_lock );
        }

    // unlock the dirty_list
        spinlock_unlock( &ppm->dirty_lock );

} // end sync_all_pages()

///////////////////////////////
void page_lock( page_t * page )
{
    // take the spinlock protecting the PG_LOCKED flag
        spinlock_lock( &page->lock );

        if( page_is_flag( page , PG_LOCKED ) )  // page is already locked
        {
        // get pointer on calling thread
        thread_t * thread = CURRENT_THREAD;

        // register thread in the page waiting queue
        xlist_add_last( XPTR( local_cxy , &page->wait_root ),
                        XPTR( local_cxy , &thread->wait_list ) );

        // release the spinlock
                spinlock_unlock( &page->lock );

        // deschedule the calling thread
        thread_block( thread , THREAD_BLOCKED_PAGE );
                sched_yield();
        }
        else                                    // page is not locked
        {
        // set the PG_LOCKED flag
                page_set_flag( page , PG_LOCKED );

        // release the spinlock
                spinlock_unlock( &page->lock );
        }
}

/////////////////////////////////
void page_unlock( page_t * page )
{
    // take the spinlock protecting the PG_LOCKED flag
        spinlock_lock( &page->lock );
  
    // check the page waiting list
        bool_t is_empty = xlist_is_empty( XPTR( local_cxy , &page->wait_root ) );

        if( is_empty == false )    // at least one waiting thread => resume it
    {
        // get an extended pointer on the first waiting thread
        xptr_t root_xp   = XPTR( local_cxy , &page->wait_root ); 
        xptr_t thread_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );

        // reactivate the first waiting thread
        thread_unblock( thread_xp , THREAD_BLOCKED_PAGE );
    }
        else                      // no waiting thread => clear the PG_LOCKED flag
        {
        page_clear_flag( page , PG_LOCKED );
    }

    // release the spinlock
        spinlock_unlock( &page->lock );
}

////////////////////////////////////////////
inline void page_refcount_up( page_t *page )
{
    hal_atomic_inc( &page->refcount );
}

//////////////////////////////////////////////
inline void page_refcount_down( page_t *page )
{
    hal_atomic_dec( &page->refcount );
}

//////////////////////////////
void page_copy(  page_t * dst,
                 page_t * src )
{
        uint32_t  size;
        void    * src_base;
        void    * dst_base;
  
        if( dst->order != src->order )
    {
        printk("\n[PANIC] in %s : src size != dst size\n", __FUNCTION__ );
        hal_core_sleep();
    }

        size = (1 << dst->order) * CONFIG_PPM_PAGE_SIZE;
        src_base = ppm_page2base( src );
        dst_base = ppm_page2base( dst );

        memcpy( dst_base , src_base , size );
}

///////////////////////////////
void page_zero( page_t * page )
{
        uint32_t   size;
        void     * base;

        size = (1 << page->order) * CONFIG_PPM_PAGE_SIZE;
        base = ppm_page2base(page);

        memset( base , 0 , size ); 
}

////////////////////////////////
void page_print( page_t * page )
{
        printk("*** Page %d : base = %x / flags = %x / order = %d / count = %d\n",
                page->index, 
                ppm_page2base( page ),
                page->flags, 
                page->order, 
                page->refcount );
}





/*
/////////////////////////////////////////
static void page_to_free( page_t * page )
{
        assert((page->state == PGINVALID) || 
               (page->state == PGVALID)   ||
               (page->state == PGINIT));

        if(page_refcount_get(page) != 0)
        {
                printk(ERROR, "ERROR: %s: cpu %d, pid %d, tid %x, page %x, state %x, count %d [%d]\n",
                       __FUNCTION__,
                       cpu_get_id(),
                       current_task->pid,
                       current_thread,
                       page,
                       page->state,
                       page_refcount_get(page),
                       cpu_time_stamp());
        }
        page->state = PGFREE;
}

////////////////////////////////////////////
static void page_to_invalid( page_t * page )
{
        assert((page->state == PGFREE)  || 
               (page->state == PGVALID) ||
               (page->state == PGLOCKEDIO));
  
        if(page->state == PGLOCKEDIO)
        {
                page->state = PGINVALID; 
                page_unlock(page);
                return;
        }
 
        page->state = PGINVALID;
}

//////////////////////////////////////////
static void page_to_valid( page_t * page )
{
        assert((page->state == PGINVALID) || 
               (page->state == PGLOCKED)  ||
               (page->state == PGLOCKEDIO));
  
        if(page->state == PGINVALID)
        {
                page->state = PGVALID;
                return;
        }

        page->state = PGVALID;
        page_unlock(page);
}

//////////////////////////////////////////////
static void page_to_locked_io( page_t * page )
{
        assert((page->state == PGINVALID) || 
               (page->state == PGVALID));

        page_lock(page);
        page->state = PGLOCKEDIO;
}

///////////////////////////////////////////
static void page_to_locked( page_t * page )
{
        assert(page->state == PGVALID);
        page_lock(page);
        page->state = PGLOCKED;
}

/////////////////////////////////////////
void page_state_set( page_t       * page,
                     page_state_t   state )
{
        switch( state )
        {
        case PGFREE:
                page_to_free(page);
                return;

        case PGINVALID:
                page_to_invalid(page);
                return;

        case PGVALID:
                page_to_valid(page);
                return;

        case PGLOCKEDIO:
                page_to_locked_io(page);
                return;

        case PGLOCKED:
                page_to_locked(page);
                return;

        case PGRESERVED:
                refcount_set(&page->count,1);

        case PGINIT:
                page->state = new_state;
                return;

        default:
                printk(ERROR, "ERROR: %s: Unknown Asked State %d\n", new_state);
                return;
        }
}
*/