2005-06-09 19:59:09 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1988, 1990, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
2006-03-15 12:45:35 +00:00
|
|
|
* Copyright (c) 2004 The FreeBSD Foundation
|
|
|
|
* Copyright (c) 2004-2006 Robert N. M. Watson
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)uipc_socket.c 8.3 (Berkeley) 4/15/94
|
|
|
|
*/
|
|
|
|
|
2006-04-01 10:43:02 +00:00
|
|
|
/*
|
|
|
|
* Comments on the socket life cycle:
|
|
|
|
*
|
|
|
|
* soalloc() sets of socket layer state for a socket, called only by
|
|
|
|
* socreate() and sonewconn(). Socket layer private.
|
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* sodealloc() tears down socket layer state for a socket, called only by
|
2006-04-01 10:43:02 +00:00
|
|
|
* sofree() and sonewconn(). Socket layer private.
|
|
|
|
*
|
|
|
|
* pru_attach() associates protocol layer state with an allocated socket;
|
|
|
|
* called only once, may fail, aborting socket allocation. This is called
|
|
|
|
* from socreate() and sonewconn(). Socket layer private.
|
|
|
|
*
|
|
|
|
* pru_detach() disassociates protocol layer state from an attached socket,
|
|
|
|
* and will be called exactly once for sockets in which pru_attach() has
|
|
|
|
* been successfully called. If pru_attach() returned an error,
|
|
|
|
* pru_detach() will not be called. Socket layer private.
|
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* pru_abort() and pru_close() notify the protocol layer that the last
|
|
|
|
* consumer of a socket is starting to tear down the socket, and that the
|
|
|
|
* protocol should terminate the connection. Historically, pru_abort() also
|
|
|
|
* detached protocol state from the socket state, but this is no longer the
|
|
|
|
* case.
|
|
|
|
*
|
2006-04-01 10:43:02 +00:00
|
|
|
* socreate() creates a socket and attaches protocol state. This is a public
|
|
|
|
* interface that may be used by socket layer consumers to create new
|
|
|
|
* sockets.
|
|
|
|
*
|
|
|
|
* sonewconn() creates a socket and attaches protocol state. This is a
|
|
|
|
* public interface that may be used by protocols to create new sockets when
|
|
|
|
* a new connection is received and will be available for accept() on a
|
|
|
|
* listen socket.
|
|
|
|
*
|
|
|
|
* soclose() destroys a socket after possibly waiting for it to disconnect.
|
|
|
|
* This is a public interface that socket consumers should use to close and
|
|
|
|
* release a socket when done with it.
|
|
|
|
*
|
|
|
|
* soabort() destroys a socket without waiting for it to disconnect (used
|
|
|
|
* only for incoming connections that are already partially or fully
|
|
|
|
* connected). This is used internally by the socket layer when clearing
|
|
|
|
* listen socket queues (due to overflow or close on the listen socket), but
|
|
|
|
* is also a public interface protocols may use to abort connections in
|
|
|
|
* their incomplete listen queues should they no longer be required. Sockets
|
2006-07-23 20:36:04 +00:00
|
|
|
* placed in completed connection listen queues should not be aborted for
|
|
|
|
* reasons described in the comment above the soclose() implementation. This
|
|
|
|
* is not a general purpose close routine, and except in the specific
|
|
|
|
* circumstances described here, should not be used.
|
2006-04-01 10:43:02 +00:00
|
|
|
*
|
|
|
|
* sofree() will free a socket and its protocol state if all references on
|
|
|
|
* the socket have been released, and is the public interface to attempt to
|
|
|
|
* free a socket when a reference is removed. This is a socket layer private
|
|
|
|
* interface.
|
|
|
|
*
|
|
|
|
* NOTE: In addition to socreate() and soclose(), which provide a single
|
|
|
|
* socket reference to the consumer to be managed as required, there are two
|
|
|
|
* calls to explicitly manage socket references, soref(), and sorele().
|
|
|
|
* Currently, these are generally required only when transitioning a socket
|
|
|
|
* from a listen queue to a file descriptor, in order to prevent garbage
|
|
|
|
* collection of the socket at an untimely moment. For a number of reasons,
|
|
|
|
* these interfaces are not preferred, and should be avoided.
|
|
|
|
*/
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2000-11-20 01:35:25 +00:00
|
|
|
#include "opt_inet.h"
|
2005-06-09 19:59:09 +00:00
|
|
|
#include "opt_mac.h"
|
|
|
|
#include "opt_zero.h"
|
2005-10-27 04:26:35 +00:00
|
|
|
#include "opt_compat.h"
|
2000-11-20 01:35:25 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1997-03-23 03:37:54 +00:00
|
|
|
#include <sys/fcntl.h>
|
2005-06-09 19:59:09 +00:00
|
|
|
#include <sys/limits.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mac.h>
|
2002-08-01 17:47:56 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mbuf.h>
|
2005-06-09 19:59:09 +00:00
|
|
|
#include <sys/mutex.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/domain.h>
|
2000-04-16 18:53:38 +00:00
|
|
|
#include <sys/file.h> /* for struct knote */
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
2000-04-16 18:53:38 +00:00
|
|
|
#include <sys/event.h>
|
2006-06-10 14:34:07 +00:00
|
|
|
#include <sys/eventhandler.h>
|
1997-09-14 02:34:14 +00:00
|
|
|
#include <sys/poll.h>
|
1999-06-17 23:54:50 +00:00
|
|
|
#include <sys/proc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/protosw.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
|
|
|
#include <sys/resourcevar.h>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/signalvar.h>
|
1995-11-03 18:33:46 +00:00
|
|
|
#include <sys/sysctl.h>
|
1998-03-28 10:33:27 +00:00
|
|
|
#include <sys/uio.h>
|
2000-06-04 04:28:31 +00:00
|
|
|
#include <sys/jail.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
#include <vm/uma.h>
|
1995-11-03 18:33:46 +00:00
|
|
|
|
2005-10-27 04:26:35 +00:00
|
|
|
#ifdef COMPAT_IA32
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <compat/freebsd32/freebsd32.h>
|
|
|
|
|
|
|
|
extern struct sysentvec ia32_freebsd_sysvec;
|
|
|
|
#endif
|
1997-08-21 20:33:42 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
static int soreceive_rcvoob(struct socket *so, struct uio *uio,
|
|
|
|
int flags);
|
|
|
|
|
|
|
|
static void filt_sordetach(struct knote *kn);
|
|
|
|
static int filt_soread(struct knote *kn, long hint);
|
|
|
|
static void filt_sowdetach(struct knote *kn);
|
2000-04-16 18:53:38 +00:00
|
|
|
static int filt_sowrite(struct knote *kn, long hint);
|
|
|
|
static int filt_solisten(struct knote *kn, long hint);
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
static struct filterops solisten_filtops =
|
2001-02-15 16:34:11 +00:00
|
|
|
{ 1, NULL, filt_sordetach, filt_solisten };
|
|
|
|
static struct filterops soread_filtops =
|
|
|
|
{ 1, NULL, filt_sordetach, filt_soread };
|
2005-06-09 19:59:09 +00:00
|
|
|
static struct filterops sowrite_filtops =
|
2001-02-15 16:34:11 +00:00
|
|
|
{ 1, NULL, filt_sowdetach, filt_sowrite };
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
uma_zone_t socket_zone;
|
1998-05-15 20:11:40 +00:00
|
|
|
so_gen_t so_gencnt; /* generation count for sockets */
|
|
|
|
|
2006-06-10 14:34:07 +00:00
|
|
|
int maxsockets;
|
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_SONAME, "soname", "socket name");
|
|
|
|
MALLOC_DEFINE(M_PCB, "pcb", "protocol control block");
|
|
|
|
|
1995-11-03 18:33:46 +00:00
|
|
|
static int somaxconn = SOMAXCONN;
|
2005-06-09 19:59:09 +00:00
|
|
|
static int somaxconn_sysctl(SYSCTL_HANDLER_ARGS);
|
|
|
|
/* XXX: we dont have SYSCTL_USHORT */
|
|
|
|
SYSCTL_PROC(_kern_ipc, KIPC_SOMAXCONN, somaxconn, CTLTYPE_UINT | CTLFLAG_RW,
|
|
|
|
0, sizeof(int), somaxconn_sysctl, "I", "Maximum pending socket connection "
|
|
|
|
"queue size");
|
|
|
|
static int numopensockets;
|
|
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, numopensockets, CTLFLAG_RD,
|
|
|
|
&numopensockets, 0, "Number of open sockets");
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
/* These aren't static because they're used in other files. */
|
|
|
|
int so_zero_copy_send = 1;
|
|
|
|
int so_zero_copy_receive = 1;
|
|
|
|
SYSCTL_NODE(_kern_ipc, OID_AUTO, zero_copy, CTLFLAG_RD, 0,
|
|
|
|
"Zero copy controls");
|
|
|
|
SYSCTL_INT(_kern_ipc_zero_copy, OID_AUTO, receive, CTLFLAG_RW,
|
|
|
|
&so_zero_copy_receive, 0, "Enable zero copy receive");
|
|
|
|
SYSCTL_INT(_kern_ipc_zero_copy, OID_AUTO, send, CTLFLAG_RW,
|
|
|
|
&so_zero_copy_send, 0, "Enable zero copy send");
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* accept_mtx locks down per-socket fields relating to accept queues. See
|
|
|
|
* socketvar.h for an annotation of the protected fields of struct socket.
|
|
|
|
*/
|
|
|
|
struct mtx accept_mtx;
|
|
|
|
MTX_SYSINIT(accept_mtx, &accept_mtx, "accept", MTX_DEF);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* so_global_mtx protects so_gencnt, numopensockets, and the per-socket
|
|
|
|
* so_gencnt field.
|
|
|
|
*/
|
|
|
|
static struct mtx so_global_mtx;
|
|
|
|
MTX_SYSINIT(so_global_mtx, &so_global_mtx, "so_glabel", MTX_DEF);
|
1994-05-25 09:21:21 +00:00
|
|
|
|
2006-07-23 20:36:04 +00:00
|
|
|
/*
|
|
|
|
* General IPC sysctl name space, used by sockets and a variety of other IPC
|
|
|
|
* types.
|
|
|
|
*/
|
2006-06-10 14:34:07 +00:00
|
|
|
SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW, 0, "IPC");
|
|
|
|
|
2006-07-23 20:36:04 +00:00
|
|
|
/*
|
|
|
|
* Sysctl to get and set the maximum global sockets limit. Notify protocols
|
|
|
|
* of the change so that they can update their dependent limits as required.
|
|
|
|
*/
|
2006-06-10 14:34:07 +00:00
|
|
|
static int
|
|
|
|
sysctl_maxsockets(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error, newmaxsockets;
|
|
|
|
|
|
|
|
newmaxsockets = maxsockets;
|
2006-07-16 23:09:39 +00:00
|
|
|
error = sysctl_handle_int(oidp, &newmaxsockets, sizeof(int), req);
|
2006-06-10 14:34:07 +00:00
|
|
|
if (error == 0 && req->newptr) {
|
|
|
|
if (newmaxsockets > maxsockets) {
|
|
|
|
maxsockets = newmaxsockets;
|
|
|
|
if (maxsockets > ((maxfiles / 4) * 3)) {
|
|
|
|
maxfiles = (maxsockets * 5) / 4;
|
|
|
|
maxfilesperproc = (maxfiles * 9) / 10;
|
|
|
|
}
|
|
|
|
EVENTHANDLER_INVOKE(maxsockets_change);
|
|
|
|
} else
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_kern_ipc, OID_AUTO, maxsockets, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&maxsockets, 0, sysctl_maxsockets, "IU",
|
|
|
|
"Maximum number of sockets avaliable");
|
|
|
|
|
|
|
|
/*
|
2006-07-16 23:09:39 +00:00
|
|
|
* Initialise maxsockets.
|
2006-06-10 14:34:07 +00:00
|
|
|
*/
|
|
|
|
static void init_maxsockets(void *ignored)
|
|
|
|
{
|
|
|
|
TUNABLE_INT_FETCH("kern.ipc.maxsockets", &maxsockets);
|
|
|
|
maxsockets = imax(maxsockets, imax(maxfiles, nmbclusters));
|
|
|
|
}
|
|
|
|
SYSINIT(param, SI_SUB_TUNABLES, SI_ORDER_ANY, init_maxsockets, NULL);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Socket operation routines. These routines are called by the routines in
|
|
|
|
* sys_socket.c or from a system process, and implement the semantics of
|
|
|
|
* socket operations by switching out to the protocol specific routines.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-05-15 20:11:40 +00:00
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Get a socket structure from our zone, and initialize it. Note that it
|
|
|
|
* would probably be better to allocate socket and PCB at the same time, but
|
|
|
|
* I'm not convinced that all the protocols can be easily modified to do
|
|
|
|
* this.
|
2005-06-09 19:59:09 +00:00
|
|
|
*
|
|
|
|
* soalloc() returns a socket with a ref count of 0.
|
1998-05-15 20:11:40 +00:00
|
|
|
*/
|
2006-06-10 14:34:07 +00:00
|
|
|
static struct socket *
|
2005-06-09 19:59:09 +00:00
|
|
|
soalloc(int mflags)
|
1998-05-15 20:11:40 +00:00
|
|
|
{
|
|
|
|
struct socket *so;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
so = uma_zalloc(socket_zone, mflags | M_ZERO);
|
2006-06-08 22:33:18 +00:00
|
|
|
if (so == NULL)
|
|
|
|
return (NULL);
|
2005-06-09 19:59:09 +00:00
|
|
|
#ifdef MAC
|
2006-06-08 22:33:18 +00:00
|
|
|
if (mac_init_socket(so, mflags) != 0) {
|
|
|
|
uma_zfree(socket_zone, so);
|
|
|
|
return (NULL);
|
1998-05-15 20:11:40 +00:00
|
|
|
}
|
2006-06-08 22:33:18 +00:00
|
|
|
#endif
|
|
|
|
SOCKBUF_LOCK_INIT(&so->so_snd, "so_snd");
|
|
|
|
SOCKBUF_LOCK_INIT(&so->so_rcv, "so_rcv");
|
|
|
|
TAILQ_INIT(&so->so_aiojobq);
|
|
|
|
mtx_lock(&so_global_mtx);
|
|
|
|
so->so_gencnt = ++so_gencnt;
|
|
|
|
++numopensockets;
|
|
|
|
mtx_unlock(&so_global_mtx);
|
2005-06-09 19:59:09 +00:00
|
|
|
return (so);
|
1998-05-15 20:11:40 +00:00
|
|
|
}
|
|
|
|
|
2006-07-23 20:36:04 +00:00
|
|
|
/*
|
|
|
|
* Free the storage associated with a socket at the socket layer, tear down
|
|
|
|
* locks, labels, etc. All protocol state is assumed already to have been
|
|
|
|
* torn down (and possibly never set up) by the caller.
|
|
|
|
*/
|
2006-06-10 14:34:07 +00:00
|
|
|
static void
|
|
|
|
sodealloc(struct socket *so)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(so->so_count == 0, ("sodealloc(): so_count %d", so->so_count));
|
|
|
|
KASSERT(so->so_pcb == NULL, ("sodealloc(): so_pcb != NULL"));
|
|
|
|
|
|
|
|
mtx_lock(&so_global_mtx);
|
|
|
|
so->so_gencnt = ++so_gencnt;
|
2006-08-02 00:45:27 +00:00
|
|
|
--numopensockets; /* Could be below, but faster here. */
|
2006-06-10 14:34:07 +00:00
|
|
|
mtx_unlock(&so_global_mtx);
|
|
|
|
if (so->so_rcv.sb_hiwat)
|
|
|
|
(void)chgsbsize(so->so_cred->cr_uidinfo,
|
|
|
|
&so->so_rcv.sb_hiwat, 0, RLIM_INFINITY);
|
|
|
|
if (so->so_snd.sb_hiwat)
|
|
|
|
(void)chgsbsize(so->so_cred->cr_uidinfo,
|
|
|
|
&so->so_snd.sb_hiwat, 0, RLIM_INFINITY);
|
|
|
|
#ifdef INET
|
|
|
|
/* remove acccept filter if one is present. */
|
|
|
|
if (so->so_accf != NULL)
|
|
|
|
do_setopt_accept_filter(so, NULL);
|
|
|
|
#endif
|
|
|
|
#ifdef MAC
|
|
|
|
mac_destroy_socket(so);
|
|
|
|
#endif
|
|
|
|
crfree(so->so_cred);
|
|
|
|
SOCKBUF_LOCK_DESTROY(&so->so_snd);
|
|
|
|
SOCKBUF_LOCK_DESTROY(&so->so_rcv);
|
|
|
|
uma_zfree(socket_zone, so);
|
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* socreate returns a socket with a ref count of 1. The socket should be
|
|
|
|
* closed with soclose().
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
socreate(dom, aso, type, proto, cred, td)
|
1994-05-24 10:09:53 +00:00
|
|
|
int dom;
|
|
|
|
struct socket **aso;
|
2005-06-09 19:59:09 +00:00
|
|
|
int type;
|
1994-05-24 10:09:53 +00:00
|
|
|
int proto;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct ucred *cred;
|
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct protosw *prp;
|
|
|
|
struct socket *so;
|
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (proto)
|
|
|
|
prp = pffindproto(dom, proto, type);
|
|
|
|
else
|
|
|
|
prp = pffindtype(dom, type);
|
2000-06-04 04:28:31 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (prp == NULL || prp->pr_usrreqs->pru_attach == NULL ||
|
|
|
|
prp->pr_usrreqs->pru_attach == pru_attach_notsupp)
|
2000-06-13 15:44:04 +00:00
|
|
|
return (EPROTONOSUPPORT);
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (jailed(cred) && jail_socket_unixiproute_only &&
|
2000-06-04 04:28:31 +00:00
|
|
|
prp->pr_domain->dom_family != PF_LOCAL &&
|
|
|
|
prp->pr_domain->dom_family != PF_INET &&
|
|
|
|
prp->pr_domain->dom_family != PF_ROUTE) {
|
|
|
|
return (EPROTONOSUPPORT);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (prp->pr_type != type)
|
|
|
|
return (EPROTOTYPE);
|
2005-06-09 19:59:09 +00:00
|
|
|
so = soalloc(M_WAITOK);
|
|
|
|
if (so == NULL)
|
1998-05-15 20:11:40 +00:00
|
|
|
return (ENOBUFS);
|
|
|
|
|
1996-03-11 15:37:44 +00:00
|
|
|
TAILQ_INIT(&so->so_incomp);
|
|
|
|
TAILQ_INIT(&so->so_comp);
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_type = type;
|
2005-06-09 19:59:09 +00:00
|
|
|
so->so_cred = crhold(cred);
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_proto = prp;
|
2005-06-09 19:59:09 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_create_socket(cred, so);
|
|
|
|
#endif
|
2005-07-01 16:28:32 +00:00
|
|
|
knlist_init(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv),
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
knlist_init(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd),
|
|
|
|
NULL, NULL, NULL);
|
2005-06-09 19:59:09 +00:00
|
|
|
so->so_count = 1;
|
|
|
|
error = (*prp->pr_usrreqs->pru_attach)(so, proto, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
2006-08-11 23:03:10 +00:00
|
|
|
KASSERT(so->so_count == 1, ("socreate: so_count %d",
|
|
|
|
so->so_count));
|
|
|
|
so->so_count = 0;
|
2006-07-11 21:56:58 +00:00
|
|
|
sodealloc(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
*aso = so;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2006-06-10 14:34:07 +00:00
|
|
|
#ifdef REGRESSION
|
|
|
|
static int regression_sonewconn_earlytest = 1;
|
|
|
|
SYSCTL_INT(_regression, OID_AUTO, sonewconn_earlytest, CTLFLAG_RW,
|
|
|
|
®ression_sonewconn_earlytest, 0, "Perform early sonewconn limit test");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* When an attempt at a new connection is noted on a socket which accepts
|
|
|
|
* connections, sonewconn is called. If the connection is possible (subject
|
|
|
|
* to space constraints, etc.) then we allocate a new structure, propoerly
|
|
|
|
* linked into the data structure of the original socket, and return this.
|
2006-06-10 14:34:07 +00:00
|
|
|
* Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
|
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Note: the ref count on the socket is 0 on return.
|
2006-06-10 14:34:07 +00:00
|
|
|
*/
|
|
|
|
struct socket *
|
|
|
|
sonewconn(head, connstatus)
|
|
|
|
register struct socket *head;
|
|
|
|
int connstatus;
|
|
|
|
{
|
|
|
|
register struct socket *so;
|
|
|
|
int over;
|
|
|
|
|
|
|
|
ACCEPT_LOCK();
|
|
|
|
over = (head->so_qlen > 3 * head->so_qlimit / 2);
|
|
|
|
ACCEPT_UNLOCK();
|
|
|
|
#ifdef REGRESSION
|
|
|
|
if (regression_sonewconn_earlytest && over)
|
|
|
|
#else
|
|
|
|
if (over)
|
|
|
|
#endif
|
|
|
|
return (NULL);
|
|
|
|
so = soalloc(M_NOWAIT);
|
|
|
|
if (so == NULL)
|
|
|
|
return (NULL);
|
|
|
|
if ((head->so_options & SO_ACCEPTFILTER) != 0)
|
|
|
|
connstatus = 0;
|
|
|
|
so->so_head = head;
|
|
|
|
so->so_type = head->so_type;
|
|
|
|
so->so_options = head->so_options &~ SO_ACCEPTCONN;
|
|
|
|
so->so_linger = head->so_linger;
|
|
|
|
so->so_state = head->so_state | SS_NOFDREF;
|
|
|
|
so->so_proto = head->so_proto;
|
|
|
|
so->so_timeo = head->so_timeo;
|
|
|
|
so->so_cred = crhold(head->so_cred);
|
|
|
|
#ifdef MAC
|
|
|
|
SOCK_LOCK(head);
|
|
|
|
mac_create_socket_from_socket(head, so);
|
|
|
|
SOCK_UNLOCK(head);
|
|
|
|
#endif
|
|
|
|
knlist_init(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv),
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
knlist_init(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd),
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat) ||
|
|
|
|
(*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) {
|
|
|
|
sodealloc(so);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
so->so_state |= connstatus;
|
|
|
|
ACCEPT_LOCK();
|
|
|
|
if (connstatus) {
|
|
|
|
TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
|
|
|
|
so->so_qstate |= SQ_COMP;
|
|
|
|
head->so_qlen++;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Keep removing sockets from the head until there's room for
|
|
|
|
* us to insert on the tail. In pre-locking revisions, this
|
|
|
|
* was a simple if(), but as we could be racing with other
|
|
|
|
* threads and soabort() requires dropping locks, we must
|
|
|
|
* loop waiting for the condition to be true.
|
|
|
|
*/
|
|
|
|
while (head->so_incqlen > head->so_qlimit) {
|
|
|
|
struct socket *sp;
|
|
|
|
sp = TAILQ_FIRST(&head->so_incomp);
|
|
|
|
TAILQ_REMOVE(&head->so_incomp, sp, so_list);
|
|
|
|
head->so_incqlen--;
|
|
|
|
sp->so_qstate &= ~SQ_INCOMP;
|
|
|
|
sp->so_head = NULL;
|
|
|
|
ACCEPT_UNLOCK();
|
|
|
|
soabort(sp);
|
|
|
|
ACCEPT_LOCK();
|
|
|
|
}
|
|
|
|
TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list);
|
|
|
|
so->so_qstate |= SQ_INCOMP;
|
|
|
|
head->so_incqlen++;
|
|
|
|
}
|
|
|
|
ACCEPT_UNLOCK();
|
|
|
|
if (connstatus) {
|
|
|
|
sorwakeup(head);
|
|
|
|
wakeup_one(&head->so_timeo);
|
|
|
|
}
|
|
|
|
return (so);
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
sobind(so, nam, td)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct socket *so;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr *nam;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
return ((*so->so_proto->pr_usrreqs->pru_bind)(so, nam, td));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* solisten() transitions a socket from a non-listening state to a listening
|
|
|
|
* state, but can also be used to update the listen queue depth on an
|
|
|
|
* existing listen socket. The protocol will call back into the sockets
|
|
|
|
* layer using solisten_proto_check() and solisten_proto() to check and set
|
|
|
|
* socket-layer listen state. Call backs are used so that the protocol can
|
2005-09-18 10:46:34 +00:00
|
|
|
* acquire both protocol and socket layer locks in whatever order is required
|
2005-06-09 19:59:09 +00:00
|
|
|
* by the protocol.
|
|
|
|
*
|
|
|
|
* Protocol implementors are advised to hold the socket lock across the
|
|
|
|
* socket-layer test and set to avoid races at the socket layer.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
solisten(so, backlog, td)
|
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
int backlog;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
|
2005-10-30 19:44:40 +00:00
|
|
|
return ((*so->so_proto->pr_usrreqs->pru_listen)(so, backlog, td));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
int
|
|
|
|
solisten_proto_check(so)
|
|
|
|
struct socket *so;
|
|
|
|
{
|
|
|
|
|
|
|
|
SOCK_LOCK_ASSERT(so);
|
|
|
|
|
|
|
|
if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
|
|
|
|
SS_ISDISCONNECTING))
|
|
|
|
return (EINVAL);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-10-30 19:44:40 +00:00
|
|
|
solisten_proto(so, backlog)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
2005-10-30 19:44:40 +00:00
|
|
|
int backlog;
|
2005-06-09 19:59:09 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
SOCK_LOCK_ASSERT(so);
|
|
|
|
|
2005-10-30 19:44:40 +00:00
|
|
|
if (backlog < 0 || backlog > somaxconn)
|
|
|
|
backlog = somaxconn;
|
|
|
|
so->so_qlimit = backlog;
|
2005-06-09 19:59:09 +00:00
|
|
|
so->so_options |= SO_ACCEPTCONN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to free a socket. This should really be sotryfree().
|
|
|
|
*
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
* sofree() will succeed if:
|
|
|
|
*
|
|
|
|
* - There are no outstanding file descriptor references or related consumers
|
|
|
|
* (so_count == 0).
|
|
|
|
*
|
|
|
|
* - The socket has been closed by user space, if ever open (SS_NOFDREF).
|
|
|
|
*
|
|
|
|
* - The protocol does not have an outstanding strong reference on the socket
|
|
|
|
* (SS_PROTOREF).
|
|
|
|
*
|
2006-04-23 15:37:23 +00:00
|
|
|
* - The socket is not in a completed connection queue, so a process has been
|
2006-04-23 15:33:38 +00:00
|
|
|
* notified that it is present. If it is removed, the user process may
|
|
|
|
* block in accept() despite select() saying the socket was ready.
|
|
|
|
*
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
* Otherwise, it will quietly abort so that a future call to sofree(), when
|
|
|
|
* conditions are right, can succeed.
|
2005-06-09 19:59:09 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
sofree(so)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2006-08-01 10:30:26 +00:00
|
|
|
struct protosw *pr = so->so_proto;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *head;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_LOCK_ASSERT();
|
|
|
|
SOCK_LOCK_ASSERT(so);
|
|
|
|
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
if ((so->so_state & SS_NOFDREF) == 0 || so->so_count != 0 ||
|
2006-04-23 15:33:38 +00:00
|
|
|
(so->so_state & SS_PROTOREF) || (so->so_qstate & SQ_COMP)) {
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
ACCEPT_UNLOCK();
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
2005-06-09 19:59:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
head = so->so_head;
|
Integrate accept locking from rwatson_netperf, introducing a new
global mutex, accept_mtx, which serializes access to the following
fields across all sockets:
so_qlen so_incqlen so_qstate
so_comp so_incomp so_list
so_head
While providing only coarse granularity, this approach avoids lock
order issues between sockets by avoiding ownership of the fields
by a specific socket and its per-socket mutexes.
While here, rewrite soclose(), sofree(), soaccept(), and
sonewconn() to add assertions, close additional races and address
lock order concerns. In particular:
- Reorganize the optimistic concurrency behavior in accept1() to
always allocate a file descriptor with falloc() so that if we do
find a socket, we don't have to encounter the "Oh, there wasn't
a socket" race that can occur if falloc() sleeps in the current
code, which broke inbound accept() ordering, not to mention
requiring backing out socket state changes in a way that raced
with the protocol level. We may want to add a lockless read of
the queue state if polling of empty queues proves to be important
to optimize.
- In accept1(), soref() the socket while holding the accept lock
so that the socket cannot be free'd in a race with the protocol
layer. Likewise in netgraph equivilents of the accept1() code.
- In sonewconn(), loop waiting for the queue to be small enough to
insert our new socket once we've committed to inserting it, or
races can occur that cause the incomplete socket queue to
overfill. In the previously implementation, it was sufficient
to simply tested once since calling soabort() didn't release
synchronization permitting another thread to insert a socket as
we discard a previous one.
- In soclose()/sofree()/et al, it is the responsibility of the
caller to remove a socket from the incomplete connection queue
before calling soabort(), which prevents soabort() from having
to walk into the accept socket to release the socket from its
queue, and avoids races when releasing the accept mutex to enter
soabort(), permitting soabort() to avoid lock ordering issues
with the caller.
- Generally cluster accept queue related operations together
throughout these functions in order to facilitate locking.
Annotate new locking in socketvar.h.
2004-06-02 04:15:39 +00:00
|
|
|
if (head != NULL) {
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT((so->so_qstate & SQ_COMP) != 0 ||
|
|
|
|
(so->so_qstate & SQ_INCOMP) != 0,
|
|
|
|
("sofree: so_head != NULL, but neither SQ_COMP nor "
|
|
|
|
"SQ_INCOMP"));
|
|
|
|
KASSERT((so->so_qstate & SQ_COMP) == 0 ||
|
|
|
|
(so->so_qstate & SQ_INCOMP) == 0,
|
|
|
|
("sofree: so->so_qstate is SQ_COMP and also SQ_INCOMP"));
|
|
|
|
TAILQ_REMOVE(&head->so_incomp, so, so_list);
|
|
|
|
head->so_incqlen--;
|
|
|
|
so->so_qstate &= ~SQ_INCOMP;
|
1996-03-11 15:37:44 +00:00
|
|
|
so->so_head = NULL;
|
2002-05-31 11:52:35 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT((so->so_qstate & SQ_COMP) == 0 &&
|
|
|
|
(so->so_qstate & SQ_INCOMP) == 0,
|
|
|
|
("sofree: so_head == NULL, but still SQ_COMP(%d) or SQ_INCOMP(%d)",
|
|
|
|
so->so_qstate & SQ_COMP, so->so_qstate & SQ_INCOMP));
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
ACCEPT_UNLOCK();
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
2006-08-01 10:30:26 +00:00
|
|
|
* From this point on, we assume that no other references to this
|
|
|
|
* socket exist anywhere else in the stack. Therefore, no locks need
|
|
|
|
* to be acquired or held.
|
|
|
|
*
|
|
|
|
* We used to do a lot of socket buffer and socket locking here, as
|
|
|
|
* well as invoke sorflush() and perform wakeups. The direct call to
|
|
|
|
* dom_dispose() and sbrelease_internal() are an inlining of what was
|
|
|
|
* necessary from sorflush().
|
|
|
|
*
|
|
|
|
* Notice that the socket buffer and kqueue state are torn down
|
|
|
|
* before calling pru_detach. This means that protocols shold not
|
|
|
|
* assume they can perform socket wakeups, etc, in their detach
|
|
|
|
* code.
|
2005-06-09 19:59:09 +00:00
|
|
|
*/
|
2006-08-01 10:30:26 +00:00
|
|
|
KASSERT((so->so_snd.sb_flags & SB_LOCK) == 0, ("sofree: snd sblock"));
|
|
|
|
KASSERT((so->so_rcv.sb_flags & SB_LOCK) == 0, ("sofree: rcv sblock"));
|
|
|
|
sbdestroy(&so->so_snd, so);
|
|
|
|
if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose != NULL)
|
|
|
|
(*pr->pr_domain->dom_dispose)(so->so_rcv.sb_mb);
|
|
|
|
sbdestroy(&so->so_rcv, so);
|
|
|
|
if (pr->pr_usrreqs->pru_detach != NULL)
|
|
|
|
(*pr->pr_usrreqs->pru_detach)(so);
|
2006-08-02 18:37:44 +00:00
|
|
|
knlist_destroy(&so->so_rcv.sb_sel.si_note);
|
|
|
|
knlist_destroy(&so->so_snd.sb_sel.si_note);
|
1998-05-15 20:11:40 +00:00
|
|
|
sodealloc(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Close a socket on last file table reference removal. Initiate disconnect
|
|
|
|
* if connected. Free socket when disconnect complete.
|
2005-06-09 19:59:09 +00:00
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* This function will sorele() the socket. Note that soclose() may be called
|
|
|
|
* prior to the ref count reaching zero. The actual socket structure will
|
|
|
|
* not be freed until the ref count reaches zero.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
soclose(so)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT(!(so->so_state & SS_NOFDREF), ("soclose: SS_NOFDREF on enter"));
|
2005-06-09 19:56:38 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
funsetown(&so->so_sigio);
|
|
|
|
if (so->so_options & SO_ACCEPTCONN) {
|
|
|
|
struct socket *sp;
|
|
|
|
ACCEPT_LOCK();
|
|
|
|
while ((sp = TAILQ_FIRST(&so->so_incomp)) != NULL) {
|
|
|
|
TAILQ_REMOVE(&so->so_incomp, sp, so_list);
|
|
|
|
so->so_incqlen--;
|
|
|
|
sp->so_qstate &= ~SQ_INCOMP;
|
|
|
|
sp->so_head = NULL;
|
|
|
|
ACCEPT_UNLOCK();
|
2006-03-16 07:03:14 +00:00
|
|
|
soabort(sp);
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_LOCK();
|
1996-04-16 03:50:08 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
while ((sp = TAILQ_FIRST(&so->so_comp)) != NULL) {
|
1999-01-25 16:58:56 +00:00
|
|
|
TAILQ_REMOVE(&so->so_comp, sp, so_list);
|
1999-02-02 07:23:28 +00:00
|
|
|
so->so_qlen--;
|
2005-06-09 19:59:09 +00:00
|
|
|
sp->so_qstate &= ~SQ_COMP;
|
1999-02-02 07:23:28 +00:00
|
|
|
sp->so_head = NULL;
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_UNLOCK();
|
2006-03-16 07:03:14 +00:00
|
|
|
soabort(sp);
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_LOCK();
|
1996-04-16 03:50:08 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_UNLOCK();
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (so->so_state & SS_ISCONNECTED) {
|
|
|
|
if ((so->so_state & SS_ISDISCONNECTING) == 0) {
|
|
|
|
error = sodisconnect(so);
|
2002-05-31 11:52:35 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
if (so->so_options & SO_LINGER) {
|
|
|
|
if ((so->so_state & SS_ISDISCONNECTING) &&
|
2002-05-31 11:52:35 +00:00
|
|
|
(so->so_state & SS_NBIO))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto drop;
|
1994-10-02 17:35:40 +00:00
|
|
|
while (so->so_state & SS_ISCONNECTED) {
|
2005-06-09 19:59:09 +00:00
|
|
|
error = tsleep(&so->so_timeo,
|
1999-04-24 18:22:34 +00:00
|
|
|
PSOCK | PCATCH, "soclos", so->so_linger * hz);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1994-10-02 17:35:40 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
drop:
|
2006-07-21 17:11:15 +00:00
|
|
|
if (so->so_proto->pr_usrreqs->pru_close != NULL)
|
|
|
|
(*so->so_proto->pr_usrreqs->pru_close)(so);
|
2005-06-09 19:59:09 +00:00
|
|
|
ACCEPT_LOCK();
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
KASSERT((so->so_state & SS_NOFDREF) == 0, ("soclose: NOFDREF"));
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_state |= SS_NOFDREF;
|
2005-06-09 19:59:09 +00:00
|
|
|
sorele(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-07-16 23:09:39 +00:00
|
|
|
* soabort() is used to abruptly tear down a connection, such as when a
|
|
|
|
* resource limit is reached (listen queue depth exceeded), or if a listen
|
|
|
|
* socket is closed while there are sockets waiting to be accepted.
|
2006-04-01 15:15:05 +00:00
|
|
|
*
|
|
|
|
* This interface is tricky, because it is called on an unreferenced socket,
|
|
|
|
* and must be called only by a thread that has actually removed the socket
|
|
|
|
* from the listen queue it was on, or races with other threads are risked.
|
|
|
|
*
|
|
|
|
* This interface will call into the protocol code, so must not be called
|
|
|
|
* with any socket locks held. Protocols do call it while holding their own
|
|
|
|
* recursible protocol mutexes, but this is something that should be subject
|
|
|
|
* to review in the future.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2006-03-16 07:03:14 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
soabort(so)
|
|
|
|
struct socket *so;
|
|
|
|
{
|
|
|
|
|
2006-04-01 15:15:05 +00:00
|
|
|
/*
|
|
|
|
* In as much as is possible, assert that no references to this
|
|
|
|
* socket are held. This is not quite the same as asserting that the
|
|
|
|
* current thread is responsible for arranging for no references, but
|
|
|
|
* is as close as we can get for now.
|
|
|
|
*/
|
|
|
|
KASSERT(so->so_count == 0, ("soabort: so_count"));
|
2006-04-23 18:15:54 +00:00
|
|
|
KASSERT((so->so_state & SS_PROTOREF) == 0, ("soabort: SS_PROTOREF"));
|
2006-04-01 15:15:05 +00:00
|
|
|
KASSERT(so->so_state & SS_NOFDREF, ("soabort: !SS_NOFDREF"));
|
2006-04-23 18:15:54 +00:00
|
|
|
KASSERT((so->so_state & SQ_COMP) == 0, ("soabort: SQ_COMP"));
|
|
|
|
KASSERT((so->so_state & SQ_INCOMP) == 0, ("soabort: SQ_INCOMP"));
|
2006-04-01 15:15:05 +00:00
|
|
|
|
2006-07-21 17:11:15 +00:00
|
|
|
if (so->so_proto->pr_usrreqs->pru_abort != NULL)
|
2006-07-11 23:18:28 +00:00
|
|
|
(*so->so_proto->pr_usrreqs->pru_abort)(so);
|
2006-04-01 15:15:05 +00:00
|
|
|
ACCEPT_LOCK();
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
sofree(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
soaccept(so, nam)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr **nam;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_LOCK(so);
|
|
|
|
KASSERT((so->so_state & SS_NOFDREF) != 0, ("soaccept: !NOFDREF"));
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_state &= ~SS_NOFDREF;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_UNLOCK(so);
|
2001-03-09 08:16:40 +00:00
|
|
|
error = (*so->so_proto->pr_usrreqs->pru_accept)(so, nam);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
soconnect(so, nam, td)
|
|
|
|
struct socket *so;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr *nam;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2002-05-31 11:52:35 +00:00
|
|
|
if (so->so_options & SO_ACCEPTCONN)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
/*
|
|
|
|
* If protocol is connection-based, can only connect once.
|
2006-07-23 20:36:04 +00:00
|
|
|
* Otherwise, if connected, try to disconnect first. This allows
|
|
|
|
* user to disconnect by connecting to, e.g., a null address.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-05-31 11:52:35 +00:00
|
|
|
if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
|
|
|
|
((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
|
2005-06-09 19:59:09 +00:00
|
|
|
(error = sodisconnect(so)))) {
|
2002-05-31 11:52:35 +00:00
|
|
|
error = EISCONN;
|
2005-06-09 19:59:09 +00:00
|
|
|
} else {
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Prevent accumulated error from previous connection from
|
|
|
|
* biting us.
|
2005-06-09 19:59:09 +00:00
|
|
|
*/
|
|
|
|
so->so_error = 0;
|
|
|
|
error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, td);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
soconnect2(so1, so2)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so1;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct socket *so2;
|
|
|
|
{
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
return ((*so1->so_proto->pr_usrreqs->pru_connect2)(so1, so2));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
sodisconnect(so)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if ((so->so_state & SS_ISCONNECTED) == 0)
|
|
|
|
return (ENOTCONN);
|
|
|
|
if (so->so_state & SS_ISDISCONNECTING)
|
|
|
|
return (EALREADY);
|
1996-07-11 16:32:50 +00:00
|
|
|
error = (*so->so_proto->pr_usrreqs->pru_disconnect)(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2005-11-28 21:45:36 +00:00
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
struct so_zerocopy_stats{
|
|
|
|
int size_ok;
|
|
|
|
int align_ok;
|
|
|
|
int found_ifp;
|
|
|
|
};
|
|
|
|
struct so_zerocopy_stats so_zerocp_stats = {0,0,0};
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <netinet/in_pcb.h>
|
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/vm_page.h>
|
|
|
|
#include <vm/vm_object.h>
|
|
|
|
#endif /*ZERO_COPY_SOCKETS*/
|
|
|
|
|
2005-11-28 18:09:03 +00:00
|
|
|
/*
|
|
|
|
* sosend_copyin() accepts a uio and prepares an mbuf chain holding part or
|
|
|
|
* all of the data referenced by the uio. If desired, it uses zero-copy.
|
|
|
|
* *space will be updated to reflect data copied in.
|
|
|
|
*
|
|
|
|
* NB: If atomic I/O is requested, the caller must already have checked that
|
|
|
|
* space can hold resid bytes.
|
|
|
|
*
|
|
|
|
* NB: In the event of an error, the caller may need to free the partial
|
|
|
|
* chain pointed to by *mpp. The contents of both *uio and *space may be
|
|
|
|
* modified even in the case of an error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sosend_copyin(struct uio *uio, struct mbuf **retmp, int atomic, long *space,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct mbuf *m, **mp, *top;
|
|
|
|
long len, resid;
|
|
|
|
int error;
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
int cow_send;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
*retmp = top = NULL;
|
|
|
|
mp = ⊤
|
|
|
|
len = 0;
|
|
|
|
resid = uio->uio_resid;
|
|
|
|
error = 0;
|
|
|
|
do {
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
cow_send = 0;
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
if (resid >= MINCLSIZE) {
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
if (top == NULL) {
|
|
|
|
MGETHDR(m, M_TRYWAIT, MT_DATA);
|
|
|
|
if (m == NULL) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
m->m_pkthdr.len = 0;
|
2006-07-16 23:09:39 +00:00
|
|
|
m->m_pkthdr.rcvif = NULL;
|
2005-11-28 18:09:03 +00:00
|
|
|
} else {
|
|
|
|
MGET(m, M_TRYWAIT, MT_DATA);
|
|
|
|
if (m == NULL) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (so_zero_copy_send &&
|
|
|
|
resid>=PAGE_SIZE &&
|
|
|
|
*space>=PAGE_SIZE &&
|
|
|
|
uio->uio_iov->iov_len>=PAGE_SIZE) {
|
|
|
|
so_zerocp_stats.size_ok++;
|
|
|
|
so_zerocp_stats.align_ok++;
|
|
|
|
cow_send = socow_setup(m, uio);
|
|
|
|
len = cow_send;
|
|
|
|
}
|
|
|
|
if (!cow_send) {
|
|
|
|
MCLGET(m, M_TRYWAIT);
|
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
|
|
m_free(m);
|
|
|
|
m = NULL;
|
|
|
|
} else {
|
|
|
|
len = min(min(MCLBYTES, resid),
|
|
|
|
*space);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* ZERO_COPY_SOCKETS */
|
|
|
|
if (top == NULL) {
|
|
|
|
m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
|
|
|
|
m->m_pkthdr.len = 0;
|
|
|
|
m->m_pkthdr.rcvif = NULL;
|
|
|
|
} else
|
|
|
|
m = m_getcl(M_TRYWAIT, MT_DATA, 0);
|
|
|
|
len = min(min(MCLBYTES, resid), *space);
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
} else {
|
|
|
|
if (top == NULL) {
|
|
|
|
m = m_gethdr(M_TRYWAIT, MT_DATA);
|
|
|
|
m->m_pkthdr.len = 0;
|
|
|
|
m->m_pkthdr.rcvif = NULL;
|
|
|
|
|
|
|
|
len = min(min(MHLEN, resid), *space);
|
|
|
|
/*
|
|
|
|
* For datagram protocols, leave room
|
|
|
|
* for protocol headers in first mbuf.
|
|
|
|
*/
|
|
|
|
if (atomic && m && len < MHLEN)
|
|
|
|
MH_ALIGN(m, len);
|
|
|
|
} else {
|
|
|
|
m = m_get(M_TRYWAIT, MT_DATA);
|
|
|
|
len = min(min(MLEN, resid), *space);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (m == NULL) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
*space -= len;
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
if (cow_send)
|
|
|
|
error = 0;
|
|
|
|
else
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
error = uiomove(mtod(m, void *), (int)len, uio);
|
|
|
|
resid = uio->uio_resid;
|
|
|
|
m->m_len = len;
|
|
|
|
*mp = m;
|
|
|
|
top->m_pkthdr.len += len;
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
mp = &m->m_next;
|
|
|
|
if (resid <= 0) {
|
|
|
|
if (flags & MSG_EOR)
|
|
|
|
top->m_flags |= M_EOR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (*space > 0 && atomic);
|
|
|
|
out:
|
|
|
|
*retmp = top;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
#define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
|
2006-01-13 10:22:01 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
sosend_dgram(so, addr, uio, top, control, flags, td)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockaddr *addr;
|
|
|
|
struct uio *uio;
|
|
|
|
struct mbuf *top;
|
|
|
|
struct mbuf *control;
|
|
|
|
int flags;
|
|
|
|
struct thread *td;
|
|
|
|
{
|
|
|
|
long space, resid;
|
|
|
|
int clen = 0, error, dontroute;
|
|
|
|
int atomic = sosendallatonce(so) || top;
|
|
|
|
|
|
|
|
KASSERT(so->so_type == SOCK_DGRAM, ("sodgram_send: !SOCK_DGRAM"));
|
|
|
|
KASSERT(so->so_proto->pr_flags & PR_ATOMIC,
|
|
|
|
("sodgram_send: !PR_ATOMIC"));
|
|
|
|
|
|
|
|
if (uio != NULL)
|
|
|
|
resid = uio->uio_resid;
|
|
|
|
else
|
|
|
|
resid = top->m_pkthdr.len;
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* In theory resid should be unsigned. However, space must be
|
|
|
|
* signed, as it might be less than 0 if we over-committed, and we
|
|
|
|
* must use a signed comparison of space and resid. On the other
|
|
|
|
* hand, a negative resid causes us to loop sending 0-length
|
|
|
|
* segments to the protocol.
|
2006-01-13 10:22:01 +00:00
|
|
|
*
|
|
|
|
* Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
|
|
|
|
* type sockets since that's an error.
|
|
|
|
*/
|
|
|
|
if (resid < 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dontroute =
|
|
|
|
(flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0;
|
|
|
|
if (td != NULL)
|
|
|
|
td->td_proc->p_stats->p_ru.ru_msgsnd++;
|
|
|
|
if (control != NULL)
|
|
|
|
clen = control->m_len;
|
|
|
|
|
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
|
|
|
if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
|
|
|
error = EPIPE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (so->so_error) {
|
|
|
|
error = so->so_error;
|
|
|
|
so->so_error = 0;
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if ((so->so_state & SS_ISCONNECTED) == 0) {
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* `sendto' and `sendmsg' is allowed on a connection-based
|
|
|
|
* socket if it supports implied connect. Return ENOTCONN if
|
|
|
|
* not connected and no address is supplied.
|
2006-01-13 10:22:01 +00:00
|
|
|
*/
|
|
|
|
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
|
|
|
|
(so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
|
|
|
|
if ((so->so_state & SS_ISCONFIRMING) == 0 &&
|
|
|
|
!(resid == 0 && clen != 0)) {
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
|
|
|
error = ENOTCONN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else if (addr == NULL) {
|
|
|
|
if (so->so_proto->pr_flags & PR_CONNREQUIRED)
|
|
|
|
error = ENOTCONN;
|
|
|
|
else
|
|
|
|
error = EDESTADDRREQ;
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do we need MSG_OOB support in SOCK_DGRAM? Signs here may be a
|
|
|
|
* problem and need fixing.
|
|
|
|
*/
|
|
|
|
space = sbspace(&so->so_snd);
|
|
|
|
if (flags & MSG_OOB)
|
|
|
|
space += 1024;
|
|
|
|
space -= clen;
|
|
|
|
if (resid > space) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
|
|
|
if (uio == NULL) {
|
|
|
|
resid = 0;
|
|
|
|
if (flags & MSG_EOR)
|
|
|
|
top->m_flags |= M_EOR;
|
|
|
|
} else {
|
|
|
|
error = sosend_copyin(uio, &top, atomic, &space, flags);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
resid = uio->uio_resid;
|
|
|
|
}
|
|
|
|
KASSERT(resid == 0, ("sosend_dgram: resid != 0"));
|
|
|
|
/*
|
|
|
|
* XXXRW: Frobbing SO_DONTROUTE here is even worse without sblock
|
|
|
|
* than with.
|
|
|
|
*/
|
|
|
|
if (dontroute) {
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
so->so_options |= SO_DONTROUTE;
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
}
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* XXX all the SBS_CANTSENDMORE checks previously done could be out
|
|
|
|
* of date. We could have recieved a reset packet in an interrupt or
|
|
|
|
* maybe we slept while doing page faults in uiomove() etc. We could
|
|
|
|
* probably recheck again inside the locking protection here, but
|
|
|
|
* there are probably other places that this also happens. We must
|
|
|
|
* rethink this.
|
2006-01-13 10:22:01 +00:00
|
|
|
*/
|
|
|
|
error = (*so->so_proto->pr_usrreqs->pru_send)(so,
|
|
|
|
(flags & MSG_OOB) ? PRUS_OOB :
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If the user set MSG_EOF, the protocol understands this flag and
|
|
|
|
* nothing left to send then use PRU_SEND_EOF instead of PRU_SEND.
|
2006-01-13 10:22:01 +00:00
|
|
|
*/
|
|
|
|
((flags & MSG_EOF) &&
|
|
|
|
(so->so_proto->pr_flags & PR_IMPLOPCL) &&
|
|
|
|
(resid <= 0)) ?
|
|
|
|
PRUS_EOF :
|
|
|
|
/* If there is more to send set PRUS_MORETOCOME */
|
|
|
|
(resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
|
|
|
|
top, addr, control, td);
|
|
|
|
if (dontroute) {
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
so->so_options &= ~SO_DONTROUTE;
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
}
|
|
|
|
clen = 0;
|
|
|
|
control = NULL;
|
|
|
|
top = NULL;
|
|
|
|
out:
|
|
|
|
if (top != NULL)
|
|
|
|
m_freem(top);
|
|
|
|
if (control != NULL)
|
|
|
|
m_freem(control);
|
|
|
|
return (error);
|
|
|
|
}
|
2005-11-28 18:09:03 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Send on a socket. If send must go all at once and message is larger than
|
|
|
|
* send buffering, then hard error. Lock against other senders. If must go
|
|
|
|
* all at once and not enough room now, then inform user that this would
|
|
|
|
* block and do nothing. Otherwise, if nonblocking, send as much as
|
|
|
|
* possible. The data to be sent is described by "uio" if nonzero, otherwise
|
|
|
|
* by the mbuf chain "top" (which must be null if uio is not). Data provided
|
|
|
|
* in mbuf chain must be small enough to send all at once.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Returns nonzero on error, timeout or signal; callers must check for short
|
|
|
|
* counts if EINTR/ERESTART are returned. Data and control buffers are freed
|
|
|
|
* on return.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2006-01-13 10:22:01 +00:00
|
|
|
#define snderr(errno) { error = (errno); goto release; }
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
soreceive_generic(), and sopoll_generic(). Add new functions sosend(),
soreceive(), and sopoll(), which are wrappers for pru_sosend,
pru_soreceive, and pru_sopoll, and are now used univerally by socket
consumers rather than either directly invoking the old so*() functions
or directly invoking the protocol switch method (about an even split
prior to this commit).
This completes an architectural change that was begun in 1996 to permit
protocols to provide substitute implementations, as now used by UDP.
Consumers now uniformly invoke sosend(), soreceive(), and sopoll() to
perform these operations on sockets -- in particular, distributed file
systems and socket system calls.
Architectural head nod: sam, gnn, wollman
2006-07-24 15:20:08 +00:00
|
|
|
sosend_generic(so, addr, uio, top, control, flags, td)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr *addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct uio *uio;
|
|
|
|
struct mbuf *top;
|
|
|
|
struct mbuf *control;
|
|
|
|
int flags;
|
2005-06-09 19:59:09 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-11-28 18:09:03 +00:00
|
|
|
long space, resid;
|
2005-06-09 19:59:09 +00:00
|
|
|
int clen = 0, error, dontroute;
|
1994-05-24 10:09:53 +00:00
|
|
|
int atomic = sosendallatonce(so) || top;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (uio != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
resid = uio->uio_resid;
|
|
|
|
else
|
|
|
|
resid = top->m_pkthdr.len;
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* In theory resid should be unsigned. However, space must be
|
|
|
|
* signed, as it might be less than 0 if we over-committed, and we
|
|
|
|
* must use a signed comparison of space and resid. On the other
|
|
|
|
* hand, a negative resid causes us to loop sending 0-length
|
|
|
|
* segments to the protocol.
|
1997-11-09 05:07:40 +00:00
|
|
|
*
|
|
|
|
* Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
|
|
|
|
* type sockets since that's an error.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-01-27 21:50:00 +00:00
|
|
|
if (resid < 0 || (so->so_type == SOCK_STREAM && (flags & MSG_EOR))) {
|
1997-11-09 05:07:40 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
dontroute =
|
|
|
|
(flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
|
|
|
|
(so->so_proto->pr_flags & PR_ATOMIC);
|
2005-06-09 19:59:09 +00:00
|
|
|
if (td != NULL)
|
|
|
|
td->td_proc->p_stats->p_ru.ru_msgsnd++;
|
|
|
|
if (control != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
clen = control->m_len;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
restart:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_snd);
|
1994-10-02 17:35:40 +00:00
|
|
|
error = sblock(&so->so_snd, SBLOCKWAIT(flags));
|
|
|
|
if (error)
|
2005-06-09 19:59:09 +00:00
|
|
|
goto out_locked;
|
1994-05-24 10:09:53 +00:00
|
|
|
do {
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_snd);
|
|
|
|
if (so->so_snd.sb_state & SBS_CANTSENDMORE)
|
1994-05-24 10:09:53 +00:00
|
|
|
snderr(EPIPE);
|
1998-02-19 19:38:20 +00:00
|
|
|
if (so->so_error) {
|
|
|
|
error = so->so_error;
|
|
|
|
so->so_error = 0;
|
|
|
|
goto release;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((so->so_state & SS_ISCONNECTED) == 0) {
|
1995-02-07 02:01:16 +00:00
|
|
|
/*
|
|
|
|
* `sendto' and `sendmsg' is allowed on a connection-
|
|
|
|
* based socket if it supports implied connect.
|
|
|
|
* Return ENOTCONN if not connected and no address is
|
|
|
|
* supplied.
|
|
|
|
*/
|
|
|
|
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
|
|
|
|
(so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((so->so_state & SS_ISCONFIRMING) == 0 &&
|
|
|
|
!(resid == 0 && clen != 0))
|
|
|
|
snderr(ENOTCONN);
|
2005-06-09 19:59:09 +00:00
|
|
|
} else if (addr == NULL)
|
1995-02-07 02:01:16 +00:00
|
|
|
snderr(so->so_proto->pr_flags & PR_CONNREQUIRED ?
|
|
|
|
ENOTCONN : EDESTADDRREQ);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
space = sbspace(&so->so_snd);
|
|
|
|
if (flags & MSG_OOB)
|
|
|
|
space += 1024;
|
1994-10-02 17:35:40 +00:00
|
|
|
if ((atomic && resid > so->so_snd.sb_hiwat) ||
|
2002-05-31 11:52:35 +00:00
|
|
|
clen > so->so_snd.sb_hiwat)
|
1994-05-24 10:09:53 +00:00
|
|
|
snderr(EMSGSIZE);
|
2002-02-28 11:22:40 +00:00
|
|
|
if (space < resid + clen &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(atomic || space < so->so_snd.sb_lowat || space < clen)) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if ((so->so_state & SS_NBIO) || (flags & MSG_NBIO))
|
1994-05-24 10:09:53 +00:00
|
|
|
snderr(EWOULDBLOCK);
|
|
|
|
sbunlock(&so->so_snd);
|
|
|
|
error = sbwait(&so->so_snd);
|
|
|
|
if (error)
|
2005-06-09 19:59:09 +00:00
|
|
|
goto out_locked;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
space -= clen;
|
|
|
|
do {
|
2005-11-28 18:09:03 +00:00
|
|
|
if (uio == NULL) {
|
|
|
|
resid = 0;
|
|
|
|
if (flags & MSG_EOR)
|
|
|
|
top->m_flags |= M_EOR;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2005-11-28 18:09:03 +00:00
|
|
|
error = sosend_copyin(uio, &top, atomic,
|
|
|
|
&space, flags);
|
|
|
|
if (error != 0) {
|
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
|
|
|
goto release;
|
At long last, commit the zero copy sockets code.
MAKEDEV: Add MAKEDEV glue for the ti(4) device nodes.
ti.4: Update the ti(4) man page to include information on the
TI_JUMBO_HDRSPLIT and TI_PRIVATE_JUMBOS kernel options,
and also include information about the new character
device interface and the associated ioctls.
man9/Makefile: Add jumbo.9 and zero_copy.9 man pages and associated
links.
jumbo.9: New man page describing the jumbo buffer allocator
interface and operation.
zero_copy.9: New man page describing the general characteristics of
the zero copy send and receive code, and what an
application author should do to take advantage of the
zero copy functionality.
NOTES: Add entries for ZERO_COPY_SOCKETS, TI_PRIVATE_JUMBOS,
TI_JUMBO_HDRSPLIT, MSIZE, and MCLSHIFT.
conf/files: Add uipc_jumbo.c and uipc_cow.c.
conf/options: Add the 5 options mentioned above.
kern_subr.c: Receive side zero copy implementation. This takes
"disposable" pages attached to an mbuf, gives them to
a user process, and then recycles the user's page.
This is only active when ZERO_COPY_SOCKETS is turned on
and the kern.ipc.zero_copy.receive sysctl variable is
set to 1.
uipc_cow.c: Send side zero copy functions. Takes a page written
by the user and maps it copy on write and assigns it
kernel virtual address space. Removes copy on write
mapping once the buffer has been freed by the network
stack.
uipc_jumbo.c: Jumbo disposable page allocator code. This allocates
(optionally) disposable pages for network drivers that
want to give the user the option of doing zero copy
receive.
uipc_socket.c: Add kern.ipc.zero_copy.{send,receive} sysctls that are
enabled if ZERO_COPY_SOCKETS is turned on.
Add zero copy send support to sosend() -- pages get
mapped into the kernel instead of getting copied if
they meet size and alignment restrictions.
uipc_syscalls.c:Un-staticize some of the sf* functions so that they
can be used elsewhere. (uipc_cow.c)
if_media.c: In the SIOCGIFMEDIA ioctl in ifmedia_ioctl(), avoid
calling malloc() with M_WAITOK. Return an error if
the M_NOWAIT malloc fails.
The ti(4) driver and the wi(4) driver, at least, call
this with a mutex held. This causes witness warnings
for 'ifconfig -a' with a wi(4) or ti(4) board in the
system. (I've only verified for ti(4)).
ip_output.c: Fragment large datagrams so that each segment contains
a multiple of PAGE_SIZE amount of data plus headers.
This allows the receiver to potentially do page
flipping on receives.
if_ti.c: Add zero copy receive support to the ti(4) driver. If
TI_PRIVATE_JUMBOS is not defined, it now uses the
jumbo(9) buffer allocator for jumbo receive buffers.
Add a new character device interface for the ti(4)
driver for the new debugging interface. This allows
(a patched version of) gdb to talk to the Tigon board
and debug the firmware. There are also a few additional
debugging ioctls available through this interface.
Add header splitting support to the ti(4) driver.
Tweak some of the default interrupt coalescing
parameters to more useful defaults.
Add hooks for supporting transmit flow control, but
leave it turned off with a comment describing why it
is turned off.
if_tireg.h: Change the firmware rev to 12.4.11, since we're really
at 12.4.11 plus fixes from 12.4.13.
Add defines needed for debugging.
Remove the ti_stats structure, it is now defined in
sys/tiio.h.
ti_fw.h: 12.4.11 firmware.
ti_fw2.h: 12.4.11 firmware, plus selected fixes from 12.4.13,
and my header splitting patches. Revision 12.4.13
doesn't handle 10/100 negotiation properly. (This
firmware is the same as what was in the tree previously,
with the addition of header splitting support.)
sys/jumbo.h: Jumbo buffer allocator interface.
sys/mbuf.h: Add a new external mbuf type, EXT_DISPOSABLE, to
indicate that the payload buffer can be thrown away /
flipped to a userland process.
socketvar.h: Add prototype for socow_setup.
tiio.h: ioctl interface to the character portion of the ti(4)
driver, plus associated structure/type definitions.
uio.h: Change prototype for uiomoveco() so that we'll know
whether the source page is disposable.
ufs_readwrite.c:Update for new prototype of uiomoveco().
vm_fault.c: In vm_fault(), check to see whether we need to do a page
based copy on write fault.
vm_object.c: Add a new function, vm_object_allocate_wait(). This
does the same thing that vm_object allocate does, except
that it gives the caller the opportunity to specify whether
it should wait on the uma_zalloc() of the object structre.
This allows vm objects to be allocated while holding a
mutex. (Without generating WITNESS warnings.)
vm_object_allocate() is implemented as a call to
vm_object_allocate_wait() with the malloc flag set to
M_WAITOK.
vm_object.h: Add prototype for vm_object_allocate_wait().
vm_page.c: Add page-based copy on write setup, clear and fault
routines.
vm_page.h: Add page based COW function prototypes and variable in
the vm_page structure.
Many thanks to Drew Gallatin, who wrote the zero copy send and receive
code, and to all the other folks who have tested and reviewed this code
over the years.
2002-06-26 03:37:47 +00:00
|
|
|
}
|
2005-11-28 18:09:03 +00:00
|
|
|
resid = uio->uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-11-28 18:09:03 +00:00
|
|
|
if (dontroute) {
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
so->so_options |= SO_DONTROUTE;
|
|
|
|
SOCK_UNLOCK(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-11-28 18:09:03 +00:00
|
|
|
/*
|
|
|
|
* XXX all the SBS_CANTSENDMORE checks previously
|
|
|
|
* done could be out of date. We could have recieved
|
|
|
|
* a reset packet in an interrupt or maybe we slept
|
2006-07-23 20:36:04 +00:00
|
|
|
* while doing page faults in uiomove() etc. We
|
|
|
|
* could probably recheck again inside the locking
|
|
|
|
* protection here, but there are probably other
|
|
|
|
* places that this also happens. We must rethink
|
|
|
|
* this.
|
2005-11-28 18:09:03 +00:00
|
|
|
*/
|
|
|
|
error = (*so->so_proto->pr_usrreqs->pru_send)(so,
|
|
|
|
(flags & MSG_OOB) ? PRUS_OOB :
|
1995-02-07 02:01:16 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If the user set MSG_EOF, the protocol understands
|
|
|
|
* this flag and nothing left to send then use
|
|
|
|
* PRU_SEND_EOF instead of PRU_SEND.
|
1995-02-07 02:01:16 +00:00
|
|
|
*/
|
2005-11-28 18:09:03 +00:00
|
|
|
((flags & MSG_EOF) &&
|
|
|
|
(so->so_proto->pr_flags & PR_IMPLOPCL) &&
|
|
|
|
(resid <= 0)) ?
|
1999-01-20 17:32:01 +00:00
|
|
|
PRUS_EOF :
|
2006-07-23 20:36:04 +00:00
|
|
|
/* If there is more to send set PRUS_MORETOCOME. */
|
2005-11-28 18:09:03 +00:00
|
|
|
(resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
|
|
|
|
top, addr, control, td);
|
|
|
|
if (dontroute) {
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
so->so_options &= ~SO_DONTROUTE;
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
}
|
|
|
|
clen = 0;
|
|
|
|
control = NULL;
|
|
|
|
top = NULL;
|
|
|
|
if (error) {
|
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
|
|
|
goto release;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
} while (resid && space > 0);
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
} while (resid);
|
|
|
|
|
|
|
|
release:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
sbunlock(&so->so_snd);
|
2005-06-09 19:59:09 +00:00
|
|
|
out_locked:
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_snd);
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
2005-06-09 19:59:09 +00:00
|
|
|
if (top != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(top);
|
2005-06-09 19:59:09 +00:00
|
|
|
if (control != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(control);
|
|
|
|
return (error);
|
|
|
|
}
|
2006-01-13 10:22:01 +00:00
|
|
|
#undef snderr
|
1994-05-24 10:09:53 +00:00
|
|
|
|
soreceive_generic(), and sopoll_generic(). Add new functions sosend(),
soreceive(), and sopoll(), which are wrappers for pru_sosend,
pru_soreceive, and pru_sopoll, and are now used univerally by socket
consumers rather than either directly invoking the old so*() functions
or directly invoking the protocol switch method (about an even split
prior to this commit).
This completes an architectural change that was begun in 1996 to permit
protocols to provide substitute implementations, as now used by UDP.
Consumers now uniformly invoke sosend(), soreceive(), and sopoll() to
perform these operations on sockets -- in particular, distributed file
systems and socket system calls.
Architectural head nod: sam, gnn, wollman
2006-07-24 15:20:08 +00:00
|
|
|
int
|
|
|
|
sosend(so, addr, uio, top, control, flags, td)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockaddr *addr;
|
|
|
|
struct uio *uio;
|
|
|
|
struct mbuf *top;
|
|
|
|
struct mbuf *control;
|
|
|
|
int flags;
|
|
|
|
struct thread *td;
|
|
|
|
{
|
|
|
|
|
|
|
|
/* XXXRW: Temporary debugging. */
|
|
|
|
KASSERT(so->so_proto->pr_usrreqs->pru_sosend != sosend,
|
|
|
|
("sosend: protocol calls sosend"));
|
|
|
|
|
|
|
|
return (so->so_proto->pr_usrreqs->pru_sosend(so, addr, uio, top,
|
|
|
|
control, flags, td));
|
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* The part of soreceive() that implements reading non-inline out-of-band
|
|
|
|
* data from a socket. For more complete comments, see soreceive(), from
|
|
|
|
* which this code originated.
|
|
|
|
*
|
|
|
|
* Note that soreceive_rcvoob(), unlike the remainder of soreceive(), is
|
|
|
|
* unable to return an mbuf chain to the caller.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
soreceive_rcvoob(so, uio, flags)
|
|
|
|
struct socket *so;
|
|
|
|
struct uio *uio;
|
|
|
|
int flags;
|
|
|
|
{
|
|
|
|
struct protosw *pr = so->so_proto;
|
|
|
|
struct mbuf *m;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
KASSERT(flags & MSG_OOB, ("soreceive_rcvoob: (flags & MSG_OOB) == 0"));
|
|
|
|
|
|
|
|
m = m_get(M_TRYWAIT, MT_DATA);
|
|
|
|
if (m == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
do {
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
if (so_zero_copy_receive) {
|
|
|
|
int disposable;
|
|
|
|
|
|
|
|
if ((m->m_flags & M_EXT)
|
|
|
|
&& (m->m_ext.ext_type == EXT_DISPOSABLE))
|
|
|
|
disposable = 1;
|
|
|
|
else
|
|
|
|
disposable = 0;
|
|
|
|
|
|
|
|
error = uiomoveco(mtod(m, void *),
|
|
|
|
min(uio->uio_resid, m->m_len),
|
|
|
|
uio, disposable);
|
|
|
|
} else
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
error = uiomove(mtod(m, void *),
|
|
|
|
(int) min(uio->uio_resid, m->m_len), uio);
|
|
|
|
m = m_free(m);
|
|
|
|
} while (uio->uio_resid && error == 0 && m);
|
|
|
|
bad:
|
|
|
|
if (m != NULL)
|
|
|
|
m_freem(m);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Following replacement or removal of the first mbuf on the first mbuf chain
|
|
|
|
* of a socket buffer, push necessary state changes back into the socket
|
|
|
|
* buffer so that other consumers see the values consistently. 'nextrecord'
|
|
|
|
* is the callers locally stored value of the original value of
|
|
|
|
* sb->sb_mb->m_nextpkt which must be restored when the lead mbuf changes.
|
|
|
|
* NOTE: 'nextrecord' may be NULL.
|
|
|
|
*/
|
|
|
|
static __inline void
|
|
|
|
sockbuf_pushsync(struct sockbuf *sb, struct mbuf *nextrecord)
|
|
|
|
{
|
|
|
|
|
|
|
|
SOCKBUF_LOCK_ASSERT(sb);
|
|
|
|
/*
|
|
|
|
* First, update for the new value of nextrecord. If necessary, make
|
|
|
|
* it the first record.
|
|
|
|
*/
|
|
|
|
if (sb->sb_mb != NULL)
|
|
|
|
sb->sb_mb->m_nextpkt = nextrecord;
|
|
|
|
else
|
|
|
|
sb->sb_mb = nextrecord;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now update any dependent socket buffer fields to reflect the new
|
|
|
|
* state. This is an expanded inline of SB_EMPTY_FIXUP(), with the
|
|
|
|
* addition of a second clause that takes care of the case where
|
|
|
|
* sb_mb has been updated, but remains the last record.
|
|
|
|
*/
|
|
|
|
if (sb->sb_mb == NULL) {
|
|
|
|
sb->sb_mbtail = NULL;
|
|
|
|
sb->sb_lastrecord = NULL;
|
|
|
|
} else if (sb->sb_mb->m_nextpkt == NULL)
|
|
|
|
sb->sb_lastrecord = sb->sb_mb;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Implement receive operations on a socket. We depend on the way that
|
|
|
|
* records are added to the sockbuf by sbappend. In particular, each record
|
|
|
|
* (mbufs linked through m_next) must begin with an address if the protocol
|
|
|
|
* so specifies, followed by an optional mbuf or mbufs containing ancillary
|
|
|
|
* data, and then zero or more mbufs of data. In order to allow parallelism
|
|
|
|
* between network receive and copying to user space, as well as avoid
|
|
|
|
* sleeping with a mutex held, we release the socket buffer mutex during the
|
|
|
|
* user space copy. Although the sockbuf is locked, new data may still be
|
|
|
|
* appended, and thus we must maintain consistency of the sockbuf during that
|
|
|
|
* time.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
2006-07-23 20:36:04 +00:00
|
|
|
* The caller may receive the data as a single mbuf chain by supplying an
|
|
|
|
* mbuf **mp0 for use in returning the chain. The uio is then used only for
|
|
|
|
* the count in uio_resid.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
soreceive_generic(), and sopoll_generic(). Add new functions sosend(),
soreceive(), and sopoll(), which are wrappers for pru_sosend,
pru_soreceive, and pru_sopoll, and are now used univerally by socket
consumers rather than either directly invoking the old so*() functions
or directly invoking the protocol switch method (about an even split
prior to this commit).
This completes an architectural change that was begun in 1996 to permit
protocols to provide substitute implementations, as now used by UDP.
Consumers now uniformly invoke sosend(), soreceive(), and sopoll() to
perform these operations on sockets -- in particular, distributed file
systems and socket system calls.
Architectural head nod: sam, gnn, wollman
2006-07-24 15:20:08 +00:00
|
|
|
soreceive_generic(so, psa, uio, mp0, controlp, flagsp)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr **psa;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct uio *uio;
|
|
|
|
struct mbuf **mp0;
|
|
|
|
struct mbuf **controlp;
|
|
|
|
int *flagsp;
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct mbuf *m, **mp;
|
|
|
|
int flags, len, error, offset;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct protosw *pr = so->so_proto;
|
|
|
|
struct mbuf *nextrecord;
|
1994-05-25 09:21:21 +00:00
|
|
|
int moff, type = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
int orig_resid = uio->uio_resid;
|
|
|
|
|
|
|
|
mp = mp0;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (psa != NULL)
|
|
|
|
*psa = NULL;
|
|
|
|
if (controlp != NULL)
|
|
|
|
*controlp = NULL;
|
|
|
|
if (flagsp != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
flags = *flagsp &~ MSG_EOR;
|
|
|
|
else
|
|
|
|
flags = 0;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (flags & MSG_OOB)
|
|
|
|
return (soreceive_rcvoob(so, uio, flags));
|
|
|
|
if (mp != NULL)
|
|
|
|
*mp = NULL;
|
|
|
|
if ((pr->pr_flags & PR_WANTRCVD) && (so->so_state & SS_ISCONFIRMING)
|
|
|
|
&& uio->uio_resid)
|
1996-07-11 16:32:50 +00:00
|
|
|
(*pr->pr_usrreqs->pru_rcvd)(so, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
restart:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-10-02 17:35:40 +00:00
|
|
|
error = sblock(&so->so_rcv, SBLOCKWAIT(flags));
|
|
|
|
if (error)
|
2005-06-09 19:59:09 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
m = so->so_rcv.sb_mb;
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If we have less data than requested, block awaiting more (subject
|
|
|
|
* to any timeout) if:
|
1994-05-24 10:09:53 +00:00
|
|
|
* 1. the current count is less than the low water mark, or
|
|
|
|
* 2. MSG_WAITALL is set, and it is possible to do the entire
|
|
|
|
* receive operation at once if we block (resid <= hiwat).
|
|
|
|
* 3. MSG_DONTWAIT is not set
|
|
|
|
* If MSG_WAITALL is set but resid is larger than the receive buffer,
|
2006-07-23 20:36:04 +00:00
|
|
|
* we have to do the receive in sections, and thus risk returning a
|
|
|
|
* short count if a timeout or signal occurs after we start.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-09 19:59:09 +00:00
|
|
|
if (m == NULL || (((flags & MSG_DONTWAIT) == 0 &&
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_rcv.sb_cc < uio->uio_resid) &&
|
|
|
|
(so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
|
|
|
|
((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
|
2005-06-09 19:59:09 +00:00
|
|
|
m->m_nextpkt == NULL && (pr->pr_flags & PR_ATOMIC) == 0)) {
|
|
|
|
KASSERT(m != NULL || !so->so_rcv.sb_cc,
|
|
|
|
("receive: m == %p so->so_rcv.sb_cc == %u",
|
|
|
|
m, so->so_rcv.sb_cc));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (so->so_error) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (m != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto dontblock;
|
|
|
|
error = so->so_error;
|
|
|
|
if ((flags & MSG_PEEK) == 0)
|
|
|
|
so->so_error = 0;
|
|
|
|
goto release;
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m)
|
|
|
|
goto dontblock;
|
|
|
|
else
|
|
|
|
goto release;
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
for (; m != NULL; m = m->m_next)
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
|
|
|
|
m = so->so_rcv.sb_mb;
|
|
|
|
goto dontblock;
|
|
|
|
}
|
|
|
|
if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
|
|
|
|
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
|
|
|
|
error = ENOTCONN;
|
|
|
|
goto release;
|
|
|
|
}
|
2002-05-31 11:52:35 +00:00
|
|
|
if (uio->uio_resid == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto release;
|
2005-06-09 19:59:09 +00:00
|
|
|
if ((so->so_state & SS_NBIO) ||
|
|
|
|
(flags & (MSG_DONTWAIT|MSG_NBIO))) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EWOULDBLOCK;
|
|
|
|
goto release;
|
|
|
|
}
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
sbunlock(&so->so_rcv);
|
|
|
|
error = sbwait(&so->so_rcv);
|
|
|
|
if (error)
|
2005-06-09 19:59:09 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
dontblock:
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* From this point onward, we maintain 'nextrecord' as a cache of the
|
|
|
|
* pointer to the next record in the socket buffer. We must keep the
|
|
|
|
* various socket buffer pointers and local stack versions of the
|
|
|
|
* pointers in sync, pushing out modifications before dropping the
|
|
|
|
* socket buffer mutex, and re-reading them when picking it up.
|
|
|
|
*
|
|
|
|
* Otherwise, we will race with the network stack appending new data
|
|
|
|
* or records onto the socket buffer by using inconsistent/stale
|
|
|
|
* versions of the field, possibly resulting in socket buffer
|
|
|
|
* corruption.
|
|
|
|
*
|
|
|
|
* By holding the high-level sblock(), we prevent simultaneous
|
|
|
|
* readers from pulling off the front of the socket buffer.
|
|
|
|
*/
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
if (uio->uio_td)
|
|
|
|
uio->uio_td->td_proc->p_stats->p_ru.ru_msgrcv++;
|
|
|
|
KASSERT(m == so->so_rcv.sb_mb, ("soreceive: m != so->so_rcv.sb_mb"));
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
nextrecord = m->m_nextpkt;
|
|
|
|
if (pr->pr_flags & PR_ADDR) {
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT(m->m_type == MT_SONAME,
|
|
|
|
("m->m_type == %d", m->m_type));
|
1994-05-24 10:09:53 +00:00
|
|
|
orig_resid = 0;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (psa != NULL)
|
|
|
|
*psa = sodupsockaddr(mtod(m, struct sockaddr *),
|
|
|
|
M_NOWAIT);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (flags & MSG_PEEK) {
|
|
|
|
m = m->m_next;
|
|
|
|
} else {
|
|
|
|
sbfree(&so->so_rcv, m);
|
2002-02-05 02:00:56 +00:00
|
|
|
so->so_rcv.sb_mb = m_free(m);
|
1997-08-16 19:16:27 +00:00
|
|
|
m = so->so_rcv.sb_mb;
|
2005-06-09 19:59:09 +00:00
|
|
|
sockbuf_pushsync(&so->so_rcv, nextrecord);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Process one or more MT_CONTROL mbufs present before any data mbufs
|
|
|
|
* in the first mbuf chain on the socket buffer. If MSG_PEEK, we
|
|
|
|
* just copy the data; if !MSG_PEEK, we call into the protocol to
|
|
|
|
* perform externalization (or freeing if controlp == NULL).
|
|
|
|
*/
|
|
|
|
if (m != NULL && m->m_type == MT_CONTROL) {
|
|
|
|
struct mbuf *cm = NULL, *cmn;
|
|
|
|
struct mbuf **cme = &cm;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (flags & MSG_PEEK) {
|
|
|
|
if (controlp != NULL) {
|
|
|
|
*controlp = m_copy(m, 0, m->m_len);
|
|
|
|
controlp = &(*controlp)->m_next;
|
|
|
|
}
|
|
|
|
m = m->m_next;
|
2005-06-09 19:56:38 +00:00
|
|
|
} else {
|
2005-06-09 19:59:09 +00:00
|
|
|
sbfree(&so->so_rcv, m);
|
|
|
|
so->so_rcv.sb_mb = m->m_next;
|
|
|
|
m->m_next = NULL;
|
|
|
|
*cme = m;
|
|
|
|
cme = &(*cme)->m_next;
|
2004-07-11 23:13:14 +00:00
|
|
|
m = so->so_rcv.sb_mb;
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
} while (m != NULL && m->m_type == MT_CONTROL);
|
|
|
|
if ((flags & MSG_PEEK) == 0)
|
|
|
|
sockbuf_pushsync(&so->so_rcv, nextrecord);
|
|
|
|
while (cm != NULL) {
|
|
|
|
cmn = cm->m_next;
|
|
|
|
cm->m_next = NULL;
|
|
|
|
if (pr->pr_domain->dom_externalize != NULL) {
|
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
|
|
|
error = (*pr->pr_domain->dom_externalize)
|
|
|
|
(cm, controlp);
|
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
|
|
|
} else if (controlp != NULL)
|
|
|
|
*controlp = cm;
|
|
|
|
else
|
|
|
|
m_freem(cm);
|
|
|
|
if (controlp != NULL) {
|
|
|
|
orig_resid = 0;
|
|
|
|
while (*controlp != NULL)
|
|
|
|
controlp = &(*controlp)->m_next;
|
|
|
|
}
|
|
|
|
cm = cmn;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2006-08-18 14:05:13 +00:00
|
|
|
if (m != NULL)
|
2005-07-28 10:10:01 +00:00
|
|
|
nextrecord = so->so_rcv.sb_mb->m_nextpkt;
|
|
|
|
else
|
2006-08-18 14:05:13 +00:00
|
|
|
nextrecord = so->so_rcv.sb_mb;
|
2005-06-09 19:59:09 +00:00
|
|
|
orig_resid = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
if (m != NULL) {
|
2003-10-28 05:47:40 +00:00
|
|
|
if ((flags & MSG_PEEK) == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT(m->m_nextpkt == nextrecord,
|
|
|
|
("soreceive: post-control, nextrecord !sync"));
|
2003-10-28 05:47:40 +00:00
|
|
|
if (nextrecord == NULL) {
|
|
|
|
KASSERT(so->so_rcv.sb_mb == m,
|
2005-06-09 19:59:09 +00:00
|
|
|
("soreceive: post-control, sb_mb!=m"));
|
|
|
|
KASSERT(so->so_rcv.sb_lastrecord == m,
|
|
|
|
("soreceive: post-control, lastrecord!=m"));
|
2003-10-28 05:47:40 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
type = m->m_type;
|
|
|
|
if (type == MT_OOBDATA)
|
|
|
|
flags |= MSG_OOB;
|
2003-10-28 05:47:40 +00:00
|
|
|
} else {
|
|
|
|
if ((flags & MSG_PEEK) == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
KASSERT(so->so_rcv.sb_mb == nextrecord,
|
|
|
|
("soreceive: sb_mb != nextrecord"));
|
|
|
|
if (so->so_rcv.sb_mb == NULL) {
|
|
|
|
KASSERT(so->so_rcv.sb_lastrecord == NULL,
|
|
|
|
("soreceive: sb_lastercord != NULL"));
|
|
|
|
}
|
2003-10-28 05:47:40 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* Now continue to read any data mbufs off of the head of the socket
|
|
|
|
* buffer until the read request is satisfied. Note that 'type' is
|
|
|
|
* used to store the type of any mbuf reads that have happened so far
|
|
|
|
* such that soreceive() can stop reading if the type changes, which
|
|
|
|
* causes soreceive() to return only one of regular data and inline
|
|
|
|
* out-of-band data in a single socket receive operation.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
moff = 0;
|
|
|
|
offset = 0;
|
2005-06-09 19:59:09 +00:00
|
|
|
while (m != NULL && uio->uio_resid > 0 && error == 0) {
|
|
|
|
/*
|
|
|
|
* If the type of mbuf has changed since the last mbuf
|
|
|
|
* examined ('type'), end the receive operation.
|
|
|
|
*/
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m->m_type == MT_OOBDATA) {
|
|
|
|
if (type != MT_OOBDATA)
|
|
|
|
break;
|
|
|
|
} else if (type == MT_OOBDATA)
|
|
|
|
break;
|
1999-01-08 17:31:30 +00:00
|
|
|
else
|
2005-11-02 13:46:32 +00:00
|
|
|
KASSERT(m->m_type == MT_DATA,
|
2005-06-09 19:59:09 +00:00
|
|
|
("m->m_type == %d", m->m_type));
|
|
|
|
so->so_rcv.sb_state &= ~SBS_RCVATMARK;
|
1994-05-24 10:09:53 +00:00
|
|
|
len = uio->uio_resid;
|
|
|
|
if (so->so_oobmark && len > so->so_oobmark - offset)
|
|
|
|
len = so->so_oobmark - offset;
|
|
|
|
if (len > m->m_len - moff)
|
|
|
|
len = m->m_len - moff;
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If mp is set, just pass back the mbufs. Otherwise copy
|
|
|
|
* them out via the uio, then free. Sockbuf must be
|
|
|
|
* consistent here (points to current mbuf, it points to next
|
|
|
|
* record) when we drop priority; we must note any additions
|
|
|
|
* to the sockbuf when we block interrupts again.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-09 19:59:09 +00:00
|
|
|
if (mp == NULL) {
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
|
|
|
#ifdef ZERO_COPY_SOCKETS
|
|
|
|
if (so_zero_copy_receive) {
|
|
|
|
int disposable;
|
|
|
|
|
|
|
|
if ((m->m_flags & M_EXT)
|
|
|
|
&& (m->m_ext.ext_type == EXT_DISPOSABLE))
|
|
|
|
disposable = 1;
|
|
|
|
else
|
|
|
|
disposable = 0;
|
|
|
|
|
|
|
|
error = uiomoveco(mtod(m, char *) + moff,
|
|
|
|
(int)len, uio,
|
|
|
|
disposable);
|
|
|
|
} else
|
|
|
|
#endif /* ZERO_COPY_SOCKETS */
|
|
|
|
error = uiomove(mtod(m, char *) + moff, (int)len, uio);
|
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
1996-11-29 19:03:42 +00:00
|
|
|
if (error)
|
|
|
|
goto release;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
|
|
|
uio->uio_resid -= len;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (len == m->m_len - moff) {
|
|
|
|
if (m->m_flags & M_EOR)
|
|
|
|
flags |= MSG_EOR;
|
|
|
|
if (flags & MSG_PEEK) {
|
|
|
|
m = m->m_next;
|
|
|
|
moff = 0;
|
|
|
|
} else {
|
|
|
|
nextrecord = m->m_nextpkt;
|
|
|
|
sbfree(&so->so_rcv, m);
|
2005-06-09 19:59:09 +00:00
|
|
|
if (mp != NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
*mp = m;
|
|
|
|
mp = &m->m_next;
|
|
|
|
so->so_rcv.sb_mb = m = m->m_next;
|
2005-06-09 19:59:09 +00:00
|
|
|
*mp = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2005-06-09 19:59:09 +00:00
|
|
|
so->so_rcv.sb_mb = m_free(m);
|
|
|
|
m = so->so_rcv.sb_mb;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-09-06 17:05:11 +00:00
|
|
|
sockbuf_pushsync(&so->so_rcv, nextrecord);
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (flags & MSG_PEEK)
|
|
|
|
moff += len;
|
|
|
|
else {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (mp != NULL) {
|
|
|
|
int copy_flag;
|
|
|
|
|
|
|
|
if (flags & MSG_DONTWAIT)
|
|
|
|
copy_flag = M_DONTWAIT;
|
|
|
|
else
|
|
|
|
copy_flag = M_TRYWAIT;
|
|
|
|
if (copy_flag == M_TRYWAIT)
|
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
|
|
|
*mp = m_copym(m, 0, len, copy_flag);
|
|
|
|
if (copy_flag == M_TRYWAIT)
|
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
|
|
|
if (*mp == NULL) {
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* m_copym() couldn't
|
|
|
|
* allocate an mbuf. Adjust
|
|
|
|
* uio_resid back (it was
|
|
|
|
* adjusted down by len
|
|
|
|
* bytes, which we didn't end
|
2005-06-09 19:59:09 +00:00
|
|
|
* up "copying" over).
|
|
|
|
*/
|
|
|
|
uio->uio_resid += len;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
m->m_data += len;
|
|
|
|
m->m_len -= len;
|
|
|
|
so->so_rcv.sb_cc -= len;
|
|
|
|
}
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (so->so_oobmark) {
|
|
|
|
if ((flags & MSG_PEEK) == 0) {
|
|
|
|
so->so_oobmark -= len;
|
|
|
|
if (so->so_oobmark == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
so->so_rcv.sb_state |= SBS_RCVATMARK;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
offset += len;
|
|
|
|
if (offset == so->so_oobmark)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (flags & MSG_EOR)
|
|
|
|
break;
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If the MSG_WAITALL flag is set (for non-atomic socket), we
|
|
|
|
* must not quit until "uio->uio_resid == 0" or an error
|
|
|
|
* termination. If a signal/timeout occurs, return with a
|
|
|
|
* short count but without error. Keep sockbuf locked
|
|
|
|
* against other readers.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-09 19:59:09 +00:00
|
|
|
while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
|
|
|
|
!sosendallatonce(so) && nextrecord == NULL) {
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
if (so->so_error || so->so_rcv.sb_state & SBS_CANTRCVMORE)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
2001-03-16 22:37:06 +00:00
|
|
|
/*
|
2005-06-09 19:59:09 +00:00
|
|
|
* Notify the protocol that some data has been
|
|
|
|
* drained before blocking.
|
2001-03-16 22:37:06 +00:00
|
|
|
*/
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
if (pr->pr_flags & PR_WANTRCVD) {
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
2001-03-16 22:37:06 +00:00
|
|
|
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
|
|
|
}
|
2003-10-28 05:47:40 +00:00
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = sbwait(&so->so_rcv);
|
2005-06-09 19:59:09 +00:00
|
|
|
if (error)
|
|
|
|
goto release;
|
1994-10-02 17:35:40 +00:00
|
|
|
m = so->so_rcv.sb_mb;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (m != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
nextrecord = m->m_nextpkt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
if (m != NULL && pr->pr_flags & PR_ATOMIC) {
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= MSG_TRUNC;
|
2004-07-10 04:38:06 +00:00
|
|
|
if ((flags & MSG_PEEK) == 0)
|
2005-06-09 19:59:09 +00:00
|
|
|
(void) sbdroprecord_locked(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if ((flags & MSG_PEEK) == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (m == NULL) {
|
2003-10-28 05:47:40 +00:00
|
|
|
/*
|
|
|
|
* First part is an inline SB_EMPTY_FIXUP(). Second
|
|
|
|
* part makes sure sb_lastrecord is up-to-date if
|
|
|
|
* there is still data in the socket buffer.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_rcv.sb_mb = nextrecord;
|
2003-10-28 05:47:40 +00:00
|
|
|
if (so->so_rcv.sb_mb == NULL) {
|
|
|
|
so->so_rcv.sb_mbtail = NULL;
|
|
|
|
so->so_rcv.sb_lastrecord = NULL;
|
|
|
|
} else if (nextrecord->m_nextpkt == NULL)
|
|
|
|
so->so_rcv.sb_lastrecord = nextrecord;
|
|
|
|
}
|
|
|
|
SBLASTRECORDCHK(&so->so_rcv);
|
|
|
|
SBLASTMBUFCHK(&so->so_rcv);
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If soreceive() is being done from the socket callback,
|
|
|
|
* then don't need to generate ACK to peer to update window,
|
|
|
|
* since ACK will be generated on return to TCP.
|
2005-06-09 19:59:09 +00:00
|
|
|
*/
|
2006-07-16 23:09:39 +00:00
|
|
|
if (!(flags & MSG_SOCALLBCK) &&
|
Chance protocol switch method pru_detach() so that it returns void
rather than an error. Detaches do not "fail", they other occur or
the protocol flags SS_PROTOREF to take ownership of the socket.
soclose() no longer looks at so_pcb to see if it's NULL, relying
entirely on the protocol to decide whether it's time to free the
socket or not using SS_PROTOREF. so_pcb is now entirely owned and
managed by the protocol code. Likewise, no longer test so_pcb in
other socket functions, such as soreceive(), which have no business
digging into protocol internals.
Protocol detach routines no longer try to free the socket on detach,
this is performed in the socket code if the protocol permits it.
In rts_detach(), no longer test for rp != NULL in detach, and
likewise in other protocols that don't permit a NULL so_pcb, reduce
the incidence of testing for it during detach.
netinet and netinet6 are not fully updated to this change, which
will be in an upcoming commit. In their current state they may leak
memory or panic.
MFC after: 3 months
2006-04-01 15:42:02 +00:00
|
|
|
(pr->pr_flags & PR_WANTRCVD)) {
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
1996-07-11 16:32:50 +00:00
|
|
|
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (orig_resid == uio->uio_resid && orig_resid &&
|
2005-06-09 19:59:09 +00:00
|
|
|
(flags & MSG_EOR) == 0 && (so->so_rcv.sb_state & SBS_CANTRCVMORE) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
sbunlock(&so->so_rcv);
|
|
|
|
goto restart;
|
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (flagsp != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
*flagsp |= flags;
|
|
|
|
release:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
sbunlock(&so->so_rcv);
|
2005-06-09 19:59:09 +00:00
|
|
|
out:
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
soreceive_generic(), and sopoll_generic(). Add new functions sosend(),
soreceive(), and sopoll(), which are wrappers for pru_sosend,
pru_soreceive, and pru_sopoll, and are now used univerally by socket
consumers rather than either directly invoking the old so*() functions
or directly invoking the protocol switch method (about an even split
prior to this commit).
This completes an architectural change that was begun in 1996 to permit
protocols to provide substitute implementations, as now used by UDP.
Consumers now uniformly invoke sosend(), soreceive(), and sopoll() to
perform these operations on sockets -- in particular, distributed file
systems and socket system calls.
Architectural head nod: sam, gnn, wollman
2006-07-24 15:20:08 +00:00
|
|
|
int
|
|
|
|
soreceive(so, psa, uio, mp0, controlp, flagsp)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockaddr **psa;
|
|
|
|
struct uio *uio;
|
|
|
|
struct mbuf **mp0;
|
|
|
|
struct mbuf **controlp;
|
|
|
|
int *flagsp;
|
|
|
|
{
|
|
|
|
|
|
|
|
/* XXXRW: Temporary debugging. */
|
|
|
|
KASSERT(so->so_proto->pr_usrreqs->pru_soreceive != soreceive,
|
|
|
|
("soreceive: protocol calls soreceive"));
|
|
|
|
|
|
|
|
return (so->so_proto->pr_usrreqs->pru_soreceive(so, psa, uio, mp0,
|
|
|
|
controlp, flagsp));
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
soshutdown(so, how)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
|
|
|
int how;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct protosw *pr = so->so_proto;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-02-27 13:48:07 +00:00
|
|
|
if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (how != SHUT_WR)
|
1994-05-24 10:09:53 +00:00
|
|
|
sorflush(so);
|
2001-02-27 13:48:07 +00:00
|
|
|
if (how != SHUT_RD)
|
1996-07-11 16:32:50 +00:00
|
|
|
return ((*pr->pr_usrreqs->pru_shutdown)(so));
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
sorflush(so)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct sockbuf *sb = &so->so_rcv;
|
|
|
|
struct protosw *pr = so->so_proto;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sockbuf asb;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* XXXRW: This is quite ugly. Previously, this code made a copy of
|
|
|
|
* the socket buffer, then zero'd the original to clear the buffer
|
|
|
|
* fields. However, with mutexes in the socket buffer, this causes
|
|
|
|
* problems. We only clear the zeroable bits of the original;
|
|
|
|
* however, we have to initialize and destroy the mutex in the copy
|
|
|
|
* so that dom_dispose() and sbrelease() can lock t as needed.
|
|
|
|
*/
|
|
|
|
SOCKBUF_LOCK(sb);
|
1994-05-24 10:09:53 +00:00
|
|
|
sb->sb_flags |= SB_NOINTR;
|
2003-02-19 05:47:46 +00:00
|
|
|
(void) sblock(sb, M_WAITOK);
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
|
|
|
* socantrcvmore_locked() drops the socket buffer mutex so that it
|
|
|
|
* can safely perform wakeups. Re-acquire the mutex before
|
|
|
|
* continuing.
|
|
|
|
*/
|
|
|
|
socantrcvmore_locked(so);
|
|
|
|
SOCKBUF_LOCK(sb);
|
1994-05-24 10:09:53 +00:00
|
|
|
sbunlock(sb);
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Invalidate/clear most of the sockbuf structure, but leave selinfo
|
|
|
|
* and mutex data unchanged.
|
2005-06-09 19:59:09 +00:00
|
|
|
*/
|
|
|
|
bzero(&asb, offsetof(struct sockbuf, sb_startzero));
|
|
|
|
bcopy(&sb->sb_startzero, &asb.sb_startzero,
|
|
|
|
sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
|
|
|
|
bzero(&sb->sb_startzero,
|
|
|
|
sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
|
|
|
|
SOCKBUF_UNLOCK(sb);
|
|
|
|
|
|
|
|
SOCKBUF_LOCK_INIT(&asb, "so_rcv");
|
|
|
|
if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose != NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
(*pr->pr_domain->dom_dispose)(asb.sb_mb);
|
1999-10-09 20:42:17 +00:00
|
|
|
sbrelease(&asb, so);
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK_DESTROY(&asb);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Perhaps this routine, and sooptcopyout(), below, ought to come in an
|
|
|
|
* additional variant to handle the case where the option value needs to be
|
|
|
|
* some kind of integer, but not a specific size. In addition to their use
|
|
|
|
* here, these functions are also called by the protocol-level pr_ctloutput()
|
|
|
|
* routines.
|
1998-08-23 03:07:17 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1998-08-23 03:07:17 +00:00
|
|
|
sooptcopyin(sopt, buf, len, minlen)
|
|
|
|
struct sockopt *sopt;
|
|
|
|
void *buf;
|
|
|
|
size_t len;
|
|
|
|
size_t minlen;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-08-23 03:07:17 +00:00
|
|
|
size_t valsize;
|
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* If the user gives us more than we wanted, we ignore it, but if we
|
|
|
|
* don't get the minimum length the caller wants, we return EINVAL.
|
|
|
|
* On success, sopt->sopt_valsize is set to however much we actually
|
|
|
|
* retrieved.
|
1998-08-23 03:07:17 +00:00
|
|
|
*/
|
|
|
|
if ((valsize = sopt->sopt_valsize) < minlen)
|
|
|
|
return EINVAL;
|
|
|
|
if (valsize > len)
|
|
|
|
sopt->sopt_valsize = valsize = len;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (sopt->sopt_td != NULL)
|
1998-08-23 03:07:17 +00:00
|
|
|
return (copyin(sopt->sopt_val, buf, valsize));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
bcopy(sopt->sopt_val, buf, valsize);
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1998-08-23 03:07:17 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Kernel version of setsockopt(2).
|
|
|
|
*
|
2005-06-09 19:59:09 +00:00
|
|
|
* XXX: optlen is size_t, not socklen_t
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
so_setsockopt(struct socket *so, int level, int optname, void *optval,
|
|
|
|
size_t optlen)
|
|
|
|
{
|
|
|
|
struct sockopt sopt;
|
|
|
|
|
|
|
|
sopt.sopt_level = level;
|
|
|
|
sopt.sopt_name = optname;
|
|
|
|
sopt.sopt_dir = SOPT_SET;
|
|
|
|
sopt.sopt_val = optval;
|
|
|
|
sopt.sopt_valsize = optlen;
|
|
|
|
sopt.sopt_td = NULL;
|
|
|
|
return (sosetopt(so, &sopt));
|
|
|
|
}
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
int
|
|
|
|
sosetopt(so, sopt)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
{
|
|
|
|
int error, optval;
|
|
|
|
struct linger l;
|
|
|
|
struct timeval tv;
|
1999-05-21 15:54:40 +00:00
|
|
|
u_long val;
|
2005-06-09 19:59:09 +00:00
|
|
|
#ifdef MAC
|
|
|
|
struct mac extmac;
|
|
|
|
#endif
|
1998-08-23 03:07:17 +00:00
|
|
|
|
|
|
|
error = 0;
|
|
|
|
if (sopt->sopt_level != SOL_SOCKET) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (so->so_proto && so->so_proto->pr_ctloutput)
|
|
|
|
return ((*so->so_proto->pr_ctloutput)
|
1998-08-23 03:07:17 +00:00
|
|
|
(so, sopt));
|
1994-05-24 10:09:53 +00:00
|
|
|
error = ENOPROTOOPT;
|
|
|
|
} else {
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
2000-11-20 01:35:25 +00:00
|
|
|
#ifdef INET
|
|
|
|
case SO_ACCEPTFILTER:
|
|
|
|
error = do_setopt_accept_filter(so, sopt);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
break;
|
2005-06-09 19:59:09 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
case SO_LINGER:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &l, sizeof l, sizeof l);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
1998-08-23 03:07:17 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_LOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
so->so_linger = l.l_linger;
|
|
|
|
if (l.l_onoff)
|
|
|
|
so->so_options |= SO_LINGER;
|
|
|
|
else
|
|
|
|
so->so_options &= ~SO_LINGER;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_UNLOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_DEBUG:
|
|
|
|
case SO_KEEPALIVE:
|
|
|
|
case SO_DONTROUTE:
|
|
|
|
case SO_USELOOPBACK:
|
|
|
|
case SO_BROADCAST:
|
|
|
|
case SO_REUSEADDR:
|
|
|
|
case SO_REUSEPORT:
|
|
|
|
case SO_OOBINLINE:
|
1996-05-09 20:15:26 +00:00
|
|
|
case SO_TIMESTAMP:
|
2005-06-09 19:59:09 +00:00
|
|
|
case SO_BINTIME:
|
|
|
|
case SO_NOSIGPIPE:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &optval, sizeof optval,
|
|
|
|
sizeof optval);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_LOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
if (optval)
|
|
|
|
so->so_options |= sopt->sopt_name;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
1998-08-23 03:07:17 +00:00
|
|
|
so->so_options &= ~sopt->sopt_name;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_UNLOCK(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SNDBUF:
|
|
|
|
case SO_RCVBUF:
|
|
|
|
case SO_SNDLOWAT:
|
|
|
|
case SO_RCVLOWAT:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &optval, sizeof optval,
|
|
|
|
sizeof optval);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
1997-06-27 15:28:54 +00:00
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Values < 1 make no sense for any of these options,
|
|
|
|
* so disallow them.
|
1997-06-27 15:28:54 +00:00
|
|
|
*/
|
|
|
|
if (optval < 1) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case SO_SNDBUF:
|
|
|
|
case SO_RCVBUF:
|
1998-08-23 03:07:17 +00:00
|
|
|
if (sbreserve(sopt->sopt_name == SO_SNDBUF ?
|
1999-10-09 20:42:17 +00:00
|
|
|
&so->so_snd : &so->so_rcv, (u_long)optval,
|
2005-06-09 19:59:09 +00:00
|
|
|
so, curthread) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = ENOBUFS;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1997-06-27 15:28:54 +00:00
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Make sure the low-water is never greater than the
|
|
|
|
* high-water.
|
1997-06-27 15:28:54 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
case SO_SNDLOWAT:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
1997-06-27 15:28:54 +00:00
|
|
|
so->so_snd.sb_lowat =
|
|
|
|
(optval > so->so_snd.sb_hiwat) ?
|
|
|
|
so->so_snd.sb_hiwat : optval;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case SO_RCVLOWAT:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
1997-06-27 15:28:54 +00:00
|
|
|
so->so_rcv.sb_lowat =
|
|
|
|
(optval > so->so_rcv.sb_hiwat) ?
|
|
|
|
so->so_rcv.sb_hiwat : optval;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SNDTIMEO:
|
|
|
|
case SO_RCVTIMEO:
|
2005-10-27 04:26:35 +00:00
|
|
|
#ifdef COMPAT_IA32
|
|
|
|
if (curthread->td_proc->p_sysent == &ia32_freebsd_sysvec) {
|
|
|
|
struct timeval32 tv32;
|
|
|
|
|
|
|
|
error = sooptcopyin(sopt, &tv32, sizeof tv32,
|
|
|
|
sizeof tv32);
|
|
|
|
CP(tv32, tv, tv_sec);
|
|
|
|
CP(tv32, tv, tv_usec);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
error = sooptcopyin(sopt, &tv, sizeof tv,
|
|
|
|
sizeof tv);
|
1998-08-23 03:07:17 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
1998-08-23 03:07:17 +00:00
|
|
|
|
1999-05-21 15:54:40 +00:00
|
|
|
/* assert(hz > 0); */
|
2005-06-09 19:59:09 +00:00
|
|
|
if (tv.tv_sec < 0 || tv.tv_sec > INT_MAX / hz ||
|
1999-05-21 15:54:40 +00:00
|
|
|
tv.tv_usec < 0 || tv.tv_usec >= 1000000) {
|
|
|
|
error = EDOM;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
/* assert(tick > 0); */
|
2005-06-09 19:59:09 +00:00
|
|
|
/* assert(ULONG_MAX - INT_MAX >= 1000000); */
|
1999-05-21 15:54:40 +00:00
|
|
|
val = (u_long)(tv.tv_sec * hz) + tv.tv_usec / tick;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (val > INT_MAX) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EDOM;
|
|
|
|
goto bad;
|
|
|
|
}
|
2002-11-27 13:34:04 +00:00
|
|
|
if (val == 0 && tv.tv_usec != 0)
|
|
|
|
val = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case SO_SNDTIMEO:
|
|
|
|
so->so_snd.sb_timeo = val;
|
|
|
|
break;
|
|
|
|
case SO_RCVTIMEO:
|
|
|
|
so->so_rcv.sb_timeo = val;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2005-09-18 21:08:03 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
case SO_LABEL:
|
|
|
|
#ifdef MAC
|
|
|
|
error = sooptcopyin(sopt, &extmac, sizeof extmac,
|
|
|
|
sizeof extmac);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
error = mac_setsockopt_label(sopt->sopt_td->td_ucred,
|
|
|
|
so, &extmac);
|
|
|
|
#else
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
#endif
|
|
|
|
break;
|
2005-09-18 21:08:03 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
if (error == 0 && so->so_proto != NULL &&
|
|
|
|
so->so_proto->pr_ctloutput != NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
(void) ((*so->so_proto->pr_ctloutput)
|
1998-08-23 03:07:17 +00:00
|
|
|
(so, sopt));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
bad:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2006-07-23 20:36:04 +00:00
|
|
|
/*
|
|
|
|
* Helper routine for getsockopt.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2003-08-05 00:27:54 +00:00
|
|
|
sooptcopyout(struct sockopt *sopt, const void *buf, size_t len)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-08-23 03:07:17 +00:00
|
|
|
int error;
|
|
|
|
size_t valsize;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
/*
|
2006-07-23 20:36:04 +00:00
|
|
|
* Documented get behavior is that we always return a value, possibly
|
|
|
|
* truncated to fit in the user's buffer. Traditional behavior is
|
|
|
|
* that we always tell the user precisely how much we copied, rather
|
|
|
|
* than something useful like the total amount we had available for
|
|
|
|
* her. Note that this interface is not idempotent; the entire
|
|
|
|
* answer must generated ahead of time.
|
1998-08-23 03:07:17 +00:00
|
|
|
*/
|
1998-08-31 15:34:55 +00:00
|
|
|
valsize = min(len, sopt->sopt_valsize);
|
1998-08-31 18:07:23 +00:00
|
|
|
sopt->sopt_valsize = valsize;
|
2005-06-09 19:59:09 +00:00
|
|
|
if (sopt->sopt_val != NULL) {
|
|
|
|
if (sopt->sopt_td != NULL)
|
1998-08-23 03:07:17 +00:00
|
|
|
error = copyout(buf, sopt->sopt_val, valsize);
|
|
|
|
else
|
|
|
|
bcopy(buf, sopt->sopt_val, valsize);
|
|
|
|
}
|
2006-02-12 15:00:27 +00:00
|
|
|
return (error);
|
1998-08-23 03:07:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sogetopt(so, sopt)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
{
|
|
|
|
int error, optval;
|
|
|
|
struct linger l;
|
|
|
|
struct timeval tv;
|
2005-06-09 19:59:09 +00:00
|
|
|
#ifdef MAC
|
|
|
|
struct mac extmac;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
error = 0;
|
|
|
|
if (sopt->sopt_level != SOL_SOCKET) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (so->so_proto && so->so_proto->pr_ctloutput) {
|
|
|
|
return ((*so->so_proto->pr_ctloutput)
|
1998-08-23 03:07:17 +00:00
|
|
|
(so, sopt));
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
|
|
|
return (ENOPROTOOPT);
|
|
|
|
} else {
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
2000-11-20 01:35:25 +00:00
|
|
|
#ifdef INET
|
2000-06-20 01:09:23 +00:00
|
|
|
case SO_ACCEPTFILTER:
|
2005-06-09 19:59:09 +00:00
|
|
|
error = do_getopt_accept_filter(so, sopt);
|
2000-06-20 01:09:23 +00:00
|
|
|
break;
|
2005-06-09 19:59:09 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
case SO_LINGER:
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_LOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
l.l_onoff = so->so_options & SO_LINGER;
|
|
|
|
l.l_linger = so->so_linger;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCK_UNLOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyout(sopt, &l, sizeof l);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_USELOOPBACK:
|
|
|
|
case SO_DONTROUTE:
|
|
|
|
case SO_DEBUG:
|
|
|
|
case SO_KEEPALIVE:
|
|
|
|
case SO_REUSEADDR:
|
|
|
|
case SO_REUSEPORT:
|
|
|
|
case SO_BROADCAST:
|
|
|
|
case SO_OOBINLINE:
|
2005-08-01 21:15:09 +00:00
|
|
|
case SO_ACCEPTCONN:
|
1996-05-09 20:15:26 +00:00
|
|
|
case SO_TIMESTAMP:
|
2005-06-09 19:59:09 +00:00
|
|
|
case SO_BINTIME:
|
|
|
|
case SO_NOSIGPIPE:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_options & sopt->sopt_name;
|
|
|
|
integer:
|
|
|
|
error = sooptcopyout(sopt, &optval, sizeof optval);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_TYPE:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_type;
|
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_ERROR:
|
2006-06-18 19:02:49 +00:00
|
|
|
SOCK_LOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_error;
|
1994-05-24 10:09:53 +00:00
|
|
|
so->so_error = 0;
|
2006-06-18 19:02:49 +00:00
|
|
|
SOCK_UNLOCK(so);
|
1998-08-23 03:07:17 +00:00
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_SNDBUF:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_snd.sb_hiwat;
|
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_RCVBUF:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_rcv.sb_hiwat;
|
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_SNDLOWAT:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_snd.sb_lowat;
|
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_RCVLOWAT:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = so->so_rcv.sb_lowat;
|
|
|
|
goto integer;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case SO_SNDTIMEO:
|
|
|
|
case SO_RCVTIMEO:
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = (sopt->sopt_name == SO_SNDTIMEO ?
|
|
|
|
so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
|
|
|
|
|
|
|
|
tv.tv_sec = optval / hz;
|
|
|
|
tv.tv_usec = (optval % hz) * tick;
|
2005-10-27 04:26:35 +00:00
|
|
|
#ifdef COMPAT_IA32
|
|
|
|
if (curthread->td_proc->p_sysent == &ia32_freebsd_sysvec) {
|
|
|
|
struct timeval32 tv32;
|
|
|
|
|
|
|
|
CP(tv, tv32, tv_sec);
|
|
|
|
CP(tv, tv32, tv_usec);
|
|
|
|
error = sooptcopyout(sopt, &tv32, sizeof tv32);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
error = sooptcopyout(sopt, &tv, sizeof tv);
|
2005-06-09 19:59:09 +00:00
|
|
|
break;
|
2005-09-18 21:08:03 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
case SO_LABEL:
|
|
|
|
#ifdef MAC
|
|
|
|
error = sooptcopyin(sopt, &extmac, sizeof(extmac),
|
|
|
|
sizeof(extmac));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = mac_getsockopt_label(sopt->sopt_td->td_ucred,
|
|
|
|
so, &extmac);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = sooptcopyout(sopt, &extmac, sizeof extmac);
|
|
|
|
#else
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
#endif
|
|
|
|
break;
|
2005-09-18 21:08:03 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
case SO_PEERLABEL:
|
|
|
|
#ifdef MAC
|
|
|
|
error = sooptcopyin(sopt, &extmac, sizeof(extmac),
|
|
|
|
sizeof(extmac));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = mac_getsockopt_peerlabel(
|
|
|
|
sopt->sopt_td->td_ucred, so, &extmac);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = sooptcopyout(sopt, &extmac, sizeof extmac);
|
|
|
|
#else
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
#endif
|
|
|
|
break;
|
2005-09-18 21:08:03 +00:00
|
|
|
|
|
|
|
case SO_LISTENQLIMIT:
|
|
|
|
optval = so->so_qlimit;
|
|
|
|
goto integer;
|
|
|
|
|
|
|
|
case SO_LISTENQLEN:
|
|
|
|
optval = so->so_qlen;
|
|
|
|
goto integer;
|
|
|
|
|
|
|
|
case SO_LISTENINCQLEN:
|
|
|
|
optval = so->so_incqlen;
|
|
|
|
goto integer;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-08-23 03:07:17 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/* XXX; prepare mbuf for (__FreeBSD__ < 3) routines. */
|
|
|
|
int
|
|
|
|
soopt_getm(struct sockopt *sopt, struct mbuf **mp)
|
|
|
|
{
|
|
|
|
struct mbuf *m, *m_prev;
|
|
|
|
int sopt_size = sopt->sopt_valsize;
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
|
|
|
|
if (m == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
return ENOBUFS;
|
|
|
|
if (sopt_size > MLEN) {
|
2005-06-09 19:59:09 +00:00
|
|
|
MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT);
|
1999-11-22 02:45:11 +00:00
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
|
|
m_free(m);
|
|
|
|
return ENOBUFS;
|
|
|
|
}
|
|
|
|
m->m_len = min(MCLBYTES, sopt_size);
|
|
|
|
} else {
|
|
|
|
m->m_len = min(MLEN, sopt_size);
|
|
|
|
}
|
|
|
|
sopt_size -= m->m_len;
|
|
|
|
*mp = m;
|
|
|
|
m_prev = m;
|
|
|
|
|
|
|
|
while (sopt_size) {
|
2005-06-09 19:59:09 +00:00
|
|
|
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
|
|
|
|
if (m == NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(*mp);
|
|
|
|
return ENOBUFS;
|
|
|
|
}
|
|
|
|
if (sopt_size > MLEN) {
|
2005-06-09 19:59:09 +00:00
|
|
|
MCLGET(m, sopt->sopt_td != NULL ? M_TRYWAIT :
|
|
|
|
M_DONTWAIT);
|
1999-11-22 02:45:11 +00:00
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
m_freem(m);
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(*mp);
|
|
|
|
return ENOBUFS;
|
|
|
|
}
|
|
|
|
m->m_len = min(MCLBYTES, sopt_size);
|
|
|
|
} else {
|
|
|
|
m->m_len = min(MLEN, sopt_size);
|
|
|
|
}
|
|
|
|
sopt_size -= m->m_len;
|
|
|
|
m_prev->m_next = m;
|
|
|
|
m_prev = m;
|
|
|
|
}
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX; copyin sopt data into mbuf chain for (__FreeBSD__ < 3) routines. */
|
|
|
|
int
|
|
|
|
soopt_mcopyin(struct sockopt *sopt, struct mbuf *m)
|
|
|
|
{
|
|
|
|
struct mbuf *m0 = m;
|
|
|
|
|
|
|
|
if (sopt->sopt_val == NULL)
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
while (m != NULL && sopt->sopt_valsize >= m->m_len) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (sopt->sopt_td != NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = copyin(sopt->sopt_val, mtod(m, char *),
|
|
|
|
m->m_len);
|
|
|
|
if (error != 0) {
|
|
|
|
m_freem(m0);
|
|
|
|
return(error);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
bcopy(sopt->sopt_val, mtod(m, char *), m->m_len);
|
|
|
|
sopt->sopt_valsize -= m->m_len;
|
2005-06-09 19:59:09 +00:00
|
|
|
sopt->sopt_val = (char *)sopt->sopt_val + m->m_len;
|
1999-11-22 02:45:11 +00:00
|
|
|
m = m->m_next;
|
|
|
|
}
|
|
|
|
if (m != NULL) /* should be allocated enoughly at ip6_sooptmcopyin() */
|
|
|
|
panic("ip6_sooptmcopyin");
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX; copyout mbuf chain data into soopt for (__FreeBSD__ < 3) routines. */
|
|
|
|
int
|
|
|
|
soopt_mcopyout(struct sockopt *sopt, struct mbuf *m)
|
|
|
|
{
|
|
|
|
struct mbuf *m0 = m;
|
|
|
|
size_t valsize = 0;
|
|
|
|
|
|
|
|
if (sopt->sopt_val == NULL)
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
while (m != NULL && sopt->sopt_valsize >= m->m_len) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (sopt->sopt_td != NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
error = copyout(mtod(m, char *), sopt->sopt_val,
|
|
|
|
m->m_len);
|
|
|
|
if (error != 0) {
|
|
|
|
m_freem(m0);
|
|
|
|
return(error);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
bcopy(mtod(m, char *), sopt->sopt_val, m->m_len);
|
|
|
|
sopt->sopt_valsize -= m->m_len;
|
2005-06-09 19:59:09 +00:00
|
|
|
sopt->sopt_val = (char *)sopt->sopt_val + m->m_len;
|
1999-11-22 02:45:11 +00:00
|
|
|
valsize += m->m_len;
|
|
|
|
m = m->m_next;
|
|
|
|
}
|
|
|
|
if (m != NULL) {
|
|
|
|
/* enough soopt buffer should be given from user-land */
|
|
|
|
m_freem(m0);
|
|
|
|
return(EINVAL);
|
|
|
|
}
|
|
|
|
sopt->sopt_valsize = valsize;
|
2006-02-12 15:00:27 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2006-07-23 20:36:04 +00:00
|
|
|
/*
|
|
|
|
* sohasoutofband(): protocol notifies socket layer of the arrival of new
|
|
|
|
* out-of-band data, which will then notify socket consumers.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
sohasoutofband(so)
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
if (so->so_sigio != NULL)
|
2005-06-09 19:59:09 +00:00
|
|
|
pgsigio(&so->so_sigio, SIGURG, 0);
|
|
|
|
selwakeuppri(&so->so_rcv.sb_sel, PSOCK);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-04-27 20:01:29 +00:00
|
|
|
|
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
sopoll(struct socket *so, int events, struct ucred *active_cred,
|
|
|
|
struct thread *td)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
soreceive_generic(), and sopoll_generic(). Add new functions sosend(),
soreceive(), and sopoll(), which are wrappers for pru_sosend,
pru_soreceive, and pru_sopoll, and are now used univerally by socket
consumers rather than either directly invoking the old so*() functions
or directly invoking the protocol switch method (about an even split
prior to this commit).
This completes an architectural change that was begun in 1996 to permit
protocols to provide substitute implementations, as now used by UDP.
Consumers now uniformly invoke sosend(), soreceive(), and sopoll() to
perform these operations on sockets -- in particular, distributed file
systems and socket system calls.
Architectural head nod: sam, gnn, wollman
2006-07-24 15:20:08 +00:00
|
|
|
|
|
|
|
/* XXXRW: Temporary debugging. */
|
|
|
|
KASSERT(so->so_proto->pr_usrreqs->pru_sopoll != sopoll,
|
|
|
|
("sopoll: protocol calls sopoll"));
|
|
|
|
|
|
|
|
return (so->so_proto->pr_usrreqs->pru_sopoll(so, events, active_cred,
|
|
|
|
td));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sopoll_generic(struct socket *so, int events, struct ucred *active_cred,
|
|
|
|
struct thread *td)
|
|
|
|
{
|
1997-09-14 02:34:14 +00:00
|
|
|
int revents = 0;
|
1997-04-27 20:01:29 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
2002-05-31 11:52:35 +00:00
|
|
|
if (events & (POLLIN | POLLRDNORM))
|
1997-09-14 02:34:14 +00:00
|
|
|
if (soreadable(so))
|
|
|
|
revents |= events & (POLLIN | POLLRDNORM);
|
1997-04-27 20:01:29 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
if (events & POLLINIGNEOF)
|
|
|
|
if (so->so_rcv.sb_cc >= so->so_rcv.sb_lowat ||
|
|
|
|
!TAILQ_EMPTY(&so->so_comp) || so->so_error)
|
|
|
|
revents |= POLLINIGNEOF;
|
|
|
|
|
2002-05-31 11:52:35 +00:00
|
|
|
if (events & (POLLOUT | POLLWRNORM))
|
1997-09-14 02:34:14 +00:00
|
|
|
if (sowriteable(so))
|
|
|
|
revents |= events & (POLLOUT | POLLWRNORM);
|
|
|
|
|
2002-05-31 11:52:35 +00:00
|
|
|
if (events & (POLLPRI | POLLRDBAND))
|
2005-06-09 19:59:09 +00:00
|
|
|
if (so->so_oobmark || (so->so_rcv.sb_state & SBS_RCVATMARK))
|
1997-09-14 02:34:14 +00:00
|
|
|
revents |= events & (POLLPRI | POLLRDBAND);
|
|
|
|
|
|
|
|
if (revents == 0) {
|
2005-06-09 19:59:09 +00:00
|
|
|
if (events &
|
|
|
|
(POLLIN | POLLINIGNEOF | POLLPRI | POLLRDNORM |
|
|
|
|
POLLRDBAND)) {
|
|
|
|
selrecord(td, &so->so_rcv.sb_sel);
|
1997-09-14 02:34:14 +00:00
|
|
|
so->so_rcv.sb_flags |= SB_SEL;
|
1997-04-27 20:01:29 +00:00
|
|
|
}
|
|
|
|
|
1997-09-14 02:34:14 +00:00
|
|
|
if (events & (POLLOUT | POLLWRNORM)) {
|
2005-06-09 19:59:09 +00:00
|
|
|
selrecord(td, &so->so_snd.sb_sel);
|
1997-09-14 02:34:14 +00:00
|
|
|
so->so_snd.sb_flags |= SB_SEL;
|
1997-04-27 20:01:29 +00:00
|
|
|
}
|
|
|
|
}
|
1997-09-14 02:34:14 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
1997-09-14 02:34:14 +00:00
|
|
|
return (revents);
|
1997-04-27 20:01:29 +00:00
|
|
|
}
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2001-02-15 16:34:11 +00:00
|
|
|
int
|
2005-06-09 19:59:09 +00:00
|
|
|
soo_kqfilter(struct file *fp, struct knote *kn)
|
2000-04-16 18:53:38 +00:00
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so = kn->kn_fp->f_data;
|
2001-02-15 16:34:11 +00:00
|
|
|
struct sockbuf *sb;
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2001-02-15 16:34:11 +00:00
|
|
|
switch (kn->kn_filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
if (so->so_options & SO_ACCEPTCONN)
|
|
|
|
kn->kn_fop = &solisten_filtops;
|
2005-06-09 19:56:38 +00:00
|
|
|
else
|
2005-06-09 19:59:09 +00:00
|
|
|
kn->kn_fop = &soread_filtops;
|
2001-02-15 16:34:11 +00:00
|
|
|
sb = &so->so_rcv;
|
|
|
|
break;
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
kn->kn_fop = &sowrite_filtops;
|
|
|
|
sb = &so->so_snd;
|
|
|
|
break;
|
|
|
|
default:
|
2005-06-09 19:59:09 +00:00
|
|
|
return (EINVAL);
|
2001-02-15 16:34:11 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(sb);
|
|
|
|
knlist_add(&sb->sb_sel.si_note, kn, 1);
|
2001-02-15 16:34:11 +00:00
|
|
|
sb->sb_flags |= SB_KNOTE;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(sb);
|
2000-04-16 18:53:38 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_sordetach(struct knote *kn)
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so = kn->kn_fp->f_data;
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
|
|
|
knlist_remove(&so->so_rcv.sb_sel.si_note, kn, 1);
|
|
|
|
if (knlist_empty(&so->so_rcv.sb_sel.si_note))
|
2000-04-16 18:53:38 +00:00
|
|
|
so->so_rcv.sb_flags &= ~SB_KNOTE;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
2000-04-16 18:53:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_soread(struct knote *kn, long hint)
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
2004-08-24 05:28:18 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
so = kn->kn_fp->f_data;
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
|
|
|
|
|
|
|
|
kn->kn_data = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
|
|
|
|
if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
|
|
|
|
kn->kn_flags |= EV_EOF;
|
2001-02-24 01:33:12 +00:00
|
|
|
kn->kn_fflags = so->so_error;
|
2004-08-24 05:28:18 +00:00
|
|
|
return (1);
|
2005-06-09 19:59:09 +00:00
|
|
|
} else if (so->so_error) /* temporary udp error */
|
2004-08-24 05:28:18 +00:00
|
|
|
return (1);
|
2005-06-09 19:59:09 +00:00
|
|
|
else if (kn->kn_sfflags & NOTE_LOWAT)
|
2004-08-24 05:28:18 +00:00
|
|
|
return (kn->kn_data >= kn->kn_sdata);
|
2005-06-09 19:59:09 +00:00
|
|
|
else
|
|
|
|
return (so->so_rcv.sb_cc >= so->so_rcv.sb_lowat);
|
2000-04-16 18:53:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_sowdetach(struct knote *kn)
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so = kn->kn_fp->f_data;
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_snd);
|
|
|
|
knlist_remove(&so->so_snd.sb_sel.si_note, kn, 1);
|
|
|
|
if (knlist_empty(&so->so_snd.sb_sel.si_note))
|
2000-04-16 18:53:38 +00:00
|
|
|
so->so_snd.sb_flags &= ~SB_KNOTE;
|
2005-06-09 19:59:09 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_snd);
|
2000-04-16 18:53:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_sowrite(struct knote *kn, long hint)
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so;
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2005-06-09 19:59:09 +00:00
|
|
|
so = kn->kn_fp->f_data;
|
|
|
|
SOCKBUF_LOCK_ASSERT(&so->so_snd);
|
2000-04-16 18:53:38 +00:00
|
|
|
kn->kn_data = sbspace(&so->so_snd);
|
2005-06-09 19:59:09 +00:00
|
|
|
if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
|
|
|
|
kn->kn_flags |= EV_EOF;
|
2001-02-24 01:33:12 +00:00
|
|
|
kn->kn_fflags = so->so_error;
|
2004-08-24 05:28:18 +00:00
|
|
|
return (1);
|
2005-06-09 19:59:09 +00:00
|
|
|
} else if (so->so_error) /* temporary udp error */
|
2004-08-24 05:28:18 +00:00
|
|
|
return (1);
|
2005-06-09 19:59:09 +00:00
|
|
|
else if (((so->so_state & SS_ISCONNECTED) == 0) &&
|
2002-05-31 11:52:35 +00:00
|
|
|
(so->so_proto->pr_flags & PR_CONNREQUIRED))
|
2004-08-24 05:28:18 +00:00
|
|
|
return (0);
|
2005-06-09 19:59:09 +00:00
|
|
|
else if (kn->kn_sfflags & NOTE_LOWAT)
|
2004-08-24 05:28:18 +00:00
|
|
|
return (kn->kn_data >= kn->kn_sdata);
|
2005-06-09 19:59:09 +00:00
|
|
|
else
|
|
|
|
return (kn->kn_data >= so->so_snd.sb_lowat);
|
2000-04-16 18:53:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_solisten(struct knote *kn, long hint)
|
|
|
|
{
|
2005-06-09 19:59:09 +00:00
|
|
|
struct socket *so = kn->kn_fp->f_data;
|
2000-04-16 18:53:38 +00:00
|
|
|
|
2002-04-26 02:07:46 +00:00
|
|
|
kn->kn_data = so->so_qlen;
|
2000-04-16 18:53:38 +00:00
|
|
|
return (! TAILQ_EMPTY(&so->so_comp));
|
|
|
|
}
|
2005-06-09 19:59:09 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
socheckuid(struct socket *so, uid_t uid)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (so == NULL)
|
|
|
|
return (EPERM);
|
|
|
|
if (so->so_cred->cr_uid != uid)
|
|
|
|
return (EPERM);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
somaxconn_sysctl(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = somaxconn;
|
|
|
|
error = sysctl_handle_int(oidp, &val, sizeof(int), req);
|
|
|
|
if (error || !req->newptr )
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (val < 1 || val > USHRT_MAX)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
somaxconn = val;
|
|
|
|
return (0);
|
|
|
|
}
|