30 files changed, 246 insertions, 220 deletions

diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index daa749c8b3fb..d8e376a5f0f1 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -524,6 +524,12 @@ static int p9_virtio_probe(struct virtio_device *vdev)
         int err;
         struct virtio_chan *chan;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
         if (!chan) {
                 pr_err("Failed to allocate virtio 9P channel\n");
diff --git a/net/Kconfig b/net/Kconfig
index ff9ffc17fa0e..44dd5786ee91 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -231,18 +231,18 @@ source "net/hsr/Kconfig"
 source "net/switchdev/Kconfig"
 
 config RPS
-        boolean
+        bool
         depends on SMP && SYSFS
         default y
 
 config RFS_ACCEL
-        boolean
+        bool
         depends on RPS
         select CPU_RMAP
         default y
 
 config XPS
-        boolean
+        bool
         depends on SMP
         default y
 
@@ -254,18 +254,18 @@ config CGROUP_NET_PRIO
           a per-interface basis.
 
 config CGROUP_NET_CLASSID
-        boolean "Network classid cgroup"
+        bool "Network classid cgroup"
         depends on CGROUPS
         ---help---
           Cgroup subsystem for use as general purpose socket classid marker that is
           being used in cls_cgroup and for netfilter matching.
 
 config NET_RX_BUSY_POLL
-        boolean
+        bool
         default y
 
 config BQL
-        boolean
+        bool
         depends on SYSFS
         select DQL
         default y
@@ -282,7 +282,7 @@ config BPF_JIT
           this feature changing /proc/sys/net/core/bpf_jit_enable
 
 config NET_FLOW_LIMIT
-        boolean
+        bool
         depends on RPS
         default y
         ---help---
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index 65728e0dc4ff..0ee453fad3de 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -987,15 +987,12 @@ static int __init br_netfilter_init(void)
         if (brnf_sysctl_header == NULL) {
                 printk(KERN_WARNING
                        "br_netfilter: can't register to sysctl.\n");
-                ret = -ENOMEM;
-                goto err1;
+                nf_unregister_hooks(br_nf_ops, ARRAY_SIZE(br_nf_ops));
+                return -ENOMEM;
         }
 #endif
         printk(KERN_NOTICE "Bridge firewalling registered\n");
         return 0;
-err1:
-        nf_unregister_hooks(br_nf_ops, ARRAY_SIZE(br_nf_ops));
-        return ret;
 }
 
 static void __exit br_netfilter_fini(void)
diff --git a/net/ceph/ceph_common.c b/net/ceph/ceph_common.c
index 5d5ab67f516d..ec565508e904 100644
--- a/net/ceph/ceph_common.c
+++ b/net/ceph/ceph_common.c
@@ -239,6 +239,8 @@ enum {
         Opt_nocrc,
         Opt_cephx_require_signatures,
         Opt_nocephx_require_signatures,
+        Opt_tcp_nodelay,
+        Opt_notcp_nodelay,
 };
 
 static match_table_t opt_tokens = {
@@ -259,6 +261,8 @@ static match_table_t opt_tokens = {
         {Opt_nocrc, "nocrc"},
         {Opt_cephx_require_signatures, "cephx_require_signatures"},
         {Opt_nocephx_require_signatures, "nocephx_require_signatures"},
+        {Opt_tcp_nodelay, "tcp_nodelay"},
+        {Opt_notcp_nodelay, "notcp_nodelay"},
         {-1, NULL}
 };
 
@@ -457,6 +461,7 @@ ceph_parse_options(char *options, const char *dev_name,
                 case Opt_nocrc:
                         opt->flags |= CEPH_OPT_NOCRC;
                         break;
+
                 case Opt_cephx_require_signatures:
                         opt->flags &= ~CEPH_OPT_NOMSGAUTH;
                         break;
@@ -464,6 +469,13 @@ ceph_parse_options(char *options, const char *dev_name,
                         opt->flags |= CEPH_OPT_NOMSGAUTH;
                         break;
 
+                case Opt_tcp_nodelay:
+                        opt->flags |= CEPH_OPT_TCP_NODELAY;
+                        break;
+                case Opt_notcp_nodelay:
+                        opt->flags &= ~CEPH_OPT_TCP_NODELAY;
+                        break;
+
                 default:
                         BUG_ON(token);
                 }
@@ -518,10 +530,12 @@ struct ceph_client *ceph_create_client(struct ceph_options *opt, void *private,
         /* msgr */
         if (ceph_test_opt(client, MYIP))
                 myaddr = &client->options->my_addr;
+
         ceph_messenger_init(&client->msgr, myaddr,
                 client->supported_features,
                 client->required_features,
-                ceph_test_opt(client, NOCRC));
+                ceph_test_opt(client, NOCRC),
+                ceph_test_opt(client, TCP_NODELAY));
 
         /* subsystems */
         err = ceph_monc_init(&client->monc, client);
diff --git a/net/ceph/ceph_strings.c b/net/ceph/ceph_strings.c
index 30560202f57b..139a9cb19b0c 100644
--- a/net/ceph/ceph_strings.c
+++ b/net/ceph/ceph_strings.c
@@ -42,17 +42,3 @@ const char *ceph_osd_state_name(int s)
                 return "???";
         }
 }
