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 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
28 */
29
30 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
31 /* All Rights Reserved */
32 /*
33 * Portions of this source code were derived from Berkeley
34 * 4.3 BSD under license from the Regents of the University of
35 * California.
36 */
37
38 /*
39 * This is the rpc server side idle loop
40 * Wait for input, call server program.
41 */
42 #include "mt.h"
43 #include "rpc_mt.h"
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <signal.h>
47 #include <rpc/rpc.h>
48 #include <errno.h>
49 #include <sys/poll.h>
50 #include <sys/types.h>
51 #include <syslog.h>
52 #include <thread.h>
53 #include <assert.h>
54 #include <libintl.h>
55 #include <values.h>
56
57 extern const char __nsl_dom[];
58
59 extern int __rpc_compress_pollfd(int, pollfd_t *, pollfd_t *);
60 extern bool_t __is_a_userfd(int P_fd);
61 extern void __destroy_userfd();
62 extern void clear_pollfd(int);
63 extern void set_pollfd(int /* fd */, short /* events */);
64 extern void svc_getreq_poll();
65 extern void (*__proc_cleanup_cb)();
66
67 static void start_threads();
68 static void create_pipe();
69 static void clear_pipe();
70 static int select_next_pollfd();
71 static SVCXPRT *make_xprt_copy();
72 static void _svc_run_mt();
73 static void _svc_run();
74
75 int _svc_prog_dispatch();
76 static void _svc_done_private();
77
78 extern rwlock_t svc_fd_lock;
79 extern mutex_t svc_door_mutex;
80 extern cond_t svc_door_waitcv;
81 extern int svc_ndoorfds;
82 extern void __svc_cleanup_door_xprts();
83 extern void __svc_free_xprtlist();
84 extern void __svc_getreq_user(struct pollfd *);
85
86 /*
87 * Maximum fragment size allowed for connection oriented connections.
88 * Zero means that no maximum size limit has been requested.
89 */
90 int __rpc_connmaxrec = 0;
91
92 /* Inter-Record Timeout in secs for non-blocked connection RPC */
93 int __rpc_irtimeout = 35;
94
95 /*
96 * Request exclusive access to tcp and udp non-priv ports bound with a
97 * wildcard addr.
98 */
99 bool_t __rpc_tp_exclbind = FALSE;
100
101 /*
102 * Maximum number of outstanding connection indications (listen backlog).
103 */
104 static int __svc_lstnbklog = 64; /* Chosen Arbitrarily */
105
106 /*
107 * XXX - eventually, all mutexes and their initializations static
108 */
109
110 /*
111 * Variables used for MT
112 */
113 int svc_mt_mode; /* multi-threading mode */
114
115 int svc_pipe[2]; /* pipe for breaking out of poll: read(0), write(1) */
116
117 /* BEGIN PROTECTED BY svc_mutex */
118
119 static int svc_thr_max = 16; /* default maximum number of threads allowed */
120
121 static int svc_thr_total; /* current number of threads */
122
123 static int svc_thr_active; /* current number of threads active */
124
125 /* circular array of file descriptors with pending data */
126
127 #define CIRCULAR_BUFSIZE 1024
128
129 static int svc_pending_fds[CIRCULAR_BUFSIZE+1]; /* fds with pending data */
130
131 static int svc_next_pending; /* next one to be processed */
132
133 static int svc_last_pending; /* last one in list */
134
135 static int svc_total_pending; /* total in list */
136
137 static int svc_thr_total_creates; /* total created - stats */
138
139 static int svc_thr_total_create_errors; /* total create errors - stats */
140
141 static int svc_waiters; /* number of waiting threads */
142
143 /* END PROTECTED BY svc_mutex */
144
145 /* BEGIN PROTECTED BY svc_fd_lock: */
146
147 int svc_nfds; /* total number of active file descriptors */
148
149 int svc_nfds_set; /* total number of fd bits set in svc_fdset */
150
151 int svc_max_fd = 0; /* largest active file descriptor */
152
153 int svc_npollfds; /* total number of active pollfds */
154
155 int svc_npollfds_set; /* total number of pollfd set in svc_pollfd */
156
157 int svc_max_pollfd; /* largest active pollfd so far */
158
159 int svc_pollfd_allocd; /* number of pollfd structures allocated */
160
161 /* END PROTECTED BY svc_fd_lock: */
162
163 /* BEGIN PROTECTED BY svc_thr_mutex */
164
165 #define POLLSET_EXTEND 256
166 static int svc_pollset_allocd;
167 static struct pollfd *svc_pollset;
168 /*
169 * array of file descriptors currently active
170 */
171 static int svc_polled; /* no of fds polled in last poll() - input */
172
173 static int svc_pollfds; /* no of active fds in last poll() - output */
174
175 static int svc_next_pollfd; /* next fd to processin svc_pollset */
176
177 bool_t svc_polling; /* true if a thread is polling */
178
179 /* END PROTECTED BY svc_thr_mutex */
180
181 /* BEGIN PROTECTED BY svc_exit_mutex */
182
183 static bool_t svc_exit_done = TRUE;
184
185 /* END PROTECTED BY svc_exit_mutex */
186
187 /* VARIABLES PROTECTED BY svc_mutex:
188 svc_thr_total, svc_thr_active, svc_pending_fds, svc_next_pending,
189 svc_last_pending, svc_total_pending, svc_thr_total_creates,
190 svc_thr_total_create_errors,
191 svcxprt_list_t::next, svcxprt_ext_t::my_xlist,
192 svc_thr_max, svc_waiters
193 */
194
195 /* VARIABLES PROTECTED BY svc_fd_lock:
196 svc_xports, svc_fdset, svc_nfds, svc_nfds_set, svc_max_fd,
197 svc_pollfd, svc_npollfds, svc_npollfds_set, svc_max_pollfd
198 */
199
200 /* VARIABLES PROTECTED BY svc_thr_mutex:
201 svc_pollset, svc_pollfds, svc_next_pollfd, svc_polling
202 svc_pollset_allocd, svc_polled
203 */
204
205 /* VARIABLES PROTECTED BY svc_exit_mutex:
206 svc_exit_done
207 */
208
209 /* VARIABLES READABLE WITHOUT LOCK:
210 svc_thr_total, svc_thr_active, svc_thr_total_creates,
211 svc_thr_total_create_errors,
212 svc_xports, svc_nfds, svc_nfds_set, svc_max_fd,
213 svc_npollfds, svc_npollfds_set, svc_max_pollfd,
214 svc_pollfds, svc_next_pollfd, svc_exit_done, svc_polling,
215 svc_thr_max, svc_waiters
216 */
217
218 /* VARIABLES PROTECTED BY "program_logic":
219 rpc_msg::, svc_req::, svcxprt_ext_t::flags, svc_mt_mode,
220 svcxprt_ext_t::parent
221 */
222
223 /* LOCK ORDER:
224 svc_exit_mutex, svc_thr_mutex, svc_mutex, svc_fd_lock
225 */
226
227
228 void
svc_run(void)229 svc_run(void)
230 {
231 /* NO OTHER THREADS ARE RUNNING */
232
233 svc_exit_done = FALSE;
234
235 while ((svc_npollfds > 0 || svc_ndoorfds > 0) && !svc_exit_done) {
236 if (svc_npollfds > 0) {
237 switch (svc_mt_mode) {
238 case RPC_SVC_MT_NONE:
239 _svc_run();
240 break;
241 default:
242 _svc_run_mt();
243 break;
244 }
245 continue;
246 }
247
248 (void) mutex_lock(&svc_door_mutex);
249 if (svc_ndoorfds > 0)
250 (void) cond_wait(&svc_door_waitcv, &svc_door_mutex);
251 (void) mutex_unlock(&svc_door_mutex);
252 }
253 }
254
255
256 /*
257 * This function causes svc_run() to exit by destroying all
258 * service handles.
259 */
260 void
svc_exit(void)261 svc_exit(void)
262 {
263 SVCXPRT *xprt;
264 int fd;
265 char dummy;
266
267 /* NO LOCKS HELD */
268
269 (void) mutex_lock(&svc_exit_mutex);
270 if (svc_exit_done) {
271 (void) mutex_unlock(&svc_exit_mutex);
272 return;
273 }
274 svc_exit_done = TRUE;
275 for (fd = 0; fd < svc_max_pollfd; fd++) {
276 xprt = svc_xports[fd];
277 if (xprt) {
278 SVC_DESTROY(xprt);
279 }
280 }
281 __svc_free_xprtlist();
282 __svc_cleanup_door_xprts();
283 (void) mutex_unlock(&svc_exit_mutex);
284
285 if (svc_mt_mode != RPC_SVC_MT_NONE) {
286 (void) mutex_lock(&svc_mutex);
287 (void) cond_broadcast(&svc_thr_fdwait);
288 (void) mutex_unlock(&svc_mutex);
289
290 (void) write(svc_pipe[1], &dummy, sizeof (dummy));
291 }
292
293 (void) mutex_lock(&svc_door_mutex);
294 (void) cond_signal(&svc_door_waitcv); /* wake up door dispatching */
295 (void) mutex_unlock(&svc_door_mutex);
296
297 /* destroy reactor information if any */
298 __destroy_userfd();
299 }
300
301
302 /*
303 * this funtion is called with svc_fd_lock and svc_thr_mutex
304 */
305
306 static int
alloc_pollset(int npollfds)307 alloc_pollset(int npollfds)
308 {
309 if (npollfds > svc_pollset_allocd) {
310 pollfd_t *tmp;
311 do {
312 svc_pollset_allocd += POLLSET_EXTEND;
313 } while (npollfds > svc_pollset_allocd);
314 tmp = realloc(svc_pollset,
315 sizeof (pollfd_t) * svc_pollset_allocd);
316 if (tmp == NULL) {
317 syslog(LOG_ERR, "alloc_pollset: out of memory");
318 return (-1);
319 }
320 svc_pollset = tmp;
321 }
322 return (0);
323 }
324
325 static void
_svc_run(void)326 _svc_run(void)
327 {
328 sigset_t set, oldset;
329 int npollfds;
330 int i;
331
332 /*
333 * Block SIGALRM while doing work. Unblock it while doing poll().
334 * This is so that services like rpc.rstatd can cause the poll()
335 * to be interrupted due to alarm() but that we don't end up in
336 * an MT-unsafe signal handler at an inopportune time.
337 */
338 (void) sigemptyset(&set);
339 (void) sigaddset(&set, SIGALRM);
340 (void) sigprocmask(SIG_BLOCK, &set, &oldset);
341 while (!svc_exit_done) {
342 /*
343 * Check whether there is any server fd on which we may want
344 * to wait.
345 */
346 (void) rw_rdlock(&svc_fd_lock);
347 if (alloc_pollset(svc_npollfds) == -1)
348 break;
349 npollfds = __rpc_compress_pollfd(svc_max_pollfd,
350 svc_pollfd, svc_pollset);
351 (void) rw_unlock(&svc_fd_lock);
352 if (npollfds == 0)
353 break; /* None waiting, hence return */
354
355 (void) sigprocmask(SIG_SETMASK, &oldset, NULL);
356 i = poll(svc_pollset, npollfds, -1);
357 (void) sigprocmask(SIG_BLOCK, &set, &oldset);
358 switch (i) {
359 case -1:
360 /*
361 * We ignore all errors, continuing with the assumption
362 * that it was set by the signal handlers (or any
363 * other outside event) and not caused by poll().
364 */
365 case 0:
366 continue;
367 default:
368 svc_getreq_poll(svc_pollset, i);
369 }
370 }
371 (void) sigprocmask(SIG_SETMASK, &oldset, NULL);
372 }
373
374 /*
375 * In _svc_run_mt, myfd is linked with mypollfd
376 * svc_pollset[mypollfd].fd == myfd
377 * However, in some cases, the link can not be made, thus we define the
378 * following values for these special cases
379 */
380 enum {
381 INVALID_POLLFD = -200,
382 FD_FROM_PENDING
383 };
384
385 static void
_svc_run_mt(void)386 _svc_run_mt(void)
387 {
388 int npollfds;
389 int n_polled, dispatch;
390
391 static bool_t first_time = TRUE;
392 bool_t main_thread = FALSE;
393 int n_new;
394 int myfd, mypollfd;
395 SVCXPRT *parent_xprt, *xprt;
396
397 /*
398 * Server is multi-threaded. Do "first time" initializations.
399 * Since only one thread exists in the beginning, there's no
400 * need for mutex protection for first time initializations.
401 */
402 if (first_time) {
403 first_time = FALSE;
404 main_thread = TRUE;
405 svc_thr_total = 1; /* this thread */
406 svc_next_pending = svc_last_pending = 0;
407
408 /*
409 * Create a pipe for waking up the poll, if new
410 * descriptors have been added to svc_fdset.
411 */
412 create_pipe();
413 }
414
415 /* OTHER THREADS ARE RUNNING */
416
417 if (svc_exit_done)
418 return;
419
420 for (;;) {
421 /*
422 * svc_thr_mutex prevents more than one thread from
423 * trying to select a descriptor to process further.
424 * svc_thr_mutex is unlocked after a thread selects
425 * a descriptor on which to receive data. If there are
426 * no such descriptors, the thread will poll with
427 * svc_thr_mutex locked, after unlocking all other
428 * locks. This prevents more than one thread from
429 * trying to poll at the same time.
430 */
431 (void) mutex_lock(&svc_thr_mutex);
432 (void) mutex_lock(&svc_mutex);
433 continue_with_locks:
434 myfd = -1;
435 mypollfd = INVALID_POLLFD;
436
437 /*
438 * Check if there are any descriptors with data pending.
439 */
440 if (svc_total_pending > 0) {
441 myfd = svc_pending_fds[svc_next_pending++];
442 mypollfd = FD_FROM_PENDING;
443 if (svc_next_pending > CIRCULAR_BUFSIZE)
444 svc_next_pending = 0;
445 svc_total_pending--;
446 }
447
448 /*
449 * Get the next active file descriptor to process.
450 */
451 if (myfd == -1 && svc_pollfds == 0) {
452 /*
453 * svc_pollset is empty; do polling
454 */
455 svc_polling = TRUE;
456
457 /*
458 * if there are no file descriptors, return
459 */
460 (void) rw_rdlock(&svc_fd_lock);
461 if (svc_npollfds == 0 ||
462 alloc_pollset(svc_npollfds + 1) == -1) {
463 (void) rw_unlock(&svc_fd_lock);
464 svc_polling = FALSE;
465 svc_thr_total--;
466 (void) mutex_unlock(&svc_mutex);
467 (void) mutex_unlock(&svc_thr_mutex);
468 if (!main_thread) {
469 thr_exit(NULL);
470 /* NOTREACHED */
471 }
472 break;
473 }
474
475 npollfds = __rpc_compress_pollfd(svc_max_pollfd,
476 svc_pollfd, svc_pollset);
477 (void) rw_unlock(&svc_fd_lock);
478
479 if (npollfds == 0) {
480 /*
481 * There are file descriptors, but none of them
482 * are available for polling. If this is the
483 * main thread, or if no thread is waiting,
484 * wait on condition variable, otherwise exit.
485 */
486 svc_polling = FALSE;
487 (void) mutex_unlock(&svc_thr_mutex);
488 if ((!main_thread) && svc_waiters > 0) {
489 svc_thr_total--;
490 (void) mutex_unlock(&svc_mutex);
491 thr_exit(NULL);
492 /* NOTREACHED */
493 }
494
495 while (svc_npollfds_set == 0 &&
496 svc_pollfds == 0 &&
497 svc_total_pending == 0 &&
498 !svc_exit_done) {
499 svc_waiters++;
500 (void) cond_wait(&svc_thr_fdwait,
501 &svc_mutex);
502 svc_waiters--;
503 }
504
505 /*
506 * Check exit flag. If this is not the main
507 * thread, exit.
508 */
509 if (svc_exit_done) {
510 svc_thr_total--;
511 (void) mutex_unlock(&svc_mutex);
512 if (!main_thread)
513 thr_exit(NULL);
514 break;
515 }
516
517 (void) mutex_unlock(&svc_mutex);
518 continue;
519 }
520
521 /*
522 * We're ready to poll. Always set svc_pipe[0]
523 * as the last one, since the poll will occasionally
524 * need to be interrupted. Release svc_mutex for
525 * the duration of the poll, but hold on to
526 * svc_thr_mutex, as we don't want any other thread
527 * to do the same.
528 */
529 svc_pollset[npollfds].fd = svc_pipe[0];
530 svc_pollset[npollfds].events = MASKVAL;
531
532 do {
533 int i, j;
534
535 (void) mutex_unlock(&svc_mutex);
536 n_polled = poll(svc_pollset, npollfds + 1, -1);
537 (void) mutex_lock(&svc_mutex);
538 if (n_polled <= 0)
539 continue;
540
541 /*
542 * Check if information returned indicates one
543 * or more closed fd's; find and remove any such
544 * information
545 */
546 for (i = 0; i <= npollfds; i++) {
547 if (svc_pollset[i].revents & POLLNVAL) {
548 /* Overwrite svc_pollset[i] */
549 for (j = i; j < npollfds; j++)
550 svc_pollset[j] =
551 svc_pollset[j + 1];
552 (void) memset(&svc_pollset[j],
553 0, sizeof (struct pollfd));
554 npollfds--;
555 n_polled--;
556 i--;
557 }
558 }
559 } while (n_polled <= 0);
560 svc_polling = FALSE;
561
562 /*
563 * If there's data in the pipe, clear it.
564 */
565 if (svc_pollset[npollfds].revents) {
566 clear_pipe();
567 n_polled--;
568 svc_pollset[npollfds].revents = 0;
569 }
570 svc_polled = npollfds;
571 svc_pollfds = n_polled;
572 svc_next_pollfd = 0;
573
574 /*
575 * Check exit flag.
576 */
577 if (svc_exit_done) {
578 svc_thr_total--;
579 (void) mutex_unlock(&svc_mutex);
580 (void) mutex_unlock(&svc_thr_mutex);
581 if (!main_thread) {
582 thr_exit(NULL);
583 /* NOTREACHED */
584 }
585 break;
586 }
587
588 /*
589 * If no descriptor is active, continue.
590 */
591 if (svc_pollfds == 0)
592 goto continue_with_locks;
593 }
594
595 /*
596 * If a file descriptor has already not been selected,
597 * choose a file descriptor.
598 * svc_pollfds and svc_next_pollfd are updated.
599 */
600 if (myfd == -1) {
601 if (select_next_pollfd(&myfd, &mypollfd) == -1)
602 goto continue_with_locks;
603 }
604
605 /*
606 * Check to see if new threads need to be started.
607 * Count of threads that could be gainfully employed is
608 * obtained as follows:
609 * - count 1 for poller
610 * - count 1 for this request
611 * - count active file descriptors (svc_pollfds)
612 * - count pending file descriptors
613 *
614 * (svc_thr_total - svc_thr_active) are already available.
615 * This thread is one of the available threads.
616 *
617 * Number of new threads should not exceed
618 * (svc_thr_max - svc_thr_total).
619 */
620 if (svc_thr_total < svc_thr_max &&
621 svc_mt_mode == RPC_SVC_MT_AUTO && !svc_exit_done) {
622 n_new = 1 + 1 + svc_pollfds + svc_total_pending -
623 (svc_thr_total - svc_thr_active);
624 if (n_new > (svc_thr_max - svc_thr_total))
625 n_new = svc_thr_max - svc_thr_total;
626 if (n_new > 0)
627 start_threads(n_new);
628 }
629
630 /*
631 * Get parent xprt. It is possible for the parent service
632 * handle to be destroyed by now, due to a race condition.
633 * Check for this, and if so, log a warning and go on.
634 */
635 parent_xprt = svc_xports[myfd];
636 if (parent_xprt == NULL) {
637 /* Check if it is not a user FD */
638 if (__is_a_userfd(myfd) == TRUE)
639 __svc_getreq_user(&(svc_pollset[mypollfd]));
640 goto continue_with_locks;
641 }
642 /* LINTED pointer alignment */
643 if (svc_defunct(parent_xprt) || svc_failed(parent_xprt))
644 goto continue_with_locks;
645
646 /*
647 * Make a copy of parent xprt, update svc_fdset.
648 */
649 if ((xprt = make_xprt_copy(parent_xprt)) == NULL)
650 goto continue_with_locks;
651
652 /*
653 * Keep track of active threads in automatic mode.
654 */
655 if (svc_mt_mode == RPC_SVC_MT_AUTO)
656 svc_thr_active++;
657
658 /*
659 * Release mutexes so other threads can get going.
660 */
661 (void) mutex_unlock(&svc_mutex);
662 (void) mutex_unlock(&svc_thr_mutex);
663
664 /*
665 * Process request.
666 */
667 {
668 struct rpc_msg *msg;
669 struct svc_req *r;
670 char *cred_area;
671
672 /* LINTED pointer alignment */
673 msg = SVCEXT(xprt)->msg;
674 /* LINTED pointer alignment */
675 r = SVCEXT(xprt)->req;
676 /* LINTED pointer alignment */
677 cred_area = SVCEXT(xprt)->cred_area;
678
679
680 msg->rm_call.cb_cred.oa_base = cred_area;
681 msg->rm_call.cb_verf.oa_base =
682 &(cred_area[MAX_AUTH_BYTES]);
683 r->rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);
684
685 /*
686 * receive RPC message
687 */
688 if ((dispatch = SVC_RECV(xprt, msg))) {
689 if (svc_mt_mode != RPC_SVC_MT_NONE)
690 /* LINTED pointer alignment */
691 svc_flags(xprt) |= SVC_ARGS_CHECK;
692 dispatch = _svc_prog_dispatch(xprt, msg, r);
693
694 /*
695 * Call cleanup procedure if set.
696 */
697 if (__proc_cleanup_cb != NULL)
698 (*__proc_cleanup_cb)(xprt);
699 } else
700 svc_args_done(xprt);
701
702 /*
703 * Finish up, if automatic mode, or not dispatched.
704 */
705 if (svc_mt_mode == RPC_SVC_MT_AUTO || !dispatch) {
706 /* LINTED pointer alignment */
707 if (svc_flags(xprt) & SVC_ARGS_CHECK)
708 svc_args_done(xprt);
709 (void) mutex_lock(&svc_mutex);
710 _svc_done_private(xprt);
711 if (svc_mt_mode == RPC_SVC_MT_AUTO) {
712 /*
713 * not active any more
714 */
715 svc_thr_active--;
716
717 /*
718 * If not main thread, exit unless
719 * there's some immediate work.
720 */
721 if (!main_thread &&
722 svc_pollfds <= 0 &&
723 svc_total_pending <= 0 &&
724 (svc_polling ||
725 svc_waiters > 0)) {
726 svc_thr_total--;
727 if (svc_thr_total ==
728 svc_waiters) {
729 (void) cond_broadcast(
730 &svc_thr_fdwait);
731 }
732 (void) mutex_unlock(&svc_mutex);
733 thr_exit(NULL);
734 /* NOTREACHED */
735 }
736 }
737 (void) mutex_unlock(&svc_mutex);
738 }
739 }
740
741 }
742 }
743
744
745 /*
746 * start_threads() - Start specified number of threads.
747 */
748 static void
start_threads(int num_threads)749 start_threads(int num_threads)
750 {
751 int i;
752
753 assert(MUTEX_HELD(&svc_mutex));
754
755 for (i = 0; i < num_threads; i++) {
756 if (thr_create(NULL, 0, (void *(*)(void *))_svc_run_mt, NULL,
757 THR_DETACHED, NULL) == 0) {
758 svc_thr_total++;
759 svc_thr_total_creates++;
760 } else {
761 svc_thr_total_create_errors++;
762 }
763 }
764 }
765
766
767 /*
768 * create_pipe() - create pipe for breaking out of poll.
769 */
770 static void
create_pipe(void)771 create_pipe(void)
772 {
773 if (pipe(svc_pipe) == -1) {
774 syslog(LOG_ERR, dgettext(__nsl_dom,
775 "RPC: svc could not create pipe - exiting"));
776 exit(1);
777 }
778 if (fcntl(svc_pipe[0], F_SETFL, O_NONBLOCK) == -1) {
779 syslog(LOG_ERR, dgettext(__nsl_dom,
780 "RPC: svc pipe error - exiting"));
781 exit(1);
782 }
783 if (fcntl(svc_pipe[1], F_SETFL, O_NONBLOCK) == -1) {
784 syslog(LOG_ERR, dgettext(__nsl_dom,
785 "RPC: svc pipe error - exiting"));
786 exit(1);
787 }
788 }
789
790
791 /*
792 * clear_pipe() - Empty data in pipe.
793 */
794 static void
clear_pipe(void)795 clear_pipe(void)
796 {
797 char buf[16];
798 int i;
799
800 do {
801 i = read(svc_pipe[0], buf, sizeof (buf));
802 } while (i == sizeof (buf));
803 }
804
805
806 /*
807 * select_next_pollfd() - Select the next active fd in svc_pollset.
808 */
809 static int
select_next_pollfd(int * fd,int * pollfdIndex)810 select_next_pollfd(int *fd, int *pollfdIndex)
811 {
812 int i;
813
814 assert(MUTEX_HELD(&svc_thr_mutex));
815 assert(MUTEX_HELD(&svc_mutex));
816
817 for (i = svc_next_pollfd; svc_pollfds > 0 && i < svc_polled; i++) {
818 if (svc_pollset[i].revents) {
819 svc_pollfds--;
820 /*
821 * No more special case for POLLNVAL, because it may
822 * be linked with a user file descriptot callback
823 */
824 svc_next_pollfd = i + 1;
825
826 *fd = svc_pollset[i].fd;
827 *pollfdIndex = i;
828
829 return (0);
830 }
831 }
832 svc_next_pollfd = svc_pollfds = 0;
833 *fd = -1;
834 *pollfdIndex = INVALID_POLLFD;
835 return (-1);
836 }
837
838
839 /*
840 * make_xprt_copy() - make a copy of the parent xprt.
841 * Clear fd bit in svc_fdset.
842 */
843 static SVCXPRT *
make_xprt_copy(SVCXPRT * parent)844 make_xprt_copy(SVCXPRT *parent)
845 {
846 /* LINTED pointer alignment */
847 SVCXPRT_LIST *xlist = SVCEXT(parent)->my_xlist;
848 SVCXPRT_LIST *xret;
849 SVCXPRT *xprt;
850 int fd = parent->xp_fd;
851
852 assert(MUTEX_HELD(&svc_mutex));
853
854 xret = xlist->next;
855 if (xret) {
856 xlist->next = xret->next;
857 xret->next = NULL;
858 xprt = xret->xprt;
859 /* LINTED pointer alignment */
860 svc_flags(xprt) = svc_flags(parent);
861 } else
862 xprt = svc_copy(parent);
863
864 if (xprt) {
865 /* LINTED pointer alignment */
866 SVCEXT(parent)->refcnt++;
867 (void) rw_wrlock(&svc_fd_lock);
868 clear_pollfd(fd);
869 (void) rw_unlock(&svc_fd_lock);
870 }
871 return (xprt);
872 }
873
874 /*
875 * _svc_done_private() - return copies to library.
876 */
877 static void
_svc_done_private(SVCXPRT * xprt)878 _svc_done_private(SVCXPRT *xprt)
879 {
880 SVCXPRT *parent;
881 SVCXPRT_LIST *xhead, *xlist;
882
883 assert(MUTEX_HELD(&svc_mutex));
884
885 /* LINTED pointer alignment */
886 if ((parent = SVCEXT(xprt)->parent) == NULL)
887 return;
888
889 /* LINTED pointer alignment */
890 xhead = SVCEXT(parent)->my_xlist;
891 /* LINTED pointer alignment */
892 xlist = SVCEXT(xprt)->my_xlist;
893 xlist->next = xhead->next;
894 xhead->next = xlist;
895
896 /* LINTED pointer alignment */
897 SVCEXT(parent)->refcnt--;
898
899 /*
900 * Propagate any error flags. This is done in both directions to
901 * ensure that if one child gets an error, everyone will see it
902 * (even if there are multiple outstanding children) and the
903 * transport will get closed.
904 */
905 /* LINTED pointer alignment */
906 svc_flags(xprt) |= svc_flags(parent);
907 /* LINTED pointer alignment */
908 if (svc_failed(xprt) || svc_defunct(xprt)) {
909 /* LINTED pointer alignment */
910 svc_flags(parent) |= (svc_flags(xprt) &
911 (SVC_FAILED | SVC_DEFUNCT));
912 /* LINTED pointer alignment */
913 if (SVCEXT(parent)->refcnt == 0)
914 _svc_destroy_private(xprt);
915 }
916 }
917
918 void
svc_done(SVCXPRT * xprt)919 svc_done(SVCXPRT *xprt)
920 {
921 if (svc_mt_mode != RPC_SVC_MT_USER)
922 return;
923
924 /*
925 * Make sure file descriptor is released in user mode.
926 * If the xprt is a door, do nothing: this work is performed by
927 * svc_door.c's return_xprt_copy() routine, which is basically a
928 * door-specific copy of _svc_done_private().
929 */
930 /* LINTED pointer alignment */
931 if (svc_type(xprt) == SVC_DOOR)
932 return;
933
934 /* LINTED pointer alignment */
935 if (svc_flags(xprt) & SVC_ARGS_CHECK)
936 svc_args_done(xprt);
937
938 (void) mutex_lock(&svc_mutex);
939 _svc_done_private(xprt);
940 (void) mutex_unlock(&svc_mutex);
941 }
942
943
944 /*
945 * Mark argument completion. Release file descriptor.
946 */
947 void
svc_args_done(SVCXPRT * xprt)948 svc_args_done(SVCXPRT *xprt)
949 {
950 char dummy;
951 /* LINTED pointer alignment */
952 SVCXPRT *parent = SVCEXT(xprt)->parent;
953 bool_t wake_up_poller;
954 enum xprt_stat stat;
955
956 /* LINTED pointer alignment */
957 svc_flags(xprt) |= svc_flags(parent);
958 /* LINTED pointer alignment */
959 svc_flags(xprt) &= ~SVC_ARGS_CHECK;
960 /* LINTED pointer alignment */
961 if (svc_failed(xprt) || svc_defunct(parent))
962 return;
963
964 /* LINTED pointer alignment */
965 if (svc_type(xprt) == SVC_CONNECTION &&
966 (stat = SVC_STAT(xprt)) != XPRT_IDLE) {
967 if (stat == XPRT_MOREREQS) {
968 (void) mutex_lock(&svc_mutex);
969 svc_pending_fds[svc_last_pending++] = xprt->xp_fd;
970 if (svc_last_pending > CIRCULAR_BUFSIZE)
971 svc_last_pending = 0;
972 svc_total_pending++;
973 (void) mutex_unlock(&svc_mutex);
974 wake_up_poller = FALSE;
975 } else {
976 /*
977 * connection failed
978 */
979 return;
980 }
981 } else {
982 (void) rw_wrlock(&svc_fd_lock);
983 set_pollfd(xprt->xp_fd, MASKVAL);
984 (void) rw_unlock(&svc_fd_lock);
985 wake_up_poller = TRUE;
986 }
987
988 if (!wake_up_poller || !svc_polling) {
989 /*
990 * Wake up any waiting threads.
991 */
992 (void) mutex_lock(&svc_mutex);
993 if (svc_waiters > 0) {
994 (void) cond_broadcast(&svc_thr_fdwait);
995 (void) mutex_unlock(&svc_mutex);
996 return;
997 }
998 (void) mutex_unlock(&svc_mutex);
999 }
1000
1001 /*
1002 * Wake up any polling thread.
1003 */
1004 if (svc_polling)
1005 (void) write(svc_pipe[1], &dummy, sizeof (dummy));
1006 }
1007
1008
1009 int
__rpc_legal_connmaxrec(int suggested)1010 __rpc_legal_connmaxrec(int suggested) {
1011 if (suggested == -1) {
1012 /* Supply default */
1013 return (RPC_MAXDATASIZE + 2*sizeof (uint32_t));
1014 } else if (suggested < 0) {
1015 return (-1);
1016 } else if (suggested > 0) {
1017 /* Round down to multiple of BYTES_PER_XDR_UNIT */
1018 suggested -= suggested % BYTES_PER_XDR_UNIT;
1019 /* If possible, allow for two fragment headers */
1020 if (suggested < MAXINT-(2*sizeof (uint32_t))) {
1021 /* Allow for two fragment headers */
1022 suggested += 2 * sizeof (uint32_t);
1023 } else {
1024 suggested = MAXINT;
1025 }
1026 if (suggested < sizeof (struct rpc_msg)) {
1027 return (-1);
1028 }
1029 }
1030 return (suggested);
1031 }
1032
1033
1034 bool_t
rpc_control(int op,void * info)1035 rpc_control(int op, void *info)
1036 {
1037 int tmp;
1038
1039 switch (op) {
1040 case RPC_SVC_MTMODE_SET:
1041 tmp = *((int *)info);
1042 if (tmp != RPC_SVC_MT_NONE && tmp != RPC_SVC_MT_AUTO &&
1043 tmp != RPC_SVC_MT_USER)
1044 return (FALSE);
1045 if (svc_mt_mode != RPC_SVC_MT_NONE && svc_mt_mode != tmp)
1046 return (FALSE);
1047 svc_mt_mode = tmp;
1048 return (TRUE);
1049 case RPC_SVC_MTMODE_GET:
1050 *((int *)info) = svc_mt_mode;
1051 return (TRUE);
1052 case RPC_SVC_THRMAX_SET:
1053 if ((tmp = *((int *)info)) < 1)
1054 return (FALSE);
1055 (void) mutex_lock(&svc_mutex);
1056 svc_thr_max = tmp;
1057 (void) mutex_unlock(&svc_mutex);
1058 return (TRUE);
1059 case RPC_SVC_THRMAX_GET:
1060 *((int *)info) = svc_thr_max;
1061 return (TRUE);
1062 case RPC_SVC_THRTOTAL_GET:
1063 *((int *)info) = svc_thr_total;
1064 return (TRUE);
1065 case RPC_SVC_THRCREATES_GET:
1066 *((int *)info) = svc_thr_total_creates;
1067 return (TRUE);
1068 case RPC_SVC_THRERRORS_GET:
1069 *((int *)info) = svc_thr_total_create_errors;
1070 return (TRUE);
1071 case RPC_SVC_USE_POLLFD:
1072 if (*((int *)info) && !__rpc_use_pollfd_done) {
1073 __rpc_use_pollfd_done = 1;
1074 return (TRUE);
1075 }
1076 return (FALSE);
1077 case RPC_SVC_CONNMAXREC_SET:
1078 tmp = __rpc_legal_connmaxrec(*(int *)info);
1079 if (tmp >= 0) {
1080 __rpc_connmaxrec = tmp;
1081 return (TRUE);
1082 } else {
1083 return (FALSE);
1084 }
1085 case RPC_SVC_CONNMAXREC_GET:
1086 *((int *)info) = __rpc_connmaxrec;
1087 return (TRUE);
1088 case RPC_SVC_IRTIMEOUT_SET:
1089 tmp = *((int *)info);
1090 if (tmp >= 0) {
1091 __rpc_irtimeout = tmp;
1092 return (TRUE);
1093 } else {
1094 return (FALSE);
1095 }
1096 /*
1097 * No mutex necessary as _EXCLBIND_SET will/should only
1098 * be used before an RPC daemon goes mt-hot.
1099 */
1100 case __RPC_SVC_EXCLBIND_SET:
1101 if (info) {
1102 __rpc_tp_exclbind = *((bool_t *)info);
1103 return (TRUE);
1104 }
1105 return (FALSE);
1106 case __RPC_SVC_EXCLBIND_GET:
1107 if (info) {
1108 *((bool_t *)info) = __rpc_tp_exclbind;
1109 return (TRUE);
1110 }
1111 return (FALSE);
1112
1113 case __RPC_SVC_LSTNBKLOG_SET:
1114 tmp = *(int *)info;
1115 if (tmp > 0) {
1116 __svc_lstnbklog = tmp;
1117 return (TRUE);
1118 }
1119 return (FALSE);
1120 case __RPC_SVC_LSTNBKLOG_GET:
1121 *(int *)info = __svc_lstnbklog;
1122 return (TRUE);
1123
1124 default:
1125 return (FALSE);
1126 }
1127 }
1128