version 1.1.2.7, 2013/06/25 08:45:50
|
version 1.1.2.17, 2013/06/26 15:04:02
|
Line 97 allocZCbuf(u_int len)
|
Line 97 allocZCbuf(u_int len)
|
int |
int |
io_etherOpen(const char *csIface, int flags, int whdr, u_int *buflen, void **zcbuf) |
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; |
register int i; |
char szStr[STRSIZ]; |
char szStr[STRSIZ]; |
struct ifreq ifr; |
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++) { |
for (i = 0; i < BPF_DEV_MAX; i++) { |
memset(szStr, 0, sizeof szStr); |
memset(szStr, 0, sizeof szStr); |
snprintf(szStr, sizeof szStr, "/dev/bpf%d", i); |
snprintf(szStr, sizeof szStr, "/dev/bpf%d", i); |
Line 114 io_etherOpen(const char *csIface, int flags, int whdr,
|
Line 122 io_etherOpen(const char *csIface, int flags, int whdr,
|
return -1; |
return -1; |
} |
} |
|
|
if (ioctl(eth, BIOCIMMEDIATE, &n) == -1) { | if (!zcbuf) { |
LOGERR; | if (ioctl(eth, BIOCGBLEN, &n) == -1) { |
close(eth); | LOGERR; |
return -1; | close(eth); |
} | return -1; |
if (whdr && ioctl(eth, BIOCSHDRCMPLT, &n) == -1) { | } else |
LOGERR; | n = (buflen && *buflen) ? *buflen : n; |
close(eth); | if (ioctl(eth, BIOCSBLEN, &n) == -1) { |
return -1; | LOGERR; |
} | close(eth); |
if (buflen && *buflen) { | return -1; |
if (!zcbuf) { | } |
if (ioctl(eth, BIOCSBLEN, buflen) == -1) { | if (buflen && *buflen) |
LOGERR; | *buflen = n; |
close(eth); | } else { |
return -1; | |
} | |
} else { | |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
n = BPF_BUFMODE_ZBUF; | n = BPF_BUFMODE_ZBUF; |
if (ioctl(eth, BIOCSETBUFMODE, &n) == -1) { | if (ioctl(eth, BIOCSETBUFMODE, &n) == -1) { |
LOGERR; | LOGERR; |
close(eth); | close(eth); |
return -1; | 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 | |
} |
} |
|
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) |
if (csIface) |
strlcpy(szStr, csIface, sizeof szStr); |
strlcpy(szStr, csIface, sizeof szStr); |
else if (io_get1stiface(szStr, sizeof szStr) == -1) { |
else if (io_get1stiface(szStr, sizeof szStr) == -1) { |
io_etherClose(eth, zcbuf); |
io_etherClose(eth, zcbuf); |
return -1; |
return -1; |
} |
} |
|
memset(&ifr, 0, sizeof ifr); |
strlcpy(ifr.ifr_name, szStr, sizeof ifr.ifr_name); |
strlcpy(ifr.ifr_name, szStr, sizeof ifr.ifr_name); |
if (ioctl(eth, BIOCSETIF, &ifr) == -1) { |
if (ioctl(eth, BIOCSETIF, &ifr) == -1) { |
LOGERR; |
LOGERR; |
Line 170 io_etherOpen(const char *csIface, int flags, int whdr,
|
Line 178 io_etherOpen(const char *csIface, int flags, int whdr,
|
return -1; |
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; |
return eth; |
} |
} |
|
|
Line 198 io_etherSend(int eth, const void *buf, size_t buflen)
|
Line 218 io_etherSend(int eth, const void *buf, size_t buflen)
|
} |
} |
|
|
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
|
static inline void |
|
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 *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 |
static inline ssize_t |
nextZCbuf(void ** __restrict zcache, struct bpf_zbuf * __restrict zbuf, | nextZCbuf(int eth, void ** __restrict zcache, struct bpf_zbuf * __restrict zbuf) |
const void * __restrict buf) | |
{ |
{ |
ssize_t rlen = -1; | ssize_t rlen = 0; |
struct bpf_zbuf_header *bzh; |
struct bpf_zbuf_header *bzh; |
|
|
if (!*zcache || *zcache == zbuf->bz_bufb) { |
if (!*zcache || *zcache == zbuf->bz_bufb) { |
bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa; |
bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa; |
if (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen)) { | if (chkZCbuf(bzh)) { |
rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); | |
*zcache = zbuf->bz_bufa; |
*zcache = zbuf->bz_bufa; |
if (buf) | rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); |
buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header); | |
} |
} |
} else if (*zcache == zbuf->bz_bufa) { |
} else if (*zcache == zbuf->bz_bufa) { |
bzh = (struct bpf_zbuf_header *) zbuf->bz_bufb; |
bzh = (struct bpf_zbuf_header *) zbuf->bz_bufb; |
if (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen)) { | if (chkZCbuf(bzh)) { |
rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); | |
*zcache = zbuf->bz_bufb; |
*zcache = zbuf->bz_bufb; |
if (buf) | rlen = atomic_load_acq_int(&bzh->bzh_kernel_len); |
buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header); | |
} |
} |
} |
} |
|
|
Line 240 ssize_t
|
Line 268 ssize_t
|
io_etherRecv(int eth, void * __restrict buf, size_t buflen, void * __restrict zcbuf) |
io_etherRecv(int eth, void * __restrict buf, size_t buflen, void * __restrict zcbuf) |
{ |
{ |
ssize_t rlen = 0; |
ssize_t rlen = 0; |
void **zcache = NULL; | void *zcache = NULL; |
| #ifdef __FreeBSD__ |
| struct bpf_zbuf bz; |
| struct bpf_zbuf_header *bzh; |
| #endif |
|
|
if (!buf || !buflen) { |
if (!buf || !buflen) { |
io_SetErr(EINVAL, "invalid arguments"); |
io_SetErr(EINVAL, "invalid arguments"); |
Line 253 io_etherRecv(int eth, void * __restrict buf, size_t bu
|
Line 285 io_etherRecv(int eth, void * __restrict buf, size_t bu
|
LOGERR; |
LOGERR; |
} else { |
} else { |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
rlen = nextZCbuf(zcache, (struct bpf_zbuf*) zcbuf, buf); | do { |
| rlen = nextZCbuf(eth, &zcache, (struct bpf_zbuf*) zcbuf); |
| if (rlen > 0) { |
| bzh = (struct bpf_zbuf_header*) zcache; |
| memcpy(buf, zcache + sizeof(struct bpf_zbuf_header), |
| MIN(buflen, rlen)); |
| ackZCbuf(bzh); |
| } |
| if (!rlen && !ioctl(eth, BIOCROTZBUF, &bz)) { |
| bzh = (struct bpf_zbuf_header*) bz.bz_bufa; |
| if (bzh && chkZCbuf(bzh)) { |
| rlen = bz.bz_buflen; |
| memcpy(buf, bz.bz_bufa + sizeof(struct bpf_zbuf_header), |
| MIN(buflen, rlen)); |
| } |
| } |
| } while (0); |
#else |
#else |
|
rlen = -1; |
io_SetErr(ENOTSUP, "bpf zero copy buffer mode is not supported"); |
io_SetErr(ENOTSUP, "bpf zero copy buffer mode is not supported"); |
#endif |
#endif |
} |
} |