-
-const char *ceph_pool_op_name(int op)
-{
-        switch (op) {
-        case POOL_OP_CREATE: return "create";
-        case POOL_OP_DELETE: return "delete";
-        case POOL_OP_AUID_CHANGE: return "auid change";
-        case POOL_OP_CREATE_SNAP: return "create snap";
-        case POOL_OP_DELETE_SNAP: return "delete snap";
-        case POOL_OP_CREATE_UNMANAGED_SNAP: return "create unmanaged snap";
-        case POOL_OP_DELETE_UNMANAGED_SNAP: return "delete unmanaged snap";
-        }
-        return "???";
-}
diff --git a/net/ceph/debugfs.c b/net/ceph/debugfs.c
index d2d525529f87..14d9995097cc 100644
--- a/net/ceph/debugfs.c
+++ b/net/ceph/debugfs.c
@@ -127,8 +127,6 @@ static int monc_show(struct seq_file *s, void *p)
                 op = le16_to_cpu(req->request->hdr.type);
                 if (op == CEPH_MSG_STATFS)
                         seq_printf(s, "%llu statfs\n", req->tid);
-                else if (op == CEPH_MSG_POOLOP)
-                        seq_printf(s, "%llu poolop\n", req->tid);
                 else if (op == CEPH_MSG_MON_GET_VERSION)
                         seq_printf(s, "%llu mon_get_version", req->tid);
                 else
diff --git a/net/ceph/messenger.c b/net/ceph/messenger.c
index 33a2f201e460..6b3f54ed65ba 100644
--- a/net/ceph/messenger.c
+++ b/net/ceph/messenger.c
@@ -510,6 +510,16 @@ static int ceph_tcp_connect(struct ceph_connection *con)
                 return ret;
         }
 
+        if (con->msgr->tcp_nodelay) {
+                int optval = 1;
+
+                ret = kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY,
+                                        (char *)&optval, sizeof(optval));
+                if (ret)
+                        pr_err("kernel_setsockopt(TCP_NODELAY) failed: %d",
+                               ret);
+        }
+
         sk_set_memalloc(sock->sk);
 
         con->sock = sock;
@@ -2922,7 +2932,8 @@ void ceph_messenger_init(struct ceph_messenger *msgr,
                         struct ceph_entity_addr *myaddr,
                         u64 supported_features,
                         u64 required_features,
-                        bool nocrc)
+                        bool nocrc,
+                        bool tcp_nodelay)
 {
         msgr->supported_features = supported_features;
         msgr->required_features = required_features;
@@ -2937,6 +2948,7 @@ void ceph_messenger_init(struct ceph_messenger *msgr,
         get_random_bytes(&msgr->inst.addr.nonce, sizeof(msgr->inst.addr.nonce));
         encode_my_addr(msgr);
         msgr->nocrc = nocrc;
+        msgr->tcp_nodelay = tcp_nodelay;
 
         atomic_set(&msgr->stopping, 0);
 
diff --git a/net/ceph/mon_client.c b/net/ceph/mon_client.c
index f2148e22b148..2b3cf05e87b0 100644
--- a/net/ceph/mon_client.c
+++ b/net/ceph/mon_client.c
@@ -410,7 +410,7 @@ out_unlocked:
 }
 
 /*
- * generic requests (e.g., statfs, poolop)
+ * generic requests (currently statfs, mon_get_version)
  */
 static struct ceph_mon_generic_request *__lookup_generic_req(
         struct ceph_mon_client *monc, u64 tid)
@@ -569,7 +569,7 @@ static void handle_statfs_reply(struct ceph_mon_client *monc,
         return;
 
 bad:
-        pr_err("corrupt generic reply, tid %llu\n", tid);
+        pr_err("corrupt statfs reply, tid %llu\n", tid);
         ceph_msg_dump(msg);
 }
 
@@ -588,7 +588,6 @@ int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
 
         kref_init(&req->kref);
         req->buf = buf;
-        req->buf_len = sizeof(*buf);
         init_completion(&req->completion);
 
         err = -ENOMEM;
@@ -611,7 +610,7 @@ int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
         err = do_generic_request(monc, req);
 
 out:
-        kref_put(&req->kref, release_generic_request);
+        put_generic_request(req);
         return err;
 }
 EXPORT_SYMBOL(ceph_monc_do_statfs);
@@ -647,7 +646,7 @@ static void handle_get_version_reply(struct ceph_mon_client *monc,
 
         return;
 bad:
-        pr_err("corrupt mon_get_version reply\n");
+        pr_err("corrupt mon_get_version reply, tid %llu\n", tid);
         ceph_msg_dump(msg);
 }
 
