1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include "lint.h"
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <sys/port_impl.h>
35 #include <errno.h>
36 #include <stdlib.h>
37 #include <sys/systm.h>
38 #include <libc.h>
39
40 /*
41 * The second argument of _portfs(PORT_CREATE, 0,,,) represents the version
42 * number of the event ports framework. The version number is required to
43 * identify possible changes/extensions of the port_event_t structure. If an
44 * extension is required the port_create() function will be mapped to a second
45 * library create function like port_create_v1(PORT_CREATE, VERSION,,,)
46 * VERSION will be a number > 0.
47 * As long as such an extension is not required the second argument will be
48 * set to 0 and no check will be done in the kernel interface.
49 */
50 int
port_create()51 port_create()
52 {
53 rval_t r;
54 r.r_vals = _portfs(PORT_CREATE | PORT_SYS_NOPORT, 0, 0, 0, 0, 0);
55 return (r.r_val1);
56 }
57
58 int
port_associate(int port,int source,uintptr_t object,int events,void * user)59 port_associate(int port, int source, uintptr_t object, int events, void *user)
60 {
61 rval_t r;
62 r.r_vals = _portfs(PORT_ASSOCIATE, port, source, object, events,
63 (uintptr_t)user);
64 return (r.r_val1);
65 }
66
67
68 int
port_get(int port,port_event_t * pe,struct timespec * to)69 port_get(int port, port_event_t *pe, struct timespec *to)
70 {
71 rval_t r;
72 if (to)
73 r.r_vals = _portfs(PORT_GET, port, (uintptr_t)pe, to->tv_sec,
74 to->tv_nsec, (uintptr_t)to);
75 else
76 r.r_vals = _portfs(PORT_GET, port, (uintptr_t)pe, 0, 0, NULL);
77 return (r.r_val1);
78 }
79
80 int
port_getn(int port,port_event_t list[],uint_t max,uint_t * nget,struct timespec * timeout)81 port_getn(int port, port_event_t list[], uint_t max, uint_t *nget,
82 struct timespec *timeout)
83 {
84 rval_t r;
85 if (nget == NULL) {
86 errno = EINVAL;
87 return (-1);
88 }
89 r.r_vals = _portfs(PORT_GETN, port, (uintptr_t)list, max, *nget,
90 (uintptr_t)timeout);
91 if (r.r_val1 == -1) {
92 /* global error, errno is already set */
93 return (-1);
94 }
95 *nget = r.r_val1;
96 if (r.r_val2 == ETIME) {
97 errno = ETIME;
98 return (-1);
99 }
100 return (r.r_val2);
101 }
102
103 int
port_dissociate(int port,int source,uintptr_t object)104 port_dissociate(int port, int source, uintptr_t object)
105 {
106 rval_t r;
107 r.r_vals = _portfs(PORT_DISSOCIATE, port, source, object, 0, 0);
108 return (r.r_val1);
109 }
110
111 int
port_send(int port,int events,void * user)112 port_send(int port, int events, void *user)
113 {
114 rval_t r;
115 r.r_vals = _portfs(PORT_SEND, port, events, (uintptr_t)user, NULL,
116 NULL);
117 return (r.r_val1);
118 }
119
120 /*
121 * _port_dispatch() will block if there are not resources available to
122 * satisfy the request.
123 */
124
125 int
_port_dispatch(int port,int flags,int source,int events,uintptr_t object,void * user)126 _port_dispatch(int port, int flags, int source, int events, uintptr_t object,
127 void *user)
128 {
129 rval_t r;
130 if (flags & PORT_SHARE_EVENT)
131 r.r_vals = _portfs(PORT_DISPATCH, port, source, events, object,
132 (uintptr_t)user);
133 else
134 r.r_vals = _portfs(PORT_DISPATCH | PORT_SYS_NOSHARE, port,
135 source, events, object, (uintptr_t)user);
136 return (r.r_val1);
137 }
138
139 int
port_sendn(int ports[],int errors[],uint_t nent,int events,void * user)140 port_sendn(int ports[], int errors[], uint_t nent, int events, void *user)
141 {
142 rval_t r;
143 uint_t offset;
144 uint_t lnent;
145 uint_t nevents;
146 if (nent <= PORT_MAX_LIST) {
147 r.r_vals = _portfs(PORT_SENDN | PORT_SYS_NOPORT,
148 (uintptr_t)ports, (uintptr_t)errors, nent, events,
149 (uintptr_t)user);
150 return (r.r_val1);
151 }
152
153 /* use chunks of max PORT_MAX_LIST elements per syscall */
154 nevents = 0;
155 for (offset = 0; offset < nent; ) {
156 lnent = nent - offset;
157 if (nent - offset > PORT_MAX_LIST)
158 lnent = PORT_MAX_LIST;
159 else
160 lnent = nent - offset;
161 r.r_vals = _portfs(PORT_SENDN | PORT_SYS_NOPORT,
162 (uintptr_t)&ports[offset], (uintptr_t)&errors[offset],
163 lnent, events, (uintptr_t)user);
164 if (r.r_val2 == -1) {
165 /* global error, return last no of events submitted */
166 if (nevents)
167 return (nevents);
168 return (-1);
169 }
170 nevents += r.r_val1;
171 offset += lnent;
172 }
173 /* list submitted */
174 return (nevents);
175 }
176
177 int
port_alert(int port,int flags,int events,void * user)178 port_alert(int port, int flags, int events, void *user)
179 {
180 rval_t r;
181 r.r_vals = _portfs(PORT_ALERT, port, flags, events, (uintptr_t)user,
182 NULL);
183 return (r.r_val1);
184 }
185