net/packet/af_packet.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              PACKET - implements raw packet sockets.
   7  *
   8  * Authors:     Ross Biro
   9  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  10  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
  11  *
  12  * Fixes:
  13  *              Alan Cox        :       verify_area() now used correctly
  14  *              Alan Cox        :       new skbuff lists, look ma no backlogs!
  15  *              Alan Cox        :       tidied skbuff lists.
  16  *              Alan Cox        :       Now uses generic datagram routines I
  17  *                                      added. Also fixed the peek/read crash
  18  *                                      from all old Linux datagram code.
  19  *              Alan Cox        :       Uses the improved datagram code.
  20  *              Alan Cox        :       Added NULL's for socket options.
  21  *              Alan Cox        :       Re-commented the code.
  22  *              Alan Cox        :       Use new kernel side addressing
  23  *              Rob Janssen     :       Correct MTU usage.
  24  *              Dave Platt      :       Counter leaks caused by incorrect
  25  *                                      interrupt locking and some slightly
  26  *                                      dubious gcc output. Can you read
  27  *                                      compiler: it said _VOLATILE_
  28  *      Richard Kooijman        :       Timestamp fixes.
  29  *              Alan Cox        :       New buffers. Use sk->mac.raw.
  30  *              Alan Cox        :       sendmsg/recvmsg support.
  31  *              Alan Cox        :       Protocol setting support
  32  *      Alexey Kuznetsov        :       Untied from IPv4 stack.
  33  *      Cyrus Durgin            :       Fixed kerneld for kmod.
  34  *      Michal Ostrowski        :       Module initialization cleanup.
  35  *         Ulises Alonso        :       Frame number limit removal and
  36  *                                      packet_set_ring memory leak.
  37  *              Eric Biederman  :       Allow for > 8 byte hardware addresses.
  38  *                                      The convention is that longer addresses
  39  *                                      will simply extend the hardware address
  40  *                                      byte arrays at the end of sockaddr_ll
  41  *                                      and packet_mreq.
  42  *
  43  *              This program is free software; you can redistribute it and/or
  44  *              modify it under the terms of the GNU General Public License
  45  *              as published by the Free Software Foundation; either version
  46  *              2 of the License, or (at your option) any later version.
  47  *
  48  */
  49
  50 #include <linux/types.h>
  51 #include <linux/mm.h>
  52 #include <linux/capability.h>
  53 #include <linux/fcntl.h>
  54 #include <linux/socket.h>
  55 #include <linux/in.h>
  56 #include <linux/inet.h>
  57 #include <linux/netdevice.h>
  58 #include <linux/if_packet.h>
  59 #include <linux/wireless.h>
  60 #include <linux/kernel.h>
  61 #include <linux/kmod.h>
  62 #include <net/net_namespace.h>
  63 #include <net/ip.h>
  64 #include <net/protocol.h>
  65 #include <linux/skbuff.h>
  66 #include <net/sock.h>
  67 #include <linux/errno.h>
  68 #include <linux/timer.h>
  69 #include <asm/system.h>
  70 #include <asm/uaccess.h>
  71 #include <asm/ioctls.h>
  72 #include <asm/page.h>
  73 #include <asm/cacheflush.h>
  74 #include <asm/io.h>
  75 #include <linux/proc_fs.h>
  76 #include <linux/seq_file.h>
  77 #include <linux/poll.h>
  78 #include <linux/module.h>
  79 #include <linux/init.h>
  80 #include <linux/mutex.h>
  81
  82 #ifdef CONFIG_INET
  83 #include <net/inet_common.h>
  84 #endif
  85
  86 /*
  87    Assumptions:
  88    - if device has no dev->hard_header routine, it adds and removes ll header
  89      inside itself. In this case ll header is invisible outside of device,
  90      but higher levels still should reserve dev->hard_header_len.
  91      Some devices are enough clever to reallocate skb, when header
  92      will not fit to reserved space (tunnel), another ones are silly
  93      (PPP).
  94    - packet socket receives packets with pulled ll header,
  95      so that SOCK_RAW should push it back.
  96
  97 On receive:
  98 -----------
  99
 100 Incoming, dev->hard_header!=NULL
 101    mac_header -> ll header
 102    data       -> data
 103
 104 Outgoing, dev->hard_header!=NULL
 105    mac_header -> ll header
 106    data       -> ll header
 107
 108 Incoming, dev->hard_header==NULL
 109    mac_header -> UNKNOWN position. It is very likely, that it points to ll
 110                  header.  PPP makes it, that is wrong, because introduce
 111                  assymetry between rx and tx paths.
 112    data       -> data
 113
 114 Outgoing, dev->hard_header==NULL
 115    mac_header -> data. ll header is still not built!
 116    data       -> data
 117
 118 Resume
 119   If dev->hard_header==NULL we are unlikely to restore sensible ll header.
 120
 121
 122 On transmit:
 123 ------------
 124
 125 dev->hard_header != NULL
 126    mac_header -> ll header
 127    data       -> ll header
 128
 129 dev->hard_header == NULL (ll header is added by device, we cannot control it)
 130    mac_header -> data
 131    data       -> data
 132
 133    We should set nh.raw on output to correct posistion,
 134    packet classifier depends on it.
 135  */
 136
 137 /* Private packet socket structures. */
 138
 139 struct packet_mclist
 140 {
 141         struct packet_mclist    *next;
 142         int                     ifindex;
 143         int                     count;
 144         unsigned short          type;
 145         unsigned short          alen;
 146         unsigned char           addr[MAX_ADDR_LEN];
 147 };
 148 /* identical to struct packet_mreq except it has
 149  * a longer address field.
 150  */
 151 struct packet_mreq_max
 152 {
 153         int             mr_ifindex;
 154         unsigned short  mr_type;
 155         unsigned short  mr_alen;
 156         unsigned char   mr_address[MAX_ADDR_LEN];
 157 };
 158
 159 #ifdef CONFIG_PACKET_MMAP
 160 static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing);
 161 #endif
 162
 163 static void packet_flush_mclist(struct sock *sk);
 164
 165 struct packet_sock {
 166         /* struct sock has to be the first member of packet_sock */
 167         struct sock             sk;
 168         struct tpacket_stats    stats;
 169 #ifdef CONFIG_PACKET_MMAP
 170         char *                  *pg_vec;
 171         unsigned int            head;
 172         unsigned int            frames_per_block;
 173         unsigned int            frame_size;
 174         unsigned int            frame_max;
 175         int                     copy_thresh;
 176 #endif
 177         struct packet_type      prot_hook;
 178         spinlock_t              bind_lock;
 179         struct mutex            pg_vec_lock;
 180         unsigned int            running:1,      /* prot_hook is attached*/
 181                                 auxdata:1,
 182                                 origdev:1;
 183         int                     ifindex;        /* bound device         */
 184         __be16                  num;
 185         struct packet_mclist    *mclist;
 186 #ifdef CONFIG_PACKET_MMAP
 187         atomic_t                mapped;
 188         unsigned int            pg_vec_order;
 189         unsigned int            pg_vec_pages;
 190         unsigned int            pg_vec_len;
 191         enum tpacket_versions   tp_version;
 192         unsigned int            tp_hdrlen;
 193         unsigned int            tp_reserve;
 194 #endif
 195 };
 196
 197 struct packet_skb_cb {
 198         unsigned int origlen;
 199         union {
 200                 struct sockaddr_pkt pkt;
 201                 struct sockaddr_ll ll;
 202         } sa;
 203 };
 204
 205 #define PACKET_SKB_CB(__skb)    ((struct packet_skb_cb *)((__skb)->cb))
 206
 207 #ifdef CONFIG_PACKET_MMAP
 208
 209 static void *packet_lookup_frame(struct packet_sock *po, unsigned int position,
 210                                  int status)
 211 {
 212         unsigned int pg_vec_pos, frame_offset;
 213         union {
 214                 struct tpacket_hdr *h1;
 215                 struct tpacket2_hdr *h2;
 216                 void *raw;
 217         } h;
 218
 219         pg_vec_pos = position / po->frames_per_block;
 220         frame_offset = position % po->frames_per_block;
 221
 222         h.raw = po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size);
 223         switch (po->tp_version) {
 224         case TPACKET_V1:
 225                 if (status != (h.h1->tp_status ? TP_STATUS_USER :
 226                                                 TP_STATUS_KERNEL))
 227                         return NULL;
 228                 break;
 229         case TPACKET_V2:
 230                 if (status != (h.h2->tp_status ? TP_STATUS_USER :
 231                                                 TP_STATUS_KERNEL))
 232                         return NULL;
 233                 break;
 234         }
 235         return h.raw;
 236 }
 237
 238 static void __packet_set_status(struct packet_sock *po, void *frame, int status)
 239 {
 240         union {
 241                 struct tpacket_hdr *h1;
 242                 struct tpacket2_hdr *h2;
 243                 void *raw;
 244         } h;
 245
 246         h.raw = frame;
 247         switch (po->tp_version) {
 248         case TPACKET_V1:
 249                 h.h1->tp_status = status;
 250                 break;
 251         case TPACKET_V2:
 252                 h.h2->tp_status = status;
 253                 break;
 254         }
 255 }
 256 #endif
 257
 258 static inline struct packet_sock *pkt_sk(struct sock *sk)
 259 {
 260         return (struct packet_sock *)sk;
 261 }
 262
 263 static void packet_sock_destruct(struct sock *sk)
 264 {
 265         WARN_ON(atomic_read(&sk->sk_rmem_alloc));
 266         WARN_ON(atomic_read(&sk->sk_wmem_alloc));
 267
 268         if (!sock_flag(sk, SOCK_DEAD)) {
 269                 printk("Attempt to release alive packet socket: %p\n", sk);
 270                 return;
 271         }
 272
 273         sk_refcnt_debug_dec(sk);
 274 }
 275
 276
 277 static const struct proto_ops packet_ops;
 278
 279 static const struct proto_ops packet_ops_spkt;
 280
 281 static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt, struct net_device *orig_dev)
 282 {
 283         struct sock *sk;
 284         struct sockaddr_pkt *spkt;
 285
 286         /*
 287          *      When we registered the protocol we saved the socket in the data
 288          *      field for just this event.
 289          */
 290
 291         sk = pt->af_packet_priv;
 292
 293         /*
 294          *      Yank back the headers [hope the device set this
 295          *      right or kerboom...]
 296          *
 297          *      Incoming packets have ll header pulled,
 298          *      push it back.
 299          *
 300          *      For outgoing ones skb->data == skb_mac_header(skb)
 301          *      so that this procedure is noop.
 302          */
 303
 304         if (skb->pkt_type == PACKET_LOOPBACK)
 305                 goto out;
 306
 307         if (dev_net(dev) != sock_net(sk))
 308                 goto out;
 309
 310         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
 311                 goto oom;
 312
 313         /* drop any routing info */
 314         dst_release(skb->dst);
 315         skb->dst = NULL;
 316
 317         /* drop conntrack reference */
 318         nf_reset(skb);
 319
 320         spkt = &PACKET_SKB_CB(skb)->sa.pkt;
 321
 322         skb_push(skb, skb->data - skb_mac_header(skb));
 323
 324         /*
 325          *      The SOCK_PACKET socket receives _all_ frames.
 326          */
 327
 328         spkt->spkt_family = dev->type;
 329         strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
 330         spkt->spkt_protocol = skb->protocol;
 331
 332         /*
 333          *      Charge the memory to the socket. This is done specifically
 334          *      to prevent sockets using all the memory up.
 335          */
 336
 337         if (sock_queue_rcv_skb(sk,skb) == 0)
 338                 return 0;
 339
 340 out:
 341         kfree_skb(skb);
 342 oom:
 343         return 0;
 344 }
 345
 346
 347 /*
 348  *      Output a raw packet to a device layer. This bypasses all the other
 349  *      protocol layers and you must therefore supply it with a complete frame
 350  */
 351
 352 static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
 353                                struct msghdr *msg, size_t len)
 354 {
 355         struct sock *sk = sock->sk;
 356         struct sockaddr_pkt *saddr=(struct sockaddr_pkt *)msg->msg_name;
 357         struct sk_buff *skb;
 358         struct net_device *dev;
 359         __be16 proto=0;
 360         int err;
 361
 362         /*
 363          *      Get and verify the address.
 364          */
 365
 366         if (saddr)
 367         {
 368                 if (msg->msg_namelen < sizeof(struct sockaddr))
 369                         return(-EINVAL);
 370                 if (msg->msg_namelen==sizeof(struct sockaddr_pkt))
 371                         proto=saddr->spkt_protocol;
 372         }
 373         else
 374                 return(-ENOTCONN);      /* SOCK_PACKET must be sent giving an address */
 375
 376         /*
 377          *      Find the device first to size check it
 378          */
 379
 380         saddr->spkt_device[13] = 0;
 381         dev = dev_get_by_name(sock_net(sk), saddr->spkt_device);
 382         err = -ENODEV;
 383         if (dev == NULL)
 384                 goto out_unlock;
 385
 386         err = -ENETDOWN;
 387         if (!(dev->flags & IFF_UP))
 388                 goto out_unlock;
 389
 390         /*
 391          *      You may not queue a frame bigger than the mtu. This is the lowest level
 392          *      raw protocol and you must do your own fragmentation at this level.
 393          */
 394
 395         err = -EMSGSIZE;
 396         if (len > dev->mtu + dev->hard_header_len)
 397                 goto out_unlock;
 398
 399         err = -ENOBUFS;
 400         skb = sock_wmalloc(sk, len + LL_RESERVED_SPACE(dev), 0, GFP_KERNEL);
 401
 402         /*
 403          *      If the write buffer is full, then tough. At this level the user gets to
 404          *      deal with the problem - do your own algorithmic backoffs. That's far
 405          *      more flexible.
 406          */
 407
 408         if (skb == NULL)
 409                 goto out_unlock;
 410
 411         /*
 412          *      Fill it in
 413          */
 414
 415         /* FIXME: Save some space for broken drivers that write a
 416          * hard header at transmission time by themselves. PPP is the
 417          * notable one here. This should really be fixed at the driver level.
 418          */
 419         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 420         skb_reset_network_header(skb);
 421
 422         /* Try to align data part correctly */
 423         if (dev->header_ops) {
 424                 skb->data -= dev->hard_header_len;
 425                 skb->tail -= dev->hard_header_len;
 426                 if (len < dev->hard_header_len)
 427                         skb_reset_network_header(skb);
 428         }
 429
 430         /* Returns -EFAULT on error */
 431         err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 432         skb->protocol = proto;
 433         skb->dev = dev;
 434         skb->priority = sk->sk_priority;
 435         if (err)
 436                 goto out_free;
 437
 438         /*
 439          *      Now send it
 440          */
 441
 442         dev_queue_xmit(skb);
 443         dev_put(dev);
 444         return(len);
 445
 446 out_free:
 447         kfree_skb(skb);
 448 out_unlock:
 449         if (dev)
 450                 dev_put(dev);
 451         return err;
 452 }
 453
 454 static inline unsigned int run_filter(struct sk_buff *skb, struct sock *sk,
 455                                       unsigned int res)
 456 {
 457         struct sk_filter *filter;
 458
 459         rcu_read_lock_bh();
 460         filter = rcu_dereference(sk->sk_filter);
 461         if (filter != NULL)
 462                 res = sk_run_filter(skb, filter->insns, filter->len);
 463         rcu_read_unlock_bh();
 464
 465         return res;
 466 }
 467
 468 /*
 469    This function makes lazy skb cloning in hope that most of packets
 470    are discarded by BPF.
 471
 472    Note tricky part: we DO mangle shared skb! skb->data, skb->len
 473    and skb->cb are mangled. It works because (and until) packets
 474    falling here are owned by current CPU. Output packets are cloned
 475    by dev_queue_xmit_nit(), input packets are processed by net_bh
 476    sequencially, so that if we return skb to original state on exit,
 477    we will not harm anyone.
 478  */
 479
 480 static int packet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
 481 {
 482         struct sock *sk;
 483         struct sockaddr_ll *sll;
 484         struct packet_sock *po;
 485         u8 * skb_head = skb->data;
 486         int skb_len = skb->len;
 487         unsigned int snaplen, res;
 488
 489         if (skb->pkt_type == PACKET_LOOPBACK)
 490                 goto drop;
 491
 492         sk = pt->af_packet_priv;
 493         po = pkt_sk(sk);
 494
 495         if (dev_net(dev) != sock_net(sk))
 496                 goto drop;
 497
 498         skb->dev = dev;
 499
 500         if (dev->header_ops) {
 501                 /* The device has an explicit notion of ll header,
 502                    exported to higher levels.
 503
 504                    Otherwise, the device hides datails of it frame
 505                    structure, so that corresponding packet head
 506                    never delivered to user.
 507                  */
 508                 if (sk->sk_type != SOCK_DGRAM)
 509                         skb_push(skb, skb->data - skb_mac_header(skb));
 510                 else if (skb->pkt_type == PACKET_OUTGOING) {
 511                         /* Special case: outgoing packets have ll header at head */
 512                         skb_pull(skb, skb_network_offset(skb));
 513                 }
 514         }
 515
 516         snaplen = skb->len;
 517
 518         res = run_filter(skb, sk, snaplen);
 519         if (!res)
 520                 goto drop_n_restore;
 521         if (snaplen > res)
 522                 snaplen = res;
 523
 524         if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 525             (unsigned)sk->sk_rcvbuf)
 526                 goto drop_n_acct;
 527
 528         if (skb_shared(skb)) {
 529                 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
 530                 if (nskb == NULL)
 531                         goto drop_n_acct;
 532
 533                 if (skb_head != skb->data) {
 534                         skb->data = skb_head;
 535                         skb->len = skb_len;
 536                 }
 537                 kfree_skb(skb);
 538                 skb = nskb;
 539         }
 540
 541         BUILD_BUG_ON(sizeof(*PACKET_SKB_CB(skb)) + MAX_ADDR_LEN - 8 >
 542                      sizeof(skb->cb));
 543
 544         sll = &PACKET_SKB_CB(skb)->sa.ll;
 545         sll->sll_family = AF_PACKET;
 546         sll->sll_hatype = dev->type;
 547         sll->sll_protocol = skb->protocol;
 548         sll->sll_pkttype = skb->pkt_type;
 549         if (unlikely(po->origdev))
 550                 sll->sll_ifindex = orig_dev->ifindex;
 551         else
 552                 sll->sll_ifindex = dev->ifindex;
 553
 554         sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
 555
 556         PACKET_SKB_CB(skb)->origlen = skb->len;
 557
 558         if (pskb_trim(skb, snaplen))
 559                 goto drop_n_acct;
 560
 561         skb_set_owner_r(skb, sk);
 562         skb->dev = NULL;
 563         dst_release(skb->dst);
 564         skb->dst = NULL;
 565
 566         /* drop conntrack reference */
 567         nf_reset(skb);
 568
 569         spin_lock(&sk->sk_receive_queue.lock);
 570         po->stats.tp_packets++;
 571         __skb_queue_tail(&sk->sk_receive_queue, skb);
 572         spin_unlock(&sk->sk_receive_queue.lock);
 573         sk->sk_data_ready(sk, skb->len);
 574         return 0;
 575
 576 drop_n_acct:
 577         spin_lock(&sk->sk_receive_queue.lock);
 578         po->stats.tp_drops++;
 579         spin_unlock(&sk->sk_receive_queue.lock);
 580
 581 drop_n_restore:
 582         if (skb_head != skb->data && skb_shared(skb)) {
 583                 skb->data = skb_head;
 584                 skb->len = skb_len;
 585         }
 586 drop:
 587         kfree_skb(skb);
 588         return 0;
 589 }
 590
 591 #ifdef CONFIG_PACKET_MMAP
 592 static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
 593 {
 594         struct sock *sk;
 595         struct packet_sock *po;
 596         struct sockaddr_ll *sll;
 597         union {
 598                 struct tpacket_hdr *h1;
 599                 struct tpacket2_hdr *h2;
 600                 void *raw;
 601         } h;
 602         u8 * skb_head = skb->data;
 603         int skb_len = skb->len;
 604         unsigned int snaplen, res;
 605         unsigned long status = TP_STATUS_LOSING|TP_STATUS_USER;
 606         unsigned short macoff, netoff, hdrlen;
 607         struct sk_buff *copy_skb = NULL;
 608         struct timeval tv;
 609         struct timespec ts;
 610
 611         if (skb->pkt_type == PACKET_LOOPBACK)
 612                 goto drop;
 613
 614         sk = pt->af_packet_priv;
 615         po = pkt_sk(sk);
 616
 617         if (dev_net(dev) != sock_net(sk))
 618                 goto drop;
 619
 620         if (dev->header_ops) {
 621                 if (sk->sk_type != SOCK_DGRAM)
 622                         skb_push(skb, skb->data - skb_mac_header(skb));
 623                 else if (skb->pkt_type == PACKET_OUTGOING) {
 624                         /* Special case: outgoing packets have ll header at head */
 625                         skb_pull(skb, skb_network_offset(skb));
 626                 }
 627         }
 628
 629         if (skb->ip_summed == CHECKSUM_PARTIAL)
 630                 status |= TP_STATUS_CSUMNOTREADY;
 631
 632         snaplen = skb->len;
 633
 634         res = run_filter(skb, sk, snaplen);
 635         if (!res)
 636                 goto drop_n_restore;
 637         if (snaplen > res)
 638                 snaplen = res;
 639
 640         if (sk->sk_type == SOCK_DGRAM) {
 641                 macoff = netoff = TPACKET_ALIGN(po->tp_hdrlen) + 16 +
 642                                   po->tp_reserve;
 643         } else {
 644                 unsigned maclen = skb_network_offset(skb);
 645                 netoff = TPACKET_ALIGN(po->tp_hdrlen +
 646                                        (maclen < 16 ? 16 : maclen)) +
 647                         po->tp_reserve;
 648                 macoff = netoff - maclen;
 649         }
 650
 651         if (macoff + snaplen > po->frame_size) {
 652                 if (po->copy_thresh &&
 653                     atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
 654                     (unsigned)sk->sk_rcvbuf) {
 655                         if (skb_shared(skb)) {
 656                                 copy_skb = skb_clone(skb, GFP_ATOMIC);
 657                         } else {
 658                                 copy_skb = skb_get(skb);
 659                                 skb_head = skb->data;
 660                         }
 661                         if (copy_skb)
 662                                 skb_set_owner_r(copy_skb, sk);
 663                 }
 664                 snaplen = po->frame_size - macoff;
 665                 if ((int)snaplen < 0)
 666                         snaplen = 0;
 667         }
 668
 669         spin_lock(&sk->sk_receive_queue.lock);
 670         h.raw = packet_lookup_frame(po, po->head, TP_STATUS_KERNEL);
 671         if (!h.raw)
 672                 goto ring_is_full;
 673         po->head = po->head != po->frame_max ? po->head+1 : 0;
 674         po->stats.tp_packets++;
 675         if (copy_skb) {
 676                 status |= TP_STATUS_COPY;
 677                 __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
 678         }
 679         if (!po->stats.tp_drops)
 680                 status &= ~TP_STATUS_LOSING;
 681         spin_unlock(&sk->sk_receive_queue.lock);
 682
 683         skb_copy_bits(skb, 0, h.raw + macoff, snaplen);
 684
 685         switch (po->tp_version) {
 686         case TPACKET_V1:
 687                 h.h1->tp_len = skb->len;
 688                 h.h1->tp_snaplen = snaplen;
 689                 h.h1->tp_mac = macoff;
 690                 h.h1->tp_net = netoff;
 691                 if (skb->tstamp.tv64)
 692                         tv = ktime_to_timeval(skb->tstamp);
 693                 else
 694                         do_gettimeofday(&tv);
 695                 h.h1->tp_sec = tv.tv_sec;
 696                 h.h1->tp_usec = tv.tv_usec;
 697                 hdrlen = sizeof(*h.h1);
 698                 break;
 699         case TPACKET_V2:
 700                 h.h2->tp_len = skb->len;
 701                 h.h2->tp_snaplen = snaplen;
 702                 h.h2->tp_mac = macoff;
 703                 h.h2->tp_net = netoff;
 704                 if (skb->tstamp.tv64)
 705                         ts = ktime_to_timespec(skb->tstamp);
 706                 else
 707                         getnstimeofday(&ts);
 708                 h.h2->tp_sec = ts.tv_sec;
 709                 h.h2->tp_nsec = ts.tv_nsec;
 710                 h.h2->tp_vlan_tci = skb->vlan_tci;
 711                 hdrlen = sizeof(*h.h2);
 712                 break;
 713         default:
 714                 BUG();
 715         }
 716
 717         sll = h.raw + TPACKET_ALIGN(hdrlen);
 718         sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
 719         sll->sll_family = AF_PACKET;
 720         sll->sll_hatype = dev->type;
 721         sll->sll_protocol = skb->protocol;
 722         sll->sll_pkttype = skb->pkt_type;
 723         if (unlikely(po->origdev))
 724                 sll->sll_ifindex = orig_dev->ifindex;
 725         else
 726                 sll->sll_ifindex = dev->ifindex;
 727
 728         __packet_set_status(po, h.raw, status);
 729         smp_mb();
 730
 731         {
 732                 struct page *p_start, *p_end;
 733                 u8 *h_end = h.raw + macoff + snaplen - 1;
 734
 735                 p_start = virt_to_page(h.raw);
 736                 p_end = virt_to_page(h_end);
 737                 while (p_start <= p_end) {
 738                         flush_dcache_page(p_start);
 739                         p_start++;
 740                 }
 741         }
 742
 743         sk->sk_data_ready(sk, 0);
 744
 745 drop_n_restore:
 746         if (skb_head != skb->data && skb_shared(skb)) {
 747                 skb->data = skb_head;
 748                 skb->len = skb_len;
 749         }
 750 drop:
 751         kfree_skb(skb);
 752         return 0;
 753
 754 ring_is_full:
 755         po->stats.tp_drops++;
 756         spin_unlock(&sk->sk_receive_queue.lock);
 757
 758         sk->sk_data_ready(sk, 0);
 759         if (copy_skb)
 760                 kfree_skb(copy_skb);
 761         goto drop_n_restore;
 762 }
 763
 764 #endif
 765
 766
 767 static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
 768                           struct msghdr *msg, size_t len)
 769 {
 770         struct sock *sk = sock->sk;
 771         struct sockaddr_ll *saddr=(struct sockaddr_ll *)msg->msg_name;
 772         struct sk_buff *skb;
 773         struct net_device *dev;
 774         __be16 proto;
 775         unsigned char *addr;
 776         int ifindex, err, reserve = 0;
 777
 778         /*
 779          *      Get and verify the address.
 780          */
 781
 782         if (saddr == NULL) {
 783                 struct packet_sock *po = pkt_sk(sk);
 784
 785                 ifindex = po->ifindex;
 786                 proto   = po->num;
 787                 addr    = NULL;
 788         } else {
 789                 err = -EINVAL;
 790                 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
 791                         goto out;
 792                 if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
 793                         goto out;
 794                 ifindex = saddr->sll_ifindex;
 795                 proto   = saddr->sll_protocol;
 796                 addr    = saddr->sll_addr;
 797         }
 798
 799
 800         dev = dev_get_by_index(sock_net(sk), ifindex);
 801         err = -ENXIO;
 802         if (dev == NULL)
 803                 goto out_unlock;
 804         if (sock->type == SOCK_RAW)
 805                 reserve = dev->hard_header_len;
 806
 807         err = -ENETDOWN;
 808         if (!(dev->flags & IFF_UP))
 809                 goto out_unlock;
 810
 811         err = -EMSGSIZE;
 812         if (len > dev->mtu+reserve)
 813                 goto out_unlock;
 814
 815         skb = sock_alloc_send_skb(sk, len + LL_ALLOCATED_SPACE(dev),
 816                                 msg->msg_flags & MSG_DONTWAIT, &err);
 817         if (skb==NULL)
 818                 goto out_unlock;
 819
 820         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 821         skb_reset_network_header(skb);
 822
 823         err = -EINVAL;
 824         if (sock->type == SOCK_DGRAM &&
 825             dev_hard_header(skb, dev, ntohs(proto), addr, NULL, len) < 0)
 826                 goto out_free;
 827
 828         /* Returns -EFAULT on error */
 829         err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 830         if (err)
 831                 goto out_free;
 832
 833         skb->protocol = proto;
 834         skb->dev = dev;
 835         skb->priority = sk->sk_priority;
 836
 837         /*
 838          *      Now send it
 839          */
 840
 841         err = dev_queue_xmit(skb);
 842         if (err > 0 && (err = net_xmit_errno(err)) != 0)
 843                 goto out_unlock;
 844
 845         dev_put(dev);
 846
 847         return(len);
 848
 849 out_free:
 850         kfree_skb(skb);
 851 out_unlock:
 852         if (dev)
 853                 dev_put(dev);
 854 out:
 855         return err;
 856 }
 857
 858 /*
 859  *      Close a PACKET socket. This is fairly simple. We immediately go
 860  *      to 'closed' state and remove our protocol entry in the device list.
 861  */
 862
 863 static int packet_release(struct socket *sock)
 864 {
 865         struct sock *sk = sock->sk;
 866         struct packet_sock *po;
 867         struct net *net;
 868
 869         if (!sk)
 870                 return 0;
 871
 872         net = sock_net(sk);
 873         po = pkt_sk(sk);
 874
 875         write_lock_bh(&net->packet.sklist_lock);
 876         sk_del_node_init(sk);
 877         write_unlock_bh(&net->packet.sklist_lock);
 878
 879         /*
 880          *      Unhook packet receive handler.
 881          */
 882
 883         if (po->running) {
 884                 /*
 885                  *      Remove the protocol hook
 886                  */
 887                 dev_remove_pack(&po->prot_hook);
 888                 po->running = 0;
 889                 po->num = 0;
 890                 __sock_put(sk);
 891         }
 892
 893         packet_flush_mclist(sk);
 894
 895 #ifdef CONFIG_PACKET_MMAP
 896         if (po->pg_vec) {
 897                 struct tpacket_req req;
 898                 memset(&req, 0, sizeof(req));
 899                 packet_set_ring(sk, &req, 1);
 900         }
 901 #endif
 902
 903         /*
 904          *      Now the socket is dead. No more input will appear.
 905          */
 906
 907         sock_orphan(sk);
 908         sock->sk = NULL;
 909
 910         /* Purge queues */
 911
 912         skb_queue_purge(&sk->sk_receive_queue);
 913         sk_refcnt_debug_release(sk);
 914
 915         sock_put(sk);
 916         return 0;
 917 }
 918
 919 /*
 920  *      Attach a packet hook.
 921  */
 922
 923 static int packet_do_bind(struct sock *sk, struct net_device *dev, __be16 protocol)
 924 {
 925         struct packet_sock *po = pkt_sk(sk);
 926         /*
 927          *      Detach an existing hook if present.
 928          */
 929
 930         lock_sock(sk);
 931
 932         spin_lock(&po->bind_lock);
 933         if (po->running) {
 934                 __sock_put(sk);
 935                 po->running = 0;
 936                 po->num = 0;
 937                 spin_unlock(&po->bind_lock);
 938                 dev_remove_pack(&po->prot_hook);
 939                 spin_lock(&po->bind_lock);
 940         }
 941
 942         po->num = protocol;
 943         po->prot_hook.type = protocol;
 944         po->prot_hook.dev = dev;
 945
 946         po->ifindex = dev ? dev->ifindex : 0;
 947
 948         if (protocol == 0)
 949                 goto out_unlock;
 950
 951         if (!dev || (dev->flags & IFF_UP)) {
 952                 dev_add_pack(&po->prot_hook);
 953                 sock_hold(sk);
 954                 po->running = 1;
 955         } else {
 956                 sk->sk_err = ENETDOWN;
 957                 if (!sock_flag(sk, SOCK_DEAD))
 958                         sk->sk_error_report(sk);
 959         }
 960
 961 out_unlock:
 962         spin_unlock(&po->bind_lock);
 963         release_sock(sk);
 964         return 0;
 965 }
 966
 967 /*
 968  *      Bind a packet socket to a device
 969  */
 970
 971 static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 972 {
 973         struct sock *sk=sock->sk;
 974         char name[15];
 975         struct net_device *dev;
 976         int err = -ENODEV;
 977
 978         /*
 979          *      Check legality
 980          */
 981
 982         if (addr_len != sizeof(struct sockaddr))
 983                 return -EINVAL;
 984         strlcpy(name,uaddr->sa_data,sizeof(name));
 985
 986         dev = dev_get_by_name(sock_net(sk), name);
 987         if (dev) {
 988                 err = packet_do_bind(sk, dev, pkt_sk(sk)->num);
 989                 dev_put(dev);
 990         }
 991         return err;
 992 }
 993
 994 static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 995 {
 996         struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
 997         struct sock *sk=sock->sk;
 998         struct net_device *dev = NULL;
 999         int err;
1000
1001
1002         /*
1003          *      Check legality
1004          */
1005
1006         if (addr_len < sizeof(struct sockaddr_ll))
1007                 return -EINVAL;
1008         if (sll->sll_family != AF_PACKET)
1009                 return -EINVAL;
1010
1011         if (sll->sll_ifindex) {
1012                 err = -ENODEV;
1013                 dev = dev_get_by_index(sock_net(sk), sll->sll_ifindex);
1014                 if (dev == NULL)
1015                         goto out;
1016         }
1017         err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num);
1018         if (dev)
1019                 dev_put(dev);
1020
1021 out:
1022         return err;
1023 }
1024
1025 static struct proto packet_proto = {
1026         .name     = "PACKET",
1027         .owner    = THIS_MODULE,
1028         .obj_size = sizeof(struct packet_sock),
1029 };
1030
1031 /*
1032  *      Create a packet of type SOCK_PACKET.
1033  */
1034
1035 static int packet_create(struct net *net, struct socket *sock, int protocol)
1036 {
1037         struct sock *sk;
1038         struct packet_sock *po;
1039         __be16 proto = (__force __be16)protocol; /* weird, but documented */
1040         int err;
1041
1042         if (!capable(CAP_NET_RAW))
1043                 return -EPERM;
1044         if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW &&
1045             sock->type != SOCK_PACKET)
1046                 return -ESOCKTNOSUPPORT;
1047
1048         sock->state = SS_UNCONNECTED;
1049
1050         err = -ENOBUFS;
1051         sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto);
1052         if (sk == NULL)
1053                 goto out;
1054
1055         sock->ops = &packet_ops;
1056         if (sock->type == SOCK_PACKET)
1057                 sock->ops = &packet_ops_spkt;
1058
1059         sock_init_data(sock, sk);
1060
1061         po = pkt_sk(sk);
1062         sk->sk_family = PF_PACKET;
1063         po->num = proto;
1064
1065         sk->sk_destruct = packet_sock_destruct;
1066         sk_refcnt_debug_inc(sk);
1067
1068         /*
1069          *      Attach a protocol block
1070          */
1071
1072         spin_lock_init(&po->bind_lock);
1073         mutex_init(&po->pg_vec_lock);
1074         po->prot_hook.func = packet_rcv;
1075
1076         if (sock->type == SOCK_PACKET)
1077                 po->prot_hook.func = packet_rcv_spkt;
1078
1079         po->prot_hook.af_packet_priv = sk;
1080
1081         if (proto) {
1082                 po->prot_hook.type = proto;
1083                 dev_add_pack(&po->prot_hook);
1084                 sock_hold(sk);
1085                 po->running = 1;
1086         }
1087
1088         write_lock_bh(&net->packet.sklist_lock);
1089         sk_add_node(sk, &net->packet.sklist);
1090         write_unlock_bh(&net->packet.sklist_lock);
1091         return(0);
1092 out:
1093         return err;
1094 }
1095
1096 /*
1097  *      Pull a packet from our receive queue and hand it to the user.
1098  *      If necessary we block.
1099  */
1100
1101 static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
1102                           struct msghdr *msg, size_t len, int flags)
1103 {
1104         struct sock *sk = sock->sk;
1105         struct sk_buff *skb;
1106         int copied, err;
1107         struct sockaddr_ll *sll;
1108
1109         err = -EINVAL;
1110         if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
1111                 goto out;
1112
1113 #if 0
1114         /* What error should we return now? EUNATTACH? */
1115         if (pkt_sk(sk)->ifindex < 0)
1116                 return -ENODEV;
1117 #endif
1118
1119         /*
1120          *      Call the generic datagram receiver. This handles all sorts
1121          *      of horrible races and re-entrancy so we can forget about it
1122          *      in the protocol layers.
1123          *
1124          *      Now it will return ENETDOWN, if device have just gone down,
1125          *      but then it will block.
1126          */
1127
1128         skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
1129
1130         /*
1131          *      An error occurred so return it. Because skb_recv_datagram()
1132          *      handles the blocking we don't see and worry about blocking
1133          *      retries.
1134          */
1135
1136         if (skb == NULL)
1137                 goto out;
1138
1139         /*
1140          *      If the address length field is there to be filled in, we fill
1141          *      it in now.
1142          */
1143
1144         sll = &PACKET_SKB_CB(skb)->sa.ll;
1145         if (sock->type == SOCK_PACKET)
1146                 msg->msg_namelen = sizeof(struct sockaddr_pkt);
1147         else
1148                 msg->msg_namelen = sll->sll_halen + offsetof(struct sockaddr_ll, sll_addr);
1149
1150         /*
1151          *      You lose any data beyond the buffer you gave. If it worries a
1152          *      user program they can ask the device for its MTU anyway.
1153          */
1154
1155         copied = skb->len;
1156         if (copied > len)
1157         {
1158                 copied=len;
1159                 msg->msg_flags|=MSG_TRUNC;
1160         }
1161
1162         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1163         if (err)
1164                 goto out_free;
1165
1166         sock_recv_timestamp(msg, sk, skb);
1167
1168         if (msg->msg_name)
1169                 memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa,
1170                        msg->msg_namelen);
1171
1172         if (pkt_sk(sk)->auxdata) {
1173                 struct tpacket_auxdata aux;
1174
1175                 aux.tp_status = TP_STATUS_USER;
1176                 if (skb->ip_summed == CHECKSUM_PARTIAL)
1177                         aux.tp_status |= TP_STATUS_CSUMNOTREADY;
1178                 aux.tp_len = PACKET_SKB_CB(skb)->origlen;
1179                 aux.tp_snaplen = skb->len;
1180                 aux.tp_mac = 0;
1181                 aux.tp_net = skb_network_offset(skb);
1182                 aux.tp_vlan_tci = skb->vlan_tci;
1183
1184                 put_cmsg(msg, SOL_PACKET, PACKET_AUXDATA, sizeof(aux), &aux);
1185         }
1186
1187         /*
1188          *      Free or return the buffer as appropriate. Again this
1189          *      hides all the races and re-entrancy issues from us.
1190          */
1191         err = (flags&MSG_TRUNC) ? skb->len : copied;
1192
1193 out_free:
1194         skb_free_datagram(sk, skb);
1195 out:
1196         return err;
1197 }
1198
1199 static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
1200                                int *uaddr_len, int peer)
1201 {
1202         struct net_device *dev;
1203         struct sock *sk = sock->sk;
1204
1205         if (peer)
1206                 return -EOPNOTSUPP;
1207
1208         uaddr->sa_family = AF_PACKET;
1209         dev = dev_get_by_index(sock_net(sk), pkt_sk(sk)->ifindex);
1210         if (dev) {
1211                 strlcpy(uaddr->sa_data, dev->name, 15);
1212                 dev_put(dev);
1213         } else
1214                 memset(uaddr->sa_data, 0, 14);
1215         *uaddr_len = sizeof(*uaddr);
1216
1217         return 0;
1218 }
1219
1220 static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
1221                           int *uaddr_len, int peer)
1222 {
1223         struct net_device *dev;
1224         struct sock *sk = sock->sk;
1225         struct packet_sock *po = pkt_sk(sk);
1226         struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
1227
1228         if (peer)
1229                 return -EOPNOTSUPP;
1230
1231         sll->sll_family = AF_PACKET;
1232         sll->sll_ifindex = po->ifindex;
1233         sll->sll_protocol = po->num;
1234         dev = dev_get_by_index(sock_net(sk), po->ifindex);
1235         if (dev) {
1236                 sll->sll_hatype = dev->type;
1237                 sll->sll_halen = dev->addr_len;
1238                 memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
1239                 dev_put(dev);
1240         } else {
1241                 sll->sll_hatype = 0;    /* Bad: we have no ARPHRD_UNSPEC */
1242                 sll->sll_halen = 0;
1243         }
1244         *uaddr_len = offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen;
1245
1246         return 0;
1247 }
1248
1249 static int packet_dev_mc(struct net_device *dev, struct packet_mclist *i,
1250                          int what)
1251 {
1252         switch (i->type) {
1253         case PACKET_MR_MULTICAST:
1254                 if (what > 0)
1255                         dev_mc_add(dev, i->addr, i->alen, 0);
1256                 else
1257                         dev_mc_delete(dev, i->addr, i->alen, 0);
1258                 break;
1259         case PACKET_MR_PROMISC:
1260                 return dev_set_promiscuity(dev, what);
1261                 break;
1262         case PACKET_MR_ALLMULTI:
1263                 return dev_set_allmulti(dev, what);
1264                 break;
1265         default:;
1266         }
1267         return 0;
1268 }
1269
1270 static void packet_dev_mclist(struct net_device *dev, struct packet_mclist *i, int what)
1271 {
1272         for ( ; i; i=i->next) {
1273                 if (i->ifindex == dev->ifindex)
1274                         packet_dev_mc(dev, i, what);
1275         }
1276 }
1277
1278 static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq)
1279 {
1280         struct packet_sock *po = pkt_sk(sk);
1281         struct packet_mclist *ml, *i;
1282         struct net_device *dev;
1283         int err;
1284
1285         rtnl_lock();
1286
1287         err = -ENODEV;
1288         dev = __dev_get_by_index(sock_net(sk), mreq->mr_ifindex);
1289         if (!dev)
1290                 goto done;
1291
1292         err = -EINVAL;
1293         if (mreq->mr_alen > dev->addr_len)
1294                 goto done;
1295
1296         err = -ENOBUFS;
1297         i = kmalloc(sizeof(*i), GFP_KERNEL);
1298         if (i == NULL)
1299                 goto done;
1300
1301         err = 0;
1302         for (ml = po->mclist; ml; ml = ml->next) {
1303                 if (ml->ifindex == mreq->mr_ifindex &&
1304                     ml->type == mreq->mr_type &&
1305                     ml->alen == mreq->mr_alen &&
1306                     memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1307                         ml->count++;
1308                         /* Free the new element ... */
1309                         kfree(i);
1310                         goto done;
1311                 }
1312         }
1313
1314         i->type = mreq->mr_type;
1315         i->ifindex = mreq->mr_ifindex;
1316         i->alen = mreq->mr_alen;
1317         memcpy(i->addr, mreq->mr_address, i->alen);
1318         i->count = 1;
1319         i->next = po->mclist;
1320         po->mclist = i;
1321         err = packet_dev_mc(dev, i, 1);
1322         if (err) {
1323                 po->mclist = i->next;
1324                 kfree(i);
1325         }
1326
1327 done:
1328         rtnl_unlock();
1329         return err;
1330 }
1331
1332 static int packet_mc_drop(struct sock *sk, struct packet_mreq_max *mreq)
1333 {
1334         struct packet_mclist *ml, **mlp;
1335
1336         rtnl_lock();
1337
1338         for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
1339                 if (ml->ifindex == mreq->mr_ifindex &&
1340                     ml->type == mreq->mr_type &&
1341                     ml->alen == mreq->mr_alen &&
1342                     memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1343                         if (--ml->count == 0) {
1344                                 struct net_device *dev;
1345                                 *mlp = ml->next;
1346                                 dev = dev_get_by_index(sock_net(sk), ml->ifindex);
1347                                 if (dev) {
1348                                         packet_dev_mc(dev, ml, -1);
1349                                         dev_put(dev);
1350                                 }
1351                                 kfree(ml);
1352                         }
1353                         rtnl_unlock();
1354                         return 0;
1355                 }
1356         }
1357         rtnl_unlock();
1358         return -EADDRNOTAVAIL;
1359 }
1360
1361 static void packet_flush_mclist(struct sock *sk)
1362 {
1363         struct packet_sock *po = pkt_sk(sk);
1364         struct packet_mclist *ml;
1365
1366         if (!po->mclist)
1367                 return;
1368
1369         rtnl_lock();
1370         while ((ml = po->mclist) != NULL) {
1371                 struct net_device *dev;
1372
1373                 po->mclist = ml->next;
1374                 if ((dev = dev_get_by_index(sock_net(sk), ml->ifindex)) != NULL) {
1375                         packet_dev_mc(dev, ml, -1);
1376                         dev_put(dev);
1377                 }
1378                 kfree(ml);
1379         }
1380         rtnl_unlock();
1381 }
1382
1383 static int
1384 packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
1385 {
1386         struct sock *sk = sock->sk;
1387         struct packet_sock *po = pkt_sk(sk);
1388         int ret;
1389
1390         if (level != SOL_PACKET)
1391                 return -ENOPROTOOPT;
1392
1393         switch(optname) {
1394         case PACKET_ADD_MEMBERSHIP:
1395         case PACKET_DROP_MEMBERSHIP:
1396         {
1397                 struct packet_mreq_max mreq;
1398                 int len = optlen;
1399                 memset(&mreq, 0, sizeof(mreq));
1400                 if (len < sizeof(struct packet_mreq))
1401                         return -EINVAL;
1402                 if (len > sizeof(mreq))
1403                         len = sizeof(mreq);
1404                 if (copy_from_user(&mreq,optval,len))
1405                         return -EFAULT;
1406                 if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
1407                         return -EINVAL;
1408                 if (optname == PACKET_ADD_MEMBERSHIP)
1409                         ret = packet_mc_add(sk, &mreq);
1410                 else
1411                         ret = packet_mc_drop(sk, &mreq);
1412                 return ret;
1413         }
1414
1415 #ifdef CONFIG_PACKET_MMAP
1416         case PACKET_RX_RING:
1417         {
1418                 struct tpacket_req req;
1419
1420                 if (optlen<sizeof(req))
1421                         return -EINVAL;
1422                 if (copy_from_user(&req,optval,sizeof(req)))
1423                         return -EFAULT;
1424                 return packet_set_ring(sk, &req, 0);
1425         }
1426         case PACKET_COPY_THRESH:
1427         {
1428                 int val;
1429
1430                 if (optlen!=sizeof(val))
1431                         return -EINVAL;
1432                 if (copy_from_user(&val,optval,sizeof(val)))
1433                         return -EFAULT;
1434
1435                 pkt_sk(sk)->copy_thresh = val;
1436                 return 0;
1437         }
1438         case PACKET_VERSION:
1439         {
1440                 int val;
1441
1442                 if (optlen != sizeof(val))
1443                         return -EINVAL;
1444                 if (po->pg_vec)
1445                         return -EBUSY;
1446                 if (copy_from_user(&val, optval, sizeof(val)))
1447                         return -EFAULT;
1448                 switch (val) {
1449                 case TPACKET_V1:
1450                 case TPACKET_V2:
1451                         po->tp_version = val;
1452                         return 0;
1453                 default:
1454                         return -EINVAL;
1455                 }
1456         }
1457         case PACKET_RESERVE:
1458         {
1459                 unsigned int val;
1460
1461                 if (optlen != sizeof(val))
1462                         return -EINVAL;
1463                 if (po->pg_vec)
1464                         return -EBUSY;
1465                 if (copy_from_user(&val, optval, sizeof(val)))
1466                         return -EFAULT;
1467                 po->tp_reserve = val;
1468                 return 0;
1469         }
1470 #endif
1471         case PACKET_AUXDATA:
1472         {
1473                 int val;
1474
1475                 if (optlen < sizeof(val))
1476                         return -EINVAL;
1477                 if (copy_from_user(&val, optval, sizeof(val)))
1478                         return -EFAULT;
1479
1480                 po->auxdata = !!val;
1481                 return 0;
1482         }
1483         case PACKET_ORIGDEV:
1484         {
1485                 int val;
1486
1487                 if (optlen < sizeof(val))
1488                         return -EINVAL;
1489                 if (copy_from_user(&val, optval, sizeof(val)))
1490                         return -EFAULT;
1491
1492                 po->origdev = !!val;
1493                 return 0;
1494         }
1495         default:
1496                 return -ENOPROTOOPT;
1497         }
1498 }
1499
1500 static int packet_getsockopt(struct socket *sock, int level, int optname,
1501                              char __user *optval, int __user *optlen)
1502 {
1503         unsigned int len;
1504         int val;
1505         struct sock *sk = sock->sk;
1506         struct packet_sock *po = pkt_sk(sk);
1507         void *data;
1508         struct tpacket_stats st;
1509
1510         if (level != SOL_PACKET)
1511                 return -ENOPROTOOPT;
1512
1513         if (get_user(len, optlen))
1514                 return -EFAULT;
1515
1516         if ((int)len < 0)
1517                 return -EINVAL;
1518
1519         switch(optname) {
1520         case PACKET_STATISTICS:
1521                 if (len > sizeof(struct tpacket_stats))
1522                         len = sizeof(struct tpacket_stats);
1523                 spin_lock_bh(&sk->sk_receive_queue.lock);
1524                 st = po->stats;
1525                 memset(&po->stats, 0, sizeof(st));
1526                 spin_unlock_bh(&sk->sk_receive_queue.lock);
1527                 st.tp_packets += st.tp_drops;
1528
1529                 data = &st;
1530                 break;
1531         case PACKET_AUXDATA:
1532                 if (len > sizeof(int))
1533                         len = sizeof(int);
1534                 val = po->auxdata;
1535
1536                 data = &val;
1537                 break;
1538         case PACKET_ORIGDEV:
1539                 if (len > sizeof(int))
1540                         len = sizeof(int);
1541                 val = po->origdev;
1542
1543                 data = &val;
1544                 break;
1545 #ifdef CONFIG_PACKET_MMAP
1546         case PACKET_VERSION:
1547                 if (len > sizeof(int))
1548                         len = sizeof(int);
1549                 val = po->tp_version;
1550                 data = &val;
1551                 break;
1552         case PACKET_HDRLEN:
1553                 if (len > sizeof(int))
1554                         len = sizeof(int);
1555                 if (copy_from_user(&val, optval, len))
1556                         return -EFAULT;
1557                 switch (val) {
1558                 case TPACKET_V1:
1559                         val = sizeof(struct tpacket_hdr);
1560                         break;
1561                 case TPACKET_V2:
1562                         val = sizeof(struct tpacket2_hdr);
1563                         break;
1564                 default:
1565                         return -EINVAL;
1566                 }
1567                 data = &val;
1568                 break;
1569         case PACKET_RESERVE:
1570                 if (len > sizeof(unsigned int))
1571                         len = sizeof(unsigned int);
1572                 val = po->tp_reserve;
1573                 data = &val;
1574                 break;
1575 #endif
1576         default:
1577                 return -ENOPROTOOPT;
1578         }
1579
1580         if (put_user(len, optlen))
1581                 return -EFAULT;
1582         if (copy_to_user(optval, data, len))
1583                 return -EFAULT;
1584         return 0;
1585 }
1586
1587
1588 static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1589 {
1590         struct sock *sk;
1591         struct hlist_node *node;
1592         struct net_device *dev = data;
1593         struct net *net = dev_net(dev);
1594
1595         read_lock(&net->packet.sklist_lock);
1596         sk_for_each(sk, node, &net->packet.sklist) {
1597                 struct packet_sock *po = pkt_sk(sk);
1598
1599                 switch (msg) {
1600                 case NETDEV_UNREGISTER:
1601                         if (po->mclist)
1602                                 packet_dev_mclist(dev, po->mclist, -1);
1603                         /* fallthrough */
1604
1605                 case NETDEV_DOWN:
1606                         if (dev->ifindex == po->ifindex) {
1607                                 spin_lock(&po->bind_lock);
1608                                 if (po->running) {
1609                                         __dev_remove_pack(&po->prot_hook);
1610                                         __sock_put(sk);
1611                                         po->running = 0;
1612                                         sk->sk_err = ENETDOWN;
1613                                         if (!sock_flag(sk, SOCK_DEAD))
1614                                                 sk->sk_error_report(sk);
1615                                 }
1616                                 if (msg == NETDEV_UNREGISTER) {
1617                                         po->ifindex = -1;
1618                                         po->prot_hook.dev = NULL;
1619                                 }
1620                                 spin_unlock(&po->bind_lock);
1621                         }
1622                         break;
1623                 case NETDEV_UP:
1624                         spin_lock(&po->bind_lock);
1625                         if (dev->ifindex == po->ifindex && po->num &&
1626                             !po->running) {
1627                                 dev_add_pack(&po->prot_hook);
1628                                 sock_hold(sk);
1629                                 po->running = 1;
1630                         }
1631                         spin_unlock(&po->bind_lock);
1632                         break;
1633                 }
1634         }
1635         read_unlock(&net->packet.sklist_lock);
1636         return NOTIFY_DONE;
1637 }
1638
1639
1640 static int packet_ioctl(struct socket *sock, unsigned int cmd,
1641                         unsigned long arg)
1642 {
1643         struct sock *sk = sock->sk;
1644
1645         switch(cmd) {
1646                 case SIOCOUTQ:
1647                 {
1648                         int amount = atomic_read(&sk->sk_wmem_alloc);
1649                         return put_user(amount, (int __user *)arg);
1650                 }
1651                 case SIOCINQ:
1652                 {
1653                         struct sk_buff *skb;
1654                         int amount = 0;
1655
1656                         spin_lock_bh(&sk->sk_receive_queue.lock);
1657                         skb = skb_peek(&sk->sk_receive_queue);
1658                         if (skb)
1659                                 amount = skb->len;
1660                         spin_unlock_bh(&sk->sk_receive_queue.lock);
1661                         return put_user(amount, (int __user *)arg);
1662                 }
1663                 case SIOCGSTAMP:
1664                         return sock_get_timestamp(sk, (struct timeval __user *)arg);
1665                 case SIOCGSTAMPNS:
1666                         return sock_get_timestampns(sk, (struct timespec __user *)arg);
1667
1668 #ifdef CONFIG_INET
1669                 case SIOCADDRT:
1670                 case SIOCDELRT:
1671                 case SIOCDARP:
1672                 case SIOCGARP:
1673                 case SIOCSARP:
1674                 case SIOCGIFADDR:
1675                 case SIOCSIFADDR:
1676                 case SIOCGIFBRDADDR:
1677                 case SIOCSIFBRDADDR:
1678                 case SIOCGIFNETMASK:
1679                 case SIOCSIFNETMASK:
1680                 case SIOCGIFDSTADDR:
1681                 case SIOCSIFDSTADDR:
1682                 case SIOCSIFFLAGS:
1683                         if (!net_eq(sock_net(sk), &init_net))
1684                                 return -ENOIOCTLCMD;
1685                         return inet_dgram_ops.ioctl(sock, cmd, arg);
1686 #endif
1687
1688                 default:
1689                         return -ENOIOCTLCMD;
1690         }
1691         return 0;
1692 }
1693
1694 #ifndef CONFIG_PACKET_MMAP
1695 #define packet_mmap sock_no_mmap
1696 #define packet_poll datagram_poll
1697 #else
1698
1699 static unsigned int packet_poll(struct file * file, struct socket *sock,
1700                                 poll_table *wait)
1701 {
1702         struct sock *sk = sock->sk;
1703         struct packet_sock *po = pkt_sk(sk);
1704         unsigned int mask = datagram_poll(file, sock, wait);
1705
1706         spin_lock_bh(&sk->sk_receive_queue.lock);
1707         if (po->pg_vec) {
1708                 unsigned last = po->head ? po->head-1 : po->frame_max;
1709
1710                 if (packet_lookup_frame(po, last, TP_STATUS_USER))
1711                         mask |= POLLIN | POLLRDNORM;
1712         }
1713         spin_unlock_bh(&sk->sk_receive_queue.lock);
1714         return mask;
1715 }
1716
1717
1718 /* Dirty? Well, I still did not learn better way to account
1719  * for user mmaps.
1720  */
1721
1722 static void packet_mm_open(struct vm_area_struct *vma)
1723 {
1724         struct file *file = vma->vm_file;
1725         struct socket * sock = file->private_data;
1726         struct sock *sk = sock->sk;
1727
1728         if (sk)
1729                 atomic_inc(&pkt_sk(sk)->mapped);
1730 }
1731
1732 static void packet_mm_close(struct vm_area_struct *vma)
1733 {
1734         struct file *file = vma->vm_file;
1735         struct socket * sock = file->private_data;
1736         struct sock *sk = sock->sk;
1737
1738         if (sk)
1739                 atomic_dec(&pkt_sk(sk)->mapped);
1740 }
1741
1742 static struct vm_operations_struct packet_mmap_ops = {
1743         .open = packet_mm_open,
1744         .close =packet_mm_close,
1745 };
1746
1747 static void free_pg_vec(char **pg_vec, unsigned int order, unsigned int len)
1748 {
1749         int i;
1750
1751         for (i = 0; i < len; i++) {
1752                 if (likely(pg_vec[i]))
1753                         free_pages((unsigned long) pg_vec[i], order);
1754         }
1755         kfree(pg_vec);
1756 }
1757
1758 static inline char *alloc_one_pg_vec_page(unsigned long order)
1759 {
1760         return (char *) __get_free_pages(GFP_KERNEL | __GFP_COMP | __GFP_ZERO,
1761                                          order);
1762 }
1763
1764 static char **alloc_pg_vec(struct tpacket_req *req, int order)
1765 {
1766         unsigned int block_nr = req->tp_block_nr;
1767         char **pg_vec;
1768         int i;
1769
1770         pg_vec = kzalloc(block_nr * sizeof(char *), GFP_KERNEL);
1771         if (unlikely(!pg_vec))
1772                 goto out;
1773
1774         for (i = 0; i < block_nr; i++) {
1775                 pg_vec[i] = alloc_one_pg_vec_page(order);
1776                 if (unlikely(!pg_vec[i]))
1777                         goto out_free_pgvec;
1778         }
1779
1780 out:
1781         return pg_vec;
1782
1783 out_free_pgvec:
1784         free_pg_vec(pg_vec, order, block_nr);
1785         pg_vec = NULL;
1786         goto out;
1787 }
1788
1789 static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing)
1790 {
1791         char **pg_vec = NULL;
1792         struct packet_sock *po = pkt_sk(sk);
1793         int was_running, order = 0;
1794         __be16 num;
1795         int err = 0;
1796
1797         if (req->tp_block_nr) {
1798                 int i;
1799
1800                 /* Sanity tests and some calculations */
1801
1802                 if (unlikely(po->pg_vec))
1803                         return -EBUSY;
1804
1805                 switch (po->tp_version) {
1806                 case TPACKET_V1:
1807                         po->tp_hdrlen = TPACKET_HDRLEN;
1808                         break;
1809                 case TPACKET_V2:
1810                         po->tp_hdrlen = TPACKET2_HDRLEN;
1811                         break;
1812                 }
1813
1814                 if (unlikely((int)req->tp_block_size <= 0))
1815                         return -EINVAL;
1816                 if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
1817                         return -EINVAL;
1818                 if (unlikely(req->tp_frame_size < po->tp_hdrlen +
1819                                                   po->tp_reserve))
1820                         return -EINVAL;
1821                 if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
1822                         return -EINVAL;
1823
1824                 po->frames_per_block = req->tp_block_size/req->tp_frame_size;
1825                 if (unlikely(po->frames_per_block <= 0))
1826                         return -EINVAL;
1827                 if (unlikely((po->frames_per_block * req->tp_block_nr) !=
1828                              req->tp_frame_nr))
1829                         return -EINVAL;
1830
1831                 err = -ENOMEM;
1832                 order = get_order(req->tp_block_size);
1833                 pg_vec = alloc_pg_vec(req, order);
1834                 if (unlikely(!pg_vec))
1835                         goto out;
1836
1837                 for (i = 0; i < req->tp_block_nr; i++) {
1838                         void *ptr = pg_vec[i];
1839                         int k;
1840
1841                         for (k = 0; k < po->frames_per_block; k++) {
1842                                 __packet_set_status(po, ptr, TP_STATUS_KERNEL);
1843                                 ptr += req->tp_frame_size;
1844                         }
1845                 }
1846                 /* Done */
1847         } else {
1848                 if (unlikely(req->tp_frame_nr))
1849                         return -EINVAL;
1850         }
1851
1852         lock_sock(sk);
1853
1854         /* Detach socket from network */
1855         spin_lock(&po->bind_lock);
1856         was_running = po->running;
1857         num = po->num;
1858         if (was_running) {
1859                 __dev_remove_pack(&po->prot_hook);
1860                 po->num = 0;
1861                 po->running = 0;
1862                 __sock_put(sk);
1863         }
1864         spin_unlock(&po->bind_lock);
1865
1866         synchronize_net();
1867
1868         err = -EBUSY;
1869         mutex_lock(&po->pg_vec_lock);
1870         if (closing || atomic_read(&po->mapped) == 0) {
1871                 err = 0;
1872 #define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
1873
1874                 spin_lock_bh(&sk->sk_receive_queue.lock);
1875                 pg_vec = XC(po->pg_vec, pg_vec);
1876                 po->frame_max = (req->tp_frame_nr - 1);
1877                 po->head = 0;
1878                 po->frame_size = req->tp_frame_size;
1879                 spin_unlock_bh(&sk->sk_receive_queue.lock);
1880
1881                 order = XC(po->pg_vec_order, order);
1882                 req->tp_block_nr = XC(po->pg_vec_len, req->tp_block_nr);
1883
1884                 po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
1885                 po->prot_hook.func = po->pg_vec ? tpacket_rcv : packet_rcv;
1886                 skb_queue_purge(&sk->sk_receive_queue);
1887 #undef XC
1888                 if (atomic_read(&po->mapped))
1889                         printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped));
1890         }
1891         mutex_unlock(&po->pg_vec_lock);
1892
1893         spin_lock(&po->bind_lock);
1894         if (was_running && !po->running) {
1895                 sock_hold(sk);
1896                 po->running = 1;
1897                 po->num = num;
1898                 dev_add_pack(&po->prot_hook);
1899         }
1900         spin_unlock(&po->bind_lock);
1901
1902         release_sock(sk);
1903
1904         if (pg_vec)
1905                 free_pg_vec(pg_vec, order, req->tp_block_nr);
1906 out:
1907         return err;
1908 }
1909
1910 static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1911 {
1912         struct sock *sk = sock->sk;
1913         struct packet_sock *po = pkt_sk(sk);
1914         unsigned long size;
1915         unsigned long start;
1916         int err = -EINVAL;
1917         int i;
1918
1919         if (vma->vm_pgoff)
1920                 return -EINVAL;
1921
1922         size = vma->vm_end - vma->vm_start;
1923
1924         mutex_lock(&po->pg_vec_lock);
1925         if (po->pg_vec == NULL)
1926                 goto out;
1927         if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
1928                 goto out;
1929
1930         start = vma->vm_start;
1931         for (i = 0; i < po->pg_vec_len; i++) {
1932                 struct page *page = virt_to_page(po->pg_vec[i]);
1933                 int pg_num;
1934
1935                 for (pg_num = 0; pg_num < po->pg_vec_pages; pg_num++, page++) {
1936                         err = vm_insert_page(vma, start, page);
1937                         if (unlikely(err))
1938                                 goto out;
1939                         start += PAGE_SIZE;
1940                 }
1941         }
1942         atomic_inc(&po->mapped);
1943         vma->vm_ops = &packet_mmap_ops;
1944         err = 0;
1945
1946 out:
1947         mutex_unlock(&po->pg_vec_lock);
1948         return err;
1949 }
1950 #endif
1951
1952
1953 static const struct proto_ops packet_ops_spkt = {
1954         .family =       PF_PACKET,
1955         .owner =        THIS_MODULE,
1956         .release =      packet_release,
1957         .bind =         packet_bind_spkt,
1958         .connect =      sock_no_connect,
1959         .socketpair =   sock_no_socketpair,
1960         .accept =       sock_no_accept,
1961         .getname =      packet_getname_spkt,
1962         .poll =         datagram_poll,
1963         .ioctl =        packet_ioctl,
1964         .listen =       sock_no_listen,
1965         .shutdown =     sock_no_shutdown,
1966         .setsockopt =   sock_no_setsockopt,
1967         .getsockopt =   sock_no_getsockopt,
1968         .sendmsg =      packet_sendmsg_spkt,
1969         .recvmsg =      packet_recvmsg,
1970         .mmap =         sock_no_mmap,
1971         .sendpage =     sock_no_sendpage,
1972 };
1973
1974 static const struct proto_ops packet_ops = {
1975         .family =       PF_PACKET,
1976         .owner =        THIS_MODULE,
1977         .release =      packet_release,
1978         .bind =         packet_bind,
1979         .connect =      sock_no_connect,
1980         .socketpair =   sock_no_socketpair,
1981         .accept =       sock_no_accept,
1982         .getname =      packet_getname,
1983         .poll =         packet_poll,
1984         .ioctl =        packet_ioctl,
1985         .listen =       sock_no_listen,
1986         .shutdown =     sock_no_shutdown,
1987         .setsockopt =   packet_setsockopt,
1988         .getsockopt =   packet_getsockopt,
1989         .sendmsg =      packet_sendmsg,
1990         .recvmsg =      packet_recvmsg,
1991         .mmap =         packet_mmap,
1992         .sendpage =     sock_no_sendpage,
1993 };
1994
1995 static struct net_proto_family packet_family_ops = {
1996         .family =       PF_PACKET,
1997         .create =       packet_create,
1998         .owner  =       THIS_MODULE,
1999 };
2000
2001 static struct notifier_block packet_netdev_notifier = {
2002         .notifier_call =packet_notifier,
2003 };
2004
2005 #ifdef CONFIG_PROC_FS
2006 static inline struct sock *packet_seq_idx(struct net *net, loff_t off)
2007 {
2008         struct sock *s;
2009         struct hlist_node *node;
2010
2011         sk_for_each(s, node, &net->packet.sklist) {
2012                 if (!off--)
2013                         return s;
2014         }
2015         return NULL;
2016 }
2017
2018 static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
2019         __acquires(seq_file_net(seq)->packet.sklist_lock)
2020 {
2021         struct net *net = seq_file_net(seq);
2022         read_lock(&net->packet.sklist_lock);
2023         return *pos ? packet_seq_idx(net, *pos - 1) : SEQ_START_TOKEN;
2024 }
2025
2026 static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2027 {
2028         struct net *net = seq_file_net(seq);
2029         ++*pos;
2030         return  (v == SEQ_START_TOKEN)
2031                 ? sk_head(&net->packet.sklist)
2032                 : sk_next((struct sock*)v) ;
2033 }
2034
2035 static void packet_seq_stop(struct seq_file *seq, void *v)
2036         __releases(seq_file_net(seq)->packet.sklist_lock)
2037 {
2038         struct net *net = seq_file_net(seq);
2039         read_unlock(&net->packet.sklist_lock);
2040 }
2041
2042 static int packet_seq_show(struct seq_file *seq, void *v)
2043 {
2044         if (v == SEQ_START_TOKEN)
2045                 seq_puts(seq, "sk       RefCnt Type Proto  Iface R Rmem   User   Inode\n");
2046         else {
2047                 struct sock *s = v;
2048                 const struct packet_sock *po = pkt_sk(s);
2049
2050                 seq_printf(seq,
2051                            "%p %-6d %-4d %04x   %-5d %1d %-6u %-6u %-6lu\n",
2052                            s,
2053                            atomic_read(&s->sk_refcnt),
2054                            s->sk_type,
2055                            ntohs(po->num),
2056                            po->ifindex,
2057                            po->running,
2058                            atomic_read(&s->sk_rmem_alloc),
2059                            sock_i_uid(s),
2060                            sock_i_ino(s) );
2061         }
2062
2063         return 0;
2064 }
2065
2066 static const struct seq_operations packet_seq_ops = {
2067         .start  = packet_seq_start,
2068         .next   = packet_seq_next,
2069         .stop   = packet_seq_stop,
2070         .show   = packet_seq_show,
2071 };
2072
2073 static int packet_seq_open(struct inode *inode, struct file *file)
2074 {
2075         return seq_open_net(inode, file, &packet_seq_ops,
2076                             sizeof(struct seq_net_private));
2077 }
2078
2079 static const struct file_operations packet_seq_fops = {
2080         .owner          = THIS_MODULE,
2081         .open           = packet_seq_open,
2082         .read           = seq_read,
2083         .llseek         = seq_lseek,
2084         .release        = seq_release_net,
2085 };
2086
2087 #endif
2088
2089 static int packet_net_init(struct net *net)
2090 {
2091         rwlock_init(&net->packet.sklist_lock);
2092         INIT_HLIST_HEAD(&net->packet.sklist);
2093
2094         if (!proc_net_fops_create(net, "packet", 0, &packet_seq_fops))
2095                 return -ENOMEM;
2096
2097         return 0;
2098 }
2099
2100 static void packet_net_exit(struct net *net)
2101 {
2102         proc_net_remove(net, "packet");
2103 }
2104
2105 static struct pernet_operations packet_net_ops = {
2106         .init = packet_net_init,
2107         .exit = packet_net_exit,
2108 };
2109
2110
2111 static void __exit packet_exit(void)
2112 {
2113         unregister_netdevice_notifier(&packet_netdev_notifier);
2114         unregister_pernet_subsys(&packet_net_ops);
2115         sock_unregister(PF_PACKET);
2116         proto_unregister(&packet_proto);
2117 }
2118
2119 static int __init packet_init(void)
2120 {
2121         int rc = proto_register(&packet_proto, 0);
2122
2123         if (rc != 0)
2124                 goto out;
2125
2126         sock_register(&packet_family_ops);
2127         register_pernet_subsys(&packet_net_ops);
2128         register_netdevice_notifier(&packet_netdev_notifier);
2129 out:
2130         return rc;
2131 }
2132
2133 module_init(packet_init);
2134 module_exit(packet_exit);
2135 MODULE_LICENSE("GPL");
2136 MODULE_ALIAS_NETPROTO(PF_PACKET);