@@ -670,7 +669,6 @@ int ceph_monc_do_get_version(struct ceph_mon_client *monc, const char *what,
 
         kref_init(&req->kref);
         req->buf = newest;
-        req->buf_len = sizeof(*newest);
         init_completion(&req->completion);
 
         req->request = ceph_msg_new(CEPH_MSG_MON_GET_VERSION,
@@ -701,134 +699,12 @@ int ceph_monc_do_get_version(struct ceph_mon_client *monc, const char *what,
 
         mutex_unlock(&monc->mutex);
 out:
-        kref_put(&req->kref, release_generic_request);
+        put_generic_request(req);
         return err;
 }
 EXPORT_SYMBOL(ceph_monc_do_get_version);
 
 /*
- * pool ops
- */
-static int get_poolop_reply_buf(const char *src, size_t src_len,
-                                char *dst, size_t dst_len)
-{
-        u32 buf_len;
-
-        if (src_len != sizeof(u32) + dst_len)
-                return -EINVAL;
-
-        buf_len = le32_to_cpu(*(__le32 *)src);
-        if (buf_len != dst_len)
-                return -EINVAL;
-
-        memcpy(dst, src + sizeof(u32), dst_len);
-        return 0;
-}
-
-static void handle_poolop_reply(struct ceph_mon_client *monc,
-                                struct ceph_msg *msg)
-{
-        struct ceph_mon_generic_request *req;
-        struct ceph_mon_poolop_reply *reply = msg->front.iov_base;
-        u64 tid = le64_to_cpu(msg->hdr.tid);
-
-        if (msg->front.iov_len < sizeof(*reply))
-                goto bad;
-        dout("handle_poolop_reply %p tid %llu\n", msg, tid);
-
-        mutex_lock(&monc->mutex);
-        req = __lookup_generic_req(monc, tid);
-        if (req) {
-                if (req->buf_len &&
-                    get_poolop_reply_buf(msg->front.iov_base + sizeof(*reply),
-                                     msg->front.iov_len - sizeof(*reply),
-                                     req->buf, req->buf_len) < 0) {
-                        mutex_unlock(&monc->mutex);
-                        goto bad;
-                }
-                req->result = le32_to_cpu(reply->reply_code);
-                get_generic_request(req);
-        }
-        mutex_unlock(&monc->mutex);
-        if (req) {
-                complete(&req->completion);
-                put_generic_request(req);
-        }
-        return;
-
-bad:
-        pr_err("corrupt generic reply, tid %llu\n", tid);
-        ceph_msg_dump(msg);
-}
-
-/*
- * Do a synchronous pool op.
- */
-static int do_poolop(struct ceph_mon_client *monc, u32 op,
-                        u32 pool, u64 snapid,
-                        char *buf, int len)
-{
-        struct ceph_mon_generic_request *req;
-        struct ceph_mon_poolop *h;
-        int err;
-
-        req = kzalloc(sizeof(*req), GFP_NOFS);
-        if (!req)
-                return -ENOMEM;
-
-        kref_init(&req->kref);
-        req->buf = buf;
-        req->buf_len = len;
-        init_completion(&req->completion);
-
-        err = -ENOMEM;
-        req->request = ceph_msg_new(CEPH_MSG_POOLOP, sizeof(*h), GFP_NOFS,
-                                    true);
-        if (!req->request)
-                goto out;
-        req->reply = ceph_msg_new(CEPH_MSG_POOLOP_REPLY, 1024, GFP_NOFS,
-                                  true);
-        if (!req->reply)
-                goto out;
-
-        /* fill out request */
-        req->request->hdr.version = cpu_to_le16(2);
-        h = req->request->front.iov_base;
-        h->monhdr.have_version = 0;
-        h->monhdr.session_mon = cpu_to_le16(-1);
-        h->monhdr.session_mon_tid = 0;
-        h->fsid = monc->monmap->fsid;
-        h->pool = cpu_to_le32(pool);
-        h->op = cpu_to_le32(op);
-        h->auid = 0;
-        h->snapid = cpu_to_le64(snapid);
-        h->name_len = 0;
-
-        err = do_generic_request(monc, req);
-
-out:
-        kref_put(&req->kref, release_generic_request);
-        return err;
-}
-
-int ceph_monc_create_snapid(struct ceph_mon_client *monc,
-                            u32 pool, u64 *snapid)
-{
-        return do_poolop(monc,  POOL_OP_CREATE_UNMANAGED_SNAP,
-                                   pool, 0, (char *)snapid, sizeof(*snapid));
-
-}
-EXPORT_SYMBOL(ceph_monc_create_snapid);
-
-int ceph_monc_delete_snapid(struct ceph_mon_client *monc,
-                            u32 pool, u64 snapid)
-{
-        return do_poolop(monc,  POOL_OP_CREATE_UNMANAGED_SNAP,
-                                   pool, snapid, NULL, 0);
-
-}
-
-/*
  * Resend pending generic requests.
  */
 static void __resend_generic_request(struct ceph_mon_client *monc)
@@ -1112,10 +988,6 @@ static void dispatch(struct ceph_connection *con, struct ceph_msg *msg)
                 handle_get_version_reply(monc, msg);
                 break;
 
-        case CEPH_MSG_POOLOP_REPLY:
-                handle_poolop_reply(monc, msg);
-                break;
-
         case CEPH_MSG_MON_MAP:
                 ceph_monc_handle_map(monc, msg);
                 break;
@@ -1154,7 +1026,6 @@ static struct ceph_msg *mon_alloc_msg(struct ceph_connection *con,
         case CEPH_MSG_MON_SUBSCRIBE_ACK:
                 m = ceph_msg_get(monc->m_subscribe_ack);
                 break;
-        case CEPH_MSG_POOLOP_REPLY:
         case CEPH_MSG_STATFS_REPLY:
                 return get_generic_reply(con, hdr, skip);
         case CEPH_MSG_AUTH_REPLY:
diff --git a/net/ceph/osd_client.c b/net/ceph/osd_client.c
index 53299c7b0ca4..41a4abc7e98e 100644
--- a/net/ceph/osd_client.c
+++ b/net/ceph/osd_client.c
@@ -1035,10 +1035,11 @@ static void put_osd(struct ceph_osd *osd)
 {
         dout("put_osd %p %d -> %d\n", osd, atomic_read(&osd->o_ref),
              atomic_read(&osd->o_ref) - 1);
-        if (atomic_dec_and_test(&osd->o_ref) && osd->o_auth.authorizer) {
+        if (atomic_dec_and_test(&osd->o_ref)) {
                 struct ceph_auth_client *ac = osd->o_osdc->client->monc.auth;
 
-                ceph_auth_destroy_authorizer(ac, osd->o_auth.authorizer);
+                if (osd->o_auth.authorizer)
+                        ceph_auth_destroy_authorizer(ac, osd->o_auth.authorizer);
                 kfree(osd);
         }
 }
@@ -1048,14 +1049,24 @@ static void put_osd(struct ceph_osd *osd)
  */
 static void __remove_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd)
 {
-        dout("__remove_osd %p\n", osd);
+        dout("%s %p osd%d\n", __func__, osd, osd->o_osd);
         WARN_ON(!list_empty(&osd->o_requests));
         WARN_ON(!list_empty(&osd->o_linger_requests));
 
-        rb_erase(&osd->o_node, &osdc->osds);
         list_del_init(&osd->o_osd_lru);
-        ceph_con_close(&osd->o_con);
-        put_osd(osd);
+        rb_erase(&osd->o_node, &osdc->osds);
+        RB_CLEAR_NODE(&osd->o_node);
+}
+
+static void remove_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd)
+{
+        dout("%s %p osd%d\n", __func__, osd, osd->o_osd);
+
+        if (!RB_EMPTY_NODE(&osd->o_node)) {
+                ceph_con_close(&osd->o_con);
+                __remove_osd(osdc, osd);
+                put_osd(osd);
+        }
 }
 
 static void remove_all_osds(struct ceph_osd_client *osdc)
@@ -1065,7 +1076,7 @@ static void remove_all_osds(struct ceph_osd_client *osdc)
         while (!RB_EMPTY_ROOT(&osdc->osds)) {
                 struct ceph_osd *osd = rb_entry(rb_first(&osdc->osds),
                                                 struct ceph_osd, o_node);
-                __remove_osd(osdc, osd);
+                remove_osd(osdc, osd);
         }
         mutex_unlock(&osdc->request_mutex);
 }
@@ -1106,7 +1117,7 @@ static void remove_old_osds(struct ceph_osd_client *osdc)
         list_for_each_entry_safe(osd, nosd, &osdc->osd_lru, o_osd_lru) {
                 if (time_before(jiffies, osd->lru_ttl))
                         break;
-                __remove_osd(osdc, osd);
+                remove_osd(osdc, osd);
         }
         mutex_unlock(&osdc->request_mutex);
 }
