Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Conflicts:
	drivers/net/ethernet/rocker/rocker.c

The rocker commit was two overlapping changes, one to rename
the ->vport member to ->pport, and another making the bitmask
expression use '1ULL' instead of plain '1'.

Signed-off-by: David S. Miller <davem@davemloft.net>

53 files changed, 269 insertions, 252 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.c b/net/bridge/br.c
index fb57ab6b24f9..02c24cf63c34 100644
--- a/net/bridge/br.c
+++ b/net/bridge/br.c
@@ -190,6 +190,8 @@ static int __init br_init(void)
 {
         int err;
 
+        BUILD_BUG_ON(sizeof(struct br_input_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb));
+
         err = stp_proto_register(&br_stp_proto);
         if (err < 0) {
                 pr_err("bridge: can't register sap for STP\n");
diff --git a/net/caif/cffrml.c b/net/caif/cffrml.c
index 8bc7caa28e64..434ba8557826 100644
--- a/net/caif/cffrml.c
+++ b/net/caif/cffrml.c
@@ -84,7 +84,7 @@ static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt)
         u16 tmp;
         u16 len;
         u16 hdrchks;
-        u16 pktchks;
+        int pktchks;
         struct cffrml *this;
         this = container_obj(layr);
 
diff --git a/net/caif/cfpkt_skbuff.c b/net/caif/cfpkt_skbuff.c
index 1be0b521ac49..f6c3b2137eea 100644
--- a/net/caif/cfpkt_skbuff.c
+++ b/net/caif/cfpkt_skbuff.c
@@ -255,9 +255,9 @@ inline u16 cfpkt_getlen(struct cfpkt *pkt)
         return skb->len;
 }
 
