Subversion Repositories HelenOS

Rev

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

Rev 4173 Rev 4252
Line 29... Line 29...
29
/** @addtogroup generic
29
/** @addtogroup generic
30
 * @{
30
 * @{
31
 */
31
 */
32
/**
32
/**
33
 * @file
33
 * @file
34
 * @brief   Kernel event notifications.
34
 * @brief Kernel event notifications.
35
 */
35
 */
36
 
36
 
37
#include <event/event.h>
37
#include <ipc/event.h>
38
#include <event/event_types.h>
38
#include <ipc/event_types.h>
39
#include <mm/slab.h>
39
#include <mm/slab.h>
40
#include <arch/types.h>
40
#include <arch/types.h>
41
#include <synch/spinlock.h>
41
#include <synch/spinlock.h>
42
#include <console/console.h>
42
#include <console/console.h>
43
#include <memstr.h>
43
#include <memstr.h>
Line 47... Line 47...
47
/**
47
/**
48
 * The events array.
48
 * The events array.
49
 * Arranging the events in this two-dimensional array should decrease the
49
 * Arranging the events in this two-dimensional array should decrease the
50
 * likelyhood of cacheline ping-pong.
50
 * likelyhood of cacheline ping-pong.
51
 */
51
 */
52
static event_t *events[EVENT_END];
52
static event_t events[EVENT_END];
53
 
53
 
54
/** Initialize kernel events. */
54
/** Initialize kernel events. */
55
void event_init(void)
55
void event_init(void)
56
{
56
{
57
    int i;
57
    unsigned int i;
58
 
58
   
59
    for (i = 0; i < EVENT_END; i++) {
59
    for (i = 0; i < EVENT_END; i++) {
60
        events[i] = (event_t *) malloc(sizeof(event_t), 0);
-
 
61
        spinlock_initialize(&events[i]->lock, "event.lock");
60
        spinlock_initialize(&events[i].lock, "event.lock");
62
        events[i]->answerbox = NULL;
61
        events[i].answerbox = NULL;
63
        events[i]->counter = 0;
62
        events[i].counter = 0;
64
        events[i]->method = 0;
63
        events[i].method = 0;
65
    }
64
    }
66
}
65
}
67
 
66
 
68
static int
67
static int
69
event_subscribe(event_type_t e, unative_t method, answerbox_t *answerbox)
68
event_subscribe(event_type_t evno, unative_t method, answerbox_t *answerbox)
70
{
69
{
71
    if (e >= EVENT_END)
70
    if (evno >= EVENT_END)
72
        return ELIMIT;
71
        return ELIMIT;
73
 
72
   
74
    int res = EEXISTS;
-
 
75
    event_t *event = events[e];
73
    spinlock_lock(&events[evno].lock);
76
 
74
   
77
    spinlock_lock(&event->lock);
75
    int res;
-
 
76
   
78
    if (!event->answerbox) {
77
    if (events[evno].answerbox == NULL) {
79
        event->answerbox = answerbox;
78
        events[evno].answerbox = answerbox;
80
        event->method = method;
79
        events[evno].method = method;
81
        event->counter = 0;
80
        events[evno].counter = 0;
82
        res = EOK;
81
        res = EOK;
-
 
82
    } else
-
 
83
        res = EEXISTS;
83
    }
84
   
84
    spinlock_unlock(&event->lock);
85
    spinlock_unlock(&events[evno].lock);
85
 
86
   
86
    return res;
87
    return res;
87
}
88
}
88
 
89
 
89
unative_t sys_event_subscribe(unative_t evno, unative_t method)
90
unative_t sys_event_subscribe(unative_t evno, unative_t method)
90
{
91
{
91
    return (unative_t) event_subscribe((event_type_t) evno, (unative_t)
92
    return (unative_t) event_subscribe((event_type_t) evno, (unative_t)
92
        method, &TASK->answerbox);
93
        method, &TASK->answerbox);
93
}
94
}
94
 
95
 