@@ -1121,8 +1132,7 @@ static int __reset_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd)
         dout("__reset_osd %p osd%d\n", osd, osd->o_osd);
         if (list_empty(&osd->o_requests) &&
             list_empty(&osd->o_linger_requests)) {
-                __remove_osd(osdc, osd);
-
+                remove_osd(osdc, osd);
                 return -ENODEV;
         }
 
@@ -1926,6 +1936,7 @@ static void reset_changed_osds(struct ceph_osd_client *osdc)
 {
         struct rb_node *p, *n;
 
+        dout("%s %p\n", __func__, osdc);
         for (p = rb_first(&osdc->osds); p; p = n) {
                 struct ceph_osd *osd = rb_entry(p, struct ceph_osd, o_node);
 
diff --git a/net/core/dev.c b/net/core/dev.c
index d030575532a2..8f9710c62e20 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -4024,6 +4024,7 @@ static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff
                 NAPI_GRO_CB(skb)->flush = 0;
                 NAPI_GRO_CB(skb)->free = 0;
                 NAPI_GRO_CB(skb)->udp_mark = 0;
+                NAPI_GRO_CB(skb)->gro_remcsum_start = 0;
 
                 /* Setup for GRO checksum validation */
                 switch (skb->ip_summed) {
@@ -5335,7 +5336,7 @@ EXPORT_SYMBOL(netdev_upper_dev_unlink);
 /**
  * netdev_bonding_info_change - Dispatch event about slave change
  * @dev: device
- * @netdev_bonding_info: info to dispatch
+ * @bonding_info: info to dispatch
  *
  * Send NETDEV_BONDING_INFO to netdev notifiers with info.
  * The caller must hold the RTNL lock.
diff --git a/net/core/filter.c b/net/core/filter.c
index ec9baea10c16..f6bdc2b1ba01 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -531,7 +531,7 @@ do_pass:
                         *insn = BPF_LDX_MEM(BPF_W, BPF_REG_A, BPF_REG_CTX, fp->k);
                         break;
 
-                /* Unkown instruction. */
+                /* Unknown instruction. */
                 default:
                         goto err;
                 }
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 9fa25b0ea145..b4899f5b7388 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -97,7 +97,7 @@
  * New xmit() return, do_div and misc clean up by Stephen Hemminger
  * <shemminger@osdl.org> 040923
  *
- * Randy Dunlap fixed u64 printk compiler waring
+ * Randy Dunlap fixed u64 printk compiler warning
  *
  * Remove FCS from BW calculation.  Lennert Buytenhek <buytenh@wantstofly.org>
  * New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 5be499b6a2d2..ab293a3066b3 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -2162,7 +2162,14 @@ replay:
                 }
                 err = rtnl_configure_link(dev, ifm);
                 if (err < 0) {
-                        unregister_netdevice(dev);
+                        if (ops->newlink) {
+                                LIST_HEAD(list_kill);
+
+                                ops->dellink(dev, &list_kill);
+                                unregister_netdevice_many(&list_kill);
+                        } else {
+                                unregister_netdevice(dev);
+                        }
                         goto out;
                 }
 
diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index d104ae15836f..f23deadf42a0 100644
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -521,10 +521,13 @@ static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
         struct device_node *phy_dn, *port_dn;
         bool phy_is_fixed = false;
         u32 phy_flags = 0;
-        int ret;
+        int mode, ret;
 
         port_dn = cd->port_dn[p->port];
-        p->phy_interface = of_get_phy_mode(port_dn);
+        mode = of_get_phy_mode(port_dn);
+        if (mode < 0)
+                mode = PHY_INTERFACE_MODE_NA;
+        p->phy_interface = mode;
 
         phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
         if (of_phy_is_fixed_link(port_dn)) {
@@ -559,6 +562,8 @@ static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
                 if (!p->phy)
                         return -ENODEV;
 
+                /* Use already configured phy mode */
+                p->phy_interface = p->phy->interface;
                 phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
                                    p->phy_interface);
         } else {
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index f0b4a31d7bd6..3a8985c94581 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -1186,7 +1186,7 @@ __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
 no_in_dev:
 
         /* Not loopback addresses on loopback should be preferred
-           in this case. It is importnat that lo is the first interface
+           in this case. It is important that lo is the first interface
            in dev_base list.
          */
         for_each_netdev_rcu(net, dev) {
diff --git a/net/ipv4/fou.c b/net/ipv4/fou.c
index 92ddea1e6457..ff069f6597ac 100644
--- a/net/ipv4/fou.c
+++ b/net/ipv4/fou.c
@@ -22,14 +22,18 @@ static LIST_HEAD(fou_list);
 struct fou {
         struct socket *sock;
         u8 protocol;
+        u8 flags;
         u16 port;
         struct udp_offload udp_offloads;
         struct list_head list;
 };
 
+#define FOU_F_REMCSUM_NOPARTIAL BIT(0)
+
 struct fou_cfg {
         u16 type;
         u8 protocol;
+        u8 flags;
         struct udp_port_cfg udp_config;
 };
 
@@ -64,24 +68,20 @@ static int fou_udp_recv(struct sock *sk, struct sk_buff *skb)
 }
 
 static struct guehdr *gue_remcsum(struct sk_buff *skb, struct guehdr *guehdr,
-                                  void *data, size_t hdrlen, u8 ipproto)
+                                  void *data, size_t hdrlen, u8 ipproto,
+                                  bool nopartial)
 {
         __be16 *pd = data;
         size_t start = ntohs(pd[0]);
         size_t offset = ntohs(pd[1]);
         size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
 
-        if (skb->remcsum_offload) {
-                /* Already processed in GRO path */
-                skb->remcsum_offload = 0;
-                return guehdr;
-        }
-
         if (!pskb_may_pull(skb, plen))
                 return NULL;
         guehdr = (struct guehdr *)&udp_hdr(skb)[1];
 
-        skb_remcsum_process(skb, (void *)guehdr + hdrlen, start, offset);
+        skb_remcsum_process(skb, (void *)guehdr + hdrlen,
+                            start, offset, nopartial);
 
         return guehdr;
 }