-inline u16 cfpkt_iterate(struct cfpkt *pkt,
-                         u16 (*iter_func)(u16, void *, u16),
-                         u16 data)
+int cfpkt_iterate(struct cfpkt *pkt,
+                  u16 (*iter_func)(u16, void *, u16),
+                  u16 data)
 {
         /*
          * Don't care about the performance hit of linearizing,
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/compat.c b/net/compat.c
index 49c6a8fb9f09..478443182bbe 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -711,24 +711,18 @@ static unsigned char nas[21] = {
 
 COMPAT_SYSCALL_DEFINE3(sendmsg, int, fd, struct compat_msghdr __user *, msg, unsigned int, flags)
 {
-        if (flags & MSG_CMSG_COMPAT)
-                return -EINVAL;
         return __sys_sendmsg(fd, (struct user_msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
 }
 
 COMPAT_SYSCALL_DEFINE4(sendmmsg, int, fd, struct compat_mmsghdr __user *, mmsg,
                        unsigned int, vlen, unsigned int, flags)
 {
-        if (flags & MSG_CMSG_COMPAT)
-                return -EINVAL;
         return __sys_sendmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
                               flags | MSG_CMSG_COMPAT);
 }
 
 COMPAT_SYSCALL_DEFINE3(recvmsg, int, fd, struct compat_msghdr __user *, msg, unsigned int, flags)
 {
-        if (flags & MSG_CMSG_COMPAT)
-                return -EINVAL;
         return __sys_recvmsg(fd, (struct user_msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
 }
 
@@ -751,9 +745,6 @@ COMPAT_SYSCALL_DEFINE5(recvmmsg, int, fd, struct compat_mmsghdr __user *, mmsg,
         int datagrams;
         struct timespec ktspec;
 
-        if (flags & MSG_CMSG_COMPAT)
-                return -EINVAL;
-
         if (timeout == NULL)
                 return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
                                       flags | MSG_CMSG_COMPAT, NULL);
diff --git a/net/core/dev.c b/net/core/dev.c
index 8f9710c62e20..962ee9d71964 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -946,7 +946,7 @@ bool dev_valid_name(const char *name)
                 return false;
 
         while (*name) {
-                if (*name == '/' || isspace(*name))
+                if (*name == '/' || *name == ':' || isspace(*name))
                         return false;
                 name++;
         }
diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index eb0c3ace7458..1d00b8922902 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -98,6 +98,7 @@ static const char netdev_features_strings[NETDEV_FEATURE_COUNT][ETH_GSTRING_LEN]
         [NETIF_F_RXALL_BIT] =            "rx-all",
         [NETIF_F_HW_L2FW_DOFFLOAD_BIT] = "l2-fwd-offload",
         [NETIF_F_BUSY_POLL_BIT] =        "busy-poll",
+        [NETIF_F_HW_SWITCH_OFFLOAD_BIT] = "hw-switch-offload",
 };
 
 static const char
diff --git a/net/core/gen_stats.c b/net/core/gen_stats.c
index 0c08062d1796..1e2f46a69d50 100644
--- a/net/core/gen_stats.c
+++ b/net/core/gen_stats.c
@@ -32,6 +32,9 @@ gnet_stats_copy(struct gnet_dump *d, int type, void *buf, int size)
         return 0;
 
 nla_put_failure:
+        kfree(d->xstats);
+        d->xstats = NULL;
+        d->xstats_len = 0;
         spin_unlock_bh(d->lock);
         return -1;
 }
@@ -305,7 +308,9 @@ int
 gnet_stats_copy_app(struct gnet_dump *d, void *st, int len)
 {
         if (d->compat_xstats) {
-                d->xstats = st;
+                d->xstats = kmemdup(st, len, GFP_ATOMIC);
+                if (!d->xstats)
+                        goto err_out;
                 d->xstats_len = len;
         }
 
@@ -313,6 +318,11 @@ gnet_stats_copy_app(struct gnet_dump *d, void *st, int len)
                 return gnet_stats_copy(d, TCA_STATS_APP, st, len);
 
         return 0;
+
+err_out:
+        d->xstats_len = 0;
+        spin_unlock_bh(d->lock);
+        return -1;
 }
 EXPORT_SYMBOL(gnet_stats_copy_app);
 
@@ -345,6 +355,9 @@ gnet_stats_finish_copy(struct gnet_dump *d)
                         return -1;
         }
 
+        kfree(d->xstats);
+        d->xstats = NULL;
+        d->xstats_len = 0;
         spin_unlock_bh(d->lock);
         return 0;
 }
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index b4899f5b7388..508155b283dd 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -1134,6 +1134,9 @@ static ssize_t pktgen_if_write(struct file *file,
                         return len;
 
                 i += len;
+                if ((value > 1) &&
+                    (!(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))
+                        return -ENOTSUPP;
                 pkt_dev->burst = value < 1 ? 1 : value;
                 sprintf(pg_result, "OK: burst=%d", pkt_dev->burst);
                 return count;
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index ab293a3066b3..25b4b5d23485 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -1300,7 +1300,6 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
         s_h = cb->args[0];
         s_idx = cb->args[1];
 
-        rcu_read_lock();
         cb->seq = net->dev_base_seq;
 
         /* A hack to preserve kernel<->userspace interface.
@@ -1322,7 +1321,7 @@ static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
         for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
                 idx = 0;
                 head = &net->dev_index_head[h];
-                hlist_for_each_entry_rcu(dev, head, index_hlist) {
+                hlist_for_each_entry(dev, head, index_hlist) {
                         if (idx < s_idx)
                                 goto cont;
                         err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
@@ -1344,7 +1343,6 @@ cont:
                 }
         }
 out:
-        rcu_read_unlock();
         cb->args[1] = idx;
         cb->args[0] = h;
 
@@ -2012,8 +2010,8 @@ replay:
         }
 
         if (1) {
-                struct nlattr *attr[ops ? ops->maxtype + 1 : 0];
-                struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 0];
+                struct nlattr *attr[ops ? ops->maxtype + 1 : 1];
+                struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 1];
                 struct nlattr **data = NULL;
                 struct nlattr **slave_data = NULL;
                 struct net *dest_net, *link_net = NULL;
@@ -2122,6 +2120,10 @@ replay:
                 if (IS_ERR(dest_net))
                         return PTR_ERR(dest_net);
 
+                err = -EPERM;
+                if (!netlink_ns_capable(skb, dest_net->user_ns, CAP_NET_ADMIN))
+                        goto out;
+
                 if (tb[IFLA_LINK_NETNSID]) {
                         int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
 
@@ -2130,6 +2132,9 @@ replay:
                                 err =  -EINVAL;
                                 goto out;
                         }
+                        err = -EPERM;
+                        if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
+                                goto out;
                 }
 
                 dev = rtnl_create_link(link_net ? : dest_net, ifname,
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 374e43bc6b80..913b94a77060 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -3620,13 +3620,14 @@ struct sk_buff *sock_dequeue_err_skb(struct sock *sk)
 {
         struct sk_buff_head *q = &sk->sk_error_queue;
         struct sk_buff *skb, *skb_next;
+        unsigned long flags;
         int err = 0;
 
-        spin_lock_bh(&q->lock);
+        spin_lock_irqsave(&q->lock, flags);
         skb = __skb_dequeue(q);
         if (skb && (skb_next = skb_peek(q)))
                 err = SKB_EXT_ERR(skb_next)->ee.ee_errno;
-        spin_unlock_bh(&q->lock);
+        spin_unlock_irqrestore(&q->lock, flags);
 
         sk->sk_err = err;
         if (err)
diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c
index 1d7c1256e845..3b81092771f8 100644
--- a/net/decnet/dn_route.c
+++ b/net/decnet/dn_route.c
@@ -1062,7 +1062,7 @@ source_ok:
         if (decnet_debug_level & 16)
                 printk(KERN_DEBUG
                        "dn_route_output_slow: initial checks complete."
-                       " dst=%o4x src=%04x oif=%d try_hard=%d\n",
+                       " dst=%04x src=%04x oif=%d try_hard=%d\n",
                        le16_to_cpu(fld.daddr), le16_to_cpu(fld.saddr),
                        fld.flowidn_oif, try_hard);
 
diff --git a/net/hsr/hsr_device.c b/net/hsr/hsr_device.c
index a138d75751df..44d27469ae55 100644
--- a/net/hsr/hsr_device.c
+++ b/net/hsr/hsr_device.c
@@ -359,8 +359,11 @@ static void hsr_dev_destroy(struct net_device *hsr_dev)
         struct hsr_port *port;
 
         hsr = netdev_priv(hsr_dev);
+
+        rtnl_lock();
         hsr_for_each_port(hsr, port)
                 hsr_del_port(port);
+        rtnl_unlock();
 
         del_timer_sync(&hsr->prune_timer);
         del_timer_sync(&hsr->announce_timer);
diff --git a/net/hsr/hsr_main.c b/net/hsr/hsr_main.c
index 779d28b65417..cd37d0011b42 100644
--- a/net/hsr/hsr_main.c
+++ b/net/hsr/hsr_main.c
@@ -36,6 +36,10 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
                         return NOTIFY_DONE;     /* Not an HSR device */
                 hsr = netdev_priv(dev);
                 port = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
+                if (port == NULL) {
+                        /* Resend of notification concerning removed device? */
+                        return NOTIFY_DONE;
+                }
         } else {
                 hsr = port->hsr;
         }
