17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 52caf0dcdSrshoaib * Common Development and Distribution License (the "License"). 62caf0dcdSrshoaib * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 212caf0dcdSrshoaib 227c478bd9Sstevel@tonic-gate /* 235f1fdc18SAnders Persson * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. 24907c2824SRobert Mustacchi * Copyright 2015 Joyent, Inc. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 287c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate /* 317c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988 327c478bd9Sstevel@tonic-gate * The Regents of the University of California 337c478bd9Sstevel@tonic-gate * All Rights Reserved 347c478bd9Sstevel@tonic-gate * 357c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from 367c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its 377c478bd9Sstevel@tonic-gate * contributors. 387c478bd9Sstevel@tonic-gate */ 3919581f84SAlexander Eremin /* 4019581f84SAlexander Eremin * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 41d865fc92SAndy Fiddaman * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. 4219581f84SAlexander Eremin */ 437c478bd9Sstevel@tonic-gate 447c478bd9Sstevel@tonic-gate #ifndef _SYS_SOCKETVAR_H 457c478bd9Sstevel@tonic-gate #define _SYS_SOCKETVAR_H 467c478bd9Sstevel@tonic-gate 477c478bd9Sstevel@tonic-gate #include <sys/types.h> 487c478bd9Sstevel@tonic-gate #include <sys/stream.h> 497c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 507c478bd9Sstevel@tonic-gate #include <sys/cred.h> 517c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 527c478bd9Sstevel@tonic-gate #include <sys/file.h> 537c478bd9Sstevel@tonic-gate #include <sys/param.h> 547c478bd9Sstevel@tonic-gate #include <sys/zone.h> 550f1702c5SYu Xiangning #include <sys/sdt.h> 560f1702c5SYu Xiangning #include <sys/modctl.h> 570f1702c5SYu Xiangning #include <sys/atomic.h> 580f1702c5SYu Xiangning #include <sys/socket.h> 590f1702c5SYu Xiangning #include <sys/ksocket.h> 607d64f41bSAnders Persson #include <sys/kstat.h> 617c478bd9Sstevel@tonic-gate 62d67944fbSScott Rotondo #ifdef _KERNEL 63d67944fbSScott Rotondo #include <sys/vfs_opreg.h> 64d67944fbSScott Rotondo #endif 65d67944fbSScott Rotondo 667c478bd9Sstevel@tonic-gate #ifdef __cplusplus 677c478bd9Sstevel@tonic-gate extern "C" { 687c478bd9Sstevel@tonic-gate #endif 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate /* 717c478bd9Sstevel@tonic-gate * Internal representation of the address used to represent addresses 727c478bd9Sstevel@tonic-gate * in the loopback transport for AF_UNIX. While the sockaddr_un is used 737c478bd9Sstevel@tonic-gate * as the sockfs layer address for AF_UNIX the pathnames contained in 747c478bd9Sstevel@tonic-gate * these addresses are not unique (due to relative pathnames) thus can not 757c478bd9Sstevel@tonic-gate * be used in the transport. 767c478bd9Sstevel@tonic-gate * 777c478bd9Sstevel@tonic-gate * The transport level address consists of a magic number (used to separate the 787c478bd9Sstevel@tonic-gate * name space for specific and implicit binds). For a specific bind 797c478bd9Sstevel@tonic-gate * this is followed by a "vnode *" which ensures that all specific binds 807c478bd9Sstevel@tonic-gate * have a unique transport level address. For implicit binds the latter 817c478bd9Sstevel@tonic-gate * part of the address is a byte string (of the same length as a pointer) 827c478bd9Sstevel@tonic-gate * that is assigned by the loopback transport. 837c478bd9Sstevel@tonic-gate * 847c478bd9Sstevel@tonic-gate * The uniqueness assumes that the loopback transport has a separate namespace 857c478bd9Sstevel@tonic-gate * for sockets in order to avoid name conflicts with e.g. TLI use of the 867c478bd9Sstevel@tonic-gate * same transport. 877c478bd9Sstevel@tonic-gate */ 887c478bd9Sstevel@tonic-gate struct so_ux_addr { 897c478bd9Sstevel@tonic-gate void *soua_vp; /* vnode pointer or assigned by tl */ 907c478bd9Sstevel@tonic-gate uint_t soua_magic; /* See below */ 917c478bd9Sstevel@tonic-gate }; 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate #define SOU_MAGIC_EXPLICIT 0x75787670 /* "uxvp" */ 947c478bd9Sstevel@tonic-gate #define SOU_MAGIC_IMPLICIT 0x616e6f6e /* "anon" */ 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate struct sockaddr_ux { 977c478bd9Sstevel@tonic-gate sa_family_t sou_family; /* AF_UNIX */ 987c478bd9Sstevel@tonic-gate struct so_ux_addr sou_addr; 997c478bd9Sstevel@tonic-gate }; 1007c478bd9Sstevel@tonic-gate 1010f1702c5SYu Xiangning #if defined(_KERNEL) || defined(_KMEMUSER) 1020f1702c5SYu Xiangning 1030f1702c5SYu Xiangning #include <sys/socket_proto.h> 1040f1702c5SYu Xiangning 1057c478bd9Sstevel@tonic-gate typedef struct sonodeops sonodeops_t; 106ff550d0eSmasputra typedef struct sonode sonode_t; 107907c2824SRobert Mustacchi typedef boolean_t (*so_krecv_f)(sonode_t *, mblk_t *, size_t, int, void *); 1087c478bd9Sstevel@tonic-gate 109bbc000e5SAnders Persson struct sodirect_s; 110bbc000e5SAnders Persson 1117c478bd9Sstevel@tonic-gate /* 1127c478bd9Sstevel@tonic-gate * The sonode represents a socket. A sonode never exist in the file system 1137c478bd9Sstevel@tonic-gate * name space and can not be opened using open() - only the socket, socketpair 1147c478bd9Sstevel@tonic-gate * and accept calls create sonodes. 1157c478bd9Sstevel@tonic-gate * 1160f1702c5SYu Xiangning * The locking of sockfs uses the so_lock mutex plus the SOLOCKED and 1170f1702c5SYu Xiangning * SOREADLOCKED flags in so_flag. The mutex protects all the state in the 1180f1702c5SYu Xiangning * sonode. It is expected that the underlying transport protocol serializes 1190f1702c5SYu Xiangning * socket operations, so sockfs will not normally not single-thread 1200f1702c5SYu Xiangning * operations. However, certain sockets, including TPI based ones, can only 1210f1702c5SYu Xiangning * handle one control operation at a time. The SOLOCKED flag is used to 1220f1702c5SYu Xiangning * single-thread operations from sockfs users to prevent e.g. multiple bind() 1230f1702c5SYu Xiangning * calls to operate on the same sonode concurrently. The SOREADLOCKED flag is 1240f1702c5SYu Xiangning * used to ensure that only one thread sleeps in kstrgetmsg for a given 1250f1702c5SYu Xiangning * sonode. This is needed to ensure atomic operation for things like 1260f1702c5SYu Xiangning * MSG_WAITALL. 1277c478bd9Sstevel@tonic-gate * 1280f1702c5SYu Xiangning * The so_fallback_rwlock is used to ensure that for sockets that can 1290f1702c5SYu Xiangning * fall back to TPI, the fallback is not initiated until all pending 1300f1702c5SYu Xiangning * operations have completed. 1317c478bd9Sstevel@tonic-gate * 1327c478bd9Sstevel@tonic-gate * Note that so_lock is sometimes held across calls that might go to sleep 1337c478bd9Sstevel@tonic-gate * (kmem_alloc and soallocproto*). This implies that no other lock in 1347c478bd9Sstevel@tonic-gate * the system should be held when calling into sockfs; from the system call 1350f1702c5SYu Xiangning * side or from strrput (in case of TPI based sockets). If locks are held 1360f1702c5SYu Xiangning * while calling into sockfs the system might hang when running low on memory. 1377c478bd9Sstevel@tonic-gate */ 1387c478bd9Sstevel@tonic-gate struct sonode { 1397c478bd9Sstevel@tonic-gate struct vnode *so_vnode; /* vnode associated with this sonode */ 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate sonodeops_t *so_ops; /* operations vector for this sonode */ 1420f1702c5SYu Xiangning void *so_priv; /* sonode private data */ 1437c478bd9Sstevel@tonic-gate 1440f1702c5SYu Xiangning krwlock_t so_fallback_rwlock; 1457c478bd9Sstevel@tonic-gate kmutex_t so_lock; /* protects sonode fields */ 1460f1702c5SYu Xiangning 1477c478bd9Sstevel@tonic-gate kcondvar_t so_state_cv; /* synchronize state changes */ 1486a571a2dSAnders Persson kcondvar_t so_single_cv; /* wait due to SOLOCKED */ 1496a571a2dSAnders Persson kcondvar_t so_read_cv; /* wait due to SOREADLOCKED */ 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate /* These fields are protected by so_lock */ 1520f1702c5SYu Xiangning 1537c478bd9Sstevel@tonic-gate uint_t so_state; /* internal state flags SS_*, below */ 1547c478bd9Sstevel@tonic-gate uint_t so_mode; /* characteristics on socket. SM_* */ 1557c478bd9Sstevel@tonic-gate ushort_t so_flag; /* flags, see below */ 1567c478bd9Sstevel@tonic-gate int so_count; /* count of opened references */ 1577c478bd9Sstevel@tonic-gate 1580f1702c5SYu Xiangning sock_connid_t so_proto_connid; /* protocol generation number */ 1590f1702c5SYu Xiangning 1600f1702c5SYu Xiangning ushort_t so_error; /* error affecting connection */ 1610f1702c5SYu Xiangning 1620f1702c5SYu Xiangning struct sockparams *so_sockparams; /* vnode or socket module */ 1637c478bd9Sstevel@tonic-gate /* Needed to recreate the same socket for accept */ 1647c478bd9Sstevel@tonic-gate short so_family; 1657c478bd9Sstevel@tonic-gate short so_type; 1667c478bd9Sstevel@tonic-gate short so_protocol; 1677c478bd9Sstevel@tonic-gate short so_version; /* From so_socket call */ 1680f1702c5SYu Xiangning 1690f1702c5SYu Xiangning /* Accept queue */ 1700f1702c5SYu Xiangning kmutex_t so_acceptq_lock; /* protects accept queue */ 1713e95bd4aSAnders Persson list_t so_acceptq_list; /* pending conns */ 1723e95bd4aSAnders Persson list_t so_acceptq_defer; /* deferred conns */ 1733e95bd4aSAnders Persson list_node_t so_acceptq_node; /* acceptq list node */ 1743e95bd4aSAnders Persson unsigned int so_acceptq_len; /* # of conns (both lists) */ 1750f1702c5SYu Xiangning unsigned int so_backlog; /* Listen backlog */ 1760f1702c5SYu Xiangning kcondvar_t so_acceptq_cv; /* wait for new conn. */ 1773e95bd4aSAnders Persson struct sonode *so_listener; /* parent socket */ 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate /* Options */ 1807c478bd9Sstevel@tonic-gate short so_options; /* From socket call, see socket.h */ 1817c478bd9Sstevel@tonic-gate struct linger so_linger; /* SO_LINGER value */ 1820f1702c5SYu Xiangning #define so_sndbuf so_proto_props.sopp_txhiwat /* SO_SNDBUF value */ 1830f1702c5SYu Xiangning #define so_sndlowat so_proto_props.sopp_txlowat /* tx low water mark */ 1840f1702c5SYu Xiangning #define so_rcvbuf so_proto_props.sopp_rxhiwat /* SO_RCVBUF value */ 1850f1702c5SYu Xiangning #define so_rcvlowat so_proto_props.sopp_rxlowat /* rx low water mark */ 1860f1702c5SYu Xiangning #define so_max_addr_len so_proto_props.sopp_maxaddrlen 1870f1702c5SYu Xiangning #define so_minpsz so_proto_props.sopp_minpsz 1880f1702c5SYu Xiangning #define so_maxpsz so_proto_props.sopp_maxpsz 1897c478bd9Sstevel@tonic-gate 190a5adac4dSYu Xiangning int so_xpg_rcvbuf; /* SO_RCVBUF value for XPG4 socket */ 1910f1702c5SYu Xiangning clock_t so_sndtimeo; /* send timeout */ 1920f1702c5SYu Xiangning clock_t so_rcvtimeo; /* recv timeout */ 1930f1702c5SYu Xiangning 1947c478bd9Sstevel@tonic-gate mblk_t *so_oobmsg; /* outofline oob data */ 1950f1702c5SYu Xiangning ssize_t so_oobmark; /* offset of the oob data */ 1960f1702c5SYu Xiangning 1977c478bd9Sstevel@tonic-gate pid_t so_pgrp; /* pgrp for signals */ 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate cred_t *so_peercred; /* connected socket peer cred */ 2007c478bd9Sstevel@tonic-gate pid_t so_cpid; /* connected socket peer cached pid */ 2017c478bd9Sstevel@tonic-gate zoneid_t so_zoneid; /* opener's zoneid */ 2027c478bd9Sstevel@tonic-gate 2030f1702c5SYu Xiangning struct pollhead so_poll_list; /* common pollhead */ 2040f1702c5SYu Xiangning short so_pollev; /* events that should be generated */ 2057c478bd9Sstevel@tonic-gate 2060f1702c5SYu Xiangning /* Receive */ 207419dcee7SAnders Persson unsigned int so_rcv_queued; /* # bytes on both rcv lists */ 208419dcee7SAnders Persson mblk_t *so_rcv_q_head; /* processing/copyout rcv queue */ 2090f1702c5SYu Xiangning mblk_t *so_rcv_q_last_head; 210419dcee7SAnders Persson mblk_t *so_rcv_head; /* protocol prequeue */ 2110f1702c5SYu Xiangning mblk_t *so_rcv_last_head; /* last mblk in b_next chain */ 212419dcee7SAnders Persson kcondvar_t so_rcv_cv; /* wait for data */ 2130f1702c5SYu Xiangning uint_t so_rcv_wanted; /* # of bytes wanted by app */ 2140f1702c5SYu Xiangning timeout_id_t so_rcv_timer_tid; 215c28749e9Skais 2160f1702c5SYu Xiangning #define so_rcv_thresh so_proto_props.sopp_rcvthresh 2170f1702c5SYu Xiangning #define so_rcv_timer_interval so_proto_props.sopp_rcvtimer 2180f1702c5SYu Xiangning 219419dcee7SAnders Persson kcondvar_t so_snd_cv; /* wait for snd buffers */ 220d36be52eSRao Shoaib uint32_t 221d36be52eSRao Shoaib so_snd_qfull: 1, /* Transmit full */ 222d36be52eSRao Shoaib so_rcv_wakeup: 1, 223d36be52eSRao Shoaib so_snd_wakeup: 1, 224d36be52eSRao Shoaib so_not_str: 1, /* B_TRUE if not streams based socket */ 225d36be52eSRao Shoaib so_pad_to_bit_31: 28; 2260f1702c5SYu Xiangning 2270f1702c5SYu Xiangning /* Communication channel with protocol */ 2280f1702c5SYu Xiangning sock_lower_handle_t so_proto_handle; 2290f1702c5SYu Xiangning sock_downcalls_t *so_downcalls; 2300f1702c5SYu Xiangning 2310f1702c5SYu Xiangning struct sock_proto_props so_proto_props; /* protocol settings */ 2320f1702c5SYu Xiangning boolean_t so_flowctrld; /* Flow controlled */ 2330f1702c5SYu Xiangning uint_t so_copyflag; /* Copy related flag */ 2340f1702c5SYu Xiangning kcondvar_t so_copy_cv; /* Copy cond variable */ 2350f1702c5SYu Xiangning 2360f1702c5SYu Xiangning /* kernel sockets */ 2370f1702c5SYu Xiangning ksocket_callbacks_t so_ksock_callbacks; 2380f1702c5SYu Xiangning void *so_ksock_cb_arg; /* callback argument */ 2390f1702c5SYu Xiangning kcondvar_t so_closing_cv; 24017169044Sbrutus 241bbc000e5SAnders Persson /* != NULL for sodirect enabled socket */ 242bbc000e5SAnders Persson struct sodirect_s *so_direct; 2433e95bd4aSAnders Persson 2443e95bd4aSAnders Persson /* socket filters */ 2453e95bd4aSAnders Persson uint_t so_filter_active; /* # of active fil */ 2463e95bd4aSAnders Persson uint_t so_filter_tx; /* pending tx ops */ 2473e95bd4aSAnders Persson struct sof_instance *so_filter_top; /* top of stack */ 2483e95bd4aSAnders Persson struct sof_instance *so_filter_bottom; /* bottom of stack */ 2493e95bd4aSAnders Persson clock_t so_filter_defertime; /* time when deferred */ 250907c2824SRobert Mustacchi 251907c2824SRobert Mustacchi /* Kernel direct receive callbacks */ 252907c2824SRobert Mustacchi so_krecv_f so_krecv_cb; /* recv callback */ 253907c2824SRobert Mustacchi void *so_krecv_arg; /* recv cb arg */ 2547c478bd9Sstevel@tonic-gate }; 2557c478bd9Sstevel@tonic-gate 2560f1702c5SYu Xiangning #define SO_HAVE_DATA(so) \ 257f0267584Sanders /* \ 258f0267584Sanders * For the (tid == 0) case we must check so_rcv_{q_,}head \ 259f0267584Sanders * rather than (so_rcv_queued > 0), since the latter does not \ 260f0267584Sanders * take into account mblks with only control/name information. \ 261f0267584Sanders */ \ 262f0267584Sanders ((so)->so_rcv_timer_tid == 0 && ((so)->so_rcv_head != NULL || \ 263f0267584Sanders (so)->so_rcv_q_head != NULL)) || \ 2640f1702c5SYu Xiangning ((so)->so_state & SS_CANTRCVMORE) 2650f1702c5SYu Xiangning 2660f1702c5SYu Xiangning /* 2670f1702c5SYu Xiangning * Events handled by the protocol (in case sd_poll is set) 2680f1702c5SYu Xiangning */ 2690f1702c5SYu Xiangning #define SO_PROTO_POLLEV (POLLIN|POLLRDNORM|POLLRDBAND) 2700f1702c5SYu Xiangning 2710f1702c5SYu Xiangning 2720f1702c5SYu Xiangning #endif /* _KERNEL || _KMEMUSER */ 2730f1702c5SYu Xiangning 2747c478bd9Sstevel@tonic-gate /* flags */ 2757c478bd9Sstevel@tonic-gate #define SOMOD 0x0001 /* update socket modification time */ 2767c478bd9Sstevel@tonic-gate #define SOACC 0x0002 /* update socket access time */ 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate #define SOLOCKED 0x0010 /* use to serialize open/closes */ 2797c478bd9Sstevel@tonic-gate #define SOREADLOCKED 0x0020 /* serialize kstrgetmsg calls */ 2806a571a2dSAnders Persson #define SOCLONE 0x0040 /* child of clone driver */ 2816a571a2dSAnders Persson #define SOASYNC_UNBIND 0x0080 /* wait for ACK of async unbind */ 2827c478bd9Sstevel@tonic-gate 283d36be52eSRao Shoaib #define SOCK_IS_NONSTR(so) ((so)->so_not_str) 2840f1702c5SYu Xiangning 2857c478bd9Sstevel@tonic-gate /* 2867c478bd9Sstevel@tonic-gate * Socket state bits. 2877c478bd9Sstevel@tonic-gate */ 2887c478bd9Sstevel@tonic-gate #define SS_ISCONNECTED 0x00000001 /* socket connected to a peer */ 2897c478bd9Sstevel@tonic-gate #define SS_ISCONNECTING 0x00000002 /* in process, connecting to peer */ 2907c478bd9Sstevel@tonic-gate #define SS_ISDISCONNECTING 0x00000004 /* in process of disconnecting */ 2917c478bd9Sstevel@tonic-gate #define SS_CANTSENDMORE 0x00000008 /* can't send more data to peer */ 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate #define SS_CANTRCVMORE 0x00000010 /* can't receive more data */ 2947c478bd9Sstevel@tonic-gate #define SS_ISBOUND 0x00000020 /* socket is bound */ 2957c478bd9Sstevel@tonic-gate #define SS_NDELAY 0x00000040 /* FNDELAY non-blocking */ 2967c478bd9Sstevel@tonic-gate #define SS_NONBLOCK 0x00000080 /* O_NONBLOCK non-blocking */ 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate #define SS_ASYNC 0x00000100 /* async i/o notify */ 2997c478bd9Sstevel@tonic-gate #define SS_ACCEPTCONN 0x00000200 /* listen done */ 3000f1702c5SYu Xiangning /* unused 0x00000400 */ /* was SS_HASCONNIND */ 3017c478bd9Sstevel@tonic-gate #define SS_SAVEDEOR 0x00000800 /* Saved MSG_EOR rcv side state */ 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate #define SS_RCVATMARK 0x00001000 /* at mark on input */ 3047c478bd9Sstevel@tonic-gate #define SS_OOBPEND 0x00002000 /* OOB pending or present - poll */ 3057c478bd9Sstevel@tonic-gate #define SS_HAVEOOBDATA 0x00004000 /* OOB data present */ 3067c478bd9Sstevel@tonic-gate #define SS_HADOOBDATA 0x00008000 /* OOB data consumed */ 3070f1702c5SYu Xiangning #define SS_CLOSING 0x00010000 /* in process of closing */ 3087c478bd9Sstevel@tonic-gate 3093e95bd4aSAnders Persson #define SS_FIL_DEFER 0x00020000 /* filter deferred notification */ 3103e95bd4aSAnders Persson #define SS_FILOP_OK 0x00040000 /* socket can attach filters */ 3113e95bd4aSAnders Persson #define SS_FIL_RCV_FLOWCTRL 0x00080000 /* filter asserted rcv flow ctrl */ 3123e95bd4aSAnders Persson #define SS_FIL_SND_FLOWCTRL 0x00100000 /* filter asserted snd flow ctrl */ 313e82bc0baSAnders Persson #define SS_FIL_STOP 0x00200000 /* no more filter actions */ 3147c478bd9Sstevel@tonic-gate 31517169044Sbrutus #define SS_SODIRECT 0x00400000 /* transport supports sodirect */ 3167c478bd9Sstevel@tonic-gate 31741174437SAnders Persson #define SS_SENTLASTREADSIG 0x01000000 /* last rx signal has been sent */ 31841174437SAnders Persson #define SS_SENTLASTWRITESIG 0x02000000 /* last tx signal has been sent */ 3190f1702c5SYu Xiangning 32041174437SAnders Persson #define SS_FALLBACK_DRAIN 0x20000000 /* data was/is being drained */ 32141174437SAnders Persson #define SS_FALLBACK_PENDING 0x40000000 /* fallback is pending */ 32241174437SAnders Persson #define SS_FALLBACK_COMP 0x80000000 /* fallback has completed */ 3230f1702c5SYu Xiangning 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate /* Set of states when the socket can't be rebound */ 3267c478bd9Sstevel@tonic-gate #define SS_CANTREBIND (SS_ISCONNECTED|SS_ISCONNECTING|SS_ISDISCONNECTING|\ 3277c478bd9Sstevel@tonic-gate SS_CANTSENDMORE|SS_CANTRCVMORE|SS_ACCEPTCONN) 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3300f1702c5SYu Xiangning * Sockets that can fall back to TPI must ensure that fall back is not 3310f1702c5SYu Xiangning * initiated while a thread is using a socket. 3320f1702c5SYu Xiangning */ 3333e95bd4aSAnders Persson #define SO_BLOCK_FALLBACK(so, fn) \ 3340f1702c5SYu Xiangning ASSERT(MUTEX_NOT_HELD(&(so)->so_lock)); \ 3350f1702c5SYu Xiangning rw_enter(&(so)->so_fallback_rwlock, RW_READER); \ 3363e95bd4aSAnders Persson if ((so)->so_state & (SS_FALLBACK_COMP|SS_FILOP_OK)) { \ 3370f1702c5SYu Xiangning if ((so)->so_state & SS_FALLBACK_COMP) { \ 3380f1702c5SYu Xiangning rw_exit(&(so)->so_fallback_rwlock); \ 3390f1702c5SYu Xiangning return (fn); \ 3403e95bd4aSAnders Persson } else { \ 3413e95bd4aSAnders Persson mutex_enter(&(so)->so_lock); \ 3423e95bd4aSAnders Persson (so)->so_state &= ~SS_FILOP_OK; \ 3433e95bd4aSAnders Persson mutex_exit(&(so)->so_lock); \ 3440f1702c5SYu Xiangning } \ 3450f1702c5SYu Xiangning } 3460f1702c5SYu Xiangning 3470f1702c5SYu Xiangning #define SO_UNBLOCK_FALLBACK(so) { \ 3480f1702c5SYu Xiangning rw_exit(&(so)->so_fallback_rwlock); \ 3490f1702c5SYu Xiangning } 3500f1702c5SYu Xiangning 3513e95bd4aSAnders Persson #define SO_SND_FLOWCTRLD(so) \ 3523e95bd4aSAnders Persson ((so)->so_snd_qfull || (so)->so_state & SS_FIL_SND_FLOWCTRL) 3533e95bd4aSAnders Persson 3540f1702c5SYu Xiangning /* Poll events */ 3550f1702c5SYu Xiangning #define SO_POLLEV_IN 0x1 /* POLLIN wakeup needed */ 3560f1702c5SYu Xiangning #define SO_POLLEV_ALWAYS 0x2 /* wakeups */ 3570f1702c5SYu Xiangning 3580f1702c5SYu Xiangning /* 3597c478bd9Sstevel@tonic-gate * Characteristics of sockets. Not changed after the socket is created. 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate #define SM_PRIV 0x001 /* privileged for broadcast, raw... */ 3627c478bd9Sstevel@tonic-gate #define SM_ATOMIC 0x002 /* atomic data transmission */ 3637c478bd9Sstevel@tonic-gate #define SM_ADDR 0x004 /* addresses given with messages */ 3647c478bd9Sstevel@tonic-gate #define SM_CONNREQUIRED 0x008 /* connection required by protocol */ 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate #define SM_FDPASSING 0x010 /* passes file descriptors */ 3677c478bd9Sstevel@tonic-gate #define SM_EXDATA 0x020 /* Can handle T_EXDATA_REQ */ 3687c478bd9Sstevel@tonic-gate #define SM_OPTDATA 0x040 /* Can handle T_OPTDATA_REQ */ 3697c478bd9Sstevel@tonic-gate #define SM_BYTESTREAM 0x080 /* Byte stream - can use M_DATA */ 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate #define SM_ACCEPTOR_ID 0x100 /* so_acceptor_id is valid */ 3727c478bd9Sstevel@tonic-gate 3730f1702c5SYu Xiangning #define SM_KERNEL 0x200 /* kernel socket */ 3740f1702c5SYu Xiangning 37507d13e57Sanders /* The modes below are only for non-streams sockets */ 3760f1702c5SYu Xiangning #define SM_ACCEPTSUPP 0x400 /* can handle accept() */ 37707d13e57Sanders #define SM_SENDFILESUPP 0x800 /* Private: proto supp sendfile */ 3780f1702c5SYu Xiangning 3797c478bd9Sstevel@tonic-gate /* 3807c478bd9Sstevel@tonic-gate * Socket versions. Used by the socket library when calling _so_socket(). 3817c478bd9Sstevel@tonic-gate */ 3827c478bd9Sstevel@tonic-gate #define SOV_STREAM 0 /* Not a socket - just a stream */ 3837c478bd9Sstevel@tonic-gate #define SOV_DEFAULT 1 /* Select based on so_default_version */ 3847c478bd9Sstevel@tonic-gate #define SOV_SOCKSTREAM 2 /* Socket plus streams operations */ 3857c478bd9Sstevel@tonic-gate #define SOV_SOCKBSD 3 /* Socket with no streams operations */ 3867c478bd9Sstevel@tonic-gate #define SOV_XPG4_2 4 /* Xnet socket */ 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate #if defined(_KERNEL) || defined(_KMEMUSER) 3890f1702c5SYu Xiangning 3907c478bd9Sstevel@tonic-gate /* 3910f1702c5SYu Xiangning * sonode create and destroy functions. 3920f1702c5SYu Xiangning */ 3930f1702c5SYu Xiangning typedef struct sonode *(*so_create_func_t)(struct sockparams *, 3940f1702c5SYu Xiangning int, int, int, int, int, int *, cred_t *); 3950f1702c5SYu Xiangning typedef void (*so_destroy_func_t)(struct sonode *); 3960f1702c5SYu Xiangning 3970f1702c5SYu Xiangning /* STREAM device information */ 3980f1702c5SYu Xiangning typedef struct sdev_info { 3990f1702c5SYu Xiangning char *sd_devpath; 4000f1702c5SYu Xiangning int sd_devpathlen; /* Is 0 if sp_devpath is a static string */ 4010f1702c5SYu Xiangning vnode_t *sd_vnode; 4020f1702c5SYu Xiangning } sdev_info_t; 4030f1702c5SYu Xiangning 4043e95bd4aSAnders Persson #define SOCKMOD_VERSION_1 1 4053e95bd4aSAnders Persson #define SOCKMOD_VERSION 2 4063e95bd4aSAnders Persson 4070f1702c5SYu Xiangning /* name of the TPI pseudo socket module */ 4080f1702c5SYu Xiangning #define SOTPI_SMOD_NAME "socktpi" 4090f1702c5SYu Xiangning 4100f1702c5SYu Xiangning typedef struct __smod_priv_s { 4110f1702c5SYu Xiangning so_create_func_t smodp_sock_create_func; 4120f1702c5SYu Xiangning so_destroy_func_t smodp_sock_destroy_func; 4130f1702c5SYu Xiangning so_proto_fallback_func_t smodp_proto_fallback_func; 4143e95bd4aSAnders Persson const char *smodp_fallback_devpath_v4; 4153e95bd4aSAnders Persson const char *smodp_fallback_devpath_v6; 4160f1702c5SYu Xiangning } __smod_priv_t; 4170f1702c5SYu Xiangning 4180f1702c5SYu Xiangning /* 4190f1702c5SYu Xiangning * Socket module register information 4200f1702c5SYu Xiangning */ 4210f1702c5SYu Xiangning typedef struct smod_reg_s { 4220f1702c5SYu Xiangning int smod_version; 4230f1702c5SYu Xiangning char *smod_name; 4240f1702c5SYu Xiangning size_t smod_uc_version; 4250f1702c5SYu Xiangning size_t smod_dc_version; 4260f1702c5SYu Xiangning so_proto_create_func_t smod_proto_create_func; 4270f1702c5SYu Xiangning 4280f1702c5SYu Xiangning /* __smod_priv_data must be NULL */ 4290f1702c5SYu Xiangning __smod_priv_t *__smod_priv; 4300f1702c5SYu Xiangning } smod_reg_t; 4310f1702c5SYu Xiangning 4320f1702c5SYu Xiangning /* 4330f1702c5SYu Xiangning * Socket module information 4340f1702c5SYu Xiangning */ 4350f1702c5SYu Xiangning typedef struct smod_info { 4360f1702c5SYu Xiangning int smod_version; 4370f1702c5SYu Xiangning char *smod_name; 4380f1702c5SYu Xiangning uint_t smod_refcnt; /* # of entries */ 4390f1702c5SYu Xiangning size_t smod_uc_version; /* upcall version */ 4400f1702c5SYu Xiangning size_t smod_dc_version; /* down call version */ 4410f1702c5SYu Xiangning so_proto_create_func_t smod_proto_create_func; 4420f1702c5SYu Xiangning so_proto_fallback_func_t smod_proto_fallback_func; 4433e95bd4aSAnders Persson const char *smod_fallback_devpath_v4; 4443e95bd4aSAnders Persson const char *smod_fallback_devpath_v6; 4450f1702c5SYu Xiangning so_create_func_t smod_sock_create_func; 4460f1702c5SYu Xiangning so_destroy_func_t smod_sock_destroy_func; 4470f1702c5SYu Xiangning list_node_t smod_node; 4480f1702c5SYu Xiangning } smod_info_t; 4490f1702c5SYu Xiangning 4507d64f41bSAnders Persson typedef struct sockparams_stats { 4517d64f41bSAnders Persson kstat_named_t sps_nfallback; /* # of fallbacks to TPI */ 4527d64f41bSAnders Persson kstat_named_t sps_nactive; /* # of active sockets */ 4537d64f41bSAnders Persson kstat_named_t sps_ncreate; /* total # of created sockets */ 4547d64f41bSAnders Persson } sockparams_stats_t; 4557d64f41bSAnders Persson 4560f1702c5SYu Xiangning /* 4570f1702c5SYu Xiangning * sockparams 4580f1702c5SYu Xiangning * 4595f1fdc18SAnders Persson * Used for mapping family/type/protocol to a socket module or STREAMS device 4607c478bd9Sstevel@tonic-gate */ 4617c478bd9Sstevel@tonic-gate struct sockparams { 4620f1702c5SYu Xiangning /* 4635f1fdc18SAnders Persson * The family, type, protocol, sdev_info and smod_name are 4640f1702c5SYu Xiangning * set when the entry is created, and they will never change 4650f1702c5SYu Xiangning * thereafter. 4660f1702c5SYu Xiangning */ 4670f1702c5SYu Xiangning int sp_family; 4687c478bd9Sstevel@tonic-gate int sp_type; 4697c478bd9Sstevel@tonic-gate int sp_protocol; 4700f1702c5SYu Xiangning 4710f1702c5SYu Xiangning sdev_info_t sp_sdev_info; /* STREAM device */ 4720f1702c5SYu Xiangning char *sp_smod_name; /* socket module name */ 4735f1fdc18SAnders Persson 4745f1fdc18SAnders Persson kmutex_t sp_lock; /* lock for refcnt and smod_info */ 4755f1fdc18SAnders Persson uint64_t sp_refcnt; /* entry reference count */ 4760f1702c5SYu Xiangning smod_info_t *sp_smod_info; /* socket module */ 4770f1702c5SYu Xiangning 4787d64f41bSAnders Persson sockparams_stats_t sp_stats; 4797d64f41bSAnders Persson kstat_t *sp_kstat; 4800f1702c5SYu Xiangning 4810f1702c5SYu Xiangning /* 4820f1702c5SYu Xiangning * The entries below are only modified while holding 4833e95bd4aSAnders Persson * sockconf_lock as a writer. 4840f1702c5SYu Xiangning */ 4850f1702c5SYu Xiangning int sp_flags; /* see below */ 4860f1702c5SYu Xiangning list_node_t sp_node; 4873e95bd4aSAnders Persson 4883e95bd4aSAnders Persson list_t sp_auto_filters; /* list of automatic filters */ 4893e95bd4aSAnders Persson list_t sp_prog_filters; /* list of programmatic filters */ 4907c478bd9Sstevel@tonic-gate }; 4917c478bd9Sstevel@tonic-gate 4923e95bd4aSAnders Persson struct sof_entry; 4933e95bd4aSAnders Persson 4943e95bd4aSAnders Persson typedef struct sp_filter { 4953e95bd4aSAnders Persson struct sof_entry *spf_filter; 4963e95bd4aSAnders Persson list_node_t spf_node; 4973e95bd4aSAnders Persson } sp_filter_t; 4983e95bd4aSAnders Persson 4990f1702c5SYu Xiangning 5000f1702c5SYu Xiangning /* 5010f1702c5SYu Xiangning * sockparams flags 5020f1702c5SYu Xiangning */ 5030f1702c5SYu Xiangning #define SOCKPARAMS_EPHEMERAL 0x1 /* temp. entry, not on global list */ 5040f1702c5SYu Xiangning 5050f1702c5SYu Xiangning extern void sockparams_init(void); 5060f1702c5SYu Xiangning extern struct sockparams *sockparams_hold_ephemeral_bydev(int, int, int, 5070f1702c5SYu Xiangning const char *, int, int *); 5080f1702c5SYu Xiangning extern struct sockparams *sockparams_hold_ephemeral_bymod(int, int, int, 5090f1702c5SYu Xiangning const char *, int, int *); 5100f1702c5SYu Xiangning extern void sockparams_ephemeral_drop_last_ref(struct sockparams *); 5110f1702c5SYu Xiangning 5123e95bd4aSAnders Persson extern struct sockparams *sockparams_create(int, int, int, char *, char *, int, 5133e95bd4aSAnders Persson int, int, int *); 5143e95bd4aSAnders Persson extern void sockparams_destroy(struct sockparams *); 5153e95bd4aSAnders Persson extern int sockparams_add(struct sockparams *); 5163e95bd4aSAnders Persson extern int sockparams_delete(int, int, int); 5173e95bd4aSAnders Persson extern int sockparams_new_filter(struct sof_entry *); 5183e95bd4aSAnders Persson extern void sockparams_filter_cleanup(struct sof_entry *); 51919581f84SAlexander Eremin extern int sockparams_copyout_socktable(uintptr_t); 5203e95bd4aSAnders Persson 5210f1702c5SYu Xiangning extern void smod_init(void); 5220f1702c5SYu Xiangning extern void smod_add(smod_info_t *); 5230f1702c5SYu Xiangning extern int smod_register(const smod_reg_t *); 5240f1702c5SYu Xiangning extern int smod_unregister(const char *); 5250f1702c5SYu Xiangning extern smod_info_t *smod_lookup_byname(const char *); 5260f1702c5SYu Xiangning 5270f1702c5SYu Xiangning #define SOCKPARAMS_HAS_DEVICE(sp) \ 5280f1702c5SYu Xiangning ((sp)->sp_sdev_info.sd_devpath != NULL) 5290f1702c5SYu Xiangning 5300f1702c5SYu Xiangning /* Increase the smod_info_t reference count */ 5310f1702c5SYu Xiangning #define SMOD_INC_REF(smodp) { \ 5320f1702c5SYu Xiangning ASSERT((smodp) != NULL); \ 5330f1702c5SYu Xiangning DTRACE_PROBE1(smodinfo__inc__ref, struct smod_info *, (smodp)); \ 5340f1702c5SYu Xiangning atomic_inc_uint(&(smodp)->smod_refcnt); \ 5350f1702c5SYu Xiangning } 5360f1702c5SYu Xiangning 5370f1702c5SYu Xiangning /* 5380f1702c5SYu Xiangning * Decreace the socket module entry reference count. 5390f1702c5SYu Xiangning * When no one mapping to the entry, we try to unload the module from the 5400f1702c5SYu Xiangning * kernel. If the module can't unload, just leave the module entry with 5410f1702c5SYu Xiangning * a zero refcnt. 5420f1702c5SYu Xiangning */ 5435f1fdc18SAnders Persson #define SMOD_DEC_REF(smodp, modname) { \ 5440f1702c5SYu Xiangning ASSERT((smodp) != NULL); \ 5450f1702c5SYu Xiangning ASSERT((smodp)->smod_refcnt != 0); \ 5460f1702c5SYu Xiangning atomic_dec_uint(&(smodp)->smod_refcnt); \ 5470f1702c5SYu Xiangning /* \ 5480f1702c5SYu Xiangning * No need to atomically check the return value because the \ 5490f1702c5SYu Xiangning * socket module framework will verify that no one is using \ 5500f1702c5SYu Xiangning * the module before unloading. Worst thing that can happen \ 5510f1702c5SYu Xiangning * here is multiple calls to mod_remove_by_name(), which is OK. \ 5520f1702c5SYu Xiangning */ \ 5530f1702c5SYu Xiangning if ((smodp)->smod_refcnt == 0) \ 5545f1fdc18SAnders Persson (void) mod_remove_by_name(modname); \ 5550f1702c5SYu Xiangning } 5560f1702c5SYu Xiangning 5570f1702c5SYu Xiangning /* Increase the reference count */ 5580f1702c5SYu Xiangning #define SOCKPARAMS_INC_REF(sp) { \ 5590f1702c5SYu Xiangning ASSERT((sp) != NULL); \ 5600f1702c5SYu Xiangning DTRACE_PROBE1(sockparams__inc__ref, struct sockparams *, (sp)); \ 5610f1702c5SYu Xiangning mutex_enter(&(sp)->sp_lock); \ 5620f1702c5SYu Xiangning (sp)->sp_refcnt++; \ 5630f1702c5SYu Xiangning ASSERT((sp)->sp_refcnt != 0); \ 5640f1702c5SYu Xiangning mutex_exit(&(sp)->sp_lock); \ 5650f1702c5SYu Xiangning } 5660f1702c5SYu Xiangning 5670f1702c5SYu Xiangning /* 5680f1702c5SYu Xiangning * Decrease the reference count. 5690f1702c5SYu Xiangning * 5700f1702c5SYu Xiangning * If the sockparams is ephemeral, then the thread dropping the last ref 5710f1702c5SYu Xiangning * count will destroy the entry. 5720f1702c5SYu Xiangning */ 5730f1702c5SYu Xiangning #define SOCKPARAMS_DEC_REF(sp) { \ 5740f1702c5SYu Xiangning ASSERT((sp) != NULL); \ 5750f1702c5SYu Xiangning DTRACE_PROBE1(sockparams__dec__ref, struct sockparams *, (sp)); \ 5760f1702c5SYu Xiangning mutex_enter(&(sp)->sp_lock); \ 5770f1702c5SYu Xiangning ASSERT((sp)->sp_refcnt > 0); \ 5780f1702c5SYu Xiangning if ((sp)->sp_refcnt == 1) { \ 5790f1702c5SYu Xiangning if ((sp)->sp_flags & SOCKPARAMS_EPHEMERAL) { \ 5800f1702c5SYu Xiangning mutex_exit(&(sp)->sp_lock); \ 5810f1702c5SYu Xiangning sockparams_ephemeral_drop_last_ref((sp)); \ 5820f1702c5SYu Xiangning } else { \ 5830f1702c5SYu Xiangning (sp)->sp_refcnt--; \ 5845f1fdc18SAnders Persson if ((sp)->sp_smod_info != NULL) { \ 5855f1fdc18SAnders Persson SMOD_DEC_REF((sp)->sp_smod_info, \ 5865f1fdc18SAnders Persson (sp)->sp_smod_name); \ 5875f1fdc18SAnders Persson } \ 5880f1702c5SYu Xiangning (sp)->sp_smod_info = NULL; \ 5890f1702c5SYu Xiangning mutex_exit(&(sp)->sp_lock); \ 5900f1702c5SYu Xiangning } \ 5910f1702c5SYu Xiangning } else { \ 5920f1702c5SYu Xiangning (sp)->sp_refcnt--; \ 5930f1702c5SYu Xiangning mutex_exit(&(sp)->sp_lock); \ 5940f1702c5SYu Xiangning } \ 5950f1702c5SYu Xiangning } 5967c478bd9Sstevel@tonic-gate 5977c478bd9Sstevel@tonic-gate /* 5987c478bd9Sstevel@tonic-gate * Used to traverse the list of AF_UNIX sockets to construct the kstat 599*bbf21555SRichard Lowe * for netstat(8). 6007c478bd9Sstevel@tonic-gate */ 6017c478bd9Sstevel@tonic-gate struct socklist { 6027c478bd9Sstevel@tonic-gate kmutex_t sl_lock; 6037c478bd9Sstevel@tonic-gate struct sonode *sl_list; 6047c478bd9Sstevel@tonic-gate }; 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate extern struct socklist socklist; 6077c478bd9Sstevel@tonic-gate /* 6087c478bd9Sstevel@tonic-gate * ss_full_waits is the number of times the reader thread 6097c478bd9Sstevel@tonic-gate * waits when the queue is full and ss_empty_waits is the number 6107c478bd9Sstevel@tonic-gate * of times the consumer thread waits when the queue is empty. 6117c478bd9Sstevel@tonic-gate * No locks for these as they are just indicators of whether 6127c478bd9Sstevel@tonic-gate * disk or network or both is slow or fast. 6137c478bd9Sstevel@tonic-gate */ 6147c478bd9Sstevel@tonic-gate struct sendfile_stats { 6157c478bd9Sstevel@tonic-gate uint32_t ss_file_cached; 6167c478bd9Sstevel@tonic-gate uint32_t ss_file_not_cached; 6177c478bd9Sstevel@tonic-gate uint32_t ss_full_waits; 6187c478bd9Sstevel@tonic-gate uint32_t ss_empty_waits; 6197c478bd9Sstevel@tonic-gate uint32_t ss_file_segmap; 6207c478bd9Sstevel@tonic-gate }; 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate /* 6237c478bd9Sstevel@tonic-gate * A single sendfile request is represented by snf_req. 6247c478bd9Sstevel@tonic-gate */ 6257c478bd9Sstevel@tonic-gate typedef struct snf_req { 6267c478bd9Sstevel@tonic-gate struct snf_req *sr_next; 6277c478bd9Sstevel@tonic-gate mblk_t *sr_mp_head; 6287c478bd9Sstevel@tonic-gate mblk_t *sr_mp_tail; 6297c478bd9Sstevel@tonic-gate kmutex_t sr_lock; 6307c478bd9Sstevel@tonic-gate kcondvar_t sr_cv; 6317c478bd9Sstevel@tonic-gate uint_t sr_qlen; 6327c478bd9Sstevel@tonic-gate int sr_hiwat; 6337c478bd9Sstevel@tonic-gate int sr_lowat; 6347c478bd9Sstevel@tonic-gate int sr_operation; 6357c478bd9Sstevel@tonic-gate struct vnode *sr_vp; 6367c478bd9Sstevel@tonic-gate file_t *sr_fp; 6377c478bd9Sstevel@tonic-gate ssize_t sr_maxpsz; 6387c478bd9Sstevel@tonic-gate u_offset_t sr_file_off; 6397c478bd9Sstevel@tonic-gate u_offset_t sr_file_size; 6407c478bd9Sstevel@tonic-gate #define SR_READ_DONE 0x80000000 6417c478bd9Sstevel@tonic-gate int sr_read_error; 6427c478bd9Sstevel@tonic-gate int sr_write_error; 6437c478bd9Sstevel@tonic-gate } snf_req_t; 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate /* A queue of sendfile requests */ 6467c478bd9Sstevel@tonic-gate struct sendfile_queue { 6477c478bd9Sstevel@tonic-gate snf_req_t *snfq_req_head; 6487c478bd9Sstevel@tonic-gate snf_req_t *snfq_req_tail; 6497c478bd9Sstevel@tonic-gate kmutex_t snfq_lock; 6507c478bd9Sstevel@tonic-gate kcondvar_t snfq_cv; 6517c478bd9Sstevel@tonic-gate int snfq_svc_threads; /* # of service threads */ 6527c478bd9Sstevel@tonic-gate int snfq_idle_cnt; /* # of idling threads */ 6537c478bd9Sstevel@tonic-gate int snfq_max_threads; 6547c478bd9Sstevel@tonic-gate int snfq_req_cnt; /* Number of requests */ 6557c478bd9Sstevel@tonic-gate }; 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate #define READ_OP 1 6587c478bd9Sstevel@tonic-gate #define SNFQ_TIMEOUT (60 * 5 * hz) /* 5 minutes */ 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate /* Socket network operations switch */ 6617c478bd9Sstevel@tonic-gate struct sonodeops { 6620f1702c5SYu Xiangning int (*sop_init)(struct sonode *, struct sonode *, cred_t *, 6637c478bd9Sstevel@tonic-gate int); 6640f1702c5SYu Xiangning int (*sop_accept)(struct sonode *, int, cred_t *, struct sonode **); 6650f1702c5SYu Xiangning int (*sop_bind)(struct sonode *, struct sockaddr *, socklen_t, 6660f1702c5SYu Xiangning int, cred_t *); 6670f1702c5SYu Xiangning int (*sop_listen)(struct sonode *, int, cred_t *); 6683e95bd4aSAnders Persson int (*sop_connect)(struct sonode *, struct sockaddr *, 6690f1702c5SYu Xiangning socklen_t, int, int, cred_t *); 6707c478bd9Sstevel@tonic-gate int (*sop_recvmsg)(struct sonode *, struct msghdr *, 6710f1702c5SYu Xiangning struct uio *, cred_t *); 6727c478bd9Sstevel@tonic-gate int (*sop_sendmsg)(struct sonode *, struct msghdr *, 6730f1702c5SYu Xiangning struct uio *, cred_t *); 6740f1702c5SYu Xiangning int (*sop_sendmblk)(struct sonode *, struct msghdr *, int, 6750f1702c5SYu Xiangning cred_t *, mblk_t **); 6760f1702c5SYu Xiangning int (*sop_getpeername)(struct sonode *, struct sockaddr *, 6770f1702c5SYu Xiangning socklen_t *, boolean_t, cred_t *); 6780f1702c5SYu Xiangning int (*sop_getsockname)(struct sonode *, struct sockaddr *, 6790f1702c5SYu Xiangning socklen_t *, cred_t *); 6800f1702c5SYu Xiangning int (*sop_shutdown)(struct sonode *, int, cred_t *); 6817c478bd9Sstevel@tonic-gate int (*sop_getsockopt)(struct sonode *, int, int, void *, 6820f1702c5SYu Xiangning socklen_t *, int, cred_t *); 6837c478bd9Sstevel@tonic-gate int (*sop_setsockopt)(struct sonode *, int, int, const void *, 6840f1702c5SYu Xiangning socklen_t, cred_t *); 6850f1702c5SYu Xiangning int (*sop_ioctl)(struct sonode *, int, intptr_t, int, 6860f1702c5SYu Xiangning cred_t *, int32_t *); 6870f1702c5SYu Xiangning int (*sop_poll)(struct sonode *, short, int, short *, 6880f1702c5SYu Xiangning struct pollhead **); 6890f1702c5SYu Xiangning int (*sop_close)(struct sonode *, int, cred_t *); 6907c478bd9Sstevel@tonic-gate }; 6917c478bd9Sstevel@tonic-gate 6920f1702c5SYu Xiangning #define SOP_INIT(so, flag, cr, flags) \ 6930f1702c5SYu Xiangning ((so)->so_ops->sop_init((so), (flag), (cr), (flags))) 6940f1702c5SYu Xiangning #define SOP_ACCEPT(so, fflag, cr, nsop) \ 6950f1702c5SYu Xiangning ((so)->so_ops->sop_accept((so), (fflag), (cr), (nsop))) 6960f1702c5SYu Xiangning #define SOP_BIND(so, name, namelen, flags, cr) \ 6970f1702c5SYu Xiangning ((so)->so_ops->sop_bind((so), (name), (namelen), (flags), (cr))) 6980f1702c5SYu Xiangning #define SOP_LISTEN(so, backlog, cr) \ 6990f1702c5SYu Xiangning ((so)->so_ops->sop_listen((so), (backlog), (cr))) 7000f1702c5SYu Xiangning #define SOP_CONNECT(so, name, namelen, fflag, flags, cr) \ 7010f1702c5SYu Xiangning ((so)->so_ops->sop_connect((so), (name), (namelen), (fflag), (flags), \ 7020f1702c5SYu Xiangning (cr))) 7030f1702c5SYu Xiangning #define SOP_RECVMSG(so, msg, uiop, cr) \ 7040f1702c5SYu Xiangning ((so)->so_ops->sop_recvmsg((so), (msg), (uiop), (cr))) 7050f1702c5SYu Xiangning #define SOP_SENDMSG(so, msg, uiop, cr) \ 7060f1702c5SYu Xiangning ((so)->so_ops->sop_sendmsg((so), (msg), (uiop), (cr))) 7070f1702c5SYu Xiangning #define SOP_SENDMBLK(so, msg, size, cr, mpp) \ 7080f1702c5SYu Xiangning ((so)->so_ops->sop_sendmblk((so), (msg), (size), (cr), (mpp))) 7090f1702c5SYu Xiangning #define SOP_GETPEERNAME(so, addr, addrlen, accept, cr) \ 7100f1702c5SYu Xiangning ((so)->so_ops->sop_getpeername((so), (addr), (addrlen), (accept), (cr))) 7110f1702c5SYu Xiangning #define SOP_GETSOCKNAME(so, addr, addrlen, cr) \ 7120f1702c5SYu Xiangning ((so)->so_ops->sop_getsockname((so), (addr), (addrlen), (cr))) 7130f1702c5SYu Xiangning #define SOP_SHUTDOWN(so, how, cr) \ 7140f1702c5SYu Xiangning ((so)->so_ops->sop_shutdown((so), (how), (cr))) 7150f1702c5SYu Xiangning #define SOP_GETSOCKOPT(so, level, optionname, optval, optlenp, flags, cr) \ 7167c478bd9Sstevel@tonic-gate ((so)->so_ops->sop_getsockopt((so), (level), (optionname), \ 7170f1702c5SYu Xiangning (optval), (optlenp), (flags), (cr))) 7180f1702c5SYu Xiangning #define SOP_SETSOCKOPT(so, level, optionname, optval, optlen, cr) \ 7197c478bd9Sstevel@tonic-gate ((so)->so_ops->sop_setsockopt((so), (level), (optionname), \ 7200f1702c5SYu Xiangning (optval), (optlen), (cr))) 7210f1702c5SYu Xiangning #define SOP_IOCTL(so, cmd, arg, mode, cr, rvalp) \ 7220f1702c5SYu Xiangning ((so)->so_ops->sop_ioctl((so), (cmd), (arg), (mode), (cr), (rvalp))) 7230f1702c5SYu Xiangning #define SOP_POLL(so, events, anyyet, reventsp, phpp) \ 7240f1702c5SYu Xiangning ((so)->so_ops->sop_poll((so), (events), (anyyet), (reventsp), (phpp))) 7250f1702c5SYu Xiangning #define SOP_CLOSE(so, flag, cr) \ 7260f1702c5SYu Xiangning ((so)->so_ops->sop_close((so), (flag), (cr))) 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate #endif /* defined(_KERNEL) || defined(_KMEMUSER) */ 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate #ifdef _KERNEL 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate #define ISALIGNED_cmsghdr(addr) \ 7337c478bd9Sstevel@tonic-gate (((uintptr_t)(addr) & (_CMSG_HDR_ALIGNMENT - 1)) == 0) 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate #define ROUNDUP_cmsglen(len) \ 7367c478bd9Sstevel@tonic-gate (((len) + _CMSG_HDR_ALIGNMENT - 1) & ~(_CMSG_HDR_ALIGNMENT - 1)) 7377c478bd9Sstevel@tonic-gate 7380f1702c5SYu Xiangning #define IS_NON_STREAM_SOCK(vp) \ 7390f1702c5SYu Xiangning ((vp)->v_type == VSOCK && (vp)->v_stream == NULL) 7407c478bd9Sstevel@tonic-gate /* 7419acbbeafSnn35248 * Macros that operate on struct cmsghdr. 7429acbbeafSnn35248 * Used in parsing msg_control. 7439acbbeafSnn35248 * The CMSG_VALID macro does not assume that the last option buffer is padded. 7447c478bd9Sstevel@tonic-gate */ 7457c478bd9Sstevel@tonic-gate #define CMSG_NEXT(cmsg) \ 7467c478bd9Sstevel@tonic-gate (struct cmsghdr *)((uintptr_t)(cmsg) + \ 7477c478bd9Sstevel@tonic-gate ROUNDUP_cmsglen((cmsg)->cmsg_len)) 7489acbbeafSnn35248 #define CMSG_CONTENT(cmsg) (&((cmsg)[1])) 7499acbbeafSnn35248 #define CMSG_CONTENTLEN(cmsg) ((cmsg)->cmsg_len - sizeof (struct cmsghdr)) 7509acbbeafSnn35248 #define CMSG_VALID(cmsg, start, end) \ 7519acbbeafSnn35248 (ISALIGNED_cmsghdr(cmsg) && \ 7529acbbeafSnn35248 ((uintptr_t)(cmsg) >= (uintptr_t)(start)) && \ 7539acbbeafSnn35248 ((uintptr_t)(cmsg) < (uintptr_t)(end)) && \ 7549acbbeafSnn35248 ((ssize_t)(cmsg)->cmsg_len >= sizeof (struct cmsghdr)) && \ 7559acbbeafSnn35248 ((uintptr_t)(cmsg) + (cmsg)->cmsg_len <= (uintptr_t)(end))) 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate /* 7587c478bd9Sstevel@tonic-gate * Maximum size of any argument that is copied in (addresses, options, 7597c478bd9Sstevel@tonic-gate * access rights). MUST be at least MAXPATHLEN + 3. 7607c478bd9Sstevel@tonic-gate * BSD and SunOS 4.X limited this to MLEN or MCLBYTES. 7617c478bd9Sstevel@tonic-gate */ 7627c478bd9Sstevel@tonic-gate #define SO_MAXARGSIZE 8192 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate /* 7657c478bd9Sstevel@tonic-gate * Convert between vnode and sonode 7667c478bd9Sstevel@tonic-gate */ 7677c478bd9Sstevel@tonic-gate #define VTOSO(vp) ((struct sonode *)((vp)->v_data)) 7687c478bd9Sstevel@tonic-gate #define SOTOV(sp) ((sp)->so_vnode) 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate /* 7717c478bd9Sstevel@tonic-gate * Internal flags for sobind() 7727c478bd9Sstevel@tonic-gate */ 7737c478bd9Sstevel@tonic-gate #define _SOBIND_REBIND 0x01 /* Bind to existing local address */ 7747c478bd9Sstevel@tonic-gate #define _SOBIND_UNSPEC 0x02 /* Bind to unspecified address */ 7757c478bd9Sstevel@tonic-gate #define _SOBIND_LOCK_HELD 0x04 /* so_excl_lock held by caller */ 7767c478bd9Sstevel@tonic-gate #define _SOBIND_NOXLATE 0x08 /* No addr translation for AF_UNIX */ 7777c478bd9Sstevel@tonic-gate #define _SOBIND_XPG4_2 0x10 /* xpg4.2 semantics */ 7787c478bd9Sstevel@tonic-gate #define _SOBIND_SOCKBSD 0x20 /* BSD semantics */ 7797c478bd9Sstevel@tonic-gate #define _SOBIND_LISTEN 0x40 /* Make into SS_ACCEPTCONN */ 7807c478bd9Sstevel@tonic-gate #define _SOBIND_SOCKETPAIR 0x80 /* Internal flag for so_socketpair() */ 7817c478bd9Sstevel@tonic-gate /* to enable listen with backlog = 1 */ 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate /* 7847c478bd9Sstevel@tonic-gate * Internal flags for sounbind() 7857c478bd9Sstevel@tonic-gate */ 7867c478bd9Sstevel@tonic-gate #define _SOUNBIND_REBIND 0x01 /* Don't clear fields - will rebind */ 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /* 7897c478bd9Sstevel@tonic-gate * Internal flags for soconnect() 7907c478bd9Sstevel@tonic-gate */ 7917c478bd9Sstevel@tonic-gate #define _SOCONNECT_NOXLATE 0x01 /* No addr translation for AF_UNIX */ 7927c478bd9Sstevel@tonic-gate #define _SOCONNECT_DID_BIND 0x02 /* Unbind when connect fails */ 7937c478bd9Sstevel@tonic-gate #define _SOCONNECT_XPG4_2 0x04 /* xpg4.2 semantics */ 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate /* 7967c478bd9Sstevel@tonic-gate * Internal flags for sodisconnect() 7977c478bd9Sstevel@tonic-gate */ 7987c478bd9Sstevel@tonic-gate #define _SODISCONNECT_LOCK_HELD 0x01 /* so_excl_lock held by caller */ 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate /* 8017c478bd9Sstevel@tonic-gate * Internal flags for sotpi_getsockopt(). 8027c478bd9Sstevel@tonic-gate */ 8037c478bd9Sstevel@tonic-gate #define _SOGETSOCKOPT_XPG4_2 0x01 /* xpg4.2 semantics */ 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate /* 8067c478bd9Sstevel@tonic-gate * Internal flags for soallocproto*() 8077c478bd9Sstevel@tonic-gate */ 8087c478bd9Sstevel@tonic-gate #define _ALLOC_NOSLEEP 0 /* Don't sleep for memory */ 8097c478bd9Sstevel@tonic-gate #define _ALLOC_INTR 1 /* Sleep until interrupt */ 8107c478bd9Sstevel@tonic-gate #define _ALLOC_SLEEP 2 /* Sleep forever */ 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate /* 8137c478bd9Sstevel@tonic-gate * Internal structure for handling AF_UNIX file descriptor passing 8147c478bd9Sstevel@tonic-gate */ 8157c478bd9Sstevel@tonic-gate struct fdbuf { 8167c478bd9Sstevel@tonic-gate int fd_size; /* In bytes, for kmem_free */ 8177c478bd9Sstevel@tonic-gate int fd_numfd; /* Number of elements below */ 8187c478bd9Sstevel@tonic-gate char *fd_ebuf; /* Extra buffer to free */ 8197c478bd9Sstevel@tonic-gate int fd_ebuflen; 8207c478bd9Sstevel@tonic-gate frtn_t fd_frtn; 8217c478bd9Sstevel@tonic-gate struct file *fd_fds[1]; /* One or more */ 8227c478bd9Sstevel@tonic-gate }; 8237c478bd9Sstevel@tonic-gate #define FDBUF_HDRSIZE (sizeof (struct fdbuf) - sizeof (struct file *)) 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate /* 8267c478bd9Sstevel@tonic-gate * Variable that can be patched to set what version of socket socket() 8277c478bd9Sstevel@tonic-gate * will create. 8287c478bd9Sstevel@tonic-gate */ 8297c478bd9Sstevel@tonic-gate extern int so_default_version; 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate #ifdef DEBUG 8327c478bd9Sstevel@tonic-gate /* Turn on extra testing capabilities */ 8337c478bd9Sstevel@tonic-gate #define SOCK_TEST 8347c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 8357c478bd9Sstevel@tonic-gate 8367c478bd9Sstevel@tonic-gate #ifdef DEBUG 8377c478bd9Sstevel@tonic-gate char *pr_state(uint_t, uint_t); 8387c478bd9Sstevel@tonic-gate char *pr_addr(int, struct sockaddr *, t_uscalar_t); 8397c478bd9Sstevel@tonic-gate int so_verify_oobstate(struct sonode *); 8407c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate /* 8437c478bd9Sstevel@tonic-gate * DEBUG macros 8447c478bd9Sstevel@tonic-gate */ 8458793b36bSNick Todd #if defined(DEBUG) 8467c478bd9Sstevel@tonic-gate #define SOCK_DEBUG 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate extern int sockdebug; 8497c478bd9Sstevel@tonic-gate extern int sockprinterr; 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate #define eprint(args) printf args 8527c478bd9Sstevel@tonic-gate #define eprintso(so, args) \ 8537c478bd9Sstevel@tonic-gate { if (sockprinterr && ((so)->so_options & SO_DEBUG)) printf args; } 8547c478bd9Sstevel@tonic-gate #define eprintline(error) \ 8557c478bd9Sstevel@tonic-gate { \ 8567c478bd9Sstevel@tonic-gate if (error != EINTR && (sockprinterr || sockdebug > 0)) \ 8577c478bd9Sstevel@tonic-gate printf("socket error %d: line %d file %s\n", \ 8587c478bd9Sstevel@tonic-gate (error), __LINE__, __FILE__); \ 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate #define eprintsoline(so, error) \ 8627c478bd9Sstevel@tonic-gate { if (sockprinterr && ((so)->so_options & SO_DEBUG)) \ 8637c478bd9Sstevel@tonic-gate printf("socket(%p) error %d: line %d file %s\n", \ 8648793b36bSNick Todd (void *)(so), (error), __LINE__, __FILE__); \ 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate #define dprint(level, args) { if (sockdebug > (level)) printf args; } 8677c478bd9Sstevel@tonic-gate #define dprintso(so, level, args) \ 8687c478bd9Sstevel@tonic-gate { if (sockdebug > (level) && ((so)->so_options & SO_DEBUG)) printf args; } 8697c478bd9Sstevel@tonic-gate 8708793b36bSNick Todd #else /* define(DEBUG) */ 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate #define eprint(args) {} 8737c478bd9Sstevel@tonic-gate #define eprintso(so, args) {} 8747c478bd9Sstevel@tonic-gate #define eprintline(error) {} 8757c478bd9Sstevel@tonic-gate #define eprintsoline(so, error) {} 8767c478bd9Sstevel@tonic-gate #define dprint(level, args) {} 8777c478bd9Sstevel@tonic-gate #define dprintso(so, level, args) {} 8787c478bd9Sstevel@tonic-gate 8798793b36bSNick Todd #endif /* defined(DEBUG) */ 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate extern struct vfsops sock_vfsops; 8820f1702c5SYu Xiangning extern struct vnodeops *socket_vnodeops; 8830f1702c5SYu Xiangning extern const struct fs_operation_def socket_vnodeops_template[]; 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate extern dev_t sockdev; 8867c478bd9Sstevel@tonic-gate 8873e95bd4aSAnders Persson extern krwlock_t sockconf_lock; 8883e95bd4aSAnders Persson 8897c478bd9Sstevel@tonic-gate /* 8907c478bd9Sstevel@tonic-gate * sockfs functions 8917c478bd9Sstevel@tonic-gate */ 8927c478bd9Sstevel@tonic-gate extern int sock_getmsg(vnode_t *, struct strbuf *, struct strbuf *, 8937c478bd9Sstevel@tonic-gate uchar_t *, int *, int, rval_t *); 8947c478bd9Sstevel@tonic-gate extern int sock_putmsg(vnode_t *, struct strbuf *, struct strbuf *, 8957c478bd9Sstevel@tonic-gate uchar_t, int, int); 8960f1702c5SYu Xiangning extern int sogetvp(char *, vnode_t **, int); 8977c478bd9Sstevel@tonic-gate extern int sockinit(int, char *); 8980f1702c5SYu Xiangning extern int solookup(int, int, int, struct sockparams **); 8997c478bd9Sstevel@tonic-gate extern void so_lock_single(struct sonode *); 9007c478bd9Sstevel@tonic-gate extern void so_unlock_single(struct sonode *, int); 9017c478bd9Sstevel@tonic-gate extern int so_lock_read(struct sonode *, int); 9027c478bd9Sstevel@tonic-gate extern int so_lock_read_intr(struct sonode *, int); 9037c478bd9Sstevel@tonic-gate extern void so_unlock_read(struct sonode *); 9047c478bd9Sstevel@tonic-gate extern void *sogetoff(mblk_t *, t_uscalar_t, t_uscalar_t, uint_t); 9057c478bd9Sstevel@tonic-gate extern void so_getopt_srcaddr(void *, t_uscalar_t, 9067c478bd9Sstevel@tonic-gate void **, t_uscalar_t *); 9077c478bd9Sstevel@tonic-gate extern int so_getopt_unix_close(void *, t_uscalar_t); 9087c478bd9Sstevel@tonic-gate extern void fdbuf_free(struct fdbuf *); 9097c478bd9Sstevel@tonic-gate extern mblk_t *fdbuf_allocmsg(int, struct fdbuf *); 9107c478bd9Sstevel@tonic-gate extern int fdbuf_create(void *, int, struct fdbuf **); 9117c478bd9Sstevel@tonic-gate extern void so_closefds(void *, t_uscalar_t, int, int); 912d865fc92SAndy Fiddaman extern void so_truncatecmsg(void *, t_uscalar_t, uint_t); 913d865fc92SAndy Fiddaman 9147c478bd9Sstevel@tonic-gate extern int so_getfdopt(void *, t_uscalar_t, int, void **, int *); 9157c478bd9Sstevel@tonic-gate t_uscalar_t so_optlen(void *, t_uscalar_t, int); 9167c478bd9Sstevel@tonic-gate extern void so_cmsg2opt(void *, t_uscalar_t, int, mblk_t *); 9177c478bd9Sstevel@tonic-gate extern t_uscalar_t 9187c478bd9Sstevel@tonic-gate so_cmsglen(mblk_t *, void *, t_uscalar_t, int); 9197c478bd9Sstevel@tonic-gate extern int so_opt2cmsg(mblk_t *, void *, t_uscalar_t, int, 9207c478bd9Sstevel@tonic-gate void *, t_uscalar_t); 9217c478bd9Sstevel@tonic-gate extern void soisconnecting(struct sonode *); 9227c478bd9Sstevel@tonic-gate extern void soisconnected(struct sonode *); 9237c478bd9Sstevel@tonic-gate extern void soisdisconnected(struct sonode *, int); 9247c478bd9Sstevel@tonic-gate extern void socantsendmore(struct sonode *); 9257c478bd9Sstevel@tonic-gate extern void socantrcvmore(struct sonode *); 9267c478bd9Sstevel@tonic-gate extern void soseterror(struct sonode *, int); 9270f1702c5SYu Xiangning extern int sogeterr(struct sonode *, boolean_t); 9287c478bd9Sstevel@tonic-gate extern int sowaitconnected(struct sonode *, int, int); 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate extern ssize_t soreadfile(file_t *, uchar_t *, u_offset_t, int *, size_t); 9317c478bd9Sstevel@tonic-gate extern void *sock_kstat_init(zoneid_t); 9327c478bd9Sstevel@tonic-gate extern void sock_kstat_fini(zoneid_t, void *); 933745b2690Stz204579 extern struct sonode *getsonode(int, int *, file_t **); 9347c478bd9Sstevel@tonic-gate /* 935da6c28aaSamw * Function wrappers (mostly around the sonode switch) for 9367c478bd9Sstevel@tonic-gate * backward compatibility. 9377c478bd9Sstevel@tonic-gate */ 9387c478bd9Sstevel@tonic-gate extern int soaccept(struct sonode *, int, struct sonode **); 9397c478bd9Sstevel@tonic-gate extern int sobind(struct sonode *, struct sockaddr *, socklen_t, 9407c478bd9Sstevel@tonic-gate int, int); 9417c478bd9Sstevel@tonic-gate extern int solisten(struct sonode *, int); 9423e95bd4aSAnders Persson extern int soconnect(struct sonode *, struct sockaddr *, socklen_t, 9437c478bd9Sstevel@tonic-gate int, int); 9447c478bd9Sstevel@tonic-gate extern int sorecvmsg(struct sonode *, struct nmsghdr *, struct uio *); 9457c478bd9Sstevel@tonic-gate extern int sosendmsg(struct sonode *, struct nmsghdr *, struct uio *); 9467c478bd9Sstevel@tonic-gate extern int soshutdown(struct sonode *, int); 9477c478bd9Sstevel@tonic-gate extern int sogetsockopt(struct sonode *, int, int, void *, socklen_t *, 9487c478bd9Sstevel@tonic-gate int); 9497c478bd9Sstevel@tonic-gate extern int sosetsockopt(struct sonode *, int, int, const void *, 9507c478bd9Sstevel@tonic-gate t_uscalar_t); 9517c478bd9Sstevel@tonic-gate 9520f1702c5SYu Xiangning extern struct sonode *socreate(struct sockparams *, int, int, int, int, 9530f1702c5SYu Xiangning int *); 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate extern int so_copyin(const void *, void *, size_t, int); 9567c478bd9Sstevel@tonic-gate extern int so_copyout(const void *, void *, size_t, int); 9577c478bd9Sstevel@tonic-gate 958907c2824SRobert Mustacchi /* 959907c2824SRobert Mustacchi * Functions to manipulate the use of direct receive callbacks. This should not 960907c2824SRobert Mustacchi * be used outside of sockfs and ksocket. These are generally considered a use 961907c2824SRobert Mustacchi * once interface for a socket and will cause all outstanding data on the socket 962907c2824SRobert Mustacchi * to be flushed. 963907c2824SRobert Mustacchi */ 964907c2824SRobert Mustacchi extern int so_krecv_set(sonode_t *, so_krecv_f, void *); 965907c2824SRobert Mustacchi extern void so_krecv_unblock(sonode_t *); 966907c2824SRobert Mustacchi 9677c478bd9Sstevel@tonic-gate #endif 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate /* 9707c478bd9Sstevel@tonic-gate * Internal structure for obtaining sonode information from the socklist. 9717c478bd9Sstevel@tonic-gate * These types match those corresponding in the sonode structure. 97278a2e113SAndy Fiddaman * This is not a published interface, and may change at any time. It is 97378a2e113SAndy Fiddaman * used for passing information back up to the kstat consumers. By converting 97478a2e113SAndy Fiddaman * kernel addresses to strings, we should be able to pass information from 97578a2e113SAndy Fiddaman * the kernel to userland regardless of n-bit kernel we are using. 9767c478bd9Sstevel@tonic-gate */ 97778a2e113SAndy Fiddaman 97878a2e113SAndy Fiddaman #define ADRSTRLEN (2 * sizeof (uint64_t) + 1) 97978a2e113SAndy Fiddaman 9807c478bd9Sstevel@tonic-gate struct sockinfo { 9817c478bd9Sstevel@tonic-gate uint_t si_size; /* real length of this struct */ 9827c478bd9Sstevel@tonic-gate short si_family; 9837c478bd9Sstevel@tonic-gate short si_type; 9847c478bd9Sstevel@tonic-gate ushort_t si_flag; 9857c478bd9Sstevel@tonic-gate uint_t si_state; 9867c478bd9Sstevel@tonic-gate uint_t si_ux_laddr_sou_magic; 9877c478bd9Sstevel@tonic-gate uint_t si_ux_faddr_sou_magic; 9887c478bd9Sstevel@tonic-gate t_scalar_t si_serv_type; 9897c478bd9Sstevel@tonic-gate t_uscalar_t si_laddr_soa_len; 9907c478bd9Sstevel@tonic-gate t_uscalar_t si_faddr_soa_len; 9917c478bd9Sstevel@tonic-gate uint16_t si_laddr_family; 9927c478bd9Sstevel@tonic-gate uint16_t si_faddr_family; 9937c478bd9Sstevel@tonic-gate char si_laddr_sun_path[MAXPATHLEN + 1]; /* NULL terminated */ 9947c478bd9Sstevel@tonic-gate char si_faddr_sun_path[MAXPATHLEN + 1]; 9950f1702c5SYu Xiangning boolean_t si_faddr_noxlate; 9967c478bd9Sstevel@tonic-gate zoneid_t si_szoneid; 99778a2e113SAndy Fiddaman char si_son_straddr[ADRSTRLEN]; 99878a2e113SAndy Fiddaman char si_lvn_straddr[ADRSTRLEN]; 99978a2e113SAndy Fiddaman char si_fvn_straddr[ADRSTRLEN]; 100078a2e113SAndy Fiddaman uint64_t si_inode; 10017c478bd9Sstevel@tonic-gate }; 10027c478bd9Sstevel@tonic-gate 10033e95bd4aSAnders Persson /* 10043e95bd4aSAnders Persson * Subcodes for sockconf() system call 10053e95bd4aSAnders Persson */ 10063e95bd4aSAnders Persson #define SOCKCONFIG_ADD_SOCK 0 10073e95bd4aSAnders Persson #define SOCKCONFIG_REMOVE_SOCK 1 10083e95bd4aSAnders Persson #define SOCKCONFIG_ADD_FILTER 2 10093e95bd4aSAnders Persson #define SOCKCONFIG_REMOVE_FILTER 3 101019581f84SAlexander Eremin #define SOCKCONFIG_GET_SOCKTABLE 4 10113e95bd4aSAnders Persson 10123e95bd4aSAnders Persson /* 10133e95bd4aSAnders Persson * Data structures for configuring socket filters. 10143e95bd4aSAnders Persson */ 10153e95bd4aSAnders Persson 10163e95bd4aSAnders Persson /* 10173e95bd4aSAnders Persson * Placement hint for automatic filters 10183e95bd4aSAnders Persson */ 10193e95bd4aSAnders Persson typedef enum { 10203e95bd4aSAnders Persson SOF_HINT_NONE, 10213e95bd4aSAnders Persson SOF_HINT_TOP, 10223e95bd4aSAnders Persson SOF_HINT_BOTTOM, 10233e95bd4aSAnders Persson SOF_HINT_BEFORE, 10243e95bd4aSAnders Persson SOF_HINT_AFTER 10253e95bd4aSAnders Persson } sof_hint_t; 10263e95bd4aSAnders Persson 10273e95bd4aSAnders Persson /* 10283e95bd4aSAnders Persson * Socket tuple. Used by sockconfig_filter_props to list socket 10293e95bd4aSAnders Persson * types of interest. 10303e95bd4aSAnders Persson */ 10313e95bd4aSAnders Persson typedef struct sof_socktuple { 10323e95bd4aSAnders Persson int sofst_family; 10333e95bd4aSAnders Persson int sofst_type; 10343e95bd4aSAnders Persson int sofst_protocol; 10353e95bd4aSAnders Persson } sof_socktuple_t; 10363e95bd4aSAnders Persson 10373e95bd4aSAnders Persson /* 10383e95bd4aSAnders Persson * Socket filter properties used by sockconfig() system call. 10393e95bd4aSAnders Persson */ 10403e95bd4aSAnders Persson struct sockconfig_filter_props { 10413e95bd4aSAnders Persson char *sfp_modname; 10423e95bd4aSAnders Persson boolean_t sfp_autoattach; 10433e95bd4aSAnders Persson sof_hint_t sfp_hint; 10443e95bd4aSAnders Persson char *sfp_hintarg; 10453e95bd4aSAnders Persson uint_t sfp_socktuple_cnt; 10463e95bd4aSAnders Persson sof_socktuple_t *sfp_socktuple; 10473e95bd4aSAnders Persson }; 10483e95bd4aSAnders Persson 104919581f84SAlexander Eremin /* 105019581f84SAlexander Eremin * Data structures for the in-kernel socket configuration table. 105119581f84SAlexander Eremin */ 105219581f84SAlexander Eremin typedef struct sockconfig_socktable_entry { 105319581f84SAlexander Eremin int se_family; 105419581f84SAlexander Eremin int se_type; 105519581f84SAlexander Eremin int se_protocol; 105619581f84SAlexander Eremin int se_refcnt; 105719581f84SAlexander Eremin int se_flags; 105819581f84SAlexander Eremin char se_modname[MODMAXNAMELEN]; 105919581f84SAlexander Eremin char se_strdev[MAXPATHLEN]; 106019581f84SAlexander Eremin } sockconfig_socktable_entry_t; 106119581f84SAlexander Eremin 106219581f84SAlexander Eremin typedef struct sockconfig_socktable { 106319581f84SAlexander Eremin uint_t num_of_entries; 106419581f84SAlexander Eremin sockconfig_socktable_entry_t *st_entries; 106519581f84SAlexander Eremin } sockconfig_socktable_t; 106619581f84SAlexander Eremin 10673e95bd4aSAnders Persson #ifdef _SYSCALL32 10683e95bd4aSAnders Persson 10693e95bd4aSAnders Persson typedef struct sof_socktuple32 { 10703e95bd4aSAnders Persson int32_t sofst_family; 10713e95bd4aSAnders Persson int32_t sofst_type; 10723e95bd4aSAnders Persson int32_t sofst_protocol; 10733e95bd4aSAnders Persson } sof_socktuple32_t; 10743e95bd4aSAnders Persson 10753e95bd4aSAnders Persson struct sockconfig_filter_props32 { 10763e95bd4aSAnders Persson caddr32_t sfp_modname; 10773e95bd4aSAnders Persson boolean_t sfp_autoattach; 10783e95bd4aSAnders Persson sof_hint_t sfp_hint; 10793e95bd4aSAnders Persson caddr32_t sfp_hintarg; 10803e95bd4aSAnders Persson uint32_t sfp_socktuple_cnt; 10813e95bd4aSAnders Persson caddr32_t sfp_socktuple; 10823e95bd4aSAnders Persson }; 10833e95bd4aSAnders Persson 108419581f84SAlexander Eremin typedef struct sockconfig_socktable32 { 108519581f84SAlexander Eremin uint_t num_of_entries; 108619581f84SAlexander Eremin caddr32_t st_entries; 108719581f84SAlexander Eremin } sockconfig_socktable32_t; 108819581f84SAlexander Eremin 10893e95bd4aSAnders Persson #endif /* _SYSCALL32 */ 10903e95bd4aSAnders Persson 10910f1702c5SYu Xiangning #define SOCKMOD_PATH "socketmod" /* dir where sockmods are stored */ 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate #ifdef __cplusplus 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate #endif 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate #endif /* _SYS_SOCKETVAR_H */ 1098