@@ -142,7 +142,9 @@ static int gue_udp_recv(struct sock *sk, struct sk_buff *skb)
 
                 if (flags & GUE_PFLAG_REMCSUM) {
                         guehdr = gue_remcsum(skb, guehdr, data + doffset,
-                                             hdrlen, guehdr->proto_ctype);
+                                             hdrlen, guehdr->proto_ctype,
+                                             !!(fou->flags &
+                                                FOU_F_REMCSUM_NOPARTIAL));
                         if (!guehdr)
                                 goto drop;
 
@@ -214,7 +216,8 @@ out_unlock:
 
 static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off,
                                       struct guehdr *guehdr, void *data,
-                                      size_t hdrlen, u8 ipproto)
+                                      size_t hdrlen, u8 ipproto,
+                                      struct gro_remcsum *grc, bool nopartial)
 {
         __be16 *pd = data;
         size_t start = ntohs(pd[0]);
@@ -222,7 +225,7 @@ static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off,
         size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
 
         if (skb->remcsum_offload)
-                return guehdr;
+                return NULL;
 
         if (!NAPI_GRO_CB(skb)->csum_valid)
                 return NULL;
@@ -234,7 +237,8 @@ static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off,
                         return NULL;
         }
 
-        skb_gro_remcsum_process(skb, (void *)guehdr + hdrlen, start, offset);
+        skb_gro_remcsum_process(skb, (void *)guehdr + hdrlen,
+                                start, offset, grc, nopartial);
 
         skb->remcsum_offload = 1;
 
