[BACK]Return to bpf.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/bpf.c between versions 1.1.2.11 and 1.1.2.20

version 1.1.2.11, 2013/06/25 10:58:22 version 1.1.2.20, 2013/06/26 16:34:28
Line 122  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) {  
                 LOGERR;  
                 close(eth);  
                 return -1;  
         }  
         if (whdr && ioctl(eth, BIOCSHDRCMPLT, &n) == -1) {  
                 LOGERR;  
                 close(eth);  
                 return -1;  
         }  
   
         if (!zcbuf) {          if (!zcbuf) {
                 if (ioctl(eth, BIOCGBLEN, &n) == -1) {                  if (ioctl(eth, BIOCGBLEN, &n) == -1) {
                         LOGERR;                          LOGERR;
                         close(eth);                          close(eth);
                         return -1;                          return -1;
                 } else                  } else
                        n = (buflen && *buflen) ? MIN(n, *buflen) : n;                        n = (buflen && *buflen) ? *buflen : n;
                 if (ioctl(eth, BIOCSBLEN, &n) == -1) {                  if (ioctl(eth, BIOCSBLEN, &n) == -1) {
                         LOGERR;                          LOGERR;
                         close(eth);                          close(eth);
Line 160  io_etherOpen(const char *csIface, int flags, int whdr, Line 149  io_etherOpen(const char *csIface, int flags, int whdr,
                         close(eth);                          close(eth);
                         return -1;                          return -1;
                 } else                  } else
                        n = (buflen && *buflen) ? MIN(n, *buflen) : n;                        n = (buflen && *buflen) ? *buflen : n;
                 if (!(*zcbuf = allocZCbuf(n))) {                  if (!(*zcbuf = allocZCbuf(n))) {
                         close(eth);                          close(eth);
                         return -1;                          return -1;
                 }                  }
                if (ioctl(eth, BIOCSETZBUF, (struct bpf_zbuf*) *zcbuf) == -1) {                if (ioctl(eth, BIOCSETZBUF, *zcbuf) == -1) {
                         LOGERR;                          LOGERR;
                         io_etherClose(eth, zcbuf);                          io_etherClose(eth, zcbuf);
                         return -1;                          return -1;
Line 189  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 218  io_etherSend(int eth, const void *buf, size_t buflen) Line 219  io_etherSend(int eth, const void *buf, size_t buflen)
   
 #ifdef __FreeBSD__  #ifdef __FreeBSD__
 static inline void  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);          atomic_store_rel_int(&bzh->bzh_user_gen, bzh->bzh_kernel_gen);
 }  }
   
 static inline int  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 true if userspace owns buffer, and false otherwise. */
         return (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen));          return (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen));
 }  }
   
static inline ssize_tstatic ssize_t
nextZCbuf(void ** __restrict zcache, struct bpf_zbuf * __restrict zbuf, nextZCbuf(int eth, struct bpf_zbuf * __restrict zbuf, void * __restrict buf, size_t buflen)
                const void * __restrict buf) 
 {  {
        ssize_t rlen = -1;        ssize_t rlen = 0;
         struct bpf_zbuf bz;
         struct bpf_zbuf_header *bzh;          struct bpf_zbuf_header *bzh;
           off_t pos = 0;
   
        if (!*zcache || *zcache == zbuf->bz_bufb) {        bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa;
                bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa;        if (chkZCbuf(bzh)) {
                if (chkZCbuf(bzh)) {                rlen = MIN(atomic_load_acq_int(&bzh->bzh_kernel_len), buflen);
                        rlen = atomic_load_acq_int(&bzh->bzh_kernel_len);                memcpy(buf + pos, zbuf->bz_bufa + sizeof(struct bpf_zbuf_header), rlen);
                        *zcache = zbuf->bz_bufa;                ackZCbuf(bzh);
                        if (buf)                pos += rlen;
                                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_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;          return rlen;
 }  }
 #endif  #endif
Line 276  ssize_t Line 276  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;  
   
         if (!buf || !buflen) {          if (!buf || !buflen) {
                 io_SetErr(EINVAL, "invalid arguments");                  io_SetErr(EINVAL, "invalid arguments");
Line 289  io_etherRecv(int eth, void * __restrict buf, size_t bu Line 288  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);                rlen = nextZCbuf(eth, (struct bpf_zbuf*) zcbuf, buf, buflen);
                 if (!rlen)
                         rlen = nextZCbuf(eth, (struct bpf_zbuf*) zcbuf, buf, buflen);
 #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
         }          }
Removed from v.1.1.2.11  
changed lines
  Added in v.1.1.2.20

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>