Subversion Repositories HelenOS

/*

 * Copyright (c) 2007 Jan Hudecek

 * Copyright (c) 2006 Jakub Jermar

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - The name of the author may not be used to endorse or promote products

 *   derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/** @addtogroup sync

 * @{

 */

/** @file

 */

#include <synch/rcu.h>

#include <synch/waitq.h>

#include <arch.h>

#include <config.h>

#include <arch/types.h>

#include <proc/tasklet.h>

#include <synch/spinlock.h>

#include <time/delay.h>

#include <panic.h>

#include <print.h>

SPINLOCK_INITIALIZE(rcu_global_lock);

typedef struct rcu_callback_list {

    struct rcu_callback_list* next;

    void (*func)(void*);

    void* data;

} rcu_callback_list_t;

typedef struct  {

#ifdef CONFIG_SMP 

    bool* cpu_mask;

#endif

    rcu_callback_list_t* next_batch, *current_batch, *done_batch;

} rcu_global_t;

rcu_global_t* _rcu_global;

tasklet_descriptor_t* rcu_tasklet_desc;

void rcu_init(void)

{

#ifdef CONFIG_SMP 

    int i;

#endif

    _rcu_global = malloc(sizeof(rcu_global_t),0);

    _rcu_global->done_batch = NULL;

    _rcu_global->current_batch = NULL;

    _rcu_global->next_batch = NULL;

    spinlock_initialize(&rcu_global_lock, "rcu_global_lock");

    rcu_tasklet_desc = tasklet_register(&rcu_tasklet, NULL);

    tasklet_disable(rcu_tasklet_desc);

#ifdef CONFIG_SMP 

    _rcu_global->cpu_mask = malloc (sizeof(bool)*config.cpu_count,0);

    for (i=0;i<config.cpu_count;i++) {

        _rcu_global->cpu_mask[i]=false;

    }

#else

    tasklet_schedule(rcu_tasklet_desc);

#endif

    tasklet_enable(rcu_tasklet_desc);

}

void rcu_synchronize(void)

{

#ifdef CONFIG_SMP

    waitq_t *wq = malloc(sizeof(waitq_t),0);

    waitq_initialize(wq);

    rcu_sync_callback(&rcu_synchronize_callback_function, wq);

    printf("going to sleep, tlock:%x, wqlock:%x\n", THREAD->lock.val, wq->lock.val);

    waitq_sleep(wq);

    printf("woken up\n");

    free(wq);

#endif

}

#ifdef CONFIG_SMP

void rcu_synchronize_callback_function(void* waitq)

{

    printf("waking up, wq:%x, wq->head:%x, next:%x, tlock:%x, wqlock:%x\n",

        waitq,

        ((waitq_t*)waitq)->head,

        ((link_t)((waitq_t*)waitq)->head).next,

        THREAD->lock.val,

        ((waitq_t*)waitq)->lock.val );

    waitq_wakeup(((waitq_t*)waitq), WAKEUP_ALL);

}

#endif

void rcu_sync_callback(void (*func)(void* data), void* data)

{

#ifndef CONFIG_SMP

    func(data);

#else

    int i;

    rcu_callback_list_t *rd;

    rd = malloc(sizeof(rcu_callback_list_t), 0);

    rd->func = func;

    rd->data = data;

    rd->next = NULL;

    printf("synccallback locking \n");

    spinlock_lock(&rcu_global_lock);

    rd->next = _rcu_global->next_batch;

    _rcu_global->next_batch = rd;

    if (_rcu_global->current_batch == NULL) {

        _rcu_global->current_batch = _rcu_global->next_batch;

        _rcu_global->next_batch = NULL;

        printf("setting callback %x as current\n",&rd->func);

        for (i=0;i<config.cpu_count;i++)

            _rcu_global->cpu_mask[i]=false;

        //we've surely passed the quiescent point just by running this method

        rcu_passQS();

    }

    for (i=0;i<config.cpu_count;i++) {

        tasklet_schedule_SMP(rcu_tasklet_desc, i);

    }

    spinlock_unlock(&rcu_global_lock);

    printf ("sync callback called,unlocking, state:%x \n",rcu_tasklet_desc->state);

#endif

}

    //TODO: polishing, comments

void rcu_tasklet(void* data)

{

    rcu_callback_list_t* rd;

    bool passed_all_QS;

#ifdef CONFIG_SMP 

    int i;

#endif

    rcu_passQS();

    passed_all_QS = true;

    printf("tasklet locking \n");

    spinlock_lock(&rcu_global_lock);

#ifdef CONFIG_SMP 

    for (i = 0; i < config.cpu_active; i++)

        passed_all_QS &= _rcu_global->cpu_mask[i];

#endif

    if (passed_all_QS) {

        if (_rcu_global->done_batch) {

            rd = _rcu_global->done_batch;

            while (rd->next) rd = rd->next;

            //append the current list to done list

            rd->next = _rcu_global->current_batch;

        } else

            _rcu_global->done_batch = _rcu_global->current_batch;

        printf("setting callback %x as done\n",&_rcu_global->current_batch->func);

        _rcu_global->current_batch = _rcu_global->next_batch;

        _rcu_global->next_batch = NULL;

#ifdef CONFIG_SMP 

        for (i=0;i<config.cpu_count;i++)

            _rcu_global->cpu_mask[i]=false;

#endif

        //we've surely passed the quiescent point just by running this method

        rcu_passQS();

    }

    spinlock_unlock(&rcu_global_lock);

    printf("tasklet unlocking \n");

}

inline void rcu_passQS(void)

{

#ifdef CONFIG_SMP 

    _rcu_global->cpu_mask[CPU->id] = true;

#endif

}

void rcu_run_callbacks(void)

{

    rcu_callback_list_t* rd;

    rcu_passQS();

    if (_rcu_global->done_batch) {

        printf("run callbacks locking\n");

        spinlock_lock(&rcu_global_lock);

        rd = _rcu_global->done_batch;

        _rcu_global->done_batch = NULL;

        spinlock_unlock(&rcu_global_lock);

        printf("run callbacks unlocking\n");

        for (; rd; rd=rd->next) {

            printf("calling %x \n",&rd->func);

            rd->func(&rd->data);

        }

    }

}