Print this page
OS-4865 lxbrand async socket errors catch programs off guard
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
OS-4213 lxbrand should be able to set TCP_DEFER_ACCEPT after other socket operations
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/sys/socketvar.h
+++ new/usr/src/uts/common/sys/socketvar.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 */
25 25
26 26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
27 27 /* All Rights Reserved */
28 28
29 29 /*
30 30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 31 * The Regents of the University of California
32 32 * All Rights Reserved
33 33 *
34 34 * University Acknowledgment- Portions of this document are derived from
35 35 * software developed by the University of California, Berkeley, and its
36 36 * contributors.
37 37 */
38 38 /*
39 39 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
40 40 */
41 41
42 42 #ifndef _SYS_SOCKETVAR_H
43 43 #define _SYS_SOCKETVAR_H
44 44
45 45 #include <sys/types.h>
46 46 #include <sys/stream.h>
47 47 #include <sys/t_lock.h>
48 48 #include <sys/cred.h>
49 49 #include <sys/vnode.h>
50 50 #include <sys/file.h>
51 51 #include <sys/param.h>
52 52 #include <sys/zone.h>
53 53 #include <sys/sdt.h>
54 54 #include <sys/modctl.h>
55 55 #include <sys/atomic.h>
56 56 #include <sys/socket.h>
57 57 #include <sys/ksocket.h>
58 58 #include <sys/kstat.h>
59 59
60 60 #ifdef _KERNEL
61 61 #include <sys/vfs_opreg.h>
62 62 #endif
63 63
64 64 #ifdef __cplusplus
65 65 extern "C" {
66 66 #endif
67 67
68 68 /*
69 69 * Internal representation of the address used to represent addresses
70 70 * in the loopback transport for AF_UNIX. While the sockaddr_un is used
71 71 * as the sockfs layer address for AF_UNIX the pathnames contained in
72 72 * these addresses are not unique (due to relative pathnames) thus can not
73 73 * be used in the transport.
74 74 *
75 75 * The transport level address consists of a magic number (used to separate the
76 76 * name space for specific and implicit binds). For a specific bind
77 77 * this is followed by a "vnode *" which ensures that all specific binds
78 78 * have a unique transport level address. For implicit binds the latter
79 79 * part of the address is a byte string (of the same length as a pointer)
80 80 * that is assigned by the loopback transport.
81 81 *
82 82 * The uniqueness assumes that the loopback transport has a separate namespace
83 83 * for sockets in order to avoid name conflicts with e.g. TLI use of the
84 84 * same transport.
85 85 */
86 86 struct so_ux_addr {
87 87 void *soua_vp; /* vnode pointer or assigned by tl */
88 88 uint_t soua_magic; /* See below */
89 89 };
90 90
91 91 #define SOU_MAGIC_EXPLICIT 0x75787670 /* "uxvp" */
92 92 #define SOU_MAGIC_IMPLICIT 0x616e6f6e /* "anon" */
93 93
94 94 struct sockaddr_ux {
95 95 sa_family_t sou_family; /* AF_UNIX */
96 96 struct so_ux_addr sou_addr;
97 97 };
98 98
99 99 #if defined(_KERNEL) || defined(_KMEMUSER)
100 100
101 101 #include <sys/socket_proto.h>
102 102
103 103 typedef struct sonodeops sonodeops_t;
104 104 typedef struct sonode sonode_t;
105 105
106 106 struct sodirect_s;
107 107
108 108 /*
109 109 * The sonode represents a socket. A sonode never exist in the file system
110 110 * name space and can not be opened using open() - only the socket, socketpair
111 111 * and accept calls create sonodes.
112 112 *
113 113 * The locking of sockfs uses the so_lock mutex plus the SOLOCKED and
114 114 * SOREADLOCKED flags in so_flag. The mutex protects all the state in the
115 115 * sonode. It is expected that the underlying transport protocol serializes
116 116 * socket operations, so sockfs will not normally not single-thread
117 117 * operations. However, certain sockets, including TPI based ones, can only
118 118 * handle one control operation at a time. The SOLOCKED flag is used to
119 119 * single-thread operations from sockfs users to prevent e.g. multiple bind()
120 120 * calls to operate on the same sonode concurrently. The SOREADLOCKED flag is
121 121 * used to ensure that only one thread sleeps in kstrgetmsg for a given
122 122 * sonode. This is needed to ensure atomic operation for things like
123 123 * MSG_WAITALL.
124 124 *
125 125 * The so_fallback_rwlock is used to ensure that for sockets that can
126 126 * fall back to TPI, the fallback is not initiated until all pending
127 127 * operations have completed.
128 128 *
129 129 * Note that so_lock is sometimes held across calls that might go to sleep
130 130 * (kmem_alloc and soallocproto*). This implies that no other lock in
131 131 * the system should be held when calling into sockfs; from the system call
132 132 * side or from strrput (in case of TPI based sockets). If locks are held
133 133 * while calling into sockfs the system might hang when running low on memory.
134 134 */
135 135 struct sonode {
136 136 struct vnode *so_vnode; /* vnode associated with this sonode */
137 137
138 138 sonodeops_t *so_ops; /* operations vector for this sonode */
139 139 void *so_priv; /* sonode private data */
140 140
141 141 krwlock_t so_fallback_rwlock;
142 142 kmutex_t so_lock; /* protects sonode fields */
143 143
144 144 kcondvar_t so_state_cv; /* synchronize state changes */
145 145 kcondvar_t so_single_cv; /* wait due to SOLOCKED */
146 146 kcondvar_t so_read_cv; /* wait due to SOREADLOCKED */
147 147
148 148 /* These fields are protected by so_lock */
149 149
150 150 uint_t so_state; /* internal state flags SS_*, below */
151 151 uint_t so_mode; /* characteristics on socket. SM_* */
152 152 ushort_t so_flag; /* flags, see below */
153 153 int so_count; /* count of opened references */
154 154
155 155 sock_connid_t so_proto_connid; /* protocol generation number */
156 156
157 157 ushort_t so_error; /* error affecting connection */
158 158
159 159 struct sockparams *so_sockparams; /* vnode or socket module */
160 160 /* Needed to recreate the same socket for accept */
161 161 short so_family;
162 162 short so_type;
163 163 short so_protocol;
164 164 short so_version; /* From so_socket call */
165 165
166 166 /* Accept queue */
167 167 kmutex_t so_acceptq_lock; /* protects accept queue */
168 168 list_t so_acceptq_list; /* pending conns */
169 169 list_t so_acceptq_defer; /* deferred conns */
170 170 list_node_t so_acceptq_node; /* acceptq list node */
171 171 unsigned int so_acceptq_len; /* # of conns (both lists) */
172 172 unsigned int so_backlog; /* Listen backlog */
173 173 kcondvar_t so_acceptq_cv; /* wait for new conn. */
174 174 struct sonode *so_listener; /* parent socket */
175 175
176 176 /* Options */
177 177 short so_options; /* From socket call, see socket.h */
178 178 struct linger so_linger; /* SO_LINGER value */
179 179 #define so_sndbuf so_proto_props.sopp_txhiwat /* SO_SNDBUF value */
180 180 #define so_sndlowat so_proto_props.sopp_txlowat /* tx low water mark */
181 181 #define so_rcvbuf so_proto_props.sopp_rxhiwat /* SO_RCVBUF value */
182 182 #define so_rcvlowat so_proto_props.sopp_rxlowat /* rx low water mark */
183 183 #define so_max_addr_len so_proto_props.sopp_maxaddrlen
184 184 #define so_minpsz so_proto_props.sopp_minpsz
185 185 #define so_maxpsz so_proto_props.sopp_maxpsz
186 186
187 187 int so_xpg_rcvbuf; /* SO_RCVBUF value for XPG4 socket */
188 188 clock_t so_sndtimeo; /* send timeout */
189 189 clock_t so_rcvtimeo; /* recv timeout */
190 190
191 191 mblk_t *so_oobmsg; /* outofline oob data */
192 192 ssize_t so_oobmark; /* offset of the oob data */
193 193
194 194 pid_t so_pgrp; /* pgrp for signals */
195 195
196 196 cred_t *so_peercred; /* connected socket peer cred */
197 197 pid_t so_cpid; /* connected socket peer cached pid */
198 198 zoneid_t so_zoneid; /* opener's zoneid */
199 199
200 200 struct pollhead so_poll_list; /* common pollhead */
201 201 short so_pollev; /* events that should be generated */
202 202
203 203 /* Receive */
204 204 unsigned int so_rcv_queued; /* # bytes on both rcv lists */
205 205 mblk_t *so_rcv_q_head; /* processing/copyout rcv queue */
206 206 mblk_t *so_rcv_q_last_head;
207 207 mblk_t *so_rcv_head; /* protocol prequeue */
208 208 mblk_t *so_rcv_last_head; /* last mblk in b_next chain */
209 209 kcondvar_t so_rcv_cv; /* wait for data */
210 210 uint_t so_rcv_wanted; /* # of bytes wanted by app */
211 211 timeout_id_t so_rcv_timer_tid;
212 212
213 213 #define so_rcv_thresh so_proto_props.sopp_rcvthresh
214 214 #define so_rcv_timer_interval so_proto_props.sopp_rcvtimer
215 215
216 216 kcondvar_t so_snd_cv; /* wait for snd buffers */
217 217 uint32_t
218 218 so_snd_qfull: 1, /* Transmit full */
219 219 so_rcv_wakeup: 1,
220 220 so_snd_wakeup: 1,
221 221 so_not_str: 1, /* B_TRUE if not streams based socket */
222 222 so_pad_to_bit_31: 28;
223 223
224 224 /* Communication channel with protocol */
225 225 sock_lower_handle_t so_proto_handle;
226 226 sock_downcalls_t *so_downcalls;
227 227
228 228 struct sock_proto_props so_proto_props; /* protocol settings */
229 229 boolean_t so_flowctrld; /* Flow controlled */
230 230 uint_t so_copyflag; /* Copy related flag */
231 231 kcondvar_t so_copy_cv; /* Copy cond variable */
232 232
233 233 /* kernel sockets */
234 234 ksocket_callbacks_t so_ksock_callbacks;
235 235 void *so_ksock_cb_arg; /* callback argument */
236 236 kcondvar_t so_closing_cv;
237 237
238 238 /* != NULL for sodirect enabled socket */
239 239 struct sodirect_s *so_direct;
240 240
241 241 /* socket filters */
242 242 uint_t so_filter_active; /* # of active fil */
243 243 uint_t so_filter_tx; /* pending tx ops */
244 244 struct sof_instance *so_filter_top; /* top of stack */
245 245 struct sof_instance *so_filter_bottom; /* bottom of stack */
246 246 clock_t so_filter_defertime; /* time when deferred */
247 247 };
248 248
249 249 #define SO_HAVE_DATA(so) \
250 250 /* \
251 251 * For the (tid == 0) case we must check so_rcv_{q_,}head \
252 252 * rather than (so_rcv_queued > 0), since the latter does not \
253 253 * take into account mblks with only control/name information. \
254 254 */ \
255 255 ((so)->so_rcv_timer_tid == 0 && ((so)->so_rcv_head != NULL || \
256 256 (so)->so_rcv_q_head != NULL)) || \
257 257 ((so)->so_state & SS_CANTRCVMORE)
258 258
259 259 /*
260 260 * Events handled by the protocol (in case sd_poll is set)
261 261 */
262 262 #define SO_PROTO_POLLEV (POLLIN|POLLRDNORM|POLLRDBAND)
263 263
264 264
265 265 #endif /* _KERNEL || _KMEMUSER */
266 266
267 267 /* flags */
268 268 #define SOMOD 0x0001 /* update socket modification time */
269 269 #define SOACC 0x0002 /* update socket access time */
270 270
271 271 #define SOLOCKED 0x0010 /* use to serialize open/closes */
272 272 #define SOREADLOCKED 0x0020 /* serialize kstrgetmsg calls */
273 273 #define SOCLONE 0x0040 /* child of clone driver */
274 274 #define SOASYNC_UNBIND 0x0080 /* wait for ACK of async unbind */
275 275
276 276 #define SOCK_IS_NONSTR(so) ((so)->so_not_str)
277 277
278 278 /*
279 279 * Socket state bits.
280 280 */
281 281 #define SS_ISCONNECTED 0x00000001 /* socket connected to a peer */
282 282 #define SS_ISCONNECTING 0x00000002 /* in process, connecting to peer */
283 283 #define SS_ISDISCONNECTING 0x00000004 /* in process of disconnecting */
284 284 #define SS_CANTSENDMORE 0x00000008 /* can't send more data to peer */
285 285
286 286 #define SS_CANTRCVMORE 0x00000010 /* can't receive more data */
287 287 #define SS_ISBOUND 0x00000020 /* socket is bound */
288 288 #define SS_NDELAY 0x00000040 /* FNDELAY non-blocking */
289 289 #define SS_NONBLOCK 0x00000080 /* O_NONBLOCK non-blocking */
|
↓ open down ↓ |
289 lines elided |
↑ open up ↑ |
290 290
291 291 #define SS_ASYNC 0x00000100 /* async i/o notify */
292 292 #define SS_ACCEPTCONN 0x00000200 /* listen done */
293 293 /* unused 0x00000400 */ /* was SS_HASCONNIND */
294 294 #define SS_SAVEDEOR 0x00000800 /* Saved MSG_EOR rcv side state */
295 295
296 296 #define SS_RCVATMARK 0x00001000 /* at mark on input */
297 297 #define SS_OOBPEND 0x00002000 /* OOB pending or present - poll */
298 298 #define SS_HAVEOOBDATA 0x00004000 /* OOB data present */
299 299 #define SS_HADOOBDATA 0x00008000 /* OOB data consumed */
300 -#define SS_CLOSING 0x00010000 /* in process of closing */
301 300
301 +#define SS_CLOSING 0x00010000 /* in process of closing */
302 302 #define SS_FIL_DEFER 0x00020000 /* filter deferred notification */
303 303 #define SS_FILOP_OK 0x00040000 /* socket can attach filters */
304 304 #define SS_FIL_RCV_FLOWCTRL 0x00080000 /* filter asserted rcv flow ctrl */
305 +
305 306 #define SS_FIL_SND_FLOWCTRL 0x00100000 /* filter asserted snd flow ctrl */
306 307 #define SS_FIL_STOP 0x00200000 /* no more filter actions */
307 -
308 308 #define SS_SODIRECT 0x00400000 /* transport supports sodirect */
309 +#define SS_FILOP_UNSF 0x00800000 /* block attaching unsafe filters */
309 310
310 311 #define SS_SENTLASTREADSIG 0x01000000 /* last rx signal has been sent */
311 312 #define SS_SENTLASTWRITESIG 0x02000000 /* last tx signal has been sent */
312 313
313 314 #define SS_FALLBACK_DRAIN 0x20000000 /* data was/is being drained */
314 315 #define SS_FALLBACK_PENDING 0x40000000 /* fallback is pending */
315 316 #define SS_FALLBACK_COMP 0x80000000 /* fallback has completed */
316 317
317 318
318 319 /* Set of states when the socket can't be rebound */
319 320 #define SS_CANTREBIND (SS_ISCONNECTED|SS_ISCONNECTING|SS_ISDISCONNECTING|\
320 321 SS_CANTSENDMORE|SS_CANTRCVMORE|SS_ACCEPTCONN)
321 322
322 323 /*
323 324 * Sockets that can fall back to TPI must ensure that fall back is not
324 - * initiated while a thread is using a socket.
325 + * initiated while a thread is using a socket. Otherwise this disables all
326 + * future filter attachment.
325 327 */
326 328 #define SO_BLOCK_FALLBACK(so, fn) \
327 329 ASSERT(MUTEX_NOT_HELD(&(so)->so_lock)); \
328 330 rw_enter(&(so)->so_fallback_rwlock, RW_READER); \
329 331 if ((so)->so_state & (SS_FALLBACK_COMP|SS_FILOP_OK)) { \
330 332 if ((so)->so_state & SS_FALLBACK_COMP) { \
331 333 rw_exit(&(so)->so_fallback_rwlock); \
332 334 return (fn); \
333 335 } else { \
334 336 mutex_enter(&(so)->so_lock); \
335 337 (so)->so_state &= ~SS_FILOP_OK; \
336 338 mutex_exit(&(so)->so_lock); \
337 339 } \
338 340 }
339 341
342 +/*
343 + * Sockets that can fall back to TPI must ensure that fall back is not
344 + * initiated while a thread is using a socket. Otherwise this disables all
345 + * future unsafe filter attachment. Safe filters can still attach after
346 + * we execute the function in which this macro is used.
347 + */
348 +#define SO_BLOCK_FALLBACK_SAFE(so, fn) \
349 + ASSERT(MUTEX_NOT_HELD(&(so)->so_lock)); \
350 + rw_enter(&(so)->so_fallback_rwlock, RW_READER); \
351 + if ((so)->so_state & SS_FALLBACK_COMP) { \
352 + rw_exit(&(so)->so_fallback_rwlock); \
353 + return (fn); \
354 + } else if (((so)->so_state & SS_FILOP_UNSF) == 0) { \
355 + mutex_enter(&(so)->so_lock); \
356 + (so)->so_state |= SS_FILOP_UNSF; \
357 + mutex_exit(&(so)->so_lock); \
358 + }
359 +
340 360 #define SO_UNBLOCK_FALLBACK(so) { \
341 361 rw_exit(&(so)->so_fallback_rwlock); \
342 362 }
343 363
344 364 #define SO_SND_FLOWCTRLD(so) \
345 365 ((so)->so_snd_qfull || (so)->so_state & SS_FIL_SND_FLOWCTRL)
346 366
347 367 /* Poll events */
348 368 #define SO_POLLEV_IN 0x1 /* POLLIN wakeup needed */
349 369 #define SO_POLLEV_ALWAYS 0x2 /* wakeups */
350 370
351 371 /*
352 372 * Characteristics of sockets. Not changed after the socket is created.
353 373 */
354 374 #define SM_PRIV 0x001 /* privileged for broadcast, raw... */
355 375 #define SM_ATOMIC 0x002 /* atomic data transmission */
356 376 #define SM_ADDR 0x004 /* addresses given with messages */
357 377 #define SM_CONNREQUIRED 0x008 /* connection required by protocol */
358 378
359 379 #define SM_FDPASSING 0x010 /* passes file descriptors */
360 380 #define SM_EXDATA 0x020 /* Can handle T_EXDATA_REQ */
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
361 381 #define SM_OPTDATA 0x040 /* Can handle T_OPTDATA_REQ */
362 382 #define SM_BYTESTREAM 0x080 /* Byte stream - can use M_DATA */
363 383
364 384 #define SM_ACCEPTOR_ID 0x100 /* so_acceptor_id is valid */
365 385
366 386 #define SM_KERNEL 0x200 /* kernel socket */
367 387
368 388 /* The modes below are only for non-streams sockets */
369 389 #define SM_ACCEPTSUPP 0x400 /* can handle accept() */
370 390 #define SM_SENDFILESUPP 0x800 /* Private: proto supp sendfile */
391 +#define SM_DEFERERR 0x1000 /* Private: defer so_error delivery */
371 392
372 393 /*
373 394 * Socket versions. Used by the socket library when calling _so_socket().
374 395 */
375 396 #define SOV_STREAM 0 /* Not a socket - just a stream */
376 397 #define SOV_DEFAULT 1 /* Select based on so_default_version */
377 398 #define SOV_SOCKSTREAM 2 /* Socket plus streams operations */
378 399 #define SOV_SOCKBSD 3 /* Socket with no streams operations */
379 400 #define SOV_XPG4_2 4 /* Xnet socket */
380 401
381 402 #if defined(_KERNEL) || defined(_KMEMUSER)
382 403
383 404 /*
384 405 * sonode create and destroy functions.
385 406 */
386 407 typedef struct sonode *(*so_create_func_t)(struct sockparams *,
387 408 int, int, int, int, int, int *, cred_t *);
388 409 typedef void (*so_destroy_func_t)(struct sonode *);
389 410
390 411 /* STREAM device information */
391 412 typedef struct sdev_info {
392 413 char *sd_devpath;
393 414 int sd_devpathlen; /* Is 0 if sp_devpath is a static string */
394 415 vnode_t *sd_vnode;
395 416 } sdev_info_t;
396 417
397 418 #define SOCKMOD_VERSION_1 1
398 419 #define SOCKMOD_VERSION 2
399 420
400 421 /* name of the TPI pseudo socket module */
401 422 #define SOTPI_SMOD_NAME "socktpi"
402 423
403 424 typedef struct __smod_priv_s {
404 425 so_create_func_t smodp_sock_create_func;
405 426 so_destroy_func_t smodp_sock_destroy_func;
406 427 so_proto_fallback_func_t smodp_proto_fallback_func;
407 428 const char *smodp_fallback_devpath_v4;
408 429 const char *smodp_fallback_devpath_v6;
409 430 } __smod_priv_t;
410 431
411 432 /*
412 433 * Socket module register information
413 434 */
414 435 typedef struct smod_reg_s {
415 436 int smod_version;
416 437 char *smod_name;
417 438 size_t smod_uc_version;
418 439 size_t smod_dc_version;
419 440 so_proto_create_func_t smod_proto_create_func;
420 441
421 442 /* __smod_priv_data must be NULL */
422 443 __smod_priv_t *__smod_priv;
423 444 } smod_reg_t;
424 445
425 446 /*
426 447 * Socket module information
427 448 */
428 449 typedef struct smod_info {
429 450 int smod_version;
430 451 char *smod_name;
431 452 uint_t smod_refcnt; /* # of entries */
432 453 size_t smod_uc_version; /* upcall version */
433 454 size_t smod_dc_version; /* down call version */
434 455 so_proto_create_func_t smod_proto_create_func;
435 456 so_proto_fallback_func_t smod_proto_fallback_func;
436 457 const char *smod_fallback_devpath_v4;
437 458 const char *smod_fallback_devpath_v6;
438 459 so_create_func_t smod_sock_create_func;
439 460 so_destroy_func_t smod_sock_destroy_func;
440 461 list_node_t smod_node;
441 462 } smod_info_t;
442 463
443 464 typedef struct sockparams_stats {
444 465 kstat_named_t sps_nfallback; /* # of fallbacks to TPI */
445 466 kstat_named_t sps_nactive; /* # of active sockets */
446 467 kstat_named_t sps_ncreate; /* total # of created sockets */
447 468 } sockparams_stats_t;
448 469
449 470 /*
450 471 * sockparams
451 472 *
452 473 * Used for mapping family/type/protocol to a socket module or STREAMS device
453 474 */
454 475 struct sockparams {
455 476 /*
456 477 * The family, type, protocol, sdev_info and smod_name are
457 478 * set when the entry is created, and they will never change
458 479 * thereafter.
459 480 */
460 481 int sp_family;
461 482 int sp_type;
462 483 int sp_protocol;
463 484
464 485 sdev_info_t sp_sdev_info; /* STREAM device */
465 486 char *sp_smod_name; /* socket module name */
466 487
467 488 kmutex_t sp_lock; /* lock for refcnt and smod_info */
468 489 uint64_t sp_refcnt; /* entry reference count */
469 490 smod_info_t *sp_smod_info; /* socket module */
470 491
471 492 sockparams_stats_t sp_stats;
472 493 kstat_t *sp_kstat;
473 494
474 495 /*
475 496 * The entries below are only modified while holding
476 497 * sockconf_lock as a writer.
477 498 */
478 499 int sp_flags; /* see below */
479 500 list_node_t sp_node;
480 501
481 502 list_t sp_auto_filters; /* list of automatic filters */
482 503 list_t sp_prog_filters; /* list of programmatic filters */
483 504 };
484 505
485 506 struct sof_entry;
486 507
487 508 typedef struct sp_filter {
488 509 struct sof_entry *spf_filter;
489 510 list_node_t spf_node;
490 511 } sp_filter_t;
491 512
492 513
493 514 /*
494 515 * sockparams flags
495 516 */
496 517 #define SOCKPARAMS_EPHEMERAL 0x1 /* temp. entry, not on global list */
497 518
498 519 extern void sockparams_init(void);
499 520 extern struct sockparams *sockparams_hold_ephemeral_bydev(int, int, int,
500 521 const char *, int, int *);
501 522 extern struct sockparams *sockparams_hold_ephemeral_bymod(int, int, int,
502 523 const char *, int, int *);
503 524 extern void sockparams_ephemeral_drop_last_ref(struct sockparams *);
504 525
505 526 extern struct sockparams *sockparams_create(int, int, int, char *, char *, int,
506 527 int, int, int *);
507 528 extern void sockparams_destroy(struct sockparams *);
508 529 extern int sockparams_add(struct sockparams *);
509 530 extern int sockparams_delete(int, int, int);
510 531 extern int sockparams_new_filter(struct sof_entry *);
511 532 extern void sockparams_filter_cleanup(struct sof_entry *);
512 533 extern int sockparams_copyout_socktable(uintptr_t);
513 534
514 535 extern void smod_init(void);
515 536 extern void smod_add(smod_info_t *);
516 537 extern int smod_register(const smod_reg_t *);
517 538 extern int smod_unregister(const char *);
518 539 extern smod_info_t *smod_lookup_byname(const char *);
519 540
520 541 #define SOCKPARAMS_HAS_DEVICE(sp) \
521 542 ((sp)->sp_sdev_info.sd_devpath != NULL)
522 543
523 544 /* Increase the smod_info_t reference count */
524 545 #define SMOD_INC_REF(smodp) { \
525 546 ASSERT((smodp) != NULL); \
526 547 DTRACE_PROBE1(smodinfo__inc__ref, struct smod_info *, (smodp)); \
527 548 atomic_inc_uint(&(smodp)->smod_refcnt); \
528 549 }
529 550
530 551 /*
531 552 * Decreace the socket module entry reference count.
532 553 * When no one mapping to the entry, we try to unload the module from the
533 554 * kernel. If the module can't unload, just leave the module entry with
534 555 * a zero refcnt.
535 556 */
536 557 #define SMOD_DEC_REF(smodp, modname) { \
537 558 ASSERT((smodp) != NULL); \
538 559 ASSERT((smodp)->smod_refcnt != 0); \
539 560 atomic_dec_uint(&(smodp)->smod_refcnt); \
540 561 /* \
541 562 * No need to atomically check the return value because the \
542 563 * socket module framework will verify that no one is using \
543 564 * the module before unloading. Worst thing that can happen \
544 565 * here is multiple calls to mod_remove_by_name(), which is OK. \
545 566 */ \
546 567 if ((smodp)->smod_refcnt == 0) \
547 568 (void) mod_remove_by_name(modname); \
548 569 }
549 570
550 571 /* Increase the reference count */
551 572 #define SOCKPARAMS_INC_REF(sp) { \
552 573 ASSERT((sp) != NULL); \
553 574 DTRACE_PROBE1(sockparams__inc__ref, struct sockparams *, (sp)); \
554 575 mutex_enter(&(sp)->sp_lock); \
555 576 (sp)->sp_refcnt++; \
556 577 ASSERT((sp)->sp_refcnt != 0); \
557 578 mutex_exit(&(sp)->sp_lock); \
558 579 }
559 580
560 581 /*
561 582 * Decrease the reference count.
562 583 *
563 584 * If the sockparams is ephemeral, then the thread dropping the last ref
564 585 * count will destroy the entry.
565 586 */
566 587 #define SOCKPARAMS_DEC_REF(sp) { \
567 588 ASSERT((sp) != NULL); \
568 589 DTRACE_PROBE1(sockparams__dec__ref, struct sockparams *, (sp)); \
569 590 mutex_enter(&(sp)->sp_lock); \
570 591 ASSERT((sp)->sp_refcnt > 0); \
571 592 if ((sp)->sp_refcnt == 1) { \
572 593 if ((sp)->sp_flags & SOCKPARAMS_EPHEMERAL) { \
573 594 mutex_exit(&(sp)->sp_lock); \
574 595 sockparams_ephemeral_drop_last_ref((sp)); \
575 596 } else { \
576 597 (sp)->sp_refcnt--; \
577 598 if ((sp)->sp_smod_info != NULL) { \
578 599 SMOD_DEC_REF((sp)->sp_smod_info, \
579 600 (sp)->sp_smod_name); \
580 601 } \
581 602 (sp)->sp_smod_info = NULL; \
582 603 mutex_exit(&(sp)->sp_lock); \
583 604 } \
584 605 } else { \
585 606 (sp)->sp_refcnt--; \
586 607 mutex_exit(&(sp)->sp_lock); \
587 608 } \
588 609 }
589 610
590 611 /*
591 612 * Used to traverse the list of AF_UNIX sockets to construct the kstat
592 613 * for netstat(1m).
593 614 */
594 615 struct socklist {
595 616 kmutex_t sl_lock;
596 617 struct sonode *sl_list;
597 618 };
598 619
599 620 extern struct socklist socklist;
600 621 /*
601 622 * ss_full_waits is the number of times the reader thread
602 623 * waits when the queue is full and ss_empty_waits is the number
603 624 * of times the consumer thread waits when the queue is empty.
604 625 * No locks for these as they are just indicators of whether
605 626 * disk or network or both is slow or fast.
606 627 */
607 628 struct sendfile_stats {
608 629 uint32_t ss_file_cached;
609 630 uint32_t ss_file_not_cached;
610 631 uint32_t ss_full_waits;
611 632 uint32_t ss_empty_waits;
612 633 uint32_t ss_file_segmap;
613 634 };
614 635
615 636 /*
616 637 * A single sendfile request is represented by snf_req.
617 638 */
618 639 typedef struct snf_req {
619 640 struct snf_req *sr_next;
620 641 mblk_t *sr_mp_head;
621 642 mblk_t *sr_mp_tail;
622 643 kmutex_t sr_lock;
623 644 kcondvar_t sr_cv;
624 645 uint_t sr_qlen;
625 646 int sr_hiwat;
626 647 int sr_lowat;
627 648 int sr_operation;
628 649 struct vnode *sr_vp;
629 650 file_t *sr_fp;
630 651 ssize_t sr_maxpsz;
631 652 u_offset_t sr_file_off;
632 653 u_offset_t sr_file_size;
633 654 #define SR_READ_DONE 0x80000000
634 655 int sr_read_error;
635 656 int sr_write_error;
636 657 } snf_req_t;
637 658
638 659 /* A queue of sendfile requests */
639 660 struct sendfile_queue {
640 661 snf_req_t *snfq_req_head;
641 662 snf_req_t *snfq_req_tail;
642 663 kmutex_t snfq_lock;
643 664 kcondvar_t snfq_cv;
644 665 int snfq_svc_threads; /* # of service threads */
645 666 int snfq_idle_cnt; /* # of idling threads */
646 667 int snfq_max_threads;
647 668 int snfq_req_cnt; /* Number of requests */
648 669 };
649 670
650 671 #define READ_OP 1
651 672 #define SNFQ_TIMEOUT (60 * 5 * hz) /* 5 minutes */
652 673
653 674 /* Socket network operations switch */
654 675 struct sonodeops {
655 676 int (*sop_init)(struct sonode *, struct sonode *, cred_t *,
656 677 int);
657 678 int (*sop_accept)(struct sonode *, int, cred_t *, struct sonode **);
658 679 int (*sop_bind)(struct sonode *, struct sockaddr *, socklen_t,
659 680 int, cred_t *);
660 681 int (*sop_listen)(struct sonode *, int, cred_t *);
661 682 int (*sop_connect)(struct sonode *, struct sockaddr *,
662 683 socklen_t, int, int, cred_t *);
663 684 int (*sop_recvmsg)(struct sonode *, struct msghdr *,
664 685 struct uio *, cred_t *);
665 686 int (*sop_sendmsg)(struct sonode *, struct msghdr *,
666 687 struct uio *, cred_t *);
667 688 int (*sop_sendmblk)(struct sonode *, struct msghdr *, int,
668 689 cred_t *, mblk_t **);
669 690 int (*sop_getpeername)(struct sonode *, struct sockaddr *,
670 691 socklen_t *, boolean_t, cred_t *);
671 692 int (*sop_getsockname)(struct sonode *, struct sockaddr *,
672 693 socklen_t *, cred_t *);
673 694 int (*sop_shutdown)(struct sonode *, int, cred_t *);
674 695 int (*sop_getsockopt)(struct sonode *, int, int, void *,
675 696 socklen_t *, int, cred_t *);
676 697 int (*sop_setsockopt)(struct sonode *, int, int, const void *,
677 698 socklen_t, cred_t *);
678 699 int (*sop_ioctl)(struct sonode *, int, intptr_t, int,
679 700 cred_t *, int32_t *);
680 701 int (*sop_poll)(struct sonode *, short, int, short *,
681 702 struct pollhead **);
682 703 int (*sop_close)(struct sonode *, int, cred_t *);
683 704 };
684 705
685 706 #define SOP_INIT(so, flag, cr, flags) \
686 707 ((so)->so_ops->sop_init((so), (flag), (cr), (flags)))
687 708 #define SOP_ACCEPT(so, fflag, cr, nsop) \
688 709 ((so)->so_ops->sop_accept((so), (fflag), (cr), (nsop)))
689 710 #define SOP_BIND(so, name, namelen, flags, cr) \
690 711 ((so)->so_ops->sop_bind((so), (name), (namelen), (flags), (cr)))
691 712 #define SOP_LISTEN(so, backlog, cr) \
692 713 ((so)->so_ops->sop_listen((so), (backlog), (cr)))
693 714 #define SOP_CONNECT(so, name, namelen, fflag, flags, cr) \
694 715 ((so)->so_ops->sop_connect((so), (name), (namelen), (fflag), (flags), \
695 716 (cr)))
696 717 #define SOP_RECVMSG(so, msg, uiop, cr) \
697 718 ((so)->so_ops->sop_recvmsg((so), (msg), (uiop), (cr)))
698 719 #define SOP_SENDMSG(so, msg, uiop, cr) \
699 720 ((so)->so_ops->sop_sendmsg((so), (msg), (uiop), (cr)))
700 721 #define SOP_SENDMBLK(so, msg, size, cr, mpp) \
701 722 ((so)->so_ops->sop_sendmblk((so), (msg), (size), (cr), (mpp)))
702 723 #define SOP_GETPEERNAME(so, addr, addrlen, accept, cr) \
703 724 ((so)->so_ops->sop_getpeername((so), (addr), (addrlen), (accept), (cr)))
704 725 #define SOP_GETSOCKNAME(so, addr, addrlen, cr) \
705 726 ((so)->so_ops->sop_getsockname((so), (addr), (addrlen), (cr)))
706 727 #define SOP_SHUTDOWN(so, how, cr) \
707 728 ((so)->so_ops->sop_shutdown((so), (how), (cr)))
708 729 #define SOP_GETSOCKOPT(so, level, optionname, optval, optlenp, flags, cr) \
709 730 ((so)->so_ops->sop_getsockopt((so), (level), (optionname), \
710 731 (optval), (optlenp), (flags), (cr)))
711 732 #define SOP_SETSOCKOPT(so, level, optionname, optval, optlen, cr) \
712 733 ((so)->so_ops->sop_setsockopt((so), (level), (optionname), \
713 734 (optval), (optlen), (cr)))
714 735 #define SOP_IOCTL(so, cmd, arg, mode, cr, rvalp) \
715 736 ((so)->so_ops->sop_ioctl((so), (cmd), (arg), (mode), (cr), (rvalp)))
716 737 #define SOP_POLL(so, events, anyyet, reventsp, phpp) \
717 738 ((so)->so_ops->sop_poll((so), (events), (anyyet), (reventsp), (phpp)))
718 739 #define SOP_CLOSE(so, flag, cr) \
719 740 ((so)->so_ops->sop_close((so), (flag), (cr)))
720 741
721 742 #endif /* defined(_KERNEL) || defined(_KMEMUSER) */
722 743
723 744 #ifdef _KERNEL
724 745
725 746 #define ISALIGNED_cmsghdr(addr) \
726 747 (((uintptr_t)(addr) & (_CMSG_HDR_ALIGNMENT - 1)) == 0)
727 748
728 749 #define ROUNDUP_cmsglen(len) \
729 750 (((len) + _CMSG_HDR_ALIGNMENT - 1) & ~(_CMSG_HDR_ALIGNMENT - 1))
730 751
731 752 #define IS_NON_STREAM_SOCK(vp) \
732 753 ((vp)->v_type == VSOCK && (vp)->v_stream == NULL)
733 754 /*
734 755 * Macros that operate on struct cmsghdr.
735 756 * Used in parsing msg_control.
736 757 * The CMSG_VALID macro does not assume that the last option buffer is padded.
737 758 */
738 759 #define CMSG_NEXT(cmsg) \
739 760 (struct cmsghdr *)((uintptr_t)(cmsg) + \
740 761 ROUNDUP_cmsglen((cmsg)->cmsg_len))
741 762 #define CMSG_CONTENT(cmsg) (&((cmsg)[1]))
742 763 #define CMSG_CONTENTLEN(cmsg) ((cmsg)->cmsg_len - sizeof (struct cmsghdr))
743 764 #define CMSG_VALID(cmsg, start, end) \
744 765 (ISALIGNED_cmsghdr(cmsg) && \
745 766 ((uintptr_t)(cmsg) >= (uintptr_t)(start)) && \
746 767 ((uintptr_t)(cmsg) < (uintptr_t)(end)) && \
747 768 ((ssize_t)(cmsg)->cmsg_len >= sizeof (struct cmsghdr)) && \
748 769 ((uintptr_t)(cmsg) + (cmsg)->cmsg_len <= (uintptr_t)(end)))
749 770
750 771 /*
751 772 * Maximum size of any argument that is copied in (addresses, options,
752 773 * access rights). MUST be at least MAXPATHLEN + 3.
753 774 * BSD and SunOS 4.X limited this to MLEN or MCLBYTES.
754 775 */
755 776 #define SO_MAXARGSIZE 8192
756 777
757 778 /*
758 779 * Convert between vnode and sonode
759 780 */
760 781 #define VTOSO(vp) ((struct sonode *)((vp)->v_data))
761 782 #define SOTOV(sp) ((sp)->so_vnode)
762 783
763 784 /*
764 785 * Internal flags for sobind()
765 786 */
766 787 #define _SOBIND_REBIND 0x01 /* Bind to existing local address */
767 788 #define _SOBIND_UNSPEC 0x02 /* Bind to unspecified address */
768 789 #define _SOBIND_LOCK_HELD 0x04 /* so_excl_lock held by caller */
769 790 #define _SOBIND_NOXLATE 0x08 /* No addr translation for AF_UNIX */
770 791 #define _SOBIND_XPG4_2 0x10 /* xpg4.2 semantics */
771 792 #define _SOBIND_SOCKBSD 0x20 /* BSD semantics */
772 793 #define _SOBIND_LISTEN 0x40 /* Make into SS_ACCEPTCONN */
773 794 #define _SOBIND_SOCKETPAIR 0x80 /* Internal flag for so_socketpair() */
774 795 /* to enable listen with backlog = 1 */
775 796
776 797 /*
777 798 * Internal flags for sounbind()
778 799 */
779 800 #define _SOUNBIND_REBIND 0x01 /* Don't clear fields - will rebind */
780 801
781 802 /*
782 803 * Internal flags for soconnect()
783 804 */
784 805 #define _SOCONNECT_NOXLATE 0x01 /* No addr translation for AF_UNIX */
785 806 #define _SOCONNECT_DID_BIND 0x02 /* Unbind when connect fails */
786 807 #define _SOCONNECT_XPG4_2 0x04 /* xpg4.2 semantics */
787 808
788 809 /*
789 810 * Internal flags for sodisconnect()
790 811 */
791 812 #define _SODISCONNECT_LOCK_HELD 0x01 /* so_excl_lock held by caller */
792 813
793 814 /*
794 815 * Internal flags for sotpi_getsockopt().
795 816 */
796 817 #define _SOGETSOCKOPT_XPG4_2 0x01 /* xpg4.2 semantics */
797 818
798 819 /*
799 820 * Internal flags for soallocproto*()
800 821 */
801 822 #define _ALLOC_NOSLEEP 0 /* Don't sleep for memory */
802 823 #define _ALLOC_INTR 1 /* Sleep until interrupt */
803 824 #define _ALLOC_SLEEP 2 /* Sleep forever */
804 825
805 826 /*
806 827 * Internal structure for handling AF_UNIX file descriptor passing
807 828 */
808 829 struct fdbuf {
809 830 int fd_size; /* In bytes, for kmem_free */
810 831 int fd_numfd; /* Number of elements below */
811 832 char *fd_ebuf; /* Extra buffer to free */
812 833 int fd_ebuflen;
813 834 frtn_t fd_frtn;
814 835 struct file *fd_fds[1]; /* One or more */
815 836 };
816 837 #define FDBUF_HDRSIZE (sizeof (struct fdbuf) - sizeof (struct file *))
817 838
818 839 /*
819 840 * Variable that can be patched to set what version of socket socket()
820 841 * will create.
821 842 */
822 843 extern int so_default_version;
823 844
824 845 #ifdef DEBUG
825 846 /* Turn on extra testing capabilities */
826 847 #define SOCK_TEST
827 848 #endif /* DEBUG */
828 849
829 850 #ifdef DEBUG
830 851 char *pr_state(uint_t, uint_t);
831 852 char *pr_addr(int, struct sockaddr *, t_uscalar_t);
832 853 int so_verify_oobstate(struct sonode *);
833 854 #endif /* DEBUG */
834 855
835 856 /*
836 857 * DEBUG macros
837 858 */
838 859 #if defined(DEBUG)
839 860 #define SOCK_DEBUG
840 861
841 862 extern int sockdebug;
842 863 extern int sockprinterr;
843 864
844 865 #define eprint(args) printf args
845 866 #define eprintso(so, args) \
846 867 { if (sockprinterr && ((so)->so_options & SO_DEBUG)) printf args; }
847 868 #define eprintline(error) \
848 869 { \
849 870 if (error != EINTR && (sockprinterr || sockdebug > 0)) \
850 871 printf("socket error %d: line %d file %s\n", \
851 872 (error), __LINE__, __FILE__); \
852 873 }
853 874
854 875 #define eprintsoline(so, error) \
855 876 { if (sockprinterr && ((so)->so_options & SO_DEBUG)) \
856 877 printf("socket(%p) error %d: line %d file %s\n", \
857 878 (void *)(so), (error), __LINE__, __FILE__); \
858 879 }
859 880 #define dprint(level, args) { if (sockdebug > (level)) printf args; }
860 881 #define dprintso(so, level, args) \
861 882 { if (sockdebug > (level) && ((so)->so_options & SO_DEBUG)) printf args; }
862 883
863 884 #else /* define(DEBUG) */
864 885
865 886 #define eprint(args) {}
866 887 #define eprintso(so, args) {}
867 888 #define eprintline(error) {}
868 889 #define eprintsoline(so, error) {}
869 890 #define dprint(level, args) {}
870 891 #define dprintso(so, level, args) {}
871 892
872 893 #endif /* defined(DEBUG) */
873 894
874 895 extern struct vfsops sock_vfsops;
875 896 extern struct vnodeops *socket_vnodeops;
876 897 extern const struct fs_operation_def socket_vnodeops_template[];
877 898
878 899 extern dev_t sockdev;
879 900
880 901 extern krwlock_t sockconf_lock;
881 902
882 903 /*
883 904 * sockfs functions
884 905 */
885 906 extern int sock_getmsg(vnode_t *, struct strbuf *, struct strbuf *,
886 907 uchar_t *, int *, int, rval_t *);
887 908 extern int sock_putmsg(vnode_t *, struct strbuf *, struct strbuf *,
888 909 uchar_t, int, int);
889 910 extern int sogetvp(char *, vnode_t **, int);
890 911 extern int sockinit(int, char *);
891 912 extern int solookup(int, int, int, struct sockparams **);
892 913 extern void so_lock_single(struct sonode *);
893 914 extern void so_unlock_single(struct sonode *, int);
894 915 extern int so_lock_read(struct sonode *, int);
895 916 extern int so_lock_read_intr(struct sonode *, int);
896 917 extern void so_unlock_read(struct sonode *);
897 918 extern void *sogetoff(mblk_t *, t_uscalar_t, t_uscalar_t, uint_t);
898 919 extern void so_getopt_srcaddr(void *, t_uscalar_t,
899 920 void **, t_uscalar_t *);
900 921 extern int so_getopt_unix_close(void *, t_uscalar_t);
901 922 extern void fdbuf_free(struct fdbuf *);
902 923 extern mblk_t *fdbuf_allocmsg(int, struct fdbuf *);
903 924 extern int fdbuf_create(void *, int, struct fdbuf **);
904 925 extern void so_closefds(void *, t_uscalar_t, int, int);
905 926 extern int so_getfdopt(void *, t_uscalar_t, int, void **, int *);
906 927 t_uscalar_t so_optlen(void *, t_uscalar_t, int);
907 928 extern void so_cmsg2opt(void *, t_uscalar_t, int, mblk_t *);
908 929 extern t_uscalar_t
909 930 so_cmsglen(mblk_t *, void *, t_uscalar_t, int);
910 931 extern int so_opt2cmsg(mblk_t *, void *, t_uscalar_t, int,
911 932 void *, t_uscalar_t);
912 933 extern void soisconnecting(struct sonode *);
913 934 extern void soisconnected(struct sonode *);
914 935 extern void soisdisconnected(struct sonode *, int);
915 936 extern void socantsendmore(struct sonode *);
916 937 extern void socantrcvmore(struct sonode *);
917 938 extern void soseterror(struct sonode *, int);
918 939 extern int sogeterr(struct sonode *, boolean_t);
919 940 extern int sowaitconnected(struct sonode *, int, int);
920 941
921 942 extern ssize_t soreadfile(file_t *, uchar_t *, u_offset_t, int *, size_t);
922 943 extern void *sock_kstat_init(zoneid_t);
923 944 extern void sock_kstat_fini(zoneid_t, void *);
924 945 extern struct sonode *getsonode(int, int *, file_t **);
925 946 /*
926 947 * Function wrappers (mostly around the sonode switch) for
927 948 * backward compatibility.
928 949 */
929 950 extern int soaccept(struct sonode *, int, struct sonode **);
930 951 extern int sobind(struct sonode *, struct sockaddr *, socklen_t,
931 952 int, int);
932 953 extern int solisten(struct sonode *, int);
933 954 extern int soconnect(struct sonode *, struct sockaddr *, socklen_t,
934 955 int, int);
935 956 extern int sorecvmsg(struct sonode *, struct nmsghdr *, struct uio *);
936 957 extern int sosendmsg(struct sonode *, struct nmsghdr *, struct uio *);
937 958 extern int soshutdown(struct sonode *, int);
938 959 extern int sogetsockopt(struct sonode *, int, int, void *, socklen_t *,
939 960 int);
940 961 extern int sosetsockopt(struct sonode *, int, int, const void *,
941 962 t_uscalar_t);
942 963
943 964 extern struct sonode *socreate(struct sockparams *, int, int, int, int,
944 965 int *);
945 966
946 967 extern int so_copyin(const void *, void *, size_t, int);
947 968 extern int so_copyout(const void *, void *, size_t, int);
948 969
949 970 #endif
950 971
951 972 /*
952 973 * Internal structure for obtaining sonode information from the socklist.
953 974 * These types match those corresponding in the sonode structure.
954 975 * This is not a published interface, and may change at any time.
955 976 */
956 977 struct sockinfo {
957 978 uint_t si_size; /* real length of this struct */
958 979 short si_family;
959 980 short si_type;
960 981 ushort_t si_flag;
961 982 uint_t si_state;
962 983 uint_t si_ux_laddr_sou_magic;
963 984 uint_t si_ux_faddr_sou_magic;
964 985 t_scalar_t si_serv_type;
965 986 t_uscalar_t si_laddr_soa_len;
966 987 t_uscalar_t si_faddr_soa_len;
967 988 uint16_t si_laddr_family;
968 989 uint16_t si_faddr_family;
969 990 char si_laddr_sun_path[MAXPATHLEN + 1]; /* NULL terminated */
970 991 char si_faddr_sun_path[MAXPATHLEN + 1];
971 992 boolean_t si_faddr_noxlate;
972 993 zoneid_t si_szoneid;
973 994 };
974 995
975 996 /*
976 997 * Subcodes for sockconf() system call
977 998 */
978 999 #define SOCKCONFIG_ADD_SOCK 0
979 1000 #define SOCKCONFIG_REMOVE_SOCK 1
980 1001 #define SOCKCONFIG_ADD_FILTER 2
981 1002 #define SOCKCONFIG_REMOVE_FILTER 3
982 1003 #define SOCKCONFIG_GET_SOCKTABLE 4
983 1004
984 1005 /*
985 1006 * Data structures for configuring socket filters.
986 1007 */
987 1008
988 1009 /*
989 1010 * Placement hint for automatic filters
990 1011 */
991 1012 typedef enum {
992 1013 SOF_HINT_NONE,
993 1014 SOF_HINT_TOP,
994 1015 SOF_HINT_BOTTOM,
995 1016 SOF_HINT_BEFORE,
996 1017 SOF_HINT_AFTER
997 1018 } sof_hint_t;
998 1019
999 1020 /*
1000 1021 * Socket tuple. Used by sockconfig_filter_props to list socket
1001 1022 * types of interest.
1002 1023 */
1003 1024 typedef struct sof_socktuple {
1004 1025 int sofst_family;
1005 1026 int sofst_type;
1006 1027 int sofst_protocol;
1007 1028 } sof_socktuple_t;
1008 1029
1009 1030 /*
1010 1031 * Socket filter properties used by sockconfig() system call.
1011 1032 */
1012 1033 struct sockconfig_filter_props {
1013 1034 char *sfp_modname;
1014 1035 boolean_t sfp_autoattach;
1015 1036 sof_hint_t sfp_hint;
1016 1037 char *sfp_hintarg;
1017 1038 uint_t sfp_socktuple_cnt;
1018 1039 sof_socktuple_t *sfp_socktuple;
1019 1040 };
1020 1041
1021 1042 /*
1022 1043 * Data structures for the in-kernel socket configuration table.
1023 1044 */
1024 1045 typedef struct sockconfig_socktable_entry {
1025 1046 int se_family;
1026 1047 int se_type;
1027 1048 int se_protocol;
1028 1049 int se_refcnt;
1029 1050 int se_flags;
1030 1051 char se_modname[MODMAXNAMELEN];
1031 1052 char se_strdev[MAXPATHLEN];
1032 1053 } sockconfig_socktable_entry_t;
1033 1054
1034 1055 typedef struct sockconfig_socktable {
1035 1056 uint_t num_of_entries;
1036 1057 sockconfig_socktable_entry_t *st_entries;
1037 1058 } sockconfig_socktable_t;
1038 1059
1039 1060 #ifdef _SYSCALL32
1040 1061
1041 1062 typedef struct sof_socktuple32 {
1042 1063 int32_t sofst_family;
1043 1064 int32_t sofst_type;
1044 1065 int32_t sofst_protocol;
1045 1066 } sof_socktuple32_t;
1046 1067
1047 1068 struct sockconfig_filter_props32 {
1048 1069 caddr32_t sfp_modname;
1049 1070 boolean_t sfp_autoattach;
1050 1071 sof_hint_t sfp_hint;
1051 1072 caddr32_t sfp_hintarg;
1052 1073 uint32_t sfp_socktuple_cnt;
1053 1074 caddr32_t sfp_socktuple;
1054 1075 };
1055 1076
1056 1077 typedef struct sockconfig_socktable32 {
1057 1078 uint_t num_of_entries;
1058 1079 caddr32_t st_entries;
1059 1080 } sockconfig_socktable32_t;
1060 1081
1061 1082 #endif /* _SYSCALL32 */
1062 1083
1063 1084 #define SOCKMOD_PATH "socketmod" /* dir where sockmods are stored */
1064 1085
1065 1086 #ifdef __cplusplus
1066 1087 }
1067 1088 #endif
1068 1089
1069 1090 #endif /* _SYS_SOCKETVAR_H */
|
↓ open down ↓ |
689 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX