Remove EVENT_NOMSG (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/trapframe.h>
13 /* #include <ros/ucq.h> included below */
14 /* #include <ros/evbitmap.h> included below */
15
16 /* Event Delivery Flags from the process to the kernel */
17 #define EVENT_IPI                               0x00001 /* IPI the vcore (usually with INDIR) */
18 #define EVENT_SPAM_PUBLIC               0x00002 /* spam the msg to public vcpd mboxes */
19 #define EVENT_INDIR                             0x00004 /* send an indirection event to vcore */
20 #define EVENT_VCORE_PRIVATE             0x00008 /* Will go to the private VCPD mbox */
21 #define EVENT_SPAM_INDIR                0x00010 /* spam INDIRs if the vcore's offline */
22 #define EVENT_VCORE_MUST_RUN    0x00020 /* spams go to a vcore that will run */
23 #define EVENT_NOTHROTTLE                0x00040 /* send all INDIRs (no throttling) */
24 #define EVENT_ROUNDROBIN                0x00080 /* pick a vcore, RR style */
25 #define EVENT_VCORE_APPRO               0x00100 /* send to where the kernel wants */
26 #define EVENT_WAKEUP                    0x00200 /* wake up the process after sending */
27
28 /* Event Message Types */
29 #define EV_NONE                                  0
30 #define EV_PREEMPT_PENDING               1
31 #define EV_GANG_PREMPT_PENDING   2
32 #define EV_VCORE_PREEMPT                 3
33 #define EV_GANG_RETURN                   4
34 #define EV_USER_IPI                              5
35 #define EV_PAGE_FAULT                    6
36 #define EV_ALARM                                 7
37 #define EV_EVENT                                 8
38 #define EV_FREE_APPLE_PIE                9
39 #define EV_SYSCALL                              10
40 #define EV_CHECK_MSGS                   11
41 #define EV_POSIX_SIGNAL                 12
42 #define NR_EVENT_TYPES                  25 /* keep me last (and 1 > the last one) */
43
44 /* Will probably have dynamic notifications later */
45 #define MAX_NR_DYN_EVENT                25
46 #define MAX_NR_EVENT                    (NR_EVENT_TYPES + MAX_NR_DYN_EVENT)
47
48 /* Want to keep this small and generic, but add items as you need them.  One
49  * item some will need is an expiration time, which ought to be put in the 64
50  * bit arg.  Will need tweaking / thought as we come up with events.  These are
51  * what get put on the per-core queue in procdata. */
52 struct event_msg {
53         uint16_t                                        ev_type;
54         uint16_t                                        ev_arg1;
55         uint32_t                                        ev_arg2;
56         void                                            *ev_arg3;
57         uint64_t                                        ev_arg4;
58 };
59
60 /* Include here since the mboxes need to know event.h basics (e.g. event_msg) */
61 #include <ros/ucq.h>
62 #include <ros/evbitmap.h>
63
64 #define EV_MBOX_UCQ                             1
65 #define EV_MBOX_BITMAP                  2
66
67 /* Structure for storing / receiving event messages.  An overflow causes the
68  * bit of the event to get set in the bitmap.  You can also have just the bit
69  * sent (and no message). */
70 struct event_mbox {
71         int                                             type;
72         union {
73                 struct ucq                              ucq;
74                 struct evbitmap                 evbm;
75         };
76 };
77
78 /* The kernel sends messages to this structure, which describes how and where
79  * to receive messages, including optional IPIs. */
80 struct event_queue {
81         struct event_mbox                       *ev_mbox;
82         int                                                     ev_flags;
83         bool                                            ev_alert_pending;
84         uint32_t                                        ev_vcore;
85         void                                            (*ev_handler)(struct event_queue *);
86         void                                            *ev_udata;
87 };
88
89 /* Big version, contains storage space for the ev_mbox.  Never access the
90  * internal mbox directly. */
91 struct event_queue_big {
92         struct event_mbox                       *ev_mbox;
93         int                                                     ev_flags;
94         bool                                            ev_alert_pending;
95         uint32_t                                        ev_vcore;
96         void                                            (*ev_handler)(struct event_queue *);
97         void                                            *ev_udata;
98         struct event_mbox                       ev_imbox;
99 };
100
101 /* Vcore state flags.  K_LOCK means the kernel is writing */
102 #define VC_K_LOCK                               0x001                           /* CASing with the kernel */
103 #define VC_PREEMPTED                    0x002                           /* VC is preempted */
104 #define VC_CAN_RCV_MSG                  0x004                           /* someone will get msg */
105 #define VC_UTHREAD_STEALING             0x008                           /* Uthread being stolen */
106 #define VC_SCP_NOVCCTX                  0x010                           /* can't go into vc ctx */
107
108 /* Racy flags, where we don't need the atomics */
109 #define VC_FPU_SAVED                    0x1000                          /* valid FPU state in anc */
110
111 /* Per-core data about preemptions and notifications */
112 struct preempt_data {
113         struct user_context                     vcore_ctx;                      /* for preemptions */
114         struct ancillary_state          preempt_anc;
115         struct user_context                     uthread_ctx;            /* for preempts or notifs */
116         uintptr_t                                       vcore_entry;            /* advertised by the user */
117         uintptr_t                                       vcore_stack;            /* advertised by the user */
118         uintptr_t                                       vcore_tls_desc;         /* advertised by the user */
119         atomic_t                                        flags;
120         int                                                     rflags;                         /* racy flags */
121         bool                                            notif_disabled;         /* vcore unwilling to recv*/
122         bool                                            notif_pending;          /* notif k_msg on the way */
123         struct event_mbox                       ev_mbox_public;         /* can be read remotely */
124         struct event_mbox                       ev_mbox_private;        /* for this vcore only */
125 };
126
127 #endif /* ROS_INC_EVENT_H */