Subversion Repositories HelenOS-historic

Rev

Rev 1 | Rev 68 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1 Rev 15
Line 37... Line 37...
37 
#include <arch/asm.h>
 37 
#include <arch/asm.h>
38 
#include <arch.h>
 38 
#include <arch.h>
39 
 
 39 
 
40 
void timeout_init(void)
 40 
void timeout_init(void)
41 
{
 41 
{
42 
    spinlock_initialize(&the->cpu->timeoutlock);
 42 
    spinlock_initialize(&CPU->timeoutlock);
43 
    list_initialize(&the->cpu->timeout_active_head);
 43 
    list_initialize(&CPU->timeout_active_head);
44 
}
 44 
}
45 
 
 45 
 
46 
 
 46 
 
47 
void timeout_reinitialize(timeout_t *t)
 47 
void timeout_reinitialize(timeout_t *t)
48 
{
 48 
{
Line 68... Line 68...
68 
    link_t *l, *m;
 68 
    link_t *l, *m;
69 
    pri_t pri;
 69 
    pri_t pri;
70 
    __u64 sum;
 70 
    __u64 sum;
71 
 
 71 
 
72 
    pri = cpu_priority_high();
 72 
    pri = cpu_priority_high();
73 
    spinlock_lock(&the->cpu->timeoutlock);
 73 
    spinlock_lock(&CPU->timeoutlock);
74 
    spinlock_lock(&t->lock);
 74 
    spinlock_lock(&t->lock);
75 
   
 75 
   
76 
    if (t->cpu)
 76 
    if (t->cpu)
77 
        panic("timeout_register: t->cpu != 0");
 77 
        panic("timeout_register: t->cpu != 0");
78 
 
 78 
 
79 
    t->cpu = the->cpu;
 79 
    t->cpu = CPU;
80 
    t->ticks = us2ticks(time);
 80 
    t->ticks = us2ticks(time);
81 
   
 81 
   
82 
    t->handler = f;
 82 
    t->handler = f;
83 
    t->arg = arg;
 83 
    t->arg = arg;
84 
   
 84 
   
85 
    /*
 85 
    /*
86 
     * Insert t into the active timeouts list according to t->ticks.
 86 
     * Insert t into the active timeouts list according to t->ticks.
87 
     */
 87 
     */
88 
    sum = 0;
 88 
    sum = 0;
89 
    l = the->cpu->timeout_active_head.next;
 89 
    l = CPU->timeout_active_head.next;
90 
    while (l != &the->cpu->timeout_active_head) {
 90 
    while (l != &CPU->timeout_active_head) {
91 
        hlp = list_get_instance(l, timeout_t, link);
 91 
        hlp = list_get_instance(l, timeout_t, link);
92 
        spinlock_lock(&hlp->lock);
 92 
        spinlock_lock(&hlp->lock);
93 
        if (t->ticks < sum + hlp->ticks) {
 93 
        if (t->ticks < sum + hlp->ticks) {
94 
            spinlock_unlock(&hlp->lock);
 94 
            spinlock_unlock(&hlp->lock);
95 
            break;
 95 
            break;
Line 107... Line 107...
107 
    t->ticks -= sum;
 107 
    t->ticks -= sum;
108 
 
 108 
 
109 
    /*
 109 
    /*
110 
     * Decrease ticks of t's immediate succesor by t->ticks.
 110 
     * Decrease ticks of t's immediate succesor by t->ticks.
111 
     */
 111 
     */
112 
    if (l != &the->cpu->timeout_active_head) {
 112 
    if (l != &CPU->timeout_active_head) {
113 
        spinlock_lock(&hlp->lock);
 113 
        spinlock_lock(&hlp->lock);
114 
        hlp->ticks -= t->ticks;
 114 
        hlp->ticks -= t->ticks;
115 
        spinlock_unlock(&hlp->lock);
 115 
        spinlock_unlock(&hlp->lock);
116 
    }
 116 
    }
117 
 
 117 
 
118 
    spinlock_unlock(&t->lock);
 118 
    spinlock_unlock(&t->lock);
119 
    spinlock_unlock(&the->cpu->timeoutlock);
 119 
    spinlock_unlock(&CPU->timeoutlock);
120 
    cpu_priority_restore(pri);
 120 
    cpu_priority_restore(pri);
121 
}
 121 
}
122 
 
 122 
 
123 
int timeout_unregister(timeout_t *t)
 123 
int timeout_unregister(timeout_t *t)
124 
{
 124 
{