source: trunk/kernel/kern/event.c @ 220

/*
 * kern/event.c - Per-CPU Events-Manager
 * 
 * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
 * Copyright (c) 2011,2012 UPMC Sorbonne Universites
 *
 * This file is part of ALMOS-kernel.
 *
 * ALMOS-kernel 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-kernel 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-kernel; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <types.h>
#include <cpu.h>
#include <cluster.h>
#include <chdev.h>
#include <pmm.h>
#include <event.h>
#include <cpu-trace.h>
#include <thread.h>

/** Initialize event */
error_t event_init(struct event_s *event)
{
        /* nothing to do in this version */
        return 0;
}

/** Destroy event */
void event_destroy(struct event_s *event)
{
        /* nothing to do in this version */
}

/** Destroy event listner */
void event_listner_destroy(struct event_listner_s *el)
{
        /* nothing to do in this version */
}

error_t event_listner_init(struct event_listner_s *el)
{
        error_t err;
        register uint_t i;
  
        el->flags = 0;
        el->prio = 0;
        err = 0;

        for(i=0; i < E_PRIO_NR; i++)
        {
                list_root_init(&el->tbl[i].root);
                el->tbl[i].count = 0;
        }


        return 0;
}


static void local_event_send(struct event_s *event, struct event_listner_s *el, bool_t isFIFO) 
{
        uint_t prio;
        uint_t irq_state;

        prio = event_get_priority(event);

        cpu_disable_all_irq(&irq_state);

        if(isFIFO)
                list_add_last(&el->tbl[prio].root, &event->e_list);
        else
                list_add_first(&el->tbl[prio].root, &event->e_list);

        el->tbl[prio].count ++;
        el->prio = (!(el->flags & EVENT_PENDING) || (el->prio > prio)) ? prio : el->prio;
        el->flags |= EVENT_PENDING;

        cpu_restore_irq(irq_state);

#if CONFIG_SHOW_LOCAL_EVENTS
        isr_dmsg(INFO, "%s: cpu %d, prio %d, el->prio %d [%d]\n", 
                 __FUNCTION__, 
                 cpu_get_id(), 
                 prio, 
                 el->prio,
                 cpu_time_stamp());
#endif
}

#if 0
static EVENT_HANDLER(re_send_backoff_handler)
{
        uint_t cpu_gid;
  
        cpu_gid = (uint_t) event_get_argument(event);
  
        event_restore(event);
  
        event_send(event, cpu_gid);

        printk(INFO, "INFO: %s, cpu %d, event %x sent to cpu_gid %d [%d]\n",
               __FUNCTION__,
               cpu_get_id(),
               event,
               cpu_gid,
               cpu_time_stamp());
  
        return 0;
}

static error_t __attribute__((noinline)) re_send_backoff(struct event_s *event, 
                                                         uint_t cpu_gid, 
                                                         uint_t tm_stamp)
{
        struct cpu_s *cpu;
        uint_t tm_now;
        uint_t irq_state;

        tm_now = cpu_time_stamp();
        cpu    = current_cpu;

        if((tm_now - tm_stamp) < cpu_get_ticks_period(cpu))
                return EAGAIN;

        event_backup(event);
  
        event_set_priority(event, E_CHR);
        event_set_handler(event, re_send_backoff_handler);
        event_set_argument(event, (void*)cpu_gid);

        cpu_disable_all_irq(&irq_state);
        local_event_send(event, &cpu->le_listner, false);
        cpu_restore_irq(irq_state);

        printk(INFO, "INFO: %s, cpu %d, event %x sent to cpu_gid %d [%d]\n",
               __FUNCTION__,
               cpu->gid,
               event,
               cpu_gid,
               tm_now);

        return 0;
}

/** This is the only function that handle remote data **/
static void remote_event_send(struct event_s *event, 
                                struct event_listner_s *el, 
                                uint_t cid, uint_t cpu_gid)
{ 
        error_t retry;
        uint_t tm_stamp;
        uint_t prio;

        tm_stamp = cpu_time_stamp();
        prio     = event_get_priority(event);

        while((retry = event_fifo_put(&el->tbl[prio].fifo, cid, event)) != 0)
        {
                retry = re_send_backoff(event, cpu_gid, tm_stamp);
    
                if(retry == 0)
                        break;
        }


#if 1
        bool_t isPending;
        uint_t flags = remote_lw((void*)&el->flags, cid);
        isPending = (flags & EVENT_PENDING) ? true : false;

        remote_sw((void*)&el->flags, cid, flags | EVENT_PENDING);
        cpu_wbflush();
        pmm_cache_flush_raddr((vma_t) &el->flags, cid, PMM_DATA);

        if((prio < E_FUNC) && (isPending == false))
        {
                (void)arch_cpu_send_ipi(cpu_gid);
        }
#else

        if((prio < E_FUNC))
        {
                (void)arch_cpu_send_ipi(cpu_gid);
        }
#endif
}
#endif

/* must be called with all irq disabled */
void event_send(struct event_s *event, uint_t cpu_gid)
{
        uint_t cid = arch_cpu_cid(cpu_gid);
        uint_t lid = arch_cpu_lid(cpu_gid);

        if (cid != current_cid)
        {
                PANIC("event not local cid [cpu %d, cid %d, cycle %u]\n", 
                      cpu_get_id(), 
                      cid,
                      cpu_time_stamp());
        }
        
        local_event_send(event, &cpu_lid2ptr(lid)->le_listner, true);
}


static void local_event_listner_notify(struct event_listner_s *el)
{
        register struct event_s *event;
        register uint_t count;
        register uint_t start_prio;
        register uint_t current_prio;

#if CONFIG_SHOW_LOCAL_EVENTS
        register uint_t cntr;
#endif
  
        count = 0;
        assert((el->flags & EVENT_PENDING) && "event_notify is called but no event is pending");

        el->flags   &= ~EVENT_PENDING;
        start_prio   = el->prio ++;
        current_prio = start_prio;

        while(current_prio < E_PRIO_NR)
        {
                if(el->prio <= start_prio)
                {
                        start_prio   = el->prio ++;
                        current_prio = start_prio;
                }

                while(el->tbl[current_prio].count != 0)
                {
                        assert(!(list_empty(&el->tbl[current_prio].root)) && "pending event queue is empty");

                        event = list_first(&el->tbl[current_prio].root, struct event_s, e_list);
                        //printk(INFO, "%d Handling event %p with prio %d\n", current_cpu->gid, event, current_prio);
                        list_unlink(&event->e_list);
      
                        el->tbl[current_prio].count --;
      
                        cpu_enable_all_irq(NULL);
                        event_get_handler(event)(event);         /* el->prio can be changed */
                        count ++;

#if CONFIG_SHOW_LOCAL_EVENTS
                        cntr ++;
#endif

                        cpu_disable_all_irq(NULL);
                }

#if CONFIG_SHOW_LOCAL_EVENTS    
                cpu_enable_all_irq(NULL);
                if(cntr)
                {
                        printk(INFO, "INFO: cpu %d, %d pending events of priority %d have been Delivered [ %u ]\n",
                               cpu_get_id(),
                               cntr, 
                               current_prio, 
                               cpu_time_stamp());
                }
                cntr = 0;
                cpu_disable_all_irq(NULL);
#endif
    
                current_prio ++;
        }

        el->count += count;
}


#if 0
static void remote_event_listner_notify(struct event_listner_s *el)
{
        struct event_listner_s *local_el;
        struct event_s *event;
        event_prio_t current_prio;
        uint_t irq_state;
        uint_t count;
        error_t err;
        uint_t cid;
  
        local_el = &current_cpu->le_listner;
        cid = current_cid;
        count    = 0;

        do
        {
                el->flags &= ~EVENT_PENDING;
                cpu_wbflush();
                pmm_cache_flush_vaddr((vma_t)&el->flags, PMM_DATA);

                cpu_disable_all_irq(&irq_state);

                for(current_prio = E_CLK; current_prio < E_PRIO_NR; current_prio++, count++)
                {
                        while((err = event_fifo_get(&el->tbl[current_prio].fifo, cid, (void**)&event)) == 0)
                                local_event_send(event, local_el, false);//event is local
                }

                cpu_restore_irq(irq_state);
                el->count += count;

        }while(el->flags & EVENT_PENDING);
}
#endif

/* must be called with all irq disabled */
void event_listner_notify(struct event_listner_s *el)
{
        local_event_listner_notify(el);
}


void* thread_event_manager(void *arg)
{
        struct thread_s *this;
        struct cpu_s *cpu;
        uint_t irq_state;

        cpu_enable_all_irq(NULL);
  
        this = current_thread;
        cpu  = current_cpu;

        thread_preempt_disable(this);

        while(1)
        {
#if 0
                printk(INFO, "INFO: Event Handler on CPU %d, event is le pending %d [%d,%d]\n",
                       cpu->gid,
                       event_is_pending(&cpu->le_listner),
                       cpu_time_stamp(),
                       cpu_get_ticks(cpu)); 
#endif
   
                cpu_disable_all_irq(&irq_state);

                if(event_is_pending(&cpu->le_listner))
                        event_listner_notify(&cpu->le_listner);
    
                wait_on(&this->info.wait_queue, WAIT_ANY);

                sched_sleep(this);

                cpu_restore_irq(irq_state);
        }

        return NULL;
}