1 /* $NetBSD: event.c,v 1.26 2021/09/26 01:16:09 thorpej Exp $ */
2
3 /*
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This software was developed by the Computer Systems Engineering group
8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
9 * contributed to Berkeley.
10 *
11 * All advertising materials mentioning features or use of this software
12 * must display the following acknowledgement:
13 * This product includes software developed by the University of
14 * California, Lawrence Berkeley Laboratory.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. Neither the name of the University nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * SUCH DAMAGE.
39 *
40 * @(#)event.c 8.1 (Berkeley) 6/11/93
41 */
42
43 /*
44 * Internal `Firm_event' interface for the keyboard and mouse drivers.
45 */
46
47 #include <sys/cdefs.h>
48 __KERNEL_RCSID(0, "$NetBSD: event.c,v 1.26 2021/09/26 01:16:09 thorpej Exp $");
49
50 #include <sys/param.h>
51 #include <sys/fcntl.h>
52 #include <sys/malloc.h>
53 #include <sys/proc.h>
54 #include <sys/systm.h>
55 #include <sys/vnode.h>
56 #include <sys/select.h>
57 #include <sys/poll.h>
58
59 #include <dev/sun/vuid_event.h>
60 #include <dev/sun/event_var.h>
61
62 int (*ev_out32_hook)(struct firm_event *, int, struct uio *);
63
64 /*
65 * Initialize a firm_event queue.
66 */
67 void
ev_init(struct evvar * ev)68 ev_init(struct evvar *ev)
69 {
70
71 ev->ev_get = ev->ev_put = 0;
72 ev->ev_q = malloc((u_long)EV_QSIZE * sizeof(struct firm_event),
73 M_DEVBUF, M_WAITOK|M_ZERO);
74 selinit(&ev->ev_sel);
75 }
76
77 /*
78 * Tear down a firm_event queue.
79 */
80 void
ev_fini(struct evvar * ev)81 ev_fini(struct evvar *ev)
82 {
83
84 seldestroy(&ev->ev_sel);
85 free(ev->ev_q, M_DEVBUF);
86 }
87
88 /*
89 * User-level interface: read, select.
90 * (User cannot write an event queue.)
91 */
92 int
ev_read(struct evvar * ev,struct uio * uio,int flags)93 ev_read(struct evvar *ev, struct uio *uio, int flags)
94 {
95 int s, n, cnt, error;
96
97 /*
98 * Make sure we can return at least 1.
99 */
100 if (uio->uio_resid < sizeof(struct firm_event))
101 return (EMSGSIZE); /* ??? */
102 s = splev();
103 while (ev->ev_get == ev->ev_put) {
104 if (flags & IO_NDELAY) {
105 splx(s);
106 return (EWOULDBLOCK);
107 }
108 ev->ev_wanted = 1;
109 error = tsleep((void *)ev, PEVENT | PCATCH, "firm_event", 0);
110 if (error) {
111 splx(s);
112 return (error);
113 }
114 }
115 /*
116 * Move firm_events from tail end of queue (there is at least one
117 * there).
118 */
119 if (ev->ev_put < ev->ev_get)
120 cnt = EV_QSIZE - ev->ev_get; /* events in [get..QSIZE) */
121 else
122 cnt = ev->ev_put - ev->ev_get; /* events in [get..put) */
123 splx(s);
124 n = howmany(uio->uio_resid, sizeof(struct firm_event));
125 if (cnt > n)
126 cnt = n;
127 if ((curproc->p_flag & PK_32) && ev_out32_hook != NULL)
128 error = (*ev_out32_hook)(&ev->ev_q[ev->ev_get], cnt, uio);
129 else
130 error = uiomove((void *)&ev->ev_q[ev->ev_get],
131 cnt * sizeof(struct firm_event), uio);
132 n -= cnt;
133 /*
134 * If we do not wrap to 0, used up all our space, or had an error,
135 * stop. Otherwise move from front of queue to put index, if there
136 * is anything there to move.
137 */
138 if ((ev->ev_get = (ev->ev_get + cnt) % EV_QSIZE) != 0 ||
139 n == 0 || error || (cnt = ev->ev_put) == 0)
140 return (error);
141 if (cnt > n)
142 cnt = n;
143 if ((curproc->p_flag & PK_32) && ev_out32_hook != NULL)
144 error = (*ev_out32_hook)(&ev->ev_q[0], cnt, uio);
145 else
146 error = uiomove((void *)&ev->ev_q[0],
147 cnt * sizeof(struct firm_event), uio);
148 ev->ev_get = cnt;
149 return (error);
150 }
151
152 int
ev_poll(struct evvar * ev,int events,struct lwp * l)153 ev_poll(struct evvar *ev, int events, struct lwp *l)
154 {
155 int s = splev(), revents = 0;
156
157 if (events & (POLLIN | POLLRDNORM)) {
158 if (ev->ev_get == ev->ev_put)
159 selrecord(l, &ev->ev_sel);
160 else
161 revents |= events & (POLLIN | POLLRDNORM);
162 }
163 revents |= events & (POLLOUT | POLLWRNORM);
164
165 splx(s);
166 return (revents);
167 }
168
169 static void
filt_evrdetach(struct knote * kn)170 filt_evrdetach(struct knote *kn)
171 {
172 struct evvar *ev = kn->kn_hook;
173 int s;
174
175 s = splev();
176 selremove_knote(&ev->ev_sel, kn);
177 splx(s);
178 }
179
180 static int
filt_evread(struct knote * kn,long hint)181 filt_evread(struct knote *kn, long hint)
182 {
183 struct evvar *ev = kn->kn_hook;
184
185 if (ev->ev_get == ev->ev_put)
186 return (0);
187
188 if (ev->ev_get < ev->ev_put)
189 kn->kn_data = ev->ev_put - ev->ev_get;
190 else
191 kn->kn_data = (EV_QSIZE - ev->ev_get) +
192 ev->ev_put;
193
194 kn->kn_data *= sizeof(struct firm_event);
195
196 return (1);
197 }
198
199 static const struct filterops ev_filtops = {
200 .f_flags = FILTEROP_ISFD,
201 .f_attach = NULL,
202 .f_detach = filt_evrdetach,
203 .f_event = filt_evread,
204 };
205
206 int
ev_kqfilter(struct evvar * ev,struct knote * kn)207 ev_kqfilter(struct evvar *ev, struct knote *kn)
208 {
209 int s;
210
211 switch (kn->kn_filter) {
212 case EVFILT_READ:
213 kn->kn_fop = &ev_filtops;
214 break;
215
216 default:
217 return (EINVAL);
218 }
219
220 kn->kn_hook = ev;
221
222 s = splev();
223 selrecord_knote(&ev->ev_sel, kn);
224 splx(s);
225
226 return (0);
227 }
228