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