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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 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 <stdio.h>
30 #include <fcntl.h>
31 #include <errno.h>
32 #include <door.h>
33 #include <unistd.h>
34 #include <stddef.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <strings.h>
38 #include <synch.h>
39 #include <sys/stat.h>
40 #include <librcm_impl.h>
41
42 #include "librcm_event.h"
43
44 #define dprint if (debug) (void) printf
45 static int debug = 1;
46
47 #define BUF_THRESHOLD 1024 /* larger bufs require a free */
48
49 /*
50 * Lookup seq_num. We can not use the standard nvlist_lookup functions since
51 * the nvlist is not allocated with NV_UNIQUE_NAME or NV_UNIQUE_NAME_TYPE.
52 */
53 static int
lookup_seq_num(nvlist_t * nvl,uint64_t * seq_num)54 lookup_seq_num(nvlist_t *nvl, uint64_t *seq_num)
55 {
56 nvpair_t *nvp = NULL;
57
58 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
59 if (strcmp(nvpair_name(nvp), RCM_SEQ_NUM) == 0 &&
60 nvpair_type(nvp) == DATA_TYPE_UINT64)
61 return (nvpair_value_uint64(nvp, seq_num));
62 }
63
64 return (ENOENT);
65 }
66
67 /*
68 * Get event service from a named door.
69 *
70 * This is similar to sysevent_post_event(), except that it deals with
71 * the "return buffer problem":
72 * Typically, the door service places the return buffer on the stack
73 * when calling door_return(). This places an artificial limit on the
74 * size of the return buffer.
75 * This problem is solved by placing large buffers on the heap, referenced
76 * through door_info. When client detects a large buffer, it will make a
77 * second door_call() to free the buffer. The client and the server agrees
78 * on a size, which is defined as BUF_THRESHOLD.
79 *
80 * Returns -1 if message not delivered. With errno set to cause of error.
81 * Returns 0 for success with the results returned in posting buffer.
82 */
83 int
get_event_service(char * door_name,void * data,size_t datalen,void ** result,size_t * rlen)84 get_event_service(char *door_name, void *data, size_t datalen,
85 void **result, size_t *rlen)
86 {
87 int service_door, error;
88 door_arg_t door_arg;
89
90 /*
91 * Open the service door
92 */
93 if ((service_door = open(door_name, O_RDONLY, 0)) == -1) {
94 errno = ESRCH;
95 return (-1);
96 }
97
98 retry1:
99 door_arg.rbuf = NULL; /* doorfs will provide return buf */
100 door_arg.rsize = 0;
101 door_arg.data_ptr = data;
102 door_arg.data_size = datalen;
103 door_arg.desc_ptr = NULL;
104 door_arg.desc_num = 0;
105
106 /*
107 * Make door call
108 * EAGAIN is returned when the door server is temporarily
109 * out of threads to service the door call. So retry.
110 */
111 if ((error = door_call(service_door, &door_arg)) == -1 &&
112 errno == EAGAIN) {
113 (void) sleep(1);
114 goto retry1;
115 }
116
117 if ((error == 0) && result) {
118
119 uint64_t seq_num = 0;
120
121 *result = NULL;
122 *rlen = 0;
123 if (door_arg.rbuf == NULL || door_arg.rsize == 0) {
124 dprint("bad return from door call\n");
125 (void) close(service_door);
126 errno = EFAULT;
127 return (-1);
128 }
129
130 (void) nvlist_unpack(door_arg.rbuf, door_arg.rsize,
131 (nvlist_t **)result, 0);
132 (void) munmap(door_arg.rbuf, door_arg.rsize);
133
134 /*
135 * If requiring a buf free, make another door call. There is
136 * no need to call munmap() after this door call, though.
137 */
138 if (lookup_seq_num((nvlist_t *)*result, &seq_num) == 0) {
139 retry2:
140 door_arg.rbuf = NULL;
141 door_arg.rsize = 0;
142 door_arg.data_ptr = (char *)&seq_num;
143 door_arg.data_size = sizeof (seq_num);
144 door_arg.desc_ptr = NULL;
145 door_arg.desc_num = 0;
146 if (door_call(service_door, &door_arg) == -1) {
147 if (errno == EAGAIN) {
148 (void) sleep(1);
149 goto retry2;
150 }
151 dprint("fail to free event buf in server\n");
152 }
153 }
154 }
155
156 (void) close(service_door);
157 return (error);
158 }
159
160 /*
161 * Export an event service door
162 */
163 struct door_result {
164 struct door_result *next;
165 void *data;
166 uint64_t seq_num;
167 };
168
169 typedef struct door_cookie {
170 uint64_t seq_num;
171 mutex_t door_lock;
172 void (*door_func)(void **, size_t *);
173 struct door_result *results;
174 } door_cookie_t;
175
176 /*
177 * add result to cookie, this is only invoked if result size > BUF_THRESHOLD
178 */
179 static void
add_door_result(door_cookie_t * cook,void * data,uint64_t seq_num)180 add_door_result(door_cookie_t *cook, void *data, uint64_t seq_num)
181 {
182 struct door_result *result;
183
184 /*
185 * Need a better way to handle memory here
186 */
187 result = malloc(sizeof (*result));
188 while (result == NULL) {
189 (void) sleep(1);
190 result = malloc(sizeof (*result));
191 }
192 result->next = NULL;
193 result->data = data;
194 result->seq_num = seq_num;
195
196 /*
197 * Attach current door result to the door cookie
198 */
199 (void) mutex_lock(&cook->door_lock);
200 if (cook->results == NULL) {
201 cook->results = result;
202 } else {
203 struct door_result *tmp = cook->results;
204 while (tmp->next) {
205 tmp = tmp->next;
206 }
207 tmp->next = result;
208 }
209 (void) mutex_unlock(&cook->door_lock);
210 }
211
212 /*
213 * free a previous door result as described by number.
214 */
215 static void
free_door_result(door_cookie_t * cook,uint64_t num)216 free_door_result(door_cookie_t *cook, uint64_t num)
217 {
218 struct door_result *prev = NULL, *tmp;
219
220 (void) mutex_lock(&cook->door_lock);
221 tmp = cook->results;
222 while (tmp && tmp->seq_num != num) {
223 prev = tmp;
224 tmp = tmp->next;
225 }
226
227 if (tmp == NULL) {
228 dprint("attempting to free nonexistent buf: %llu\n",
229 (unsigned long long)num);
230 (void) mutex_unlock(&cook->door_lock);
231 return;
232 }
233
234 if (prev) {
235 prev->next = tmp->next;
236 } else {
237 cook->results = tmp->next;
238 }
239 (void) mutex_unlock(&cook->door_lock);
240
241 free(tmp->data);
242 free(tmp);
243 }
244
245 /*ARGSUSED*/
246 static void
door_service(void * cookie,char * args,size_t alen,door_desc_t * ddp,uint_t ndid)247 door_service(void *cookie, char *args, size_t alen,
248 door_desc_t *ddp, uint_t ndid)
249 {
250 nvlist_t *nvl;
251 size_t nvl_size = 0;
252 char rbuf[BUF_THRESHOLD];
253 door_cookie_t *cook = (door_cookie_t *)cookie;
254 uint64_t seq_num = 0;
255
256 /*
257 * Special case for asking to free buffer
258 */
259 if (alen == sizeof (uint64_t)) {
260 free_door_result(cookie, *(uint64_t *)(void *)args);
261 (void) door_return(NULL, 0, NULL, 0);
262 }
263
264 /*
265 * door_func update args to point to return results.
266 * memory for results are dynamically allocated.
267 */
268 (*cook->door_func)((void **)&args, &alen);
269
270 /*
271 * If no results, just return
272 */
273 if (args == NULL) {
274 dprint("null results returned from door_func().\n");
275 (void) door_return(NULL, 0, NULL, 0);
276 }
277
278 /* Determine the size of the packed nvlist */
279 nvl = (nvlist_t *)(void *)args;
280 args = NULL;
281 alen = 0;
282 if (errno = nvlist_size(nvl, &nvl_size, NV_ENCODE_NATIVE)) {
283 nvlist_free(nvl);
284 dprint("failure to sizeup door results: %s\n", strerror(errno));
285 (void) door_return(NULL, 0, NULL, 0);
286 }
287
288 /*
289 * If the size of the packed nvlist would exceed the buffer threshold
290 * then get a sequence number and add it to the nvlist.
291 */
292 if (nvl_size > BUF_THRESHOLD) {
293 (void) mutex_lock(&cook->door_lock);
294 cook->seq_num++;
295 seq_num = cook->seq_num;
296 (void) mutex_unlock(&cook->door_lock);
297 (void) nvlist_add_uint64(nvl, RCM_SEQ_NUM, seq_num);
298 }
299
300 /* Refill the args with a packed version of the nvlist */
301 if (errno = nvlist_pack(nvl, &args, &alen, NV_ENCODE_NATIVE, 0)) {
302 nvlist_free(nvl);
303 dprint("failure to pack door results: %s\n", strerror(errno));
304 (void) door_return(NULL, 0, NULL, 0);
305 }
306 nvlist_free(nvl);
307
308 /*
309 * Based on the size of the packed nvlist, either use the local buffer
310 * or add it to the results list.
311 */
312 if (alen <= BUF_THRESHOLD) {
313 bcopy(args, rbuf, alen);
314 (void) free(args);
315 args = rbuf;
316 } else {
317 /*
318 * for long data, append results to end of queue in cook
319 * and set ndid, ask client to do another door_call
320 * to free the buffer.
321 */
322 add_door_result(cook, args, seq_num);
323 }
324
325 (void) door_return(args, alen, NULL, 0);
326 }
327
328 int
create_event_service(char * door_name,void (* func)(void ** data,size_t * datalen))329 create_event_service(char *door_name,
330 void (*func)(void **data, size_t *datalen))
331 {
332 int service_door, fd;
333 door_cookie_t *cookie;
334
335 /* create an fs file */
336 fd = open(door_name, O_EXCL|O_CREAT, S_IREAD|S_IWRITE);
337 if ((fd == -1) && (errno != EEXIST)) {
338 return (-1);
339 }
340 (void) close(fd);
341
342 /* allocate space for door cookie */
343 if ((cookie = calloc(1, sizeof (*cookie))) == NULL) {
344 return (-1);
345 }
346
347 cookie->door_func = func;
348 if ((service_door = door_create(door_service, (void *)cookie,
349 DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
350 dprint("door create failed: %s\n", strerror(errno));
351 free(cookie);
352 return (-1);
353 }
354
355 retry:
356 (void) fdetach(door_name);
357 if (fattach(service_door, door_name) != 0) {
358 if (errno == EBUSY) {
359 /*
360 * EBUSY error may occur if anyone references the door
361 * file while we are fattach'ing. Since librcm, in the
362 * the process context of a DR initiator program, may
363 * reference the door file (via open/close/stat/
364 * door_call etc.) while we are still fattach'ing,
365 * retry on EBUSY.
366 */
367 goto retry;
368 }
369 dprint("door attaching failed: %s\n", strerror(errno));
370 free(cookie);
371 (void) close(service_door);
372 return (-1);
373 }
374
375 return (service_door);
376 }
377
378 int
revoke_event_service(int fd)379 revoke_event_service(int fd)
380 {
381 struct door_info info;
382 door_cookie_t *cookie;
383
384 if (door_info(fd, &info) == -1) {
385 return (-1);
386 }
387
388 if (door_revoke(fd) != 0) {
389 return (-1);
390 }
391
392 /* wait for existing door calls to finish */
393 (void) sleep(1);
394
395 if ((cookie = (door_cookie_t *)(uintptr_t)info.di_data) != NULL) {
396 struct door_result *tmp = cookie->results;
397 while (tmp) {
398 cookie->results = tmp->next;
399 free(tmp->data);
400 free(tmp);
401 tmp = cookie->results;
402 }
403 free(cookie);
404 }
405 return (0);
406 }
407