--- libaitio/src/bpf.c 2013/06/25 08:55:02 1.1.2.9 +++ libaitio/src/bpf.c 2013/06/26 22:48:10 1.1.2.21 @@ -1,3 +1,48 @@ +/************************************************************************* +* (C) 2013 AITNET ltd - Sofia/Bulgaria - +* by Michael Pounov +* +* $Author: misho $ +* $Id: bpf.c,v 1.1.2.21 2013/06/26 22:48:10 misho Exp $ +* +************************************************************************** +The ELWIX and AITNET software is distributed under the following +terms: + +All of the documentation and software included in the ELWIX and AITNET +Releases is copyrighted by ELWIX - Sofia/Bulgaria + +Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 + by Michael Pounov . All rights reserved. + +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. +3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: +This product includes software developed by Michael Pounov +ELWIX - Embedded LightWeight unIX and its contributors. +4. Neither the name of AITNET 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 AITNET 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. +*/ #include "global.h" @@ -97,11 +142,19 @@ allocZCbuf(u_int len) int io_etherOpen(const char *csIface, int flags, int whdr, u_int *buflen, void **zcbuf) { - int n = 1, eth = -1; + int eth = -1; register int i; char szStr[STRSIZ]; struct ifreq ifr; + u_int n = 1; +#ifndef __FreeBSD__ + if (zcbuf) { + io_SetErr(ENOTSUP, "bpf zero copy buffer mode is not supported"); + return -1; + } +#endif + for (i = 0; i < BPF_DEV_MAX; i++) { memset(szStr, 0, sizeof szStr); snprintf(szStr, sizeof szStr, "/dev/bpf%d", i); @@ -114,55 +167,55 @@ io_etherOpen(const char *csIface, int flags, int whdr, return -1; } - if (ioctl(eth, BIOCIMMEDIATE, &n) == -1) { - LOGERR; - close(eth); - return -1; - } - if (whdr && ioctl(eth, BIOCSHDRCMPLT, &n) == -1) { - LOGERR; - close(eth); - return -1; - } - if (buflen && *buflen) { - if (!zcbuf) { - if (ioctl(eth, BIOCSBLEN, buflen) == -1) { - LOGERR; - close(eth); - return -1; - } - } else { + if (!zcbuf) { + if (ioctl(eth, BIOCGBLEN, &n) == -1) { + LOGERR; + close(eth); + return -1; + } else + n = (buflen && *buflen) ? *buflen : n; + if (ioctl(eth, BIOCSBLEN, &n) == -1) { + LOGERR; + close(eth); + return -1; + } + if (buflen && *buflen) + *buflen = n; + } else { #ifdef __FreeBSD__ - n = BPF_BUFMODE_ZBUF; - if (ioctl(eth, BIOCSETBUFMODE, &n) == -1) { - LOGERR; - close(eth); - return -1; - } - if (ioctl(eth, BIOCGETZMAX, &n) == -1) { - LOGERR; - close(eth); - return -1; - } else - *buflen = MIN(n, *buflen); - if (!(*zcbuf = allocZCbuf(*buflen))) { - close(eth); - return -1; - } - if (ioctl(eth, BIOCSETZBUF, (struct bpf_zbuf*) *zcbuf) == -1) { - LOGERR; - io_etherClose(eth, zcbuf); - return -1; - } -#endif + n = BPF_BUFMODE_ZBUF; + if (ioctl(eth, BIOCSETBUFMODE, &n) == -1) { + LOGERR; + close(eth); + return -1; } + if (ioctl(eth, BIOCGETZMAX, &n) == -1) { + LOGERR; + close(eth); + return -1; + } else + n = (buflen && *buflen) ? *buflen : n; + if (!(*zcbuf = allocZCbuf(n))) { + close(eth); + return -1; + } + if (ioctl(eth, BIOCSETZBUF, *zcbuf) == -1) { + LOGERR; + io_etherClose(eth, zcbuf); + return -1; + } + if (buflen && *buflen) + *buflen = n; +#endif } + if (csIface) strlcpy(szStr, csIface, sizeof szStr); else if (io_get1stiface(szStr, sizeof szStr) == -1) { io_etherClose(eth, zcbuf); return -1; } + memset(&ifr, 0, sizeof ifr); strlcpy(ifr.ifr_name, szStr, sizeof ifr.ifr_name); if (ioctl(eth, BIOCSETIF, &ifr) == -1) { LOGERR; @@ -170,6 +223,18 @@ io_etherOpen(const char *csIface, int flags, int whdr, return -1; } + n = 1; + if (whdr && ioctl(eth, BIOCSHDRCMPLT, &n) == -1) { + LOGERR; + io_etherClose(eth, zcbuf); + return -1; + } + if (ioctl(eth, BIOCIMMEDIATE, &n) == -1) { + LOGERR; + io_etherClose(eth, zcbuf); + return -1; + } + return eth; } @@ -199,47 +264,46 @@ io_etherSend(int eth, const void *buf, size_t buflen) #ifdef __FreeBSD__ static inline void -ackZCbuf(struct bpf_zbuf_header * __restrict bzh) +ackZCbuf(struct bpf_zbuf_header *bzh) { atomic_store_rel_int(&bzh->bzh_user_gen, bzh->bzh_kernel_gen); } static inline int -chkZCbuf(struct bpf_zbuf_header * __restrict bzh) +chkZCbuf(struct bpf_zbuf_header *bzh) { /* return true if userspace owns buffer, and false otherwise. */ return (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen)); } -static inline ssize_t -nextZCbuf(void ** __restrict zcache, struct bpf_zbuf * __restrict zbuf, - const void * __restrict buf) +static ssize_t +nextZCbuf(int eth, struct bpf_zbuf * __restrict zbuf, void * __restrict buf, size_t buflen) { - ssize_t rlen = -1; + ssize_t rlen = 0; + struct bpf_zbuf bz; struct bpf_zbuf_header *bzh; + off_t pos = 0; - if (!*zcache || *zcache == zbuf->bz_bufb) { - bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa; - if (chkZCbuf(bzh)) { - rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); - *zcache = zbuf->bz_bufa; - if (buf) - buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header); - ackZCbuf(bzh); - } else - io_SetErr(EAGAIN, "kernel owns the buffer"); - } else if (*zcache == zbuf->bz_bufa) { - bzh = (struct bpf_zbuf_header *) zbuf->bz_bufb; - if (chkZCbuf(bzh)) { - rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); - *zcache = zbuf->bz_bufb; - if (buf) - buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header); - ackZCbuf(bzh); - } else - io_SetErr(EAGAIN, "kernel owns the buffer"); + bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa; + if (chkZCbuf(bzh)) { + rlen = MIN(atomic_load_acq_int(&bzh->bzh_kernel_len), buflen); + memcpy(buf + pos, zbuf->bz_bufa + sizeof(struct bpf_zbuf_header), rlen); + ackZCbuf(bzh); + pos += rlen; } + bzh = (struct bpf_zbuf_header *) zbuf->bz_bufb; + if (chkZCbuf(bzh)) { + rlen = MIN(atomic_load_acq_int(&bzh->bzh_kernel_len), buflen); + memcpy(buf + pos, zbuf->bz_bufb + sizeof(struct bpf_zbuf_header), rlen); + ackZCbuf(bzh); + pos += rlen; + } + if (!pos) { + if ((rlen = ioctl(eth, BIOCROTZBUF, &bz)) == -1) + LOGERR; + } else + rlen = pos; return rlen; } #endif @@ -257,7 +321,6 @@ ssize_t io_etherRecv(int eth, void * __restrict buf, size_t buflen, void * __restrict zcbuf) { ssize_t rlen = 0; - void **zcache = NULL; if (!buf || !buflen) { io_SetErr(EINVAL, "invalid arguments"); @@ -270,8 +333,11 @@ io_etherRecv(int eth, void * __restrict buf, size_t bu LOGERR; } else { #ifdef __FreeBSD__ - rlen = nextZCbuf(zcache, (struct bpf_zbuf*) zcbuf, buf); + rlen = nextZCbuf(eth, (struct bpf_zbuf*) zcbuf, buf, buflen); + if (!rlen) + rlen = nextZCbuf(eth, (struct bpf_zbuf*) zcbuf, buf, buflen); #else + rlen = -1; io_SetErr(ENOTSUP, "bpf zero copy buffer mode is not supported"); #endif }