Syscalls take event_queues for completion (XCC)
[akaros.git] / kern / include / ros / event.h
1 /* Copyright (c) 2010-2011 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Kernel interface for event/notification delivery and preemption. */
6
7 #ifndef ROS_INC_EVENT_H
8 #define ROS_INC_EVENT_H
9
10 #include <ros/common.h>
11 #include <ros/atomic.h>
12 #include <ros/bcq_struct.h>
13 #include <ros/arch/trapframe.h>
14
15 /* Event Delivery Flags. */
16 #define EVENT_IPI                               0x001   /* IPI the core */
17 #define EVENT_NOMSG                             0x002   /* just send the bit, not the msg */
18 #define EVENT_ROUNDROBIN                0x004   /* pick a vcore, RR style */
19 #define EVENT_VCORE_APPRO               0x008   /* send to where the kernel wants */
20
21 /* Event Message Types */
22 #define EV_NONE                                  0
23 #define EV_PREEMPT_PENDING               1
24 #define EV_GANG_PREMPT_PENDING   2
25 #define EV_VCORE_REVOKE                  3
26 #define EV_GANG_RETURN                   4
27 #define EV_USER_IPI                              5
28 #define EV_PAGE_FAULT                    6
29 #define EV_ALARM                                 7
30 #define EV_EVENT                                 8
31 #define EV_FREE_APPLE_PIE                9
32 #define EV_SYSCALL                              10
33 #define NR_EVENT_TYPES                  11 /* keep me last */
34
35 /* Will probably have dynamic notifications later */
36 #define MAX_NR_DYN_EVENT                25
37 #define MAX_NR_EVENT                    (NR_EVENT_TYPES + MAX_NR_DYN_EVENT)
38
39 /* Want to keep this small and generic, but add items as you need them.  One
40  * item some will need is an expiration time, which ought to be put in the 64
41  * bit arg.  Will need tweaking / thought as we come up with events.  These are
42  * what get put on the per-core queue in procdata. */
43 struct event_msg {
44         uint16_t                                        ev_type;
45         uint16_t                                        ev_arg1;
46         uint32_t                                        ev_arg2;
47         void                                            *ev_arg3;
48         uint64_t                                        ev_arg4;
49 };
50
51 /* Random numbers */
52 #define NR_BCQ_EVENTS 10                /* nr events in a bcq */
53 #define NR_BCQ_EV_LOOPS 4               /* how many loops to try to enqueue */
54
55 DEFINE_BCQ_TYPES(event_msg, struct event_msg, NR_BCQ_EVENTS);
56
57 /* Structure for storing / receiving event messages.  An overflow causes the
58  * bit of the event to get set in the bitmap.  You can also have just the bit
59  * sent (and no message). */
60 struct event_mbox {
61         struct event_msg_bcq            ev_msgs;
62         uint8_t                                         ev_bitmap[(MAX_NR_EVENT - 1) / 8 + 1];
63         unsigned int                            ev_overflows;
64 };
65
66 /* The kernel sends messages to this structure, which describes how and where
67  * to receive messages, including optional IPIs. */
68 struct event_queue {
69         struct event_mbox                       *ev_mbox;
70         int                                                     ev_flags;
71         uint32_t                                        ev_vcore;
72         void                                            (*ev_handler)(struct event_queue *);
73 };
74
75 /* Big version, contains storage space for the ev_mbox.  Never access the
76  * internal mbox directly. */
77 struct event_queue_big {
78         struct event_mbox                       *ev_mbox;
79         int                                                     ev_flags;
80         uint32_t                                        ev_vcore;
81         void                                            (*ev_handler)(struct event_queue *);
82         struct event_mbox                       ev_imbox;
83 };
84
85 /* Per-core data about preemptions and notifications */
86 struct preempt_data {
87         struct user_trapframe           preempt_tf;
88         struct ancillary_state          preempt_anc;
89         struct user_trapframe           notif_tf;
90         uintptr_t                                       transition_stack;       /* advertised by the user */
91         bool                                            notif_enabled;          /* vcore willing to recv */
92         bool                                            notif_pending;          /* notif k_msg on the way */
93         seq_ctr_t                                       preempt_tf_valid;
94         struct event_mbox                       ev_mbox;
95 };
96
97 /* Structs for different types of events that need parameters. */
98 // TODO: think about this a bit.  And don't want to make them til we need them.
99
100 /* Example: want the vcoreid of what was lost. */
101 struct ev_vcore_revoke {
102         uint16_t                                        type;
103         uint16_t                                        pad1;
104         uint32_t                                        vcoreid;
105         void                                            *pad3;
106         uint64_t                                        pad4;
107 };
108
109 #endif /* ROS_INC_EVENT_H */