diff --git a/net/hsr/hsr_slave.c b/net/hsr/hsr_slave.c
index a348dcbcd683..7d37366cc695 100644
--- a/net/hsr/hsr_slave.c
+++ b/net/hsr/hsr_slave.c
@@ -181,8 +181,10 @@ void hsr_del_port(struct hsr_port *port)
         list_del_rcu(&port->port_list);
 
         if (port != master) {
-                netdev_update_features(master->dev);
-                dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
+                if (master != NULL) {
+                        netdev_update_features(master->dev);
+                        dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
+                }
                 netdev_rx_handler_unregister(port->dev);
                 dev_set_promiscuity(port->dev, -1);
         }
@@ -192,5 +194,7 @@ void hsr_del_port(struct hsr_port *port)
          */
 
         synchronize_rcu();
-        dev_put(port->dev);
+
+        if (port != master)
+                dev_put(port->dev);
 }
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index e5b6d0ddcb58..2c8d98e728c0 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -664,7 +664,7 @@ struct sk_buff *ip_check_defrag(struct sk_buff *skb, u32 user)
         if (skb->protocol != htons(ETH_P_IP))
                 return skb;
 
-        if (!skb_copy_bits(skb, 0, &iph, sizeof(iph)))
+        if (skb_copy_bits(skb, 0, &iph, sizeof(iph)) < 0)
                 return skb;
 
         if (iph.ihl < 5 || iph.version != 4)
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index d68199d9b2b0..a7aea2048a0d 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -888,7 +888,8 @@ static int __ip_append_data(struct sock *sk,
         cork->length += length;
         if (((length > mtu) || (skb && skb_is_gso(skb))) &&
             (sk->sk_protocol == IPPROTO_UDP) &&
-            (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len) {
+            (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len &&
+            (sk->sk_type == SOCK_DGRAM)) {
                 err = ip_ufo_append_data(sk, queue, getfrag, from, length,
                                          hh_len, fragheaderlen, transhdrlen,
                                          maxfraglen, flags);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 8fdd27b17306..fb4cf8b8e121 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -4770,7 +4770,7 @@ static bool tcp_should_expand_sndbuf(const struct sock *sk)
                 return false;
 
         /* If we filled the congestion window, do not expand.  */
-        if (tp->packets_out >= tp->snd_cwnd)
+        if (tcp_packets_in_flight(tp) >= tp->snd_cwnd)
                 return false;
 
         return true;
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 783bccfcc060..88d2cf0cae52 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -4935,6 +4935,21 @@ int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
         return ret;
 }
 
+static
+int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
+                        void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        struct inet6_dev *idev = ctl->extra1;
+        int min_mtu = IPV6_MIN_MTU;
+        struct ctl_table lctl;
+
+        lctl = *ctl;
+        lctl.extra1 = &min_mtu;
+        lctl.extra2 = idev ? &idev->dev->mtu : NULL;
+
+        return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
+}
+
 static void dev_disable_change(struct inet6_dev *idev)
 {
         struct netdev_notifier_info info;
@@ -5086,7 +5101,7 @@ static struct addrconf_sysctl_table
                         .data           = &ipv6_devconf.mtu6,
                         .maxlen         = sizeof(int),
                         .mode           = 0644,
-                        .proc_handler   = proc_dointvec,
+                        .proc_handler   = addrconf_sysctl_mtu,
                 },
                 {
                         .procname       = "accept_ra",
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index 7deebf102cba..0a04a37305d5 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -1298,7 +1298,8 @@ emsgsize:
         if (((length > mtu) ||
              (skb && skb_is_gso(skb))) &&
             (sk->sk_protocol == IPPROTO_UDP) &&
-            (rt->dst.dev->features & NETIF_F_UFO)) {
+            (rt->dst.dev->features & NETIF_F_UFO) &&
+            (sk->sk_type == SOCK_DGRAM)) {
                 err = ip6_ufo_append_data(sk, queue, getfrag, from, length,
                                           hh_len, fragheaderlen,
                                           transhdrlen, mtu, flags, rt);
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index 40695b9751c1..9940a41efca1 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -811,7 +811,7 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
                         break;
         }
         spin_unlock_irqrestore(&self->spinlock, flags);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
 }
 
 /*
diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c
index 3c83a1e5ab03..1215693fdd22 100644
--- a/net/irda/irnet/irnet_ppp.c
+++ b/net/irda/irnet/irnet_ppp.c
@@ -305,7 +305,7 @@ irnet_ctrl_read(irnet_socket *	ap,
 
   /* Put ourselves on the wait queue to be woken up */
   add_wait_queue(&irnet_events.rwait, &wait);
-  current->state = TASK_INTERRUPTIBLE;
+  set_current_state(TASK_INTERRUPTIBLE);
   for(;;)
     {
       /* If there is unread events */
@@ -321,7 +321,7 @@ irnet_ctrl_read(irnet_socket *	ap,
       /* Yield and wait to be woken up */
       schedule();
     }
-  current->state = TASK_RUNNING;
+  __set_current_state(TASK_RUNNING);
   remove_wait_queue(&irnet_events.rwait, &wait);
 
   /* Did we got it ? */
diff --git a/net/mac80211/chan.c b/net/mac80211/chan.c
index ff0d2db09df9..5bcd4e5589d3 100644
--- a/net/mac80211/chan.c
+++ b/net/mac80211/chan.c
@@ -1508,6 +1508,8 @@ static void __ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata)
         if (ieee80211_chanctx_refcount(local, ctx) == 0)
                 ieee80211_free_chanctx(local, ctx);
 
+        sdata->radar_required = false;
+
         /* Unreserving may ready an in-place reservation. */
         if (use_reserved_switch)
                 ieee80211_vif_use_reserved_switch(local);
@@ -1566,6 +1568,9 @@ int ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
         ieee80211_recalc_smps_chanctx(local, ctx);
         ieee80211_recalc_radar_chanctx(local, ctx);
  out:
+        if (ret)
+                sdata->radar_required = false;
+
         mutex_unlock(&local->chanctx_mtx);
         return ret;
 }
diff --git a/net/mac80211/rc80211_minstrel.c b/net/mac80211/rc80211_minstrel.c
index 7c86a002df95..ef6e8a6c4253 100644
--- a/net/mac80211/rc80211_minstrel.c
+++ b/net/mac80211/rc80211_minstrel.c
@@ -373,7 +373,7 @@ minstrel_get_rate(void *priv, struct ieee80211_sta *sta,
                 rate++;
                 mi->sample_deferred++;
         } else {
-                if (!msr->sample_limit != 0)
+                if (!msr->sample_limit)
                         return;
 
                 mi->sample_packets++;
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index 88a18ffe2975..07bd8db00af8 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -566,6 +566,7 @@ ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx)
                 if (tx->sdata->control_port_no_encrypt)
                         info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
                 info->control.flags |= IEEE80211_TX_CTRL_PORT_CTRL_PROTO;
+                info->flags |= IEEE80211_TX_CTL_USE_MINRATE;
         }
 
         return TX_CONTINUE;
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index 76cc9ffd87fa..49532672f66d 100644
--- a/net/netfilter/ipvs/ip_vs_ctl.c
+++ b/net/netfilter/ipvs/ip_vs_ctl.c
@@ -3466,7 +3466,7 @@ static int ip_vs_genl_set_cmd(struct sk_buff *skb, struct genl_info *info)
                 if (udest.af == 0)
                         udest.af = svc->af;
 