95
bool event_is_subscribed(event_type_t e)
96
bool event_is_subscribed(event_type_t evno)
96
{
97
{
97
    bool res;
98
    bool res;
98
 
99
   
99
    ASSERT(e < EVENT_END);
100
    ASSERT(evno < EVENT_END);
-
 
101
   
100
    spinlock_lock(&events[e]->lock);
102
    spinlock_lock(&events[evno].lock);
101
    res = events[e]->answerbox != NULL;
103
    res = events[evno].answerbox != NULL;
102
    spinlock_unlock(&events[e]->lock);
104
    spinlock_unlock(&events[evno].lock);
103
 
105
   
104
    return res;
106
    return res;
105
}
107
}
106
 
108
 
107
 
109
 
108
void event_cleanup_answerbox(answerbox_t *answerbox)
110
void event_cleanup_answerbox(answerbox_t *answerbox)
109
{
111
{
110
    int i;
112
    unsigned int i;
111
 
113
   
112
    for (i = 0; i < EVENT_END; i++) {
114
    for (i = 0; i < EVENT_END; i++) {
113
        spinlock_lock(&events[i]->lock);
115
        spinlock_lock(&events[i].lock);
114
        if (events[i]->answerbox == answerbox) {
116
        if (events[i].answerbox == answerbox) {
115
            events[i]->answerbox = NULL;
117
            events[i].answerbox = NULL;
116
            events[i]->counter = 0;
118
            events[i].counter = 0;
117
            events[i]->method = 0;
119
            events[i].method = 0;
118
        }
120
        }
119
        spinlock_unlock(&events[i]->lock);
121
        spinlock_unlock(&events[i].lock);
120
    }
122
    }
121
}
123
}
122
 
124
 
123
void
125
void
124
event_notify(event_type_t e, unative_t a1, unative_t a2, unative_t a3,
126
event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
125
    unative_t a4, unative_t a5)
127
    unative_t a4, unative_t a5)
126
{
128
{
127
    ASSERT(e < EVENT_END);
129
    ASSERT(evno < EVENT_END);
128
    event_t *event = events[e];
-
 
-
 
130
   
129
    spinlock_lock(&event->lock);
131
    spinlock_lock(&events[evno].lock);
130
    if (event->answerbox) {
132
    if (events[evno].answerbox != NULL) {
131
        call_t *call = ipc_call_alloc(FRAME_ATOMIC);
133
        call_t *call = ipc_call_alloc(FRAME_ATOMIC);
132
        if (call) {
134
        if (call) {
133
            call->flags |= IPC_CALL_NOTIF;
135
            call->flags |= IPC_CALL_NOTIF;
134
            call->priv = ++event->counter;
136
            call->priv = ++events[evno].counter;
135
            IPC_SET_METHOD(call->data, event->method);
137
            IPC_SET_METHOD(call->data, events[evno].method);
136
            IPC_SET_ARG1(call->data, a1);
138
            IPC_SET_ARG1(call->data, a1);
137
            IPC_SET_ARG2(call->data, a2);
139
            IPC_SET_ARG2(call->data, a2);
138
            IPC_SET_ARG3(call->data, a3);
140
            IPC_SET_ARG3(call->data, a3);
139
            IPC_SET_ARG4(call->data, a4);
141
            IPC_SET_ARG4(call->data, a4);
140
            IPC_SET_ARG5(call->data, a5);
142
            IPC_SET_ARG5(call->data, a5);
141
 
143
           
142
            spinlock_lock(&event->answerbox->irq_lock);
144
            spinlock_lock(&events[evno].answerbox->irq_lock);
143
            list_append(&call->link, &event->answerbox->irq_notifs);
145
            list_append(&call->link, &events[evno].answerbox->irq_notifs);
144
            spinlock_unlock(&event->answerbox->irq_lock);
146
            spinlock_unlock(&events[evno].answerbox->irq_lock);
145
 
147
           
146
            waitq_wakeup(&event->answerbox->wq, WAKEUP_FIRST);
148
            waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST);
147
        }
149
        }
148
    }
150
    }
149
    spinlock_unlock(&event->lock);
151
    spinlock_unlock(&events[evno].lock);
150
}
152
}
151
 
153
 
152
/** @}
154
/** @}
153
 */
155
 */