@@ -254,6 +258,10 @@ static struct sk_buff **gue_gro_receive(struct sk_buff **head,
         void *data;
         u16 doffset = 0;
         int flush = 1;
+        struct fou *fou = container_of(uoff, struct fou, udp_offloads);
+        struct gro_remcsum grc;
+
+        skb_gro_remcsum_init(&grc);
 
         off = skb_gro_offset(skb);
         len = off + sizeof(*guehdr);
@@ -295,7 +303,9 @@ static struct sk_buff **gue_gro_receive(struct sk_buff **head,
                 if (flags & GUE_PFLAG_REMCSUM) {
                         guehdr = gue_gro_remcsum(skb, off, guehdr,
                                                  data + doffset, hdrlen,
-                                                 guehdr->proto_ctype);
+                                                 guehdr->proto_ctype, &grc,
+                                                 !!(fou->flags &
+                                                    FOU_F_REMCSUM_NOPARTIAL));
                         if (!guehdr)
                                 goto out;
 
@@ -345,6 +355,7 @@ out_unlock:
         rcu_read_unlock();
 out:
         NAPI_GRO_CB(skb)->flush |= flush;
+        skb_gro_remcsum_cleanup(skb, &grc);
 
         return pp;
 }
@@ -455,6 +466,7 @@ static int fou_create(struct net *net, struct fou_cfg *cfg,
 
         sk = sock->sk;
 
+        fou->flags = cfg->flags;
         fou->port = cfg->udp_config.local_udp_port;
 
         /* Initial for fou type */
@@ -541,6 +553,7 @@ static struct nla_policy fou_nl_policy[FOU_ATTR_MAX + 1] = {
         [FOU_ATTR_AF] = { .type = NLA_U8, },
         [FOU_ATTR_IPPROTO] = { .type = NLA_U8, },
         [FOU_ATTR_TYPE] = { .type = NLA_U8, },
+        [FOU_ATTR_REMCSUM_NOPARTIAL] = { .type = NLA_FLAG, },
 };
 
 static int parse_nl_config(struct genl_info *info,
@@ -571,6 +584,9 @@ static int parse_nl_config(struct genl_info *info,
         if (info->attrs[FOU_ATTR_TYPE])
                 cfg->type = nla_get_u8(info->attrs[FOU_ATTR_TYPE]);
 
+        if (info->attrs[FOU_ATTR_REMCSUM_NOPARTIAL])
+                cfg->flags |= FOU_F_REMCSUM_NOPARTIAL;
+
         return 0;
 }
 
diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
index 53db2c309572..ea82fd492c1b 100644
--- a/net/ipv4/tcp_fastopen.c
+++ b/net/ipv4/tcp_fastopen.c
@@ -134,6 +134,7 @@ static bool tcp_fastopen_create_child(struct sock *sk,
         struct tcp_sock *tp;
         struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
         struct sock *child;
+        u32 end_seq;
 
         req->num_retrans = 0;
         req->num_timeout = 0;
@@ -185,20 +186,35 @@ static bool tcp_fastopen_create_child(struct sock *sk,
 
         /* Queue the data carried in the SYN packet. We need to first
          * bump skb's refcnt because the caller will attempt to free it.
+         * Note that IPv6 might also have used skb_get() trick
+         * in tcp_v6_conn_request() to keep this SYN around (treq->pktopts)
+         * So we need to eventually get a clone of the packet,
+         * before inserting it in sk_receive_queue.
          *
          * XXX (TFO) - we honor a zero-payload TFO request for now,
          * (any reason not to?) but no need to queue the skb since
          * there is no data. How about SYN+FIN?
          */
-        if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq + 1) {
-                skb = skb_get(skb);
-                skb_dst_drop(skb);
-                __skb_pull(skb, tcp_hdr(skb)->doff * 4);
-                skb_set_owner_r(skb, child);
-                __skb_queue_tail(&child->sk_receive_queue, skb);
-                tp->syn_data_acked = 1;
+        end_seq = TCP_SKB_CB(skb)->end_seq;
+        if (end_seq != TCP_SKB_CB(skb)->seq + 1) {
+                struct sk_buff *skb2;
+
+                if (unlikely(skb_shared(skb)))
+                        skb2 = skb_clone(skb, GFP_ATOMIC);
+                else
+                        skb2 = skb_get(skb);
+
+                if (likely(skb2)) {
+                        skb_dst_drop(skb2);
+                        __skb_pull(skb2, tcp_hdrlen(skb));
+                        skb_set_owner_r(skb2, child);
+                        __skb_queue_tail(&child->sk_receive_queue, skb2);
+                        tp->syn_data_acked = 1;
+                } else {
+                        end_seq = TCP_SKB_CB(skb)->seq + 1;
+                }
         }
-        tcp_rsk(req)->rcv_nxt = tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
+        tcp_rsk(req)->rcv_nxt = tp->rcv_nxt = end_seq;
         sk->sk_data_ready(sk);
         bh_unlock_sock(child);
         sock_put(child);
diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c
index d10f6f4ead27..4915d8284a86 100644
--- a/net/ipv4/udp_offload.c
+++ b/net/ipv4/udp_offload.c
@@ -402,6 +402,13 @@ int udp_gro_complete(struct sk_buff *skb, int nhoff)
         }
 
         rcu_read_unlock();
+
+        if (skb->remcsum_offload)
+                skb_shinfo(skb)->gso_type |= SKB_GSO_TUNNEL_REMCSUM;
+
+        skb->encapsulation = 1;
+        skb_set_inner_mac_header(skb, nhoff + sizeof(struct udphdr));
+
         return err;
 }
 
@@ -410,9 +417,13 @@ static int udp4_gro_complete(struct sk_buff *skb, int nhoff)
         const struct iphdr *iph = ip_hdr(skb);
         struct udphdr *uh = (struct udphdr *)(skb->data + nhoff);
 
-        if (uh->check)
+        if (uh->check) {
+                skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
                 uh->check = ~udp_v4_check(skb->len - nhoff, iph->saddr,
                                           iph->daddr, 0);
+        } else {
+                skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
+        }
 
         return udp_gro_complete(skb, nhoff);
 }
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index 2f780cba6e12..f45d6db50a45 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -172,7 +172,7 @@ static void __net_exit ip6_fl_purge(struct net *net)
 {
         int i;
 
-        spin_lock(&ip6_fl_lock);
+        spin_lock_bh(&ip6_fl_lock);
         for (i = 0; i <= FL_HASH_MASK; i++) {
                 struct ip6_flowlabel *fl;
                 struct ip6_flowlabel __rcu **flp;
@@ -190,7 +190,7 @@ static void __net_exit ip6_fl_purge(struct net *net)
                         flp = &fl->next;
                 }
         }
-        spin_unlock(&ip6_fl_lock);
+        spin_unlock_bh(&ip6_fl_lock);
 }
 
 static struct ip6_flowlabel *fl_intern(struct net *net,
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index d33df4cbd872..7deebf102cba 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -1273,7 +1273,7 @@ emsgsize:
         /* If this is the first and only packet and device
          * supports checksum offloading, let's use it.
          */
-        if (!skb &&
+        if (!skb && sk->sk_protocol == IPPROTO_UDP &&
             length + fragheaderlen < mtu &&
             rt->dst.dev->features & NETIF_F_V6_CSUM &&
             !exthdrlen)
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 98565ce0ebcd..4688bd4d7f59 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -141,7 +141,7 @@ static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
         u32 *p = NULL;
 
         if (!(rt->dst.flags & DST_HOST))
-                return NULL;
+                return dst_cow_metrics_generic(dst, old);
 
         peer = rt6_get_peer_create(rt);
         if (peer) {
diff --git a/net/ipv6/udp_offload.c b/net/ipv6/udp_offload.c
index a56276996b72..ab889bb16b3c 100644
--- a/net/ipv6/udp_offload.c
+++ b/net/ipv6/udp_offload.c
@@ -161,9 +161,13 @@ static int udp6_gro_complete(struct sk_buff *skb, int nhoff)
         const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
         struct udphdr *uh = (struct udphdr *)(skb->data + nhoff);
 
-        if (uh->check)
+        if (uh->check) {
+                skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
                 uh->check = ~udp_v6_check(skb->len - nhoff, &ipv6h->saddr,
                                           &ipv6h->daddr, 0);
+        } else {
+                skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
+        }
 
         return udp_gro_complete(skb, nhoff);
 }
diff --git a/net/netfilter/nft_compat.c b/net/netfilter/nft_compat.c
index 265e190f2218..c598f74063a1 100644
--- a/net/netfilter/nft_compat.c
+++ b/net/netfilter/nft_compat.c
@@ -19,6 +19,7 @@
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
 #include <linux/netfilter_ipv6/ip6_tables.h>
+#include <linux/netfilter_bridge/ebtables.h>
 #include <net/netfilter/nf_tables.h>
 
 static int nft_compat_chain_validate_dependency(const char *tablename,
@@ -40,6 +41,7 @@ static int nft_compat_chain_validate_dependency(const char *tablename,
 union nft_entry {
         struct ipt_entry e4;
         struct ip6t_entry e6;
+        struct ebt_entry ebt;
 };
 
 static inline void
@@ -50,9 +52,9 @@ nft_compat_set_par(struct xt_action_param *par, void *xt, const void *xt_info)
         par->hotdrop    = false;
 }
 
-static void nft_target_eval(const struct nft_expr *expr,
-                            struct nft_data data[NFT_REG_MAX + 1],
-                            const struct nft_pktinfo *pkt)
+static void nft_target_eval_xt(const struct nft_expr *expr,
+                               struct nft_data data[NFT_REG_MAX + 1],
+                               const struct nft_pktinfo *pkt)
 {
         void *info = nft_expr_priv(expr);
         struct xt_target *target = expr->ops->data;
@@ -66,7 +68,7 @@ static void nft_target_eval(const struct nft_expr *expr,
         if (pkt->xt.hotdrop)
                 ret = NF_DROP;
 
-        switch(ret) {
+        switch (ret) {
         case XT_CONTINUE:
                 data[NFT_REG_VERDICT].verdict = NFT_CONTINUE;
                 break;
@@ -74,7 +76,41 @@ static void nft_target_eval(const struct nft_expr *expr,
                 data[NFT_REG_VERDICT].verdict = ret;
                 break;
         }
-        return;
+}
+
+static void nft_target_eval_bridge(const struct nft_expr *expr,
+                                   struct nft_data data[NFT_REG_MAX + 1],
+                                   const struct nft_pktinfo *pkt)
+{
+        void *info = nft_expr_priv(expr);
+        struct xt_target *target = expr->ops->data;
+        struct sk_buff *skb = pkt->skb;
+        int ret;
+
+        nft_compat_set_par((struct xt_action_param *)&pkt->xt, target, info);
+
+        ret = target->target(skb, &pkt->xt);
+
+        if (pkt->xt.hotdrop)
+                ret = NF_DROP;
+
+        switch (ret) {
+        case EBT_ACCEPT:
+                data[NFT_REG_VERDICT].verdict = NF_ACCEPT;
+                break;
+        case EBT_DROP:
+                data[NFT_REG_VERDICT].verdict = NF_DROP;
+                break;
+        case EBT_CONTINUE:
+                data[NFT_REG_VERDICT].verdict = NFT_CONTINUE;
+                break;
+        case EBT_RETURN:
+                data[NFT_REG_VERDICT].verdict = NFT_RETURN;
+                break;
+        default:
+                data[NFT_REG_VERDICT].verdict = ret;
+                break;
+        }
 }
 
 static const struct nla_policy nft_target_policy[NFTA_TARGET_MAX + 1] = {
@@ -100,6 +136,10 @@ nft_target_set_tgchk_param(struct xt_tgchk_param *par,
                 entry->e6.ipv6.proto = proto;
                 entry->e6.ipv6.invflags = inv ? IP6T_INV_PROTO : 0;
                 break;
+        case NFPROTO_BRIDGE:
+                entry->ebt.ethproto = proto;
+                entry->ebt.invflags = inv ? EBT_IPROTO : 0;
+                break;
         }
         par->entryinfo  = entry;
         par->target     = target;
@@ -307,6 +347,10 @@ nft_match_set_mtchk_param(struct xt_mtchk_param *par, const struct nft_ctx *ctx,
                 entry->e6.ipv6.proto = proto;
                 entry->e6.ipv6.invflags = inv ? IP6T_INV_PROTO : 0;
                 break;
+        case NFPROTO_BRIDGE:
+                entry->ebt.ethproto = proto;
+                entry->ebt.invflags = inv ? EBT_IPROTO : 0;
+                break;
         }
         par->entryinfo  = entry;
         par->match      = match;
@@ -490,6 +534,9 @@ nfnl_compat_get(struct sock *nfnl, struct sk_buff *skb,
         case AF_INET6:
                 fmt = "ip6t_%s";
                 break;
+        case NFPROTO_BRIDGE:
+                fmt = "ebt_%s";
+                break;
         default:
                 pr_err("nft_compat: unsupported protocol %d\n",
                         nfmsg->nfgen_family);
@@ -663,13 +710,17 @@ nft_target_select_ops(const struct nft_ctx *ctx,
 
         nft_target->ops.type = &nft_target_type;
         nft_target->ops.size = NFT_EXPR_SIZE(XT_ALIGN(target->targetsize));
-        nft_target->ops.eval = nft_target_eval;
         nft_target->ops.init = nft_target_init;
         nft_target->ops.destroy = nft_target_destroy;
         nft_target->ops.dump = nft_target_dump;
         nft_target->ops.validate = nft_target_validate;
         nft_target->ops.data = target;
 
+        if (family == NFPROTO_BRIDGE)
+                nft_target->ops.eval = nft_target_eval_bridge;
+        else
+                nft_target->ops.eval = nft_target_eval_xt;
+
         list_add(&nft_target->head, &nft_target_list);
 
         return &nft_target->ops;
diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index 6404a726d17b..9615b8b9fb37 100644
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -39,6 +39,7 @@ static void nft_lookup_eval(const struct nft_expr *expr,
 
 static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX + 1] = {
         [NFTA_LOOKUP_SET]       = { .type = NLA_STRING },
+        [NFTA_LOOKUP_SET_ID]    = { .type = NLA_U32 },
         [NFTA_LOOKUP_SREG]      = { .type = NLA_U32 },
         [NFTA_LOOKUP_DREG]      = { .type = NLA_U32 },
 };
diff --git a/net/openvswitch/flow.c b/net/openvswitch/flow.c
index e2c348b8baca..50ec42f170a0 100644
--- a/net/openvswitch/flow.c
+++ b/net/openvswitch/flow.c
@@ -717,6 +717,8 @@ int ovs_flow_key_extract_userspace(const struct nlattr *attr,
 {
         int err;
 
+        memset(key, 0, OVS_SW_FLOW_KEY_METADATA_SIZE);
+
         /* Extract metadata from netlink attributes. */
         err = ovs_nla_get_flow_metadata(attr, key, log);
         if (err)
diff --git a/net/openvswitch/flow_netlink.c b/net/openvswitch/flow_netlink.c
index 993281e6278d..216f20b90aa5 100644
--- a/net/openvswitch/flow_netlink.c
+++ b/net/openvswitch/flow_netlink.c
@@ -1516,7 +1516,7 @@ int ovs_nla_put_identifier(const struct sw_flow *flow, struct sk_buff *skb)
 /* Called with ovs_mutex or RCU read lock. */
 int ovs_nla_put_masked_key(const struct sw_flow *flow, struct sk_buff *skb)
 {
-        return ovs_nla_put_key(&flow->mask->key, &flow->key,
+        return ovs_nla_put_key(&flow->key, &flow->key,
                                 OVS_FLOW_ATTR_KEY, false, skb);
 }
 
@@ -1746,7 +1746,7 @@ static int validate_and_copy_set_tun(const struct nlattr *attr,
         struct sw_flow_key key;
         struct ovs_tunnel_info *tun_info;
         struct nlattr *a;
-        int err, start, opts_type;
+        int err = 0, start, opts_type;
 
         ovs_match_init(&match, &key, NULL);
         opts_type = ipv4_tun_from_nlattr(nla_data(attr), &match, false, log);
diff --git a/net/rds/cong.c b/net/rds/cong.c
index e5b65acd650b..e6144b8246fd 100644
--- a/net/rds/cong.c
+++ b/net/rds/cong.c
@@ -221,7 +221,21 @@ void rds_cong_queue_updates(struct rds_cong_map *map)
         list_for_each_entry(conn, &map->m_conn_list, c_map_item) {
                 if (!test_and_set_bit(0, &conn->c_map_queued)) {
                         rds_stats_inc(s_cong_update_queued);
-                        rds_send_xmit(conn);
+                        /* We cannot inline the call to rds_send_xmit() here
+                         * for two reasons (both pertaining to a TCP transport):
+                         * 1. When we get here from the receive path, we
+                         *    are already holding the sock_lock (held by
+                         *    tcp_v4_rcv()). So inlining calls to
+                         *    tcp_setsockopt and/or tcp_sendmsg will deadlock
+                         *    when it tries to get the sock_lock())
+                         * 2. Interrupts are masked so that we can mark the
+                         *    the port congested from both send and recv paths.
+                         *    (See comment around declaration of rdc_cong_lock).
+                         *    An attempt to get the sock_lock() here will
+                         *    therefore trigger warnings.
+                         * Defer the xmit to rds_send_worker() instead.
+                         */
+                        queue_delayed_work(rds_wq, &conn->c_send_w, 0);
                 }
         }
 
diff --git a/net/sched/Kconfig b/net/sched/Kconfig
index 899d0319f2b2..2274e723a3df 100644
--- a/net/sched/Kconfig
+++ b/net/sched/Kconfig
@@ -348,7 +348,7 @@ config NET_SCH_PLUG
 comment "Classification"
 
 config NET_CLS
-        boolean
+        bool
 
 config NET_CLS_BASIC
         tristate "Elementary classification (BASIC)"
diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c
index 651f49ab601f..9dd0ea8db463 100644
--- a/net/sunrpc/backchannel_rqst.c
+++ b/net/sunrpc/backchannel_rqst.c
@@ -309,12 +309,15 @@ void xprt_complete_bc_request(struct rpc_rqst *req, uint32_t copied)
         struct rpc_xprt *xprt = req->rq_xprt;
         struct svc_serv *bc_serv = xprt->bc_serv;
 
+        spin_lock(&xprt->bc_pa_lock);
+        list_del(&req->rq_bc_pa_list);
+        spin_unlock(&xprt->bc_pa_lock);
+
         req->rq_private_buf.len = copied;
         set_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
 
         dprintk("RPC:       add callback request to list\n");
         spin_lock(&bc_serv->sv_cb_lock);
-        list_del(&req->rq_bc_pa_list);
         list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
         wake_up(&bc_serv->sv_cb_waitq);
         spin_unlock(&bc_serv->sv_cb_lock);
diff --git a/net/switchdev/Kconfig b/net/switchdev/Kconfig
index 155754588fd6..86a47e17cfaf 100644
--- a/net/switchdev/Kconfig
+++ b/net/switchdev/Kconfig
@@ -3,7 +3,7 @@
 #
 
 config NET_SWITCHDEV
-        boolean "Switch (and switch-ish) device support (EXPERIMENTAL)"
+        bool "Switch (and switch-ish) device support (EXPERIMENTAL)"
         depends on INET
         ---help---
           This module provides glue between core networking code and device