Home | History | Annotate | Line # | Download | only in libsockin
sockin.c revision 1.8 
      1 /*	$NetBSD: sockin.c,v 1.8 2008/12/18 00:24:13 pooka Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2008 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 #include <sys/cdefs.h>
     29 __KERNEL_RCSID(0, "$NetBSD: sockin.c,v 1.8 2008/12/18 00:24:13 pooka Exp $");
     30 
     31 #include <sys/param.h>
     32 #include <sys/condvar.h>
     33 #include <sys/domain.h>
     34 #include <sys/kmem.h>
     35 #include <sys/kthread.h>
     36 #include <sys/mbuf.h>
     37 #include <sys/mutex.h>
     38 #include <sys/poll.h>
     39 #include <sys/protosw.h>
     40 #include <sys/queue.h>
     41 #include <sys/socket.h>
     42 #include <sys/socketvar.h>
     43 #include <sys/time.h>
     44 
     45 #include <net/radix.h>
     46 
     47 #include <netinet/in.h>
     48 #include <netinet/in_systm.h>
     49 #include <netinet/ip.h>
     50 
     51 #include <rump/rumpuser.h>
     52 
     53 /*
     54  * An inet communication domain which uses the socket interface.
     55  * Currently supports only IPv4 UDP, but could easily be extended to
     56  * support IPv6 and TCP by adding more stuff to the protosw.
     57  */
     58 
     59 DOMAIN_DEFINE(sockindomain);
     60 
     61 static void	sockin_init(void);
     62 static int	sockin_usrreq(struct socket *, int, struct mbuf *,
     63 			      struct mbuf *, struct mbuf *, struct lwp *);
     64 static int	sockin_ctloutput(int op, struct socket *, struct sockopt *);
     65 
     66 const struct protosw sockinsw[] = {
     67 {
     68 	.pr_type = SOCK_DGRAM,
     69 	.pr_domain = &sockindomain,
     70 	.pr_protocol = IPPROTO_UDP,
     71 	.pr_flags = PR_ATOMIC|PR_ADDR,
     72 	.pr_usrreq = sockin_usrreq,
     73 	.pr_ctloutput = sockin_ctloutput,
     74 },
     75 {
     76 	.pr_type = SOCK_STREAM,
     77 	.pr_domain = &sockindomain,
     78 	.pr_protocol = IPPROTO_TCP,
     79 	.pr_flags = PR_CONNREQUIRED|PR_WANTRCVD|PR_LISTEN|PR_ABRTACPTDIS,
     80 	.pr_usrreq = sockin_usrreq,
     81 	.pr_ctloutput = sockin_ctloutput,
     82 }};
     83 
     84 struct domain sockindomain = {
     85 	.dom_family = PF_INET,
     86 	.dom_name = "socket_inet",
     87 	.dom_init = sockin_init,
     88 	.dom_externalize = NULL,
     89 	.dom_dispose = NULL,
     90 	.dom_protosw = sockinsw,
     91 	.dom_protoswNPROTOSW = &sockinsw[__arraycount(sockinsw)],
     92 	.dom_rtattach = rn_inithead,
     93 	.dom_rtoffset = 32,
     94 	.dom_maxrtkey = sizeof(struct sockaddr_in),
     95 	.dom_ifattach = NULL,
     96 	.dom_ifdetach = NULL,
     97 	.dom_ifqueues = { NULL },
     98 	.dom_link = { NULL },
     99 	.dom_mowner = MOWNER_INIT("",""),
    100 	.dom_rtcache = { NULL },
    101 	.dom_sockaddr_cmp = NULL
    102 };
    103 
    104 /* only for testing */
    105 #if 0
    106 #define SOCKIN_NOTHREAD
    107 #endif
    108 
    109 #define SO2S(so) ((intptr_t)(so->so_internal))
    110 #define SOCKIN_SBSIZE 65536
    111 
    112 struct sockin_unit {
    113 	struct socket *su_so;
    114 
    115 	LIST_ENTRY(sockin_unit) su_entries;
    116 };
    117 static LIST_HEAD(, sockin_unit) su_ent = LIST_HEAD_INITIALIZER(su_ent);
    118 static kmutex_t su_mtx;
    119 static bool rebuild;
    120 static int nsock;
    121 
    122 static int
    123 registersock(struct socket *so, int news)
    124 {
    125 	struct sockin_unit *su;
    126 
    127 	su = kmem_alloc(sizeof(*su), KM_NOSLEEP);
    128 	if (!su)
    129 		return ENOMEM;
    130 
    131 	so->so_internal = (void *)(intptr_t)news;
    132 	su->su_so = so;
    133 
    134 	mutex_enter(&su_mtx);
    135 	LIST_INSERT_HEAD(&su_ent, su, su_entries);
    136 	nsock++;
    137 	rebuild = true;
    138 	mutex_exit(&su_mtx);
    139 
    140 	return 0;
    141 }
    142 
    143 static void
    144 sockin_process(struct socket *so)
    145 {
    146 	struct sockaddr_in from;
    147 	struct iovec io;
    148 	struct msghdr rmsg;
    149 	struct mbuf *m;
    150 	ssize_t n;
    151 	size_t plen;
    152 	int error;
    153 
    154 	plen = IP_MAXPACKET;
    155 	m = m_gethdr(M_WAIT, MT_DATA);
    156 	MEXTMALLOC(m, plen, M_WAIT);
    157 
    158 	memset(&rmsg, 0, sizeof(rmsg));
    159 	io.iov_base = mtod(m, void *);
    160 	io.iov_len = plen;
    161 	rmsg.msg_iov = &io;
    162 	rmsg.msg_iovlen = 1;
    163 	rmsg.msg_name = (struct sockaddr *)&from;
    164 	rmsg.msg_namelen = sizeof(from);
    165 
    166 	n = rumpuser_net_recvmsg(SO2S(so), &rmsg, 0, &error);
    167 	if (n <= 0) {
    168 		m_freem(m);
    169 		return;
    170 	}
    171 	m->m_len = m->m_pkthdr.len = n;
    172 
    173 	if (so->so_proto->pr_type == SOCK_DGRAM) {
    174 		if (!sbappendaddr(&so->so_rcv, rmsg.msg_name, m, NULL)) {
    175 			m_freem(m);
    176 		}
    177 	} else {
    178 		sbappendstream(&so->so_rcv, m);
    179 	}
    180 
    181 	sorwakeup(so);
    182 }
    183 
    184 #ifndef SOCKIN_NOTHREAD
    185 static void
    186 sockin_accept(struct socket *so)
    187 {
    188 	struct socket *nso;
    189 	struct sockaddr_in sin;
    190 	int news, error, slen;
    191 
    192 	slen = sizeof(sin);
    193 	news = rumpuser_net_accept(SO2S(so), (struct sockaddr *)&sin,
    194 	    &slen, &error);
    195 	if (news == -1)
    196 		return;
    197 
    198 	if ((nso = sonewconn(so, SS_ISCONNECTED)) == NULL)
    199 		goto errout;
    200 	if (registersock(nso, news) != 0)
    201 		goto errout;
    202 	return;
    203 
    204  errout:
    205 	rumpuser_close(news, &error);
    206 	if (nso)
    207 		soclose(nso);
    208 }
    209 
    210 #define POLLTIMEOUT 100	/* check for new entries every 100ms */
    211 
    212 /* XXX: doesn't handle socket (kernel) locking properly? */
    213 static void
    214 sockinworker(void *arg)
    215 {
    216 	struct pollfd *pfds = NULL, *npfds;
    217 	struct sockin_unit *su_iter;
    218 	struct socket *so;
    219 	int cursock = 0, i, rv, error;
    220 
    221 	/*
    222 	 * Loop reading requests.  Check for new sockets periodically
    223 	 * (could be smarter, but I'm lazy).
    224 	 */
    225 	for (;;) {
    226 		if (rebuild) {
    227 			npfds = NULL;
    228 			mutex_enter(&su_mtx);
    229 			if (nsock)
    230 				npfds = kmem_alloc(nsock * sizeof(*npfds),
    231 				    KM_NOSLEEP);
    232 			if (npfds || nsock == 0) {
    233 				if (pfds)
    234 					kmem_free(pfds, cursock*sizeof(*pfds));
    235 				pfds = npfds;
    236 				cursock = nsock;
    237 				rebuild = false;
    238 
    239 				i = 0;
    240 				LIST_FOREACH(su_iter, &su_ent, su_entries) {
    241 					pfds[i].fd = SO2S(su_iter->su_so);
    242 					pfds[i].events = POLLIN;
    243 					pfds[i].revents = 0;
    244 					i++;
    245 				}
    246 				KASSERT(i == nsock);
    247 			}
    248 			mutex_exit(&su_mtx);
    249 		}
    250 
    251 		/* find affected sockets & process */
    252 		rv = rumpuser_poll(pfds, cursock, POLLTIMEOUT, &error);
    253 		for (i = 0; i < cursock && rv > 0; i++) {
    254 			if (pfds[i].revents & POLLIN) {
    255 				mutex_enter(&su_mtx);
    256 				LIST_FOREACH(su_iter, &su_ent, su_entries) {
    257 					if (SO2S(su_iter->su_so)==pfds[i].fd) {
    258 						so = su_iter->su_so;
    259 						mutex_exit(&su_mtx);
    260 						mutex_enter(softnet_lock);
    261 						if(so->so_options&SO_ACCEPTCONN)
    262 							sockin_accept(so);
    263 						else
    264 							sockin_process(so);
    265 						mutex_exit(softnet_lock);
    266 						mutex_enter(&su_mtx);
    267 						break;
    268 					}
    269 				}
    270 				/* if we can't find it, just wing it */
    271 				KASSERT(rebuild || su_iter);
    272 				mutex_exit(&su_mtx);
    273 				pfds[i].revents = 0;
    274 				rv--;
    275 				i = -1;
    276 				continue;
    277 			}
    278 
    279 			/* something else?  ignore */
    280 			if (pfds[i].revents) {
    281 				pfds[i].revents = 0;
    282 				rv--;
    283 			}
    284 		}
    285 		KASSERT(rv <= 0);
    286 	}
    287 
    288 }
    289 #endif /* SOCKIN_NOTHREAD */
    290 
    291 static void
    292 sockin_init()
    293 {
    294 #ifndef SOCKIN_NOTHREAD
    295 	int rv;
    296 
    297 	if ((rv = kthread_create(PRI_NONE, 0, NULL, sockinworker,
    298 	    NULL, NULL, "sockwork")) != 0)
    299 		panic("sockin_init: could not create worker thread\n");
    300 #endif
    301 	mutex_init(&su_mtx, MUTEX_DEFAULT, IPL_NONE);
    302 }
    303 
    304 static int
    305 sockin_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
    306 	struct mbuf *control, struct lwp *l)
    307 {
    308 	int error = 0, rv;
    309 
    310 	switch (req) {
    311 	case PRU_ATTACH:
    312 	{
    313 		int news;
    314 
    315 		sosetlock(so);
    316 		if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
    317 			error = soreserve(so, SOCKIN_SBSIZE, SOCKIN_SBSIZE);
    318 			if (error)
    319 				break;
    320 		}
    321 
    322 		news = rumpuser_net_socket(PF_INET, so->so_proto->pr_type,
    323 		    0, &error);
    324 		if (news == -1)
    325 			break;
    326 
    327 		if ((error = registersock(so, news)) != 0)
    328 			rumpuser_close(news, &error);
    329 
    330 		break;
    331 	}
    332 
    333 	case PRU_ACCEPT:
    334 		/* we do all the work in the worker thread */
    335 		break;
    336 
    337 	case PRU_BIND:
    338 		rumpuser_net_bind(SO2S(so), mtod(nam, const struct sockaddr *),
    339 		    sizeof(struct sockaddr_in), &error);
    340 		break;
    341 
    342 	case PRU_CONNECT:
    343 		/* don't bother to connect udp sockets, always sendmsg */
    344 		if (so->so_proto->pr_type == SOCK_DGRAM)
    345 			break;
    346 
    347 		rv = rumpuser_net_connect(SO2S(so),
    348 		    mtod(nam, struct sockaddr *), sizeof(struct sockaddr_in),
    349 		    &error);
    350 		if (rv == 0)
    351 		soisconnected(so);
    352 		break;
    353 
    354 	case PRU_LISTEN:
    355 		rumpuser_net_listen(SO2S(so), so->so_qlimit, &error);
    356 		break;
    357 
    358 	case PRU_SEND:
    359 	{
    360 		struct sockaddr *saddr;
    361 		struct msghdr mhdr;
    362 		struct iovec iov[16];
    363 		struct mbuf *m2;
    364 		size_t tot;
    365 		int i, s;
    366 
    367 		memset(&mhdr, 0, sizeof(mhdr));
    368 
    369 		tot = 0;
    370 		for (i = 0, m2 = m; m2; m2 = m2->m_next, i++) {
    371 			if (i > 16)
    372 				panic("lazy bum");
    373 			iov[i].iov_base = m2->m_data;
    374 			iov[i].iov_len = m2->m_len;
    375 			tot += m2->m_len;
    376 
    377 		}
    378 		mhdr.msg_iov = iov;
    379 		mhdr.msg_iovlen = i;
    380 		s = SO2S(so);
    381 
    382 		if (so->so_proto->pr_type == SOCK_DGRAM) {
    383 			saddr = mtod(nam, struct sockaddr *);
    384 			mhdr.msg_name = saddr;
    385 			mhdr.msg_namelen = saddr->sa_len;
    386 		}
    387 
    388 		rumpuser_net_sendmsg(s, &mhdr, 0, &error);
    389 
    390 		m_freem(m);
    391 		m_freem(control);
    392 #ifdef SOCKIN_NOTHREAD
    393 		/* this assumes too many things to list.. buthey, testing */
    394 		sockin_process(so);
    395 #endif
    396 	}
    397 		break;
    398 
    399 	case PRU_SHUTDOWN:
    400 	{
    401 		struct sockin_unit *su_iter;
    402 
    403 		mutex_enter(&su_mtx);
    404 		LIST_FOREACH(su_iter, &su_ent, su_entries) {
    405 			if (su_iter->su_so == so)
    406 				break;
    407 		}
    408 		if (!su_iter)
    409 			panic("no such socket");
    410 
    411 		LIST_REMOVE(su_iter, su_entries);
    412 		nsock--;
    413 		rebuild = true;
    414 		mutex_exit(&su_mtx);
    415 
    416 		rumpuser_close(SO2S(su_iter->su_so), &error);
    417 		kmem_free(su_iter, sizeof(*su_iter));
    418 	}
    419 		break;
    420 
    421 	default:
    422 		panic("sockin_usrreq: IMPLEMENT ME, req %d not supported", req);
    423 	}
    424 
    425 	return error;
    426 }
    427 
    428 static int
    429 sockin_ctloutput(int op, struct socket *so, struct sockopt *sopt)
    430 {
    431 
    432 	/* XXX: we should also do something here */
    433 	return 0;
    434 }
    435