-                if (udest.af != svc->af) {
+                if (udest.af != svc->af && cmd != IPVS_CMD_DEL_DEST) {
                         /* The synchronization protocol is incompatible
                          * with mixed family services
                          */
diff --git a/net/netfilter/nft_compat.c b/net/netfilter/nft_compat.c
index a990df2f3f71..29fbcf25f88f 100644
--- a/net/netfilter/nft_compat.c
+++ b/net/netfilter/nft_compat.c
@@ -634,8 +634,12 @@ nft_match_select_ops(const struct nft_ctx *ctx,
                 struct xt_match *match = nft_match->ops.data;
 
                 if (strcmp(match->name, mt_name) == 0 &&
-                    match->revision == rev && match->family == family)
+                    match->revision == rev && match->family == family) {
+                        if (!try_module_get(match->me))
+                                return ERR_PTR(-ENOENT);
+
                         return &nft_match->ops;
+                }
         }
 
         match = xt_request_find_match(family, mt_name, rev);
@@ -704,8 +708,12 @@ nft_target_select_ops(const struct nft_ctx *ctx,
                 struct xt_target *target = nft_target->ops.data;
 
                 if (strcmp(target->name, tg_name) == 0 &&
-                    target->revision == rev && target->family == family)
+                    target->revision == rev && target->family == family) {
+                        if (!try_module_get(target->me))
+                                return ERR_PTR(-ENOENT);
+
                         return &nft_target->ops;
+                }
         }
 
         target = xt_request_find_target(family, tg_name, rev);
