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 2007 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 /*
30 * Define and initialize MT data for libnsl.
31 * The _libnsl_lock_init() function below is the library's .init handler.
32 */
33
34 #include "mt.h"
35 #include "rpc_mt.h"
36 #include <unistd.h>
37 #include <rpc/rpc.h>
38 #include <sys/time.h>
39 #include <stdlib.h>
40 #include <syslog.h>
41
42 extern mutex_t _ti_userlock;
43
44 sigset_t fillset; /* from sigfillset() */
45
46 rwlock_t svc_lock; /* protects the services list (svc.c) */
47 rwlock_t svc_fd_lock; /* protects svc_fdset and the xports[] array */
48 rwlock_t rpcbaddr_cache_lock; /* protects the RPCBIND address cache */
49 static rwlock_t *rwlock_table[] = {
50 &svc_lock,
51 &svc_fd_lock,
52 &rpcbaddr_cache_lock
53 };
54
55 mutex_t authdes_lock; /* protects authdes cache (svcauth_des.c) */
56 mutex_t authnone_lock; /* auth_none.c serialization */
57 mutex_t authsvc_lock; /* protects the Auths list (svc_auth.c) */
58 mutex_t clntraw_lock; /* clnt_raw.c serialization */
59 mutex_t dname_lock; /* domainname and domain_fd (getdname.c) */
60 /* and default_domain (rpcdname.c) */
61 mutex_t dupreq_lock; /* dupreq variables (svc_dg.c) */
62 mutex_t keyserv_lock; /* protects first_time and hostname */
63 /* (key_call.c) */
64 mutex_t libnsl_trace_lock; /* serializes rpc_trace() (rpc_trace.c) */
65 mutex_t loopnconf_lock; /* loopnconf (rpcb_clnt.c) */
66 mutex_t ops_lock; /* serializes ops initializations */
67 mutex_t portnum_lock; /* protects ``port'' static in bindresvport() */
68 mutex_t proglst_lock; /* protects proglst list (svc_simple.c) */
69 mutex_t rpcsoc_lock; /* serializes clnt_com_create() (rpc_soc.c) */
70 mutex_t svcraw_lock; /* svc_raw.c serialization */
71 mutex_t xprtlist_lock; /* xprtlist (svc_generic.c) */
72 mutex_t serialize_pkey; /* serializes calls to public key routines */
73 mutex_t svc_thr_mutex; /* protects thread related variables */
74 mutex_t svc_mutex; /* protects service handle free lists */
75 mutex_t svc_exit_mutex; /* used for clean mt exit */
76
77 static mutex_t *mutex_table[] = {
78 &authdes_lock,
79 &authnone_lock,
80 &authsvc_lock,
81 &clntraw_lock,
82 &dname_lock,
83 &dupreq_lock,
84 &keyserv_lock,
85 &libnsl_trace_lock,
86 &loopnconf_lock,
87 &ops_lock,
88 &portnum_lock,
89 &proglst_lock,
90 &rpcsoc_lock,
91 &svcraw_lock,
92 &xprtlist_lock,
93 &serialize_pkey,
94 &svc_thr_mutex,
95 &svc_mutex,
96 &svc_exit_mutex
97 };
98
99 cond_t svc_thr_fdwait; /* threads wait on this for work */
100
101 static void
_libnsl_prefork()102 _libnsl_prefork()
103 {
104 (void) mutex_lock(&_ti_userlock);
105 }
106
107 static void
_libnsl_child_atfork()108 _libnsl_child_atfork()
109 {
110 (void) mutex_unlock(&_ti_userlock);
111 }
112
113 static void
_libnsl_parent_atfork()114 _libnsl_parent_atfork()
115 {
116 (void) mutex_unlock(&_ti_userlock);
117 }
118
119 #pragma init(_libnsl_lock_init)
120
121 void
_libnsl_lock_init()122 _libnsl_lock_init()
123 {
124 int i;
125
126 (void) sigfillset(&fillset);
127
128 for (i = 0; i < (sizeof (mutex_table) / sizeof (mutex_table[0])); i++)
129 (void) mutex_init(mutex_table[i], 0, (void *) 0);
130
131 for (i = 0; i < (sizeof (rwlock_table) / sizeof (rwlock_table[0])); i++)
132 (void) rwlock_init(rwlock_table[i], 0, (void *) 0);
133
134 (void) cond_init(&svc_thr_fdwait, USYNC_THREAD, 0);
135
136 /*
137 * There is no way to unregister these atfork functions,
138 * but we don't need to. The dynamic linker and libc take
139 * care of unregistering them if/when the library is unloaded.
140 */
141 (void) pthread_atfork(_libnsl_prefork,
142 _libnsl_parent_atfork, _libnsl_child_atfork);
143 }
144
145 #pragma fini(_libnsl_fini)
146
147 void _key_call_fini(void);
148
149 void
_libnsl_fini()150 _libnsl_fini()
151 {
152 _key_call_fini();
153 }
154
155 #undef rpc_createerr
156
157 struct rpc_createerr rpc_createerr;
158
159 struct rpc_createerr *
__rpc_createerr()160 __rpc_createerr()
161 {
162 static pthread_key_t rce_key = PTHREAD_ONCE_KEY_NP;
163 struct rpc_createerr *rce_addr;
164
165 if (thr_main())
166 return (&rpc_createerr);
167 rce_addr = thr_get_storage(&rce_key, sizeof (*rce_addr), free);
168 if (rce_addr == NULL) {
169 syslog(LOG_ERR, "__rpc_createerr : out of memory.");
170 return (&rpc_createerr);
171 }
172 return (rce_addr);
173 }
174
175 #undef rpc_callerr
176
177 struct rpc_err rpc_callerr;
178
179 struct rpc_err *
__rpc_callerr(void)180 __rpc_callerr(void)
181 {
182 static pthread_key_t rpc_callerr_key = PTHREAD_ONCE_KEY_NP;
183 struct rpc_err *tsd;
184
185 if (thr_main())
186 return (&rpc_callerr);
187 tsd = thr_get_storage(&rpc_callerr_key, sizeof (struct rpc_err), free);
188 if (tsd == NULL) {
189 syslog(LOG_ERR, "__rpc_callerr : out of memory.");
190 return (&rpc_callerr);
191 }
192 return (tsd);
193 }
194