usb_pf.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1990, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * This code is derived from the Stanford/CMU enet packet filter,
    6  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
    7  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
    8  * Berkeley Laboratory.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  */
   34 
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD: releng/8.3/sys/dev/usb/usb_pf.c 221174 2011-04-28 16:18:30Z hselasky $");
   37 #include <sys/param.h>
   38 #include <sys/kernel.h>
   39 #include <sys/bus.h>
   40 #include <sys/fcntl.h>
   41 #include <sys/malloc.h>
   42 #include <sys/proc.h>
   43 #include <sys/socket.h>
   44 #include <sys/sockio.h>
   45 #include <net/if.h>
   46 #include <net/if_types.h>
   47 #include <net/bpf.h>
   48 #include <sys/sysctl.h>
   49 
   50 #include <dev/usb/usb.h>
   51 #include <dev/usb/usbdi.h>
   52 #include <dev/usb/usb_busdma.h>
   53 #include <dev/usb/usb_controller.h>
   54 #include <dev/usb/usb_core.h>
   55 #include <dev/usb/usb_process.h>
   56 #include <dev/usb/usb_device.h>
   57 #include <dev/usb/usb_bus.h>
   58 #include <dev/usb/usb_pf.h>
   59 #include <dev/usb/usb_transfer.h>
   60 
   61 static int usb_no_pf;
   62 
   63 SYSCTL_INT(_hw_usb, OID_AUTO, no_pf, CTLFLAG_RW,
   64     &usb_no_pf, 0, "Set to disable USB packet filtering");
   65 
   66 TUNABLE_INT("hw.usb.no_pf", &usb_no_pf);
   67 
   68 void
   69 usbpf_attach(struct usb_bus *ubus)
   70 {
   71         struct ifnet *ifp;
   72 
   73         if (usb_no_pf != 0) {
   74                 ubus->ifp = NULL;
   75                 return;
   76         }
   77 
   78         ifp = ubus->ifp = if_alloc(IFT_USB);
   79         if (ifp == NULL) {
   80                 device_printf(ubus->parent, "usbpf: Could not allocate "
   81                     "instance\n");
   82                 return;
   83         }
   84 
   85         if_initname(ifp, "usbus", device_get_unit(ubus->bdev));
   86         ifp->if_flags = IFF_CANTCONFIG;
   87         if_attach(ifp);
   88         if_up(ifp);
   89 
   90         /*
   91          * XXX According to the specification of DLT_USB, it indicates
   92          * packets beginning with USB setup header. But not sure all
   93          * packets would be.
   94          */
   95         bpfattach(ifp, DLT_USB, USBPF_HDR_LEN);
   96 
   97         if (bootverbose)
   98                 device_printf(ubus->parent, "usbpf: Attached\n");
   99 }
  100 
  101 void
  102 usbpf_detach(struct usb_bus *ubus)
  103 {
  104         struct ifnet *ifp = ubus->ifp;
  105 
  106         if (ifp != NULL) {
  107                 bpfdetach(ifp);
  108                 if_down(ifp);
  109                 if_detach(ifp);
  110                 if_free(ifp);
  111         }
  112         ubus->ifp = NULL;
  113 }
  114 
  115 static uint32_t
  116 usbpf_aggregate_xferflags(struct usb_xfer_flags *flags)
  117 {
  118         uint32_t val = 0;
  119 
  120         if (flags->force_short_xfer == 1)
  121                 val |= USBPF_FLAG_FORCE_SHORT_XFER;
  122         if (flags->short_xfer_ok == 1)
  123                 val |= USBPF_FLAG_SHORT_XFER_OK;
  124         if (flags->short_frames_ok == 1)
  125                 val |= USBPF_FLAG_SHORT_FRAMES_OK;
  126         if (flags->pipe_bof == 1)
  127                 val |= USBPF_FLAG_PIPE_BOF;
  128         if (flags->proxy_buffer == 1)
  129                 val |= USBPF_FLAG_PROXY_BUFFER;
  130         if (flags->ext_buffer == 1)
  131                 val |= USBPF_FLAG_EXT_BUFFER;
  132         if (flags->manual_status == 1)
  133                 val |= USBPF_FLAG_MANUAL_STATUS;
  134         if (flags->no_pipe_ok == 1)
  135                 val |= USBPF_FLAG_NO_PIPE_OK;
  136         if (flags->stall_pipe == 1)
  137                 val |= USBPF_FLAG_STALL_PIPE;
  138         return (val);
  139 }
  140 
  141 static uint32_t
  142 usbpf_aggregate_status(struct usb_xfer_flags_int *flags)
  143 {
  144         uint32_t val = 0;
  145 
  146         if (flags->open == 1)
  147                 val |= USBPF_STATUS_OPEN;
  148         if (flags->transferring == 1)
  149                 val |= USBPF_STATUS_TRANSFERRING;
  150         if (flags->did_dma_delay == 1)
  151                 val |= USBPF_STATUS_DID_DMA_DELAY;
  152         if (flags->did_close == 1)
  153                 val |= USBPF_STATUS_DID_CLOSE;
  154         if (flags->draining == 1)
  155                 val |= USBPF_STATUS_DRAINING;
  156         if (flags->started == 1)
  157                 val |= USBPF_STATUS_STARTED;
  158         if (flags->bandwidth_reclaimed == 1)
  159                 val |= USBPF_STATUS_BW_RECLAIMED;
  160         if (flags->control_xfr == 1)
  161                 val |= USBPF_STATUS_CONTROL_XFR;
  162         if (flags->control_hdr == 1)
  163                 val |= USBPF_STATUS_CONTROL_HDR;
  164         if (flags->control_act == 1)
  165                 val |= USBPF_STATUS_CONTROL_ACT;
  166         if (flags->control_stall == 1)
  167                 val |= USBPF_STATUS_CONTROL_STALL;
  168         if (flags->short_frames_ok == 1)
  169                 val |= USBPF_STATUS_SHORT_FRAMES_OK;
  170         if (flags->short_xfer_ok == 1)
  171                 val |= USBPF_STATUS_SHORT_XFER_OK;
  172 #if USB_HAVE_BUSDMA
  173         if (flags->bdma_enable == 1)
  174                 val |= USBPF_STATUS_BDMA_ENABLE;
  175         if (flags->bdma_no_post_sync == 1)
  176                 val |= USBPF_STATUS_BDMA_NO_POST_SYNC;
  177         if (flags->bdma_setup == 1)
  178                 val |= USBPF_STATUS_BDMA_SETUP;
  179 #endif
  180         if (flags->isochronous_xfr == 1)
  181                 val |= USBPF_STATUS_ISOCHRONOUS_XFR;
  182         if (flags->curr_dma_set == 1)
  183                 val |= USBPF_STATUS_CURR_DMA_SET;
  184         if (flags->can_cancel_immed == 1)
  185                 val |= USBPF_STATUS_CAN_CANCEL_IMMED;
  186         if (flags->doing_callback == 1)
  187                 val |= USBPF_STATUS_DOING_CALLBACK;
  188 
  189         return (val);
  190 }
  191 
  192 static int
  193 usbpf_xfer_frame_is_read(struct usb_xfer *xfer, uint32_t frame)
  194 {
  195         int isread;
  196 
  197         if ((frame == 0) && (xfer->flags_int.control_xfr != 0) &&
  198             (xfer->flags_int.control_hdr != 0)) {
  199                 /* special case */
  200                 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
  201                         /* The device controller writes to memory */
  202                         isread = 1;
  203                 } else {
  204                         /* The host controller reads from memory */
  205                         isread = 0;
  206                 }
  207         } else {
  208                 isread = USB_GET_DATA_ISREAD(xfer);
  209         }
  210         return (isread);
  211 }
  212 
  213 static uint32_t
  214 usbpf_xfer_precompute_size(struct usb_xfer *xfer, int type)
  215 {
  216         uint32_t totlen;
  217         uint32_t x;
  218         uint32_t nframes;
  219 
  220         if (type == USBPF_XFERTAP_SUBMIT)
  221                 nframes = xfer->nframes;
  222         else
  223                 nframes = xfer->aframes;
  224 
  225         totlen = USBPF_HDR_LEN + (USBPF_FRAME_HDR_LEN * nframes);
  226 
  227         /* precompute all trace lengths */
  228         for (x = 0; x != nframes; x++) {
  229                 if (usbpf_xfer_frame_is_read(xfer, x)) {
  230                         if (type != USBPF_XFERTAP_SUBMIT) {
  231                                 totlen += USBPF_FRAME_ALIGN(
  232                                     xfer->frlengths[x]);
  233                         }
  234                 } else {
  235                         if (type == USBPF_XFERTAP_SUBMIT) {
  236                                 totlen += USBPF_FRAME_ALIGN(
  237                                     xfer->frlengths[x]);
  238                         }
  239                 }
  240         }
  241         return (totlen);
  242 }
  243 
  244 void
  245 usbpf_xfertap(struct usb_xfer *xfer, int type)
  246 {
  247         struct usb_bus *bus;
  248         struct usbpf_pkthdr *up;
  249         struct usbpf_framehdr *uf;
  250         usb_frlength_t offset;
  251         uint32_t totlen;
  252         uint32_t frame;
  253         uint32_t temp;
  254         uint32_t nframes;
  255         uint32_t x;
  256         uint8_t *buf;
  257         uint8_t *ptr;
  258 
  259         bus = xfer->xroot->bus;
  260 
  261         /* sanity checks */
  262         if (usb_no_pf != 0)
  263                 return;
  264         if (bus->ifp == NULL)
  265                 return;
  266         if (!bpf_peers_present(bus->ifp->if_bpf))
  267                 return;
  268 
  269         totlen = usbpf_xfer_precompute_size(xfer, type);
  270 
  271         if (type == USBPF_XFERTAP_SUBMIT)
  272                 nframes = xfer->nframes;
  273         else
  274                 nframes = xfer->aframes;
  275 
  276         /*
  277          * XXX TODO XXX
  278          *
  279          * When BPF supports it we could pass a fragmented array of
  280          * buffers avoiding the data copy operation here.
  281          */
  282         buf = ptr = malloc(totlen, M_TEMP, M_NOWAIT);
  283         if (buf == NULL) {
  284                 device_printf(bus->parent, "usbpf: Out of memory\n");
  285                 return;
  286         }
  287 
  288         up = (struct usbpf_pkthdr *)ptr;
  289         ptr += USBPF_HDR_LEN;
  290 
  291         /* fill out header */
  292         temp = device_get_unit(bus->bdev);
  293         up->up_totlen = htole32(totlen);
  294         up->up_busunit = htole32(temp);
  295         up->up_address = xfer->xroot->udev->device_index;
  296         if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
  297                 up->up_mode = USBPF_MODE_DEVICE;
  298         else
  299                 up->up_mode = USBPF_MODE_HOST;
  300         up->up_type = type;
  301         up->up_xfertype = xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE;
  302         temp = usbpf_aggregate_xferflags(&xfer->flags);
  303         up->up_flags = htole32(temp);
  304         temp = usbpf_aggregate_status(&xfer->flags_int);
  305         up->up_status = htole32(temp);
  306         temp = xfer->error;
  307         up->up_error = htole32(temp);
  308         temp = xfer->interval;
  309         up->up_interval = htole32(temp);
  310         up->up_frames = htole32(nframes);
  311         temp = xfer->max_packet_size;
  312         up->up_packet_size = htole32(temp);
  313         temp = xfer->max_packet_count;
  314         up->up_packet_count = htole32(temp);
  315         temp = xfer->endpointno;
  316         up->up_endpoint = htole32(temp);
  317         up->up_speed = xfer->xroot->udev->speed;
  318 
  319         /* clear reserved area */
  320         memset(up->up_reserved, 0, sizeof(up->up_reserved));
  321 
  322         /* init offset and frame */
  323         offset = 0;
  324         frame = 0;
  325 
  326         /* iterate all the USB frames and copy data, if any */
  327         for (x = 0; x != nframes; x++) {
  328                 uint32_t length;
  329                 int isread;
  330 
  331                 /* get length */
  332                 length = xfer->frlengths[x];
  333 
  334                 /* get frame header pointer */
  335                 uf = (struct usbpf_framehdr *)ptr;
  336                 ptr += USBPF_FRAME_HDR_LEN;
  337 
  338                 /* fill out packet header */
  339                 uf->length = htole32(length);
  340                 uf->flags = 0;
  341 
  342                 /* get information about data read/write */
  343                 isread = usbpf_xfer_frame_is_read(xfer, x);
  344 
  345                 /* check if we need to copy any data */
  346                 if (isread) {
  347                         if (type == USBPF_XFERTAP_SUBMIT)
  348                                 length = 0;
  349                         else {
  350                                 uf->flags |= htole32(
  351                                     USBPF_FRAMEFLAG_DATA_FOLLOWS);
  352                         }
  353                 } else {
  354                         if (type != USBPF_XFERTAP_SUBMIT)
  355                                 length = 0;
  356                         else {
  357                                 uf->flags |= htole32(
  358                                     USBPF_FRAMEFLAG_DATA_FOLLOWS);
  359                         }
  360                 }
  361 
  362                 /* check if data is read direction */
  363                 if (isread)
  364                         uf->flags |= htole32(USBPF_FRAMEFLAG_READ);
  365 
  366                 /* copy USB data, if any */
  367                 if (length != 0) {
  368                         /* copy data */
  369                         usbd_copy_out(&xfer->frbuffers[frame],
  370                             offset, ptr, length);
  371 
  372                         /* align length */
  373                         temp = USBPF_FRAME_ALIGN(length);
  374 
  375                         /* zero pad */
  376                         if (temp != length)
  377                                 memset(ptr + length, 0, temp - length);
  378 
  379                         ptr += temp;
  380                 }
  381 
  382                 if (xfer->flags_int.isochronous_xfr) {
  383                         offset += usbd_xfer_old_frame_length(xfer, x);
  384                 } else {
  385                         frame ++;
  386                 }
  387         }
  388 
  389         bpf_tap(bus->ifp->if_bpf, buf, totlen);
  390 
  391         free(buf, M_TEMP);
  392 }
Cache object: f9eb859554192bc1e33dd2575bd2ca08
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/usb/usb_pf.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/usb_pf.c