diff --git a/net/netfilter/nft_hash.c b/net/netfilter/nft_hash.c
index 61e6c407476a..c82df0a48fcd 100644
--- a/net/netfilter/nft_hash.c
+++ b/net/netfilter/nft_hash.c
@@ -192,8 +192,6 @@ static int nft_hash_init(const struct nft_set *set,
                 .key_offset = offsetof(struct nft_hash_elem, key),
                 .key_len = set->klen,
                 .hashfn = jhash,
-                .grow_decision = rht_grow_above_75,
-                .shrink_decision = rht_shrink_below_30,
         };
 
         return rhashtable_init(priv, &params);
diff --git a/net/netfilter/xt_recent.c b/net/netfilter/xt_recent.c
index 30dbe34915ae..45e1b30e4fb2 100644
--- a/net/netfilter/xt_recent.c
+++ b/net/netfilter/xt_recent.c
@@ -378,12 +378,11 @@ static int recent_mt_check(const struct xt_mtchk_param *par,
         mutex_lock(&recent_mutex);
         t = recent_table_lookup(recent_net, info->name);
         if (t != NULL) {
-                if (info->hit_count > t->nstamps_max_mask) {
-                        pr_info("hitcount (%u) is larger than packets to be remembered (%u) for table %s\n",
-                                info->hit_count, t->nstamps_max_mask + 1,
-                                info->name);
-                        ret = -EINVAL;
-                        goto out;
+                if (nstamp_mask > t->nstamps_max_mask) {
+                        spin_lock_bh(&recent_lock);
+                        recent_table_flush(t);
+                        t->nstamps_max_mask = nstamp_mask;
+                        spin_unlock_bh(&recent_lock);
                 }
 
                 t->refcnt++;
diff --git a/net/netfilter/xt_socket.c b/net/netfilter/xt_socket.c
index 1ba67931eb1b..13332dbf291d 100644
--- a/net/netfilter/xt_socket.c
+++ b/net/netfilter/xt_socket.c
@@ -243,12 +243,13 @@ static int
 extract_icmp6_fields(const struct sk_buff *skb,
                      unsigned int outside_hdrlen,
                      int *protocol,
-                     struct in6_addr **raddr,
-                     struct in6_addr **laddr,
+                     const struct in6_addr **raddr,
+                     const struct in6_addr **laddr,
                      __be16 *rport,
-                     __be16 *lport)
+                     __be16 *lport,
+                     struct ipv6hdr *ipv6_var)
 {
-        struct ipv6hdr *inside_iph, _inside_iph;
+        const struct ipv6hdr *inside_iph;
         struct icmp6hdr *icmph, _icmph;
         __be16 *ports, _ports[2];
         u8 inside_nexthdr;
@@ -263,12 +264,14 @@ extract_icmp6_fields(const struct sk_buff *skb,
         if (icmph->icmp6_type & ICMPV6_INFOMSG_MASK)
                 return 1;
 
-        inside_iph = skb_header_pointer(skb, outside_hdrlen + sizeof(_icmph), sizeof(_inside_iph), &_inside_iph);
+        inside_iph = skb_header_pointer(skb, outside_hdrlen + sizeof(_icmph),
+                                        sizeof(*ipv6_var), ipv6_var);
         if (inside_iph == NULL)
                 return 1;
         inside_nexthdr = inside_iph->nexthdr;
 
-        inside_hdrlen = ipv6_skip_exthdr(skb, outside_hdrlen + sizeof(_icmph) + sizeof(_inside_iph),
+        inside_hdrlen = ipv6_skip_exthdr(skb, outside_hdrlen + sizeof(_icmph) +
+                                              sizeof(*ipv6_var),
                                          &inside_nexthdr, &inside_fragoff);
         if (inside_hdrlen < 0)
                 return 1; /* hjm: Packet has no/incomplete transport layer headers. */
@@ -315,10 +318,10 @@ xt_socket_get_sock_v6(struct net *net, const u8 protocol,
 static bool
 socket_mt6_v1_v2(const struct sk_buff *skb, struct xt_action_param *par)
 {
-        struct ipv6hdr *iph = ipv6_hdr(skb);
+        struct ipv6hdr ipv6_var, *iph = ipv6_hdr(skb);
         struct udphdr _hdr, *hp = NULL;
         struct sock *sk = skb->sk;
-        struct in6_addr *daddr = NULL, *saddr = NULL;
+        const struct in6_addr *daddr = NULL, *saddr = NULL;
         __be16 uninitialized_var(dport), uninitialized_var(sport);
         int thoff = 0, uninitialized_var(tproto);
         const struct xt_socket_mtinfo1 *info = (struct xt_socket_mtinfo1 *) par->matchinfo;
@@ -342,7 +345,7 @@ socket_mt6_v1_v2(const struct sk_buff *skb, struct xt_action_param *par)
 
         } else if (tproto == IPPROTO_ICMPV6) {
                 if (extract_icmp6_fields(skb, thoff, &tproto, &saddr, &daddr,
-                                         &sport, &dport))
+                                         &sport, &dport, &ipv6_var))
                         return false;
         } else {
                 return false;
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index a96025c0583f..6b0f21950e09 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -3124,8 +3124,6 @@ static int __init netlink_proto_init(void)
                 .key_len = sizeof(u32), /* portid */
                 .hashfn = jhash,
                 .max_shift = 16, /* 64K */
-                .grow_decision = rht_grow_above_75,
-                .shrink_decision = rht_shrink_below_30,
         };
 
         if (err != 0)
diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c
index ae5e77cdc0ca..5bae7243c577 100644
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@ -2194,14 +2194,55 @@ static int __net_init ovs_init_net(struct net *net)
         return 0;
 }
 
-static void __net_exit ovs_exit_net(struct net *net)
+static void __net_exit list_vports_from_net(struct net *net, struct net *dnet,
+                                            struct list_head *head)
 {
-        struct datapath *dp, *dp_next;
         struct ovs_net *ovs_net = net_generic(net, ovs_net_id);
+        struct datapath *dp;
+
+        list_for_each_entry(dp, &ovs_net->dps, list_node) {
+                int i;
+
+                for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++) {
+                        struct vport *vport;
+
+                        hlist_for_each_entry(vport, &dp->ports[i], dp_hash_node) {
+                                struct netdev_vport *netdev_vport;
+
+                                if (vport->ops->type != OVS_VPORT_TYPE_INTERNAL)
+                                        continue;
+
+                                netdev_vport = netdev_vport_priv(vport);
+                                if (dev_net(netdev_vport->dev) == dnet)
+                                        list_add(&vport->detach_list, head);
+                        }
+                }
+        }
+}
+
+static void __net_exit ovs_exit_net(struct net *dnet)
+{
+        struct datapath *dp, *dp_next;
+        struct ovs_net *ovs_net = net_generic(dnet, ovs_net_id);
+        struct vport *vport, *vport_next;
+        struct net *net;
+        LIST_HEAD(head);
 
         ovs_lock();
         list_for_each_entry_safe(dp, dp_next, &ovs_net->dps, list_node)
                 __dp_destroy(dp);
+
+        rtnl_lock();
+        for_each_net(net)
+                list_vports_from_net(net, dnet, &head);
+        rtnl_unlock();
+
+        /* Detach all vports from given namespace. */
+        list_for_each_entry_safe(vport, vport_next, &head, detach_list) {
+                list_del(&vport->detach_list);
+                ovs_dp_detach_port(vport);
+        }
+
         ovs_unlock();
 
         cancel_work_sync(&ovs_net->dp_notify_work);
diff --git a/net/openvswitch/flow_netlink.c b/net/openvswitch/flow_netlink.c
index 216f20b90aa5..22b18c145c92 100644
--- a/net/openvswitch/flow_netlink.c
+++ b/net/openvswitch/flow_netlink.c
@@ -2253,14 +2253,20 @@ static int masked_set_action_to_set_action_attr(const struct nlattr *a,
                                                 struct sk_buff *skb)
 {
         const struct nlattr *ovs_key = nla_data(a);
+        struct nlattr *nla;
         size_t key_len = nla_len(ovs_key) / 2;
 
         /* Revert the conversion we did from a non-masked set action to
          * masked set action.
          */
-        if (nla_put(skb, OVS_ACTION_ATTR_SET, nla_len(a) - key_len, ovs_key))
+        nla = nla_nest_start(skb, OVS_ACTION_ATTR_SET);
+        if (!nla)
                 return -EMSGSIZE;
 
+        if (nla_put(skb, nla_type(ovs_key), key_len, nla_data(ovs_key)))
+                return -EMSGSIZE;
+
+        nla_nest_end(skb, nla);
         return 0;
 }
 
diff --git a/net/openvswitch/vport.h b/net/openvswitch/vport.h
index f8ae295fb001..bc85331a6c60 100644
--- a/net/openvswitch/vport.h
+++ b/net/openvswitch/vport.h
@@ -103,6 +103,7 @@ struct vport_portids {
  * @ops: Class structure.
  * @percpu_stats: Points to per-CPU statistics used and maintained by vport
  * @err_stats: Points to error statistics used and maintained by vport
+ * @detach_list: list used for detaching vport in net-exit call.
  */
 struct vport {
         struct rcu_head rcu;
@@ -117,6 +118,7 @@ struct vport {
         struct pcpu_sw_netstats __percpu *percpu_stats;
 
         struct vport_err_stats err_stats;
+        struct list_head detach_list;
 };
 
 /**
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index 404c9735aee9..8167aecc1594 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -704,6 +704,10 @@ static void prb_retire_rx_blk_timer_expired(unsigned long data)
 
         if (pkc->last_kactive_blk_num == pkc->kactive_blk_num) {
                 if (!frozen) {
+                        if (!BLOCK_NUM_PKTS(pbd)) {
+                                /* An empty block. Just refresh the timer. */
+                                goto refresh_timer;
+                        }
                         prb_retire_current_block(pkc, po, TP_STATUS_BLK_TMO);
                         if (!prb_dispatch_next_block(pkc, po))
                                 goto refresh_timer;
@@ -804,7 +808,11 @@ static void prb_close_block(struct tpacket_kbdq_core *pkc1,
                 h1->ts_last_pkt.ts_sec = last_pkt->tp_sec;
                 h1->ts_last_pkt.ts_nsec = last_pkt->tp_nsec;
         } else {
-                /* Ok, we tmo'd - so get the current time */
+                /* Ok, we tmo'd - so get the current time.
+                 *
+                 * It shouldn't really happen as we don't close empty
+                 * blocks. See prb_retire_rx_blk_timer_expired().
+                 */
                 struct timespec ts;
                 getnstimeofday(&ts);
                 h1->ts_last_pkt.ts_sec = ts.tv_sec;
@@ -1355,14 +1363,14 @@ static int packet_rcv_fanout(struct sk_buff *skb, struct net_device *dev,
                 return 0;
         }
 
+        if (fanout_has_flag(f, PACKET_FANOUT_FLAG_DEFRAG)) {
+                skb = ip_check_defrag(skb, IP_DEFRAG_AF_PACKET);
+                if (!skb)
+                        return 0;
+        }
         switch (f->type) {
         case PACKET_FANOUT_HASH:
         default:
-                if (fanout_has_flag(f, PACKET_FANOUT_FLAG_DEFRAG)) {
-                        skb = ip_check_defrag(skb, IP_DEFRAG_AF_PACKET);
-                        if (!skb)
-                                return 0;
-                }
                 idx = fanout_demux_hash(f, skb, num);
                 break;
         case PACKET_FANOUT_LB:
diff --git a/net/rxrpc/ar-ack.c b/net/rxrpc/ar-ack.c
index c6be17a959a6..e0547f521f20 100644
--- a/net/rxrpc/ar-ack.c
+++ b/net/rxrpc/ar-ack.c
@@ -218,7 +218,8 @@ static void rxrpc_resend(struct rxrpc_call *call)
         struct rxrpc_header *hdr;
         struct sk_buff *txb;
         unsigned long *p_txb, resend_at;
-        int loop, stop;
+        bool stop;
+        int loop;
         u8 resend;
 
         _enter("{%d,%d,%d,%d},",
@@ -226,7 +227,7 @@ static void rxrpc_resend(struct rxrpc_call *call)
                atomic_read(&call->sequence),
                CIRC_CNT(call->acks_head, call->acks_tail, call->acks_winsz));
 
-        stop = 0;
+        stop = false;
         resend = 0;
         resend_at = 0;
 
@@ -255,11 +256,11 @@ static void rxrpc_resend(struct rxrpc_call *call)
                         _proto("Tx DATA %%%u { #%d }",
                                ntohl(sp->hdr.serial), ntohl(sp->hdr.seq));
                         if (rxrpc_send_packet(call->conn->trans, txb) < 0) {
-                                stop = 0;
+                                stop = true;
                                 sp->resend_at = jiffies + 3;
                         } else {
                                 sp->resend_at =
-                                        jiffies + rxrpc_resend_timeout * HZ;
+                                        jiffies + rxrpc_resend_timeout;
                         }
                 }
 
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/sched/ematch.c b/net/sched/ematch.c
index 6742200b1307..fbb7ebfc58c6 100644
--- a/net/sched/ematch.c
+++ b/net/sched/ematch.c
@@ -228,6 +228,7 @@ static int tcf_em_validate(struct tcf_proto *tp,
                                  * to replay the request.
                                  */
                                 module_put(em->ops->owner);
+                                em->ops = NULL;
                                 err = -EAGAIN;
                         }
 #endif
diff --git a/net/sunrpc/auth_gss/gss_rpc_upcall.c b/net/sunrpc/auth_gss/gss_rpc_upcall.c
index abbb7dcd1689..59eeed43eda2 100644
--- a/net/sunrpc/auth_gss/gss_rpc_upcall.c
+++ b/net/sunrpc/auth_gss/gss_rpc_upcall.c
@@ -217,6 +217,8 @@ static void gssp_free_receive_pages(struct gssx_arg_accept_sec_context *arg)
 
         for (i = 0; i < arg->npages && arg->pages[i]; i++)
                 __free_page(arg->pages[i]);
+
+        kfree(arg->pages);
 }
 
 static int gssp_alloc_receive_pages(struct gssx_arg_accept_sec_context *arg)
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 224a82f24d3c..1095be9c80ab 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -463,6 +463,8 @@ static int rsc_parse(struct cache_detail *cd,
                 /* number of additional gid's */
                 if (get_int(&mesg, &N))
                         goto out;
+                if (N < 0 || N > NGROUPS_MAX)
+                        goto out;
                 status = -ENOMEM;
                 rsci.cred.cr_group_info = groups_alloc(N);
                 if (rsci.cred.cr_group_info == NULL)
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
diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index dcb797c60806..95c514a1d7d9 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -2363,8 +2363,6 @@ int tipc_sk_rht_init(struct net *net)
                 .hashfn = jhash,
                 .max_shift = 20, /* 1M */
                 .min_shift = 8,  /* 256 */
-                .grow_decision = rht_grow_above_75,
-                .shrink_decision = rht_shrink_below_30,
         };
 
         return rhashtable_init(&tn->sk_rht, &rht_params);
diff --git a/net/wireless/core.c b/net/wireless/core.c
index 3af0ecf1cc16..2a0bbd22854b 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -1199,6 +1199,7 @@ out_fail_wq:
         regulatory_exit();
 out_fail_reg:
         debugfs_remove(ieee80211_debugfs_dir);
+        nl80211_exit();
 out_fail_nl80211:
         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
 out_fail_notifier:
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 96fe32889f5e..864b782c0202 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -2654,10 +2654,6 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
                         return err;
         }
 
-        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
-        if (!msg)
-                return -ENOMEM;
-
         err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
                                   info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
                                   &flags);
@@ -2666,6 +2662,10 @@ static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
             !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
                 return -EOPNOTSUPP;
 
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return -ENOMEM;
+
         wdev = rdev_add_virtual_intf(rdev,
                                 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
                                 type, err ? NULL : &flags, &params);
@@ -12528,9 +12528,7 @@ static int cfg80211_net_detect_results(struct sk_buff *msg,
                         }
 
                         for (j = 0; j < match->n_channels; j++) {
-                                if (nla_put_u32(msg,
-                                                NL80211_ATTR_WIPHY_FREQ,
-                                                match->channels[j])) {
+                                if (nla_put_u32(msg, j, match->channels[j])) {
                                         nla_nest_cancel(msg, nl_freqs);
                                         nla_nest_cancel(msg, nl_match);
                                         goto out;
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index b586d0dcb09e..48dfc7b4e981 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -228,7 +228,7 @@ static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
 
 /* We keep a static world regulatory domain in case of the absence of CRDA */
 static const struct ieee80211_regdomain world_regdom = {
-        .n_reg_rules = 6,
+        .n_reg_rules = 8,
         .alpha2 =  "00",
         .reg_rules = {
                 /* IEEE 802.11b/g, channels 1..11 */