Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Oct 2010 18:47:02 +0000 (11:47 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 23 Oct 2010 18:47:02 +0000 (11:47 -0700)
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6: (1699 commits)
  bnx2/bnx2x: Unsupported Ethtool operations should return -EINVAL.
  vlan: Calling vlan_hwaccel_do_receive() is always valid.
  tproxy: use the interface primary IP address as a default value for --on-ip
  tproxy: added IPv6 support to the socket match
  cxgb3: function namespace cleanup
  tproxy: added IPv6 support to the TPROXY target
  tproxy: added IPv6 socket lookup function to nf_tproxy_core
  be2net: Changes to use only priority codes allowed by f/w
  tproxy: allow non-local binds of IPv6 sockets if IP_TRANSPARENT is enabled
  tproxy: added tproxy sockopt interface in the IPV6 layer
  tproxy: added udp6_lib_lookup function
  tproxy: added const specifiers to udp lookup functions
  tproxy: split off ipv6 defragmentation to a separate module
  l2tp: small cleanup
  nf_nat: restrict ICMP translation for embedded header
  can: mcp251x: fix generation of error frames
  can: mcp251x: fix endless loop in interrupt handler if CANINTF_MERRF is set
  can-raw: add msg_flags to distinguish local traffic
  9p: client code cleanup
  rds: make local functions/variables static
  ...

Fix up conflicts in net/core/dev.c, drivers/net/pcmcia/smc91c92_cs.c and
drivers/net/wireless/ath/ath9k/debug.c as per David

57 files changed:
1  2 
Documentation/feature-removal-schedule.txt
MAINTAINERS
arch/arm/mach-omap2/board-omap3pandora.c
drivers/bluetooth/hci_ldisc.c
drivers/net/3c527.c
drivers/net/Kconfig
drivers/net/bfin_mac.c
drivers/net/cxgb4/cxgb4_main.c
drivers/net/irda/sir_dev.c
drivers/net/pcmcia/3c574_cs.c
drivers/net/pcmcia/3c589_cs.c
drivers/net/pcmcia/axnet_cs.c
drivers/net/pcmcia/com20020_cs.c
drivers/net/pcmcia/fmvj18x_cs.c
drivers/net/pcmcia/ibmtr_cs.c
drivers/net/pcmcia/nmclan_cs.c
drivers/net/pcmcia/pcnet_cs.c
drivers/net/pcmcia/smc91c92_cs.c
drivers/net/pcmcia/xirc2ps_cs.c
drivers/net/ppp_generic.c
drivers/net/usb/hso.c
drivers/net/wireless/airo.c
drivers/net/wireless/ath/ath5k/debug.c
drivers/net/wireless/ath/ath9k/debug.c
drivers/net/wireless/ath/ath9k/htc_drv_main.c
drivers/net/wireless/iwlwifi/iwl-3945-rs.c
drivers/net/wireless/iwlwifi/iwl-agn-rs.c
drivers/net/wireless/iwlwifi/iwl-debugfs.c
drivers/net/wireless/libertas/if_cs.c
drivers/net/wireless/ray_cs.c
drivers/net/wireless/rt2x00/rt2x00debug.c
drivers/net/wireless/wl1251/debugfs.c
drivers/net/wireless/wl3501_cs.c
drivers/s390/scsi/zfcp_qdio.c
drivers/scsi/bnx2i/bnx2i.h
drivers/scsi/bnx2i/bnx2i_hwi.c
drivers/vhost/net.c
drivers/vhost/vhost.c
drivers/vhost/vhost.h
include/linux/netfilter/nfnetlink_conntrack.h
include/linux/pci_ids.h
net/bluetooth/rfcomm/tty.c
net/core/datagram.c
net/core/dev.c
net/core/skbuff.c
net/core/sock.c
net/ipv4/netfilter/nf_nat_core.c
net/mac80211/debugfs.c
net/mac80211/debugfs_key.c
net/mac80211/debugfs_netdev.c
net/mac80211/debugfs_sta.c
net/mac80211/rate.c
net/mac80211/rc80211_pid_debugfs.c
net/netfilter/core.c
net/netfilter/nf_conntrack_netlink.c
net/sctp/probe.c
net/socket.c

diff --cc MAINTAINERS
Simple merge
Simple merge
Simple merge
index 77efe462b9215914dd1071c8875635ebabff6d09,d24f54b8c19a3b73ee5d526eddf2169fa7c2db80..7ca1fc8a3a766c7def1cd1063b3f09af4ed7e85b
@@@ -215,16 -219,9 +222,9 @@@ menuconfig NET_ETHERNE
  
  if NET_ETHERNET
  
- config MII
-       tristate "Generic Media Independent Interface device support"
-       help
-         Most ethernet controllers have MII transceiver either as an external
-         or internal device.  It is safe to say Y or M here even if your
-         ethernet card lack MII.
  config MACB
        tristate "Atmel MACB support"
 -      depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91SAM9G20 || ARCH_AT91SAM9G45 || ARCH_AT91CAP9
 +      depends on HAVE_NET_MACB
        select PHYLIB
        help
          The Atmel MACB ethernet interface is found on many AT32 and AT91
Simple merge
Simple merge
Simple merge
index ff824e11f0b6865a74a0f55de50f7a02d659e75c,042f6777e6b9133865ff207c37d45a65a88dffba..2807a0fcadc4f7a8630d41a92173c2942ecbda1b
@@@ -279,11 -280,11 +279,10 @@@ static int tc574_probe(struct pcmcia_de
        spin_lock_init(&lp->window_lock);
        link->resource[0]->end = 32;
        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 -      link->conf.Attributes = CONF_ENABLE_IRQ;
 -      link->conf.IntType = INT_MEMORY_AND_IO;
 -      link->conf.ConfigIndex = 1;
 +      link->config_flags |= CONF_ENABLE_IRQ;
 +      link->config_index = 1;
  
        dev->netdev_ops = &el3_netdev_ops;
-       SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
        dev->watchdog_timeo = TX_TIMEOUT;
  
        return tc574_config(link);
Simple merge
Simple merge
Simple merge
index 1c327598bbe80efaa346d4f460ce54461f898368,8f26d548d1bb2eb65105a082971ea3438cd76417..9226cda4d054d4156f1f05e9a2df07856b300b10
@@@ -594,10 -605,9 +595,10 @@@ static int fmvj18x_setup_mfc(struct pcm
      if (i != 0)
        return -1;
  
 -    lp->base = ioremap(req.Base, req.Size);
 +    lp->base = ioremap(link->resource[3]->start,
 +                     resource_size(link->resource[3]));
      if (lp->base == NULL) {
-       printk(KERN_NOTICE "fmvj18x_cs: ioremap failed\n");
+       netdev_notice(dev, "ioremap failed\n");
        return -1;
      }
  
index bf7dff96d881d20ade26849c61604882709e4fd2,dc85282193bf2e415ec18249d58fa8e58098a858..15d57f5b6f2967b0eadb3335b1ec835230ec7f1b
@@@ -101,20 -103,11 +102,10 @@@ static void ibmtr_detach(struct pcmcia_
  
  typedef struct ibmtr_dev_t {
        struct pcmcia_device    *p_dev;
 -    struct net_device *dev;
 -    window_handle_t     sram_win_handle;
 -    struct tok_info   *ti;
 +      struct net_device       *dev;
 +      struct tok_info         *ti;
  } ibmtr_dev_t;
  
- static void netdev_get_drvinfo(struct net_device *dev,
-                              struct ethtool_drvinfo *info)
- {
-       strcpy(info->driver, "ibmtr_cs");
- }
- static const struct ethtool_ops netdev_ethtool_ops = {
-       .get_drvinfo            = netdev_get_drvinfo,
- };
  static irqreturn_t ibmtr_interrupt(int irq, void *dev_id) {
        ibmtr_dev_t *info = dev_id;
        struct net_device *dev = info->dev;
Simple merge
index 5d7d1d3088ae148b6491fc07482b0970178b9466,c94311aed1ab6e999025165b4fee8514ff720e4c..03096c80103d5c0fc98a52990aa18ec2d9af3804
@@@ -1466,13 -1513,12 +1446,13 @@@ static int setup_shmem_window(struct pc
  
      ei_status.tx_start_page = start_pg;
      ei_status.rx_start_page = start_pg + TX_PAGES;
 -    ei_status.stop_page = start_pg + ((req.Size - offset) >> 8);
 +    ei_status.stop_page = start_pg + (
 +          (resource_size(link->resource[3]) - offset) >> 8);
  
      /* set up block i/o functions */
-     ei_status.get_8390_hdr = &shmem_get_8390_hdr;
-     ei_status.block_input = &shmem_block_input;
-     ei_status.block_output = &shmem_block_output;
+     ei_status.get_8390_hdr = shmem_get_8390_hdr;
+     ei_status.block_input = shmem_block_input;
+     ei_status.block_output = shmem_block_output;
  
      info->flags |= USE_SHMEM;
      return 0;
index 0af2fc8ec164a7b2a200ee0452777538d93d4b4e,7204a4b5529bc4cb91ef4b0376a41ab00744c1a3..8a9ff53189236eff17bca6abd2afb8d5f9ac8809
@@@ -792,10 -819,13 +794,10 @@@ static int check_sig(struct pcmcia_devi
      }
  
      if (width) {
-           printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
 -          modconf_t mod = {
 -                  .Attributes = CONF_IO_CHANGE_WIDTH,
 -          };
+           pr_info("using 8-bit IO window\n");
  
            smc91c92_suspend(link);
 -          pcmcia_modify_configuration(link, &mod);
 +          pcmcia_fixup_iowidth(link);
            smc91c92_resume(link);
            return check_sig(link);
      }
index 1fece617c069b68ddb6b384741bf43519d52b99c,d858b5e4c4a7f1601ea856f1591bcb94fd19d9e5..a46b7fd6c0f5483f4a117f4c3c9a7e00b7b93e81
@@@ -792,11 -832,9 +786,11 @@@ xirc2ps_config(struct pcmcia_device * l
             * try to configure as Ethernet only.
             * .... */
        }
-       printk(KNOT_XIRC "no ports available\n");
+       pr_notice("no ports available\n");
      } else {
 +      link->io_lines = 10;
        link->resource[0]->end = 16;
 +      link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
        for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
            link->resource[0]->start = ioaddr;
            if (!(err = pcmcia_request_io(link)))
Simple merge
Simple merge
Simple merge
index fb339c3852ee6859b327a5d366165b1c45d8eea5,42ea5b1bdb122303753af6c16b830707772bbf67..acda56ee521bdf0d2d42102fa8e14188e480fb05
@@@ -483,9 -480,62 +483,63 @@@ static const struct file_operations fop
        .write = write_file_antenna,
        .open = ath5k_debugfs_open,
        .owner = THIS_MODULE,
 +      .llseek = default_llseek,
  };
  
+ /* debugfs: misc */
+ static ssize_t read_file_misc(struct file *file, char __user *user_buf,
+                                  size_t count, loff_t *ppos)
+ {
+       struct ath5k_softc *sc = file->private_data;
+       char buf[700];
+       unsigned int len = 0;
+       u32 filt = ath5k_hw_get_rx_filter(sc->ah);
+       len += snprintf(buf+len, sizeof(buf)-len, "bssid-mask: %pM\n",
+                       sc->bssidmask);
+       len += snprintf(buf+len, sizeof(buf)-len, "filter-flags: 0x%x ",
+                       filt);
+       if (filt & AR5K_RX_FILTER_UCAST)
+               len += snprintf(buf+len, sizeof(buf)-len, " UCAST");
+       if (filt & AR5K_RX_FILTER_MCAST)
+               len += snprintf(buf+len, sizeof(buf)-len, " MCAST");
+       if (filt & AR5K_RX_FILTER_BCAST)
+               len += snprintf(buf+len, sizeof(buf)-len, " BCAST");
+       if (filt & AR5K_RX_FILTER_CONTROL)
+               len += snprintf(buf+len, sizeof(buf)-len, " CONTROL");
+       if (filt & AR5K_RX_FILTER_BEACON)
+               len += snprintf(buf+len, sizeof(buf)-len, " BEACON");
+       if (filt & AR5K_RX_FILTER_PROM)
+               len += snprintf(buf+len, sizeof(buf)-len, " PROM");
+       if (filt & AR5K_RX_FILTER_XRPOLL)
+               len += snprintf(buf+len, sizeof(buf)-len, " XRPOLL");
+       if (filt & AR5K_RX_FILTER_PROBEREQ)
+               len += snprintf(buf+len, sizeof(buf)-len, " PROBEREQ");
+       if (filt & AR5K_RX_FILTER_PHYERR_5212)
+               len += snprintf(buf+len, sizeof(buf)-len, " PHYERR-5212");
+       if (filt & AR5K_RX_FILTER_RADARERR_5212)
+               len += snprintf(buf+len, sizeof(buf)-len, " RADARERR-5212");
+       if (filt & AR5K_RX_FILTER_PHYERR_5211)
+               snprintf(buf+len, sizeof(buf)-len, " PHYERR-5211");
+       if (filt & AR5K_RX_FILTER_RADARERR_5211)
+               len += snprintf(buf+len, sizeof(buf)-len, " RADARERR-5211");
+       len += snprintf(buf+len, sizeof(buf)-len, "\nopmode: %s (%d)\n",
+                       ath_opmode_to_string(sc->opmode), sc->opmode);
+       if (len > sizeof(buf))
+               len = sizeof(buf);
+       return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+ }
+ static const struct file_operations fops_misc = {
+       .read = read_file_misc,
+       .open = ath5k_debugfs_open,
+       .owner = THIS_MODULE,
+ };
  
  /* debugfs: frameerrors */
  
index cf500bf25ad578d6c205c63bd70a9d281a72a7b5,7f764e3d1c0a92d788c3bff3ede92a02a1d64e93..43e71a944cb17331340e2460b9f0fae79323e9da
@@@ -379,100 -375,9 +379,10 @@@ static ssize_t read_file_interrupt(stru
  static const struct file_operations fops_interrupt = {
        .read = read_file_interrupt,
        .open = ath9k_debugfs_open,
 -      .owner = THIS_MODULE
 +      .owner = THIS_MODULE,
 +      .llseek = default_llseek,
  };
  
- void ath_debug_stat_rc(struct ath_softc *sc, int final_rate)
- {
-       struct ath_rc_stats *stats;
-       stats = &sc->debug.stats.rcstats[final_rate];
-       stats->success++;
- }
- void ath_debug_stat_retries(struct ath_softc *sc, int rix,
-                           int xretries, int retries, u8 per)
- {
-       struct ath_rc_stats *stats = &sc->debug.stats.rcstats[rix];
-       stats->xretries += xretries;
-       stats->retries += retries;
-       stats->per = per;
- }
- static ssize_t read_file_rcstat(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
- {
-       struct ath_softc *sc = file->private_data;
-       char *buf;
-       unsigned int len = 0, max;
-       int i = 0;
-       ssize_t retval;
-       if (sc->cur_rate_table == NULL)
-               return 0;
-       max = 80 + sc->cur_rate_table->rate_cnt * 1024 + 1;
-       buf = kmalloc(max, GFP_KERNEL);
-       if (buf == NULL)
-               return -ENOMEM;
-       len += sprintf(buf, "%6s %6s %6s "
-                      "%10s %10s %10s %10s\n",
-                      "HT", "MCS", "Rate",
-                      "Success", "Retries", "XRetries", "PER");
-       for (i = 0; i < sc->cur_rate_table->rate_cnt; i++) {
-               u32 ratekbps = sc->cur_rate_table->info[i].ratekbps;
-               struct ath_rc_stats *stats = &sc->debug.stats.rcstats[i];
-               char mcs[5];
-               char htmode[5];
-               int used_mcs = 0, used_htmode = 0;
-               if (WLAN_RC_PHY_HT(sc->cur_rate_table->info[i].phy)) {
-                       used_mcs = snprintf(mcs, 5, "%d",
-                               sc->cur_rate_table->info[i].ratecode);
-                       if (WLAN_RC_PHY_40(sc->cur_rate_table->info[i].phy))
-                               used_htmode = snprintf(htmode, 5, "HT40");
-                       else if (WLAN_RC_PHY_20(sc->cur_rate_table->info[i].phy))
-                               used_htmode = snprintf(htmode, 5, "HT20");
-                       else
-                               used_htmode = snprintf(htmode, 5, "????");
-               }
-               mcs[used_mcs] = '\0';
-               htmode[used_htmode] = '\0';
-               len += snprintf(buf + len, max - len,
-                       "%6s %6s %3u.%d: "
-                       "%10u %10u %10u %10u\n",
-                       htmode,
-                       mcs,
-                       ratekbps / 1000,
-                       (ratekbps % 1000) / 100,
-                       stats->success,
-                       stats->retries,
-                       stats->xretries,
-                       stats->per);
-       }
-       if (len > max)
-               len = max;
-       retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
-       kfree(buf);
-       return retval;
- }
- static const struct file_operations fops_rcstat = {
-       .read = read_file_rcstat,
-       .open = ath9k_debugfs_open,
-       .owner = THIS_MODULE,
-       .llseek = default_llseek,
- };
  static const char * ath_wiphy_state_str(enum ath_wiphy_state state)
  {
        switch (state) {
Simple merge
index 46da03753fd5ee25874c92752bbc241b0e3a0fef,5ca624a64c42719d21a5ad73b0b04598b2935a97..97007d9e2c1fa23b9a22152260931465b21f7cb8
@@@ -43,9 -43,9 +43,8 @@@
  #include <linux/if_arp.h>
  #include <linux/ioport.h>
  #include <linux/skbuff.h>
- #include <linux/ethtool.h>
  #include <linux/ieee80211.h>
  
 -#include <pcmcia/cs.h>
  #include <pcmcia/cistpl.h>
  #include <pcmcia/cisreg.h>
  #include <pcmcia/ds.h>
index 0000000000000000000000000000000000000000,6e5caaa9f613a4340d9078f70b61a210d2f32c65..6c274007d200f53fa950a4a737387d9714fb32e6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,541 +1,545 @@@
+ /*
+  * This file is part of wl1251
+  *
+  * Copyright (C) 2009 Nokia Corporation
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * version 2 as published by the Free Software Foundation.
+  *
+  * This program is distributed in the hope that it will be useful, but
+  * WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+  * 02110-1301 USA
+  *
+  */
+ #include "debugfs.h"
+ #include <linux/skbuff.h>
+ #include <linux/slab.h>
+ #include "wl1251.h"
+ #include "acx.h"
+ #include "ps.h"
+ /* ms */
+ #define WL1251_DEBUGFS_STATS_LIFETIME 1000
+ /* debugfs macros idea from mac80211 */
+ #define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...)            \
+ static ssize_t name## _read(struct file *file, char __user *userbuf,  \
+                           size_t count, loff_t *ppos)                 \
+ {                                                                     \
+       struct wl1251 *wl = file->private_data;                         \
+       char buf[buflen];                                               \
+       int res;                                                        \
+                                                                       \
+       res = scnprintf(buf, buflen, fmt "\n", ##value);                \
+       return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
+ }                                                                     \
+                                                                       \
+ static const struct file_operations name## _ops = {                   \
+       .read = name## _read,                                           \
+       .open = wl1251_open_file_generic,                               \
++      .llseek = generic_file_llseek,                                  \
+ };
+ #define DEBUGFS_ADD(name, parent)                                     \
+       wl->debugfs.name = debugfs_create_file(#name, 0400, parent,     \
+                                              wl, &name## _ops);       \
+       if (IS_ERR(wl->debugfs.name)) {                                 \
+               ret = PTR_ERR(wl->debugfs.name);                        \
+               wl->debugfs.name = NULL;                                \
+               goto out;                                               \
+       }
+ #define DEBUGFS_DEL(name)                                             \
+       do {                                                            \
+               debugfs_remove(wl->debugfs.name);                       \
+               wl->debugfs.name = NULL;                                \
+       } while (0)
+ #define DEBUGFS_FWSTATS_FILE(sub, name, buflen, fmt)                  \
+ static ssize_t sub## _ ##name## _read(struct file *file,              \
+                                     char __user *userbuf,             \
+                                     size_t count, loff_t *ppos)       \
+ {                                                                     \
+       struct wl1251 *wl = file->private_data;                         \
+       char buf[buflen];                                               \
+       int res;                                                        \
+                                                                       \
+       wl1251_debugfs_update_stats(wl);                                \
+                                                                       \
+       res = scnprintf(buf, buflen, fmt "\n",                          \
+                       wl->stats.fw_stats->sub.name);                  \
+       return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
+ }                                                                     \
+                                                                       \
+ static const struct file_operations sub## _ ##name## _ops = {         \
+       .read = sub## _ ##name## _read,                                 \
+       .open = wl1251_open_file_generic,                               \
++      .llseek = generic_file_llseek,                                  \
+ };
+ #define DEBUGFS_FWSTATS_ADD(sub, name)                                \
+       DEBUGFS_ADD(sub## _ ##name, wl->debugfs.fw_statistics)
+ #define DEBUGFS_FWSTATS_DEL(sub, name)                                \
+       DEBUGFS_DEL(sub## _ ##name)
+ static void wl1251_debugfs_update_stats(struct wl1251 *wl)
+ {
+       int ret;
+       mutex_lock(&wl->mutex);
+       ret = wl1251_ps_elp_wakeup(wl);
+       if (ret < 0)
+               goto out;
+       if (wl->state == WL1251_STATE_ON &&
+           time_after(jiffies, wl->stats.fw_stats_update +
+                      msecs_to_jiffies(WL1251_DEBUGFS_STATS_LIFETIME))) {
+               wl1251_acx_statistics(wl, wl->stats.fw_stats);
+               wl->stats.fw_stats_update = jiffies;
+       }
+       wl1251_ps_elp_sleep(wl);
+ out:
+       mutex_unlock(&wl->mutex);
+ }
+ static int wl1251_open_file_generic(struct inode *inode, struct file *file)
+ {
+       file->private_data = inode->i_private;
+       return 0;
+ }
+ DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, out_of_mem, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, hw_stuck, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, dropped, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, fcs_err, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, path_reset, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rx, reset_counter, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(dma, rx_requested, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(dma, rx_errors, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(dma, tx_requested, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(dma, tx_errors, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, fiqs, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, rx_headers, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, rx_rdys, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, irqs, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, tx_procs, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, decrypt_done, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, dma0_done, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, dma1_done, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, commands, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, rx_procs, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, pci_pm, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, wakeups, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(isr, low_rssi, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(wep, addr_key_count, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(wep, default_key_count, 20, "%u");
+ /* skipping wep.reserved */
+ DEBUGFS_FWSTATS_FILE(wep, key_not_found, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(wep, packets, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(wep, interrupt, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, ps_enter, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, elp_enter, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, power_save_off, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, enable_ps, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, disable_ps, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, 20, "%u");
+ /* skipping cont_miss_bcns_spread for now */
+ DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(mic, rx_pkts, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(mic, calc_failure, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, heart_beat, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, calibration, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, rx_mismatch, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, rx_pool, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, oom_late, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(event, tx_stuck, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data,
+                    20, "%u");
+ DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, 20, "%u");
+ DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, 20, "%u");
+ DEBUGFS_READONLY_FILE(retry_count, 20, "%u", wl->stats.retry_count);
+ DEBUGFS_READONLY_FILE(excessive_retries, 20, "%u",
+                     wl->stats.excessive_retries);
+ static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
+                                size_t count, loff_t *ppos)
+ {
+       struct wl1251 *wl = file->private_data;
+       u32 queue_len;
+       char buf[20];
+       int res;
+       queue_len = skb_queue_len(&wl->tx_queue);
+       res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
+       return simple_read_from_buffer(userbuf, count, ppos, buf, res);
+ }
+ static const struct file_operations tx_queue_len_ops = {
+       .read = tx_queue_len_read,
+       .open = wl1251_open_file_generic,
++      .llseek = generic_file_llseek,
+ };
+ static ssize_t tx_queue_status_read(struct file *file, char __user *userbuf,
+                                   size_t count, loff_t *ppos)
+ {
+       struct wl1251 *wl = file->private_data;
+       char buf[3], status;
+       int len;
+       if (wl->tx_queue_stopped)
+               status = 's';
+       else
+               status = 'r';
+       len = scnprintf(buf, sizeof(buf), "%c\n", status);
+       return simple_read_from_buffer(userbuf, count, ppos, buf, len);
+ }
+ static const struct file_operations tx_queue_status_ops = {
+       .read = tx_queue_status_read,
+       .open = wl1251_open_file_generic,
++      .llseek = generic_file_llseek,
+ };
+ static void wl1251_debugfs_delete_files(struct wl1251 *wl)
+ {
+       DEBUGFS_FWSTATS_DEL(tx, internal_desc_overflow);
+       DEBUGFS_FWSTATS_DEL(rx, out_of_mem);
+       DEBUGFS_FWSTATS_DEL(rx, hdr_overflow);
+       DEBUGFS_FWSTATS_DEL(rx, hw_stuck);
+       DEBUGFS_FWSTATS_DEL(rx, dropped);
+       DEBUGFS_FWSTATS_DEL(rx, fcs_err);
+       DEBUGFS_FWSTATS_DEL(rx, xfr_hint_trig);
+       DEBUGFS_FWSTATS_DEL(rx, path_reset);
+       DEBUGFS_FWSTATS_DEL(rx, reset_counter);
+       DEBUGFS_FWSTATS_DEL(dma, rx_requested);
+       DEBUGFS_FWSTATS_DEL(dma, rx_errors);
+       DEBUGFS_FWSTATS_DEL(dma, tx_requested);
+       DEBUGFS_FWSTATS_DEL(dma, tx_errors);
+       DEBUGFS_FWSTATS_DEL(isr, cmd_cmplt);
+       DEBUGFS_FWSTATS_DEL(isr, fiqs);
+       DEBUGFS_FWSTATS_DEL(isr, rx_headers);
+       DEBUGFS_FWSTATS_DEL(isr, rx_mem_overflow);
+       DEBUGFS_FWSTATS_DEL(isr, rx_rdys);
+       DEBUGFS_FWSTATS_DEL(isr, irqs);
+       DEBUGFS_FWSTATS_DEL(isr, tx_procs);
+       DEBUGFS_FWSTATS_DEL(isr, decrypt_done);
+       DEBUGFS_FWSTATS_DEL(isr, dma0_done);
+       DEBUGFS_FWSTATS_DEL(isr, dma1_done);
+       DEBUGFS_FWSTATS_DEL(isr, tx_exch_complete);
+       DEBUGFS_FWSTATS_DEL(isr, commands);
+       DEBUGFS_FWSTATS_DEL(isr, rx_procs);
+       DEBUGFS_FWSTATS_DEL(isr, hw_pm_mode_changes);
+       DEBUGFS_FWSTATS_DEL(isr, host_acknowledges);
+       DEBUGFS_FWSTATS_DEL(isr, pci_pm);
+       DEBUGFS_FWSTATS_DEL(isr, wakeups);
+       DEBUGFS_FWSTATS_DEL(isr, low_rssi);
+       DEBUGFS_FWSTATS_DEL(wep, addr_key_count);
+       DEBUGFS_FWSTATS_DEL(wep, default_key_count);
+       /* skipping wep.reserved */
+       DEBUGFS_FWSTATS_DEL(wep, key_not_found);
+       DEBUGFS_FWSTATS_DEL(wep, decrypt_fail);
+       DEBUGFS_FWSTATS_DEL(wep, packets);
+       DEBUGFS_FWSTATS_DEL(wep, interrupt);
+       DEBUGFS_FWSTATS_DEL(pwr, ps_enter);
+       DEBUGFS_FWSTATS_DEL(pwr, elp_enter);
+       DEBUGFS_FWSTATS_DEL(pwr, missing_bcns);
+       DEBUGFS_FWSTATS_DEL(pwr, wake_on_host);
+       DEBUGFS_FWSTATS_DEL(pwr, wake_on_timer_exp);
+       DEBUGFS_FWSTATS_DEL(pwr, tx_with_ps);
+       DEBUGFS_FWSTATS_DEL(pwr, tx_without_ps);
+       DEBUGFS_FWSTATS_DEL(pwr, rcvd_beacons);
+       DEBUGFS_FWSTATS_DEL(pwr, power_save_off);
+       DEBUGFS_FWSTATS_DEL(pwr, enable_ps);
+       DEBUGFS_FWSTATS_DEL(pwr, disable_ps);
+       DEBUGFS_FWSTATS_DEL(pwr, fix_tsf_ps);
+       /* skipping cont_miss_bcns_spread for now */
+       DEBUGFS_FWSTATS_DEL(pwr, rcvd_awake_beacons);
+       DEBUGFS_FWSTATS_DEL(mic, rx_pkts);
+       DEBUGFS_FWSTATS_DEL(mic, calc_failure);
+       DEBUGFS_FWSTATS_DEL(aes, encrypt_fail);
+       DEBUGFS_FWSTATS_DEL(aes, decrypt_fail);
+       DEBUGFS_FWSTATS_DEL(aes, encrypt_packets);
+       DEBUGFS_FWSTATS_DEL(aes, decrypt_packets);
+       DEBUGFS_FWSTATS_DEL(aes, encrypt_interrupt);
+       DEBUGFS_FWSTATS_DEL(aes, decrypt_interrupt);
+       DEBUGFS_FWSTATS_DEL(event, heart_beat);
+       DEBUGFS_FWSTATS_DEL(event, calibration);
+       DEBUGFS_FWSTATS_DEL(event, rx_mismatch);
+       DEBUGFS_FWSTATS_DEL(event, rx_mem_empty);
+       DEBUGFS_FWSTATS_DEL(event, rx_pool);
+       DEBUGFS_FWSTATS_DEL(event, oom_late);
+       DEBUGFS_FWSTATS_DEL(event, phy_transmit_error);
+       DEBUGFS_FWSTATS_DEL(event, tx_stuck);
+       DEBUGFS_FWSTATS_DEL(ps, pspoll_timeouts);
+       DEBUGFS_FWSTATS_DEL(ps, upsd_timeouts);
+       DEBUGFS_FWSTATS_DEL(ps, upsd_max_sptime);
+       DEBUGFS_FWSTATS_DEL(ps, upsd_max_apturn);
+       DEBUGFS_FWSTATS_DEL(ps, pspoll_max_apturn);
+       DEBUGFS_FWSTATS_DEL(ps, pspoll_utilization);
+       DEBUGFS_FWSTATS_DEL(ps, upsd_utilization);
+       DEBUGFS_FWSTATS_DEL(rxpipe, rx_prep_beacon_drop);
+       DEBUGFS_FWSTATS_DEL(rxpipe, descr_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_DEL(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_DEL(rxpipe, missed_beacon_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_DEL(rxpipe, tx_xfr_host_int_trig_rx_data);
+       DEBUGFS_DEL(tx_queue_len);
+       DEBUGFS_DEL(tx_queue_status);
+       DEBUGFS_DEL(retry_count);
+       DEBUGFS_DEL(excessive_retries);
+ }
+ static int wl1251_debugfs_add_files(struct wl1251 *wl)
+ {
+       int ret = 0;
+       DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
+       DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
+       DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
+       DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
+       DEBUGFS_FWSTATS_ADD(rx, dropped);
+       DEBUGFS_FWSTATS_ADD(rx, fcs_err);
+       DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
+       DEBUGFS_FWSTATS_ADD(rx, path_reset);
+       DEBUGFS_FWSTATS_ADD(rx, reset_counter);
+       DEBUGFS_FWSTATS_ADD(dma, rx_requested);
+       DEBUGFS_FWSTATS_ADD(dma, rx_errors);
+       DEBUGFS_FWSTATS_ADD(dma, tx_requested);
+       DEBUGFS_FWSTATS_ADD(dma, tx_errors);
+       DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
+       DEBUGFS_FWSTATS_ADD(isr, fiqs);
+       DEBUGFS_FWSTATS_ADD(isr, rx_headers);
+       DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
+       DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
+       DEBUGFS_FWSTATS_ADD(isr, irqs);
+       DEBUGFS_FWSTATS_ADD(isr, tx_procs);
+       DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
+       DEBUGFS_FWSTATS_ADD(isr, dma0_done);
+       DEBUGFS_FWSTATS_ADD(isr, dma1_done);
+       DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
+       DEBUGFS_FWSTATS_ADD(isr, commands);
+       DEBUGFS_FWSTATS_ADD(isr, rx_procs);
+       DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
+       DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
+       DEBUGFS_FWSTATS_ADD(isr, pci_pm);
+       DEBUGFS_FWSTATS_ADD(isr, wakeups);
+       DEBUGFS_FWSTATS_ADD(isr, low_rssi);
+       DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
+       DEBUGFS_FWSTATS_ADD(wep, default_key_count);
+       /* skipping wep.reserved */
+       DEBUGFS_FWSTATS_ADD(wep, key_not_found);
+       DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
+       DEBUGFS_FWSTATS_ADD(wep, packets);
+       DEBUGFS_FWSTATS_ADD(wep, interrupt);
+       DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
+       DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
+       DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
+       DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
+       DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
+       DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
+       DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
+       DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
+       DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
+       DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
+       DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
+       DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
+       /* skipping cont_miss_bcns_spread for now */
+       DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
+       DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
+       DEBUGFS_FWSTATS_ADD(mic, calc_failure);
+       DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
+       DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
+       DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
+       DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
+       DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
+       DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
+       DEBUGFS_FWSTATS_ADD(event, heart_beat);
+       DEBUGFS_FWSTATS_ADD(event, calibration);
+       DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
+       DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
+       DEBUGFS_FWSTATS_ADD(event, rx_pool);
+       DEBUGFS_FWSTATS_ADD(event, oom_late);
+       DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
+       DEBUGFS_FWSTATS_ADD(event, tx_stuck);
+       DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
+       DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
+       DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
+       DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
+       DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
+       DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
+       DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
+       DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
+       DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
+       DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
+       DEBUGFS_ADD(tx_queue_len, wl->debugfs.rootdir);
+       DEBUGFS_ADD(tx_queue_status, wl->debugfs.rootdir);
+       DEBUGFS_ADD(retry_count, wl->debugfs.rootdir);
+       DEBUGFS_ADD(excessive_retries, wl->debugfs.rootdir);
+ out:
+       if (ret < 0)
+               wl1251_debugfs_delete_files(wl);
+       return ret;
+ }
+ void wl1251_debugfs_reset(struct wl1251 *wl)
+ {
+       if (wl->stats.fw_stats != NULL)
+               memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
+       wl->stats.retry_count = 0;
+       wl->stats.excessive_retries = 0;
+ }
+ int wl1251_debugfs_init(struct wl1251 *wl)
+ {
+       int ret;
+       wl->debugfs.rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
+       if (IS_ERR(wl->debugfs.rootdir)) {
+               ret = PTR_ERR(wl->debugfs.rootdir);
+               wl->debugfs.rootdir = NULL;
+               goto err;
+       }
+       wl->debugfs.fw_statistics = debugfs_create_dir("fw-statistics",
+                                                      wl->debugfs.rootdir);
+       if (IS_ERR(wl->debugfs.fw_statistics)) {
+               ret = PTR_ERR(wl->debugfs.fw_statistics);
+               wl->debugfs.fw_statistics = NULL;
+               goto err_root;
+       }
+       wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
+                                     GFP_KERNEL);
+       if (!wl->stats.fw_stats) {
+               ret = -ENOMEM;
+               goto err_fw;
+       }
+       wl->stats.fw_stats_update = jiffies;
+       ret = wl1251_debugfs_add_files(wl);
+       if (ret < 0)
+               goto err_file;
+       return 0;
+ err_file:
+       kfree(wl->stats.fw_stats);
+       wl->stats.fw_stats = NULL;
+ err_fw:
+       debugfs_remove(wl->debugfs.fw_statistics);
+       wl->debugfs.fw_statistics = NULL;
+ err_root:
+       debugfs_remove(wl->debugfs.rootdir);
+       wl->debugfs.rootdir = NULL;
+ err:
+       return ret;
+ }
+ void wl1251_debugfs_exit(struct wl1251 *wl)
+ {
+       wl1251_debugfs_delete_files(wl);
+       kfree(wl->stats.fw_stats);
+       wl->stats.fw_stats = NULL;
+       debugfs_remove(wl->debugfs.fw_statistics);
+       wl->debugfs.fw_statistics = NULL;
+       debugfs_remove(wl->debugfs.rootdir);
+       wl->debugfs.rootdir = NULL;
+ }
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index af3c11ded5fd4910ed0dccea161a801298036731,edc892989992bdfed2a9cd015b2593f2b28616b2..073d06ae091f26efc519323f37b94d9ab56c2817
@@@ -106,10 -104,10 +104,10 @@@ struct vhost_virtqueue 
         * vhost_work execution acts instead of rcu_read_lock() and the end of
         * vhost_work execution acts instead of rcu_read_lock().
         * Writers use virtqueue mutex. */
 -      void *private_data;
 +      void __rcu *private_data;
        /* Log write descriptors */
        void __user *log_base;
-       struct vhost_log log[VHOST_NET_MAX_SG];
+       struct vhost_log *log;
  };
  
  struct vhost_dev {
Simple merge
Simple merge
Simple merge
diff --cc net/core/dev.c
index 7ec85e27beed840b8da5f9dae620bcd48453f3f7,6d4218cdb7392c1e8fd1e320aac4aefb754d80f9..78b5a89b0f40a455e4229fb04b291e87877b491b
  #include <linux/jhash.h>
  #include <linux/random.h>
  #include <trace/events/napi.h>
 +#include <trace/events/net.h>
 +#include <trace/events/skb.h>
  #include <linux/pci.h>
+ #include <linux/inetdevice.h>
  
  #include "net-sysfs.h"
  
@@@ -2835,10 -2898,6 +2905,8 @@@ static int __netif_receive_skb(struct s
        if (!netdev_tstamp_prequeue)
                net_timestamp_check(skb);
  
-       if (vlan_tx_tag_present(skb) && vlan_hwaccel_do_receive(skb))
-               return NET_RX_SUCCESS;
 +      trace_netif_receive_skb(skb);
 +
        /* if we've gotten here through NAPI, check netpoll */
        if (netpoll_receive_skb(skb))
                return NET_RX_DROP;
Simple merge
diff --cc net/core/sock.c
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc net/socket.c